1#![allow(clippy::useless_conversion)]
2use crate::expr::*;
3impl serde::Serialize for AggCall {
4 #[allow(deprecated)]
5 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6 where
7 S: serde::Serializer,
8 {
9 use serde::ser::SerializeStruct;
10 let mut len = 0;
11 if self.kind != 0 {
12 len += 1;
13 }
14 if !self.args.is_empty() {
15 len += 1;
16 }
17 if self.return_type.is_some() {
18 len += 1;
19 }
20 if self.distinct {
21 len += 1;
22 }
23 if !self.order_by.is_empty() {
24 len += 1;
25 }
26 if self.filter.is_some() {
27 len += 1;
28 }
29 if !self.direct_args.is_empty() {
30 len += 1;
31 }
32 if self.udf.is_some() {
33 len += 1;
34 }
35 if self.scalar.is_some() {
36 len += 1;
37 }
38 let mut struct_ser = serializer.serialize_struct("expr.AggCall", len)?;
39 if self.kind != 0 {
40 let v = agg_call::Kind::try_from(self.kind)
41 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
42 struct_ser.serialize_field("kind", &v)?;
43 }
44 if !self.args.is_empty() {
45 struct_ser.serialize_field("args", &self.args)?;
46 }
47 if let Some(v) = self.return_type.as_ref() {
48 struct_ser.serialize_field("returnType", v)?;
49 }
50 if self.distinct {
51 struct_ser.serialize_field("distinct", &self.distinct)?;
52 }
53 if !self.order_by.is_empty() {
54 struct_ser.serialize_field("orderBy", &self.order_by)?;
55 }
56 if let Some(v) = self.filter.as_ref() {
57 struct_ser.serialize_field("filter", v)?;
58 }
59 if !self.direct_args.is_empty() {
60 struct_ser.serialize_field("directArgs", &self.direct_args)?;
61 }
62 if let Some(v) = self.udf.as_ref() {
63 struct_ser.serialize_field("udf", v)?;
64 }
65 if let Some(v) = self.scalar.as_ref() {
66 struct_ser.serialize_field("scalar", v)?;
67 }
68 struct_ser.end()
69 }
70}
71impl<'de> serde::Deserialize<'de> for AggCall {
72 #[allow(deprecated)]
73 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
74 where
75 D: serde::Deserializer<'de>,
76 {
77 const FIELDS: &[&str] = &[
78 "kind",
79 "args",
80 "return_type",
81 "returnType",
82 "distinct",
83 "order_by",
84 "orderBy",
85 "filter",
86 "direct_args",
87 "directArgs",
88 "udf",
89 "scalar",
90 ];
91
92 #[allow(clippy::enum_variant_names)]
93 enum GeneratedField {
94 Kind,
95 Args,
96 ReturnType,
97 Distinct,
98 OrderBy,
99 Filter,
100 DirectArgs,
101 Udf,
102 Scalar,
103 }
104 impl<'de> serde::Deserialize<'de> for GeneratedField {
105 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
106 where
107 D: serde::Deserializer<'de>,
108 {
109 struct GeneratedVisitor;
110
111 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
112 type Value = GeneratedField;
113
114 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
115 write!(formatter, "expected one of: {:?}", &FIELDS)
116 }
117
118 #[allow(unused_variables)]
119 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
120 where
121 E: serde::de::Error,
122 {
123 match value {
124 "kind" => Ok(GeneratedField::Kind),
125 "args" => Ok(GeneratedField::Args),
126 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
127 "distinct" => Ok(GeneratedField::Distinct),
128 "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
129 "filter" => Ok(GeneratedField::Filter),
130 "directArgs" | "direct_args" => Ok(GeneratedField::DirectArgs),
131 "udf" => Ok(GeneratedField::Udf),
132 "scalar" => Ok(GeneratedField::Scalar),
133 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
134 }
135 }
136 }
137 deserializer.deserialize_identifier(GeneratedVisitor)
138 }
139 }
140 struct GeneratedVisitor;
141 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
142 type Value = AggCall;
143
144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
145 formatter.write_str("struct expr.AggCall")
146 }
147
148 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCall, V::Error>
149 where
150 V: serde::de::MapAccess<'de>,
151 {
152 let mut kind__ = None;
153 let mut args__ = None;
154 let mut return_type__ = None;
155 let mut distinct__ = None;
156 let mut order_by__ = None;
157 let mut filter__ = None;
158 let mut direct_args__ = None;
159 let mut udf__ = None;
160 let mut scalar__ = None;
161 while let Some(k) = map_.next_key()? {
162 match k {
163 GeneratedField::Kind => {
164 if kind__.is_some() {
165 return Err(serde::de::Error::duplicate_field("kind"));
166 }
167 kind__ = Some(map_.next_value::<agg_call::Kind>()? as i32);
168 }
169 GeneratedField::Args => {
170 if args__.is_some() {
171 return Err(serde::de::Error::duplicate_field("args"));
172 }
173 args__ = Some(map_.next_value()?);
174 }
175 GeneratedField::ReturnType => {
176 if return_type__.is_some() {
177 return Err(serde::de::Error::duplicate_field("returnType"));
178 }
179 return_type__ = map_.next_value()?;
180 }
181 GeneratedField::Distinct => {
182 if distinct__.is_some() {
183 return Err(serde::de::Error::duplicate_field("distinct"));
184 }
185 distinct__ = Some(map_.next_value()?);
186 }
187 GeneratedField::OrderBy => {
188 if order_by__.is_some() {
189 return Err(serde::de::Error::duplicate_field("orderBy"));
190 }
191 order_by__ = Some(map_.next_value()?);
192 }
193 GeneratedField::Filter => {
194 if filter__.is_some() {
195 return Err(serde::de::Error::duplicate_field("filter"));
196 }
197 filter__ = map_.next_value()?;
198 }
199 GeneratedField::DirectArgs => {
200 if direct_args__.is_some() {
201 return Err(serde::de::Error::duplicate_field("directArgs"));
202 }
203 direct_args__ = Some(map_.next_value()?);
204 }
205 GeneratedField::Udf => {
206 if udf__.is_some() {
207 return Err(serde::de::Error::duplicate_field("udf"));
208 }
209 udf__ = map_.next_value()?;
210 }
211 GeneratedField::Scalar => {
212 if scalar__.is_some() {
213 return Err(serde::de::Error::duplicate_field("scalar"));
214 }
215 scalar__ = map_.next_value()?;
216 }
217 }
218 }
219 Ok(AggCall {
220 kind: kind__.unwrap_or_default(),
221 args: args__.unwrap_or_default(),
222 return_type: return_type__,
223 distinct: distinct__.unwrap_or_default(),
224 order_by: order_by__.unwrap_or_default(),
225 filter: filter__,
226 direct_args: direct_args__.unwrap_or_default(),
227 udf: udf__,
228 scalar: scalar__,
229 })
230 }
231 }
232 deserializer.deserialize_struct("expr.AggCall", FIELDS, GeneratedVisitor)
233 }
234}
235impl serde::Serialize for agg_call::Kind {
236 #[allow(deprecated)]
237 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
238 where
239 S: serde::Serializer,
240 {
241 let variant = match self {
242 Self::Unspecified => "UNSPECIFIED",
243 Self::Sum => "SUM",
244 Self::Min => "MIN",
245 Self::Max => "MAX",
246 Self::Count => "COUNT",
247 Self::Avg => "AVG",
248 Self::StringAgg => "STRING_AGG",
249 Self::ApproxCountDistinct => "APPROX_COUNT_DISTINCT",
250 Self::ArrayAgg => "ARRAY_AGG",
251 Self::FirstValue => "FIRST_VALUE",
252 Self::Sum0 => "SUM0",
253 Self::VarPop => "VAR_POP",
254 Self::VarSamp => "VAR_SAMP",
255 Self::StddevPop => "STDDEV_POP",
256 Self::StddevSamp => "STDDEV_SAMP",
257 Self::BitAnd => "BIT_AND",
258 Self::BitOr => "BIT_OR",
259 Self::BitXor => "BIT_XOR",
260 Self::BoolAnd => "BOOL_AND",
261 Self::BoolOr => "BOOL_OR",
262 Self::JsonbAgg => "JSONB_AGG",
263 Self::JsonbObjectAgg => "JSONB_OBJECT_AGG",
264 Self::PercentileCont => "PERCENTILE_CONT",
265 Self::PercentileDisc => "PERCENTILE_DISC",
266 Self::Mode => "MODE",
267 Self::LastValue => "LAST_VALUE",
268 Self::Grouping => "GROUPING",
269 Self::InternalLastSeenValue => "INTERNAL_LAST_SEEN_VALUE",
270 Self::ApproxPercentile => "APPROX_PERCENTILE",
271 Self::ArgMin => "ARG_MIN",
272 Self::ArgMax => "ARG_MAX",
273 Self::UserDefined => "USER_DEFINED",
274 Self::WrapScalar => "WRAP_SCALAR",
275 };
276 serializer.serialize_str(variant)
277 }
278}
279impl<'de> serde::Deserialize<'de> for agg_call::Kind {
280 #[allow(deprecated)]
281 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
282 where
283 D: serde::Deserializer<'de>,
284 {
285 const FIELDS: &[&str] = &[
286 "UNSPECIFIED",
287 "SUM",
288 "MIN",
289 "MAX",
290 "COUNT",
291 "AVG",
292 "STRING_AGG",
293 "APPROX_COUNT_DISTINCT",
294 "ARRAY_AGG",
295 "FIRST_VALUE",
296 "SUM0",
297 "VAR_POP",
298 "VAR_SAMP",
299 "STDDEV_POP",
300 "STDDEV_SAMP",
301 "BIT_AND",
302 "BIT_OR",
303 "BIT_XOR",
304 "BOOL_AND",
305 "BOOL_OR",
306 "JSONB_AGG",
307 "JSONB_OBJECT_AGG",
308 "PERCENTILE_CONT",
309 "PERCENTILE_DISC",
310 "MODE",
311 "LAST_VALUE",
312 "GROUPING",
313 "INTERNAL_LAST_SEEN_VALUE",
314 "APPROX_PERCENTILE",
315 "ARG_MIN",
316 "ARG_MAX",
317 "USER_DEFINED",
318 "WRAP_SCALAR",
319 ];
320
321 struct GeneratedVisitor;
322
323 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
324 type Value = agg_call::Kind;
325
326 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
327 write!(formatter, "expected one of: {:?}", &FIELDS)
328 }
329
330 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
331 where
332 E: serde::de::Error,
333 {
334 i32::try_from(v)
335 .ok()
336 .and_then(|x| x.try_into().ok())
337 .ok_or_else(|| {
338 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
339 })
340 }
341
342 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
343 where
344 E: serde::de::Error,
345 {
346 i32::try_from(v)
347 .ok()
348 .and_then(|x| x.try_into().ok())
349 .ok_or_else(|| {
350 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
351 })
352 }
353
354 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
355 where
356 E: serde::de::Error,
357 {
358 match value {
359 "UNSPECIFIED" => Ok(agg_call::Kind::Unspecified),
360 "SUM" => Ok(agg_call::Kind::Sum),
361 "MIN" => Ok(agg_call::Kind::Min),
362 "MAX" => Ok(agg_call::Kind::Max),
363 "COUNT" => Ok(agg_call::Kind::Count),
364 "AVG" => Ok(agg_call::Kind::Avg),
365 "STRING_AGG" => Ok(agg_call::Kind::StringAgg),
366 "APPROX_COUNT_DISTINCT" => Ok(agg_call::Kind::ApproxCountDistinct),
367 "ARRAY_AGG" => Ok(agg_call::Kind::ArrayAgg),
368 "FIRST_VALUE" => Ok(agg_call::Kind::FirstValue),
369 "SUM0" => Ok(agg_call::Kind::Sum0),
370 "VAR_POP" => Ok(agg_call::Kind::VarPop),
371 "VAR_SAMP" => Ok(agg_call::Kind::VarSamp),
372 "STDDEV_POP" => Ok(agg_call::Kind::StddevPop),
373 "STDDEV_SAMP" => Ok(agg_call::Kind::StddevSamp),
374 "BIT_AND" => Ok(agg_call::Kind::BitAnd),
375 "BIT_OR" => Ok(agg_call::Kind::BitOr),
376 "BIT_XOR" => Ok(agg_call::Kind::BitXor),
377 "BOOL_AND" => Ok(agg_call::Kind::BoolAnd),
378 "BOOL_OR" => Ok(agg_call::Kind::BoolOr),
379 "JSONB_AGG" => Ok(agg_call::Kind::JsonbAgg),
380 "JSONB_OBJECT_AGG" => Ok(agg_call::Kind::JsonbObjectAgg),
381 "PERCENTILE_CONT" => Ok(agg_call::Kind::PercentileCont),
382 "PERCENTILE_DISC" => Ok(agg_call::Kind::PercentileDisc),
383 "MODE" => Ok(agg_call::Kind::Mode),
384 "LAST_VALUE" => Ok(agg_call::Kind::LastValue),
385 "GROUPING" => Ok(agg_call::Kind::Grouping),
386 "INTERNAL_LAST_SEEN_VALUE" => Ok(agg_call::Kind::InternalLastSeenValue),
387 "APPROX_PERCENTILE" => Ok(agg_call::Kind::ApproxPercentile),
388 "ARG_MIN" => Ok(agg_call::Kind::ArgMin),
389 "ARG_MAX" => Ok(agg_call::Kind::ArgMax),
390 "USER_DEFINED" => Ok(agg_call::Kind::UserDefined),
391 "WRAP_SCALAR" => Ok(agg_call::Kind::WrapScalar),
392 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
393 }
394 }
395 }
396 deserializer.deserialize_any(GeneratedVisitor)
397 }
398}
399impl serde::Serialize for AggType {
400 #[allow(deprecated)]
401 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
402 where
403 S: serde::Serializer,
404 {
405 use serde::ser::SerializeStruct;
406 let mut len = 0;
407 if self.kind != 0 {
408 len += 1;
409 }
410 if self.udf_meta.is_some() {
411 len += 1;
412 }
413 if self.scalar_expr.is_some() {
414 len += 1;
415 }
416 let mut struct_ser = serializer.serialize_struct("expr.AggType", len)?;
417 if self.kind != 0 {
418 let v = agg_call::Kind::try_from(self.kind)
419 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
420 struct_ser.serialize_field("kind", &v)?;
421 }
422 if let Some(v) = self.udf_meta.as_ref() {
423 struct_ser.serialize_field("udfMeta", v)?;
424 }
425 if let Some(v) = self.scalar_expr.as_ref() {
426 struct_ser.serialize_field("scalarExpr", v)?;
427 }
428 struct_ser.end()
429 }
430}
431impl<'de> serde::Deserialize<'de> for AggType {
432 #[allow(deprecated)]
433 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
434 where
435 D: serde::Deserializer<'de>,
436 {
437 const FIELDS: &[&str] = &[
438 "kind",
439 "udf_meta",
440 "udfMeta",
441 "scalar_expr",
442 "scalarExpr",
443 ];
444
445 #[allow(clippy::enum_variant_names)]
446 enum GeneratedField {
447 Kind,
448 UdfMeta,
449 ScalarExpr,
450 }
451 impl<'de> serde::Deserialize<'de> for GeneratedField {
452 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
453 where
454 D: serde::Deserializer<'de>,
455 {
456 struct GeneratedVisitor;
457
458 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
459 type Value = GeneratedField;
460
461 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
462 write!(formatter, "expected one of: {:?}", &FIELDS)
463 }
464
465 #[allow(unused_variables)]
466 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
467 where
468 E: serde::de::Error,
469 {
470 match value {
471 "kind" => Ok(GeneratedField::Kind),
472 "udfMeta" | "udf_meta" => Ok(GeneratedField::UdfMeta),
473 "scalarExpr" | "scalar_expr" => Ok(GeneratedField::ScalarExpr),
474 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
475 }
476 }
477 }
478 deserializer.deserialize_identifier(GeneratedVisitor)
479 }
480 }
481 struct GeneratedVisitor;
482 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
483 type Value = AggType;
484
485 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
486 formatter.write_str("struct expr.AggType")
487 }
488
489 fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggType, V::Error>
490 where
491 V: serde::de::MapAccess<'de>,
492 {
493 let mut kind__ = None;
494 let mut udf_meta__ = None;
495 let mut scalar_expr__ = None;
496 while let Some(k) = map_.next_key()? {
497 match k {
498 GeneratedField::Kind => {
499 if kind__.is_some() {
500 return Err(serde::de::Error::duplicate_field("kind"));
501 }
502 kind__ = Some(map_.next_value::<agg_call::Kind>()? as i32);
503 }
504 GeneratedField::UdfMeta => {
505 if udf_meta__.is_some() {
506 return Err(serde::de::Error::duplicate_field("udfMeta"));
507 }
508 udf_meta__ = map_.next_value()?;
509 }
510 GeneratedField::ScalarExpr => {
511 if scalar_expr__.is_some() {
512 return Err(serde::de::Error::duplicate_field("scalarExpr"));
513 }
514 scalar_expr__ = map_.next_value()?;
515 }
516 }
517 }
518 Ok(AggType {
519 kind: kind__.unwrap_or_default(),
520 udf_meta: udf_meta__,
521 scalar_expr: scalar_expr__,
522 })
523 }
524 }
525 deserializer.deserialize_struct("expr.AggType", FIELDS, GeneratedVisitor)
526 }
527}
528impl serde::Serialize for Constant {
529 #[allow(deprecated)]
530 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
531 where
532 S: serde::Serializer,
533 {
534 use serde::ser::SerializeStruct;
535 let mut len = 0;
536 if self.datum.is_some() {
537 len += 1;
538 }
539 if self.r#type.is_some() {
540 len += 1;
541 }
542 let mut struct_ser = serializer.serialize_struct("expr.Constant", len)?;
543 if let Some(v) = self.datum.as_ref() {
544 struct_ser.serialize_field("datum", v)?;
545 }
546 if let Some(v) = self.r#type.as_ref() {
547 struct_ser.serialize_field("type", v)?;
548 }
549 struct_ser.end()
550 }
551}
552impl<'de> serde::Deserialize<'de> for Constant {
553 #[allow(deprecated)]
554 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
555 where
556 D: serde::Deserializer<'de>,
557 {
558 const FIELDS: &[&str] = &[
559 "datum",
560 "type",
561 ];
562
563 #[allow(clippy::enum_variant_names)]
564 enum GeneratedField {
565 Datum,
566 Type,
567 }
568 impl<'de> serde::Deserialize<'de> for GeneratedField {
569 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
570 where
571 D: serde::Deserializer<'de>,
572 {
573 struct GeneratedVisitor;
574
575 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
576 type Value = GeneratedField;
577
578 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
579 write!(formatter, "expected one of: {:?}", &FIELDS)
580 }
581
582 #[allow(unused_variables)]
583 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
584 where
585 E: serde::de::Error,
586 {
587 match value {
588 "datum" => Ok(GeneratedField::Datum),
589 "type" => Ok(GeneratedField::Type),
590 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
591 }
592 }
593 }
594 deserializer.deserialize_identifier(GeneratedVisitor)
595 }
596 }
597 struct GeneratedVisitor;
598 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
599 type Value = Constant;
600
601 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
602 formatter.write_str("struct expr.Constant")
603 }
604
605 fn visit_map<V>(self, mut map_: V) -> std::result::Result<Constant, V::Error>
606 where
607 V: serde::de::MapAccess<'de>,
608 {
609 let mut datum__ = None;
610 let mut r#type__ = None;
611 while let Some(k) = map_.next_key()? {
612 match k {
613 GeneratedField::Datum => {
614 if datum__.is_some() {
615 return Err(serde::de::Error::duplicate_field("datum"));
616 }
617 datum__ = map_.next_value()?;
618 }
619 GeneratedField::Type => {
620 if r#type__.is_some() {
621 return Err(serde::de::Error::duplicate_field("type"));
622 }
623 r#type__ = map_.next_value()?;
624 }
625 }
626 }
627 Ok(Constant {
628 datum: datum__,
629 r#type: r#type__,
630 })
631 }
632 }
633 deserializer.deserialize_struct("expr.Constant", FIELDS, GeneratedVisitor)
634 }
635}
636impl serde::Serialize for ExprNode {
637 #[allow(deprecated)]
638 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
639 where
640 S: serde::Serializer,
641 {
642 use serde::ser::SerializeStruct;
643 let mut len = 0;
644 if self.function_type != 0 {
645 len += 1;
646 }
647 if self.return_type.is_some() {
648 len += 1;
649 }
650 if self.rex_node.is_some() {
651 len += 1;
652 }
653 let mut struct_ser = serializer.serialize_struct("expr.ExprNode", len)?;
654 if self.function_type != 0 {
655 let v = expr_node::Type::try_from(self.function_type)
656 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.function_type)))?;
657 struct_ser.serialize_field("functionType", &v)?;
658 }
659 if let Some(v) = self.return_type.as_ref() {
660 struct_ser.serialize_field("returnType", v)?;
661 }
662 if let Some(v) = self.rex_node.as_ref() {
663 match v {
664 expr_node::RexNode::InputRef(v) => {
665 struct_ser.serialize_field("inputRef", v)?;
666 }
667 expr_node::RexNode::Constant(v) => {
668 struct_ser.serialize_field("constant", v)?;
669 }
670 expr_node::RexNode::FuncCall(v) => {
671 struct_ser.serialize_field("funcCall", v)?;
672 }
673 expr_node::RexNode::Udf(v) => {
674 struct_ser.serialize_field("udf", v)?;
675 }
676 expr_node::RexNode::Now(v) => {
677 struct_ser.serialize_field("now", v)?;
678 }
679 }
680 }
681 struct_ser.end()
682 }
683}
684impl<'de> serde::Deserialize<'de> for ExprNode {
685 #[allow(deprecated)]
686 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
687 where
688 D: serde::Deserializer<'de>,
689 {
690 const FIELDS: &[&str] = &[
691 "function_type",
692 "functionType",
693 "return_type",
694 "returnType",
695 "input_ref",
696 "inputRef",
697 "constant",
698 "func_call",
699 "funcCall",
700 "udf",
701 "now",
702 ];
703
704 #[allow(clippy::enum_variant_names)]
705 enum GeneratedField {
706 FunctionType,
707 ReturnType,
708 InputRef,
709 Constant,
710 FuncCall,
711 Udf,
712 Now,
713 }
714 impl<'de> serde::Deserialize<'de> for GeneratedField {
715 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
716 where
717 D: serde::Deserializer<'de>,
718 {
719 struct GeneratedVisitor;
720
721 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
722 type Value = GeneratedField;
723
724 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
725 write!(formatter, "expected one of: {:?}", &FIELDS)
726 }
727
728 #[allow(unused_variables)]
729 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
730 where
731 E: serde::de::Error,
732 {
733 match value {
734 "functionType" | "function_type" => Ok(GeneratedField::FunctionType),
735 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
736 "inputRef" | "input_ref" => Ok(GeneratedField::InputRef),
737 "constant" => Ok(GeneratedField::Constant),
738 "funcCall" | "func_call" => Ok(GeneratedField::FuncCall),
739 "udf" => Ok(GeneratedField::Udf),
740 "now" => Ok(GeneratedField::Now),
741 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
742 }
743 }
744 }
745 deserializer.deserialize_identifier(GeneratedVisitor)
746 }
747 }
748 struct GeneratedVisitor;
749 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
750 type Value = ExprNode;
751
752 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
753 formatter.write_str("struct expr.ExprNode")
754 }
755
756 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExprNode, V::Error>
757 where
758 V: serde::de::MapAccess<'de>,
759 {
760 let mut function_type__ = None;
761 let mut return_type__ = None;
762 let mut rex_node__ = None;
763 while let Some(k) = map_.next_key()? {
764 match k {
765 GeneratedField::FunctionType => {
766 if function_type__.is_some() {
767 return Err(serde::de::Error::duplicate_field("functionType"));
768 }
769 function_type__ = Some(map_.next_value::<expr_node::Type>()? as i32);
770 }
771 GeneratedField::ReturnType => {
772 if return_type__.is_some() {
773 return Err(serde::de::Error::duplicate_field("returnType"));
774 }
775 return_type__ = map_.next_value()?;
776 }
777 GeneratedField::InputRef => {
778 if rex_node__.is_some() {
779 return Err(serde::de::Error::duplicate_field("inputRef"));
780 }
781 rex_node__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| expr_node::RexNode::InputRef(x.0));
782 }
783 GeneratedField::Constant => {
784 if rex_node__.is_some() {
785 return Err(serde::de::Error::duplicate_field("constant"));
786 }
787 rex_node__ = map_.next_value::<::std::option::Option<_>>()?.map(expr_node::RexNode::Constant)
788;
789 }
790 GeneratedField::FuncCall => {
791 if rex_node__.is_some() {
792 return Err(serde::de::Error::duplicate_field("funcCall"));
793 }
794 rex_node__ = map_.next_value::<::std::option::Option<_>>()?.map(expr_node::RexNode::FuncCall)
795;
796 }
797 GeneratedField::Udf => {
798 if rex_node__.is_some() {
799 return Err(serde::de::Error::duplicate_field("udf"));
800 }
801 rex_node__ = map_.next_value::<::std::option::Option<_>>()?.map(expr_node::RexNode::Udf)
802;
803 }
804 GeneratedField::Now => {
805 if rex_node__.is_some() {
806 return Err(serde::de::Error::duplicate_field("now"));
807 }
808 rex_node__ = map_.next_value::<::std::option::Option<_>>()?.map(expr_node::RexNode::Now)
809;
810 }
811 }
812 }
813 Ok(ExprNode {
814 function_type: function_type__.unwrap_or_default(),
815 return_type: return_type__,
816 rex_node: rex_node__,
817 })
818 }
819 }
820 deserializer.deserialize_struct("expr.ExprNode", FIELDS, GeneratedVisitor)
821 }
822}
823impl serde::Serialize for expr_node::NowRexNode {
824 #[allow(deprecated)]
825 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
826 where
827 S: serde::Serializer,
828 {
829 use serde::ser::SerializeStruct;
830 let len = 0;
831 let struct_ser = serializer.serialize_struct("expr.ExprNode.NowRexNode", len)?;
832 struct_ser.end()
833 }
834}
835impl<'de> serde::Deserialize<'de> for expr_node::NowRexNode {
836 #[allow(deprecated)]
837 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
838 where
839 D: serde::Deserializer<'de>,
840 {
841 const FIELDS: &[&str] = &[
842 ];
843
844 #[allow(clippy::enum_variant_names)]
845 enum GeneratedField {
846 }
847 impl<'de> serde::Deserialize<'de> for GeneratedField {
848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
849 where
850 D: serde::Deserializer<'de>,
851 {
852 struct GeneratedVisitor;
853
854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
855 type Value = GeneratedField;
856
857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
858 write!(formatter, "expected one of: {:?}", &FIELDS)
859 }
860
861 #[allow(unused_variables)]
862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
863 where
864 E: serde::de::Error,
865 {
866 Err(serde::de::Error::unknown_field(value, FIELDS))
867 }
868 }
869 deserializer.deserialize_identifier(GeneratedVisitor)
870 }
871 }
872 struct GeneratedVisitor;
873 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
874 type Value = expr_node::NowRexNode;
875
876 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
877 formatter.write_str("struct expr.ExprNode.NowRexNode")
878 }
879
880 fn visit_map<V>(self, mut map_: V) -> std::result::Result<expr_node::NowRexNode, V::Error>
881 where
882 V: serde::de::MapAccess<'de>,
883 {
884 while map_.next_key::<GeneratedField>()?.is_some() {
885 let _ = map_.next_value::<serde::de::IgnoredAny>()?;
886 }
887 Ok(expr_node::NowRexNode {
888 })
889 }
890 }
891 deserializer.deserialize_struct("expr.ExprNode.NowRexNode", FIELDS, GeneratedVisitor)
892 }
893}
894impl serde::Serialize for expr_node::Type {
895 #[allow(deprecated)]
896 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
897 where
898 S: serde::Serializer,
899 {
900 let variant = match self {
901 Self::Unspecified => "UNSPECIFIED",
902 Self::Add => "ADD",
903 Self::Subtract => "SUBTRACT",
904 Self::Multiply => "MULTIPLY",
905 Self::Divide => "DIVIDE",
906 Self::Modulus => "MODULUS",
907 Self::Equal => "EQUAL",
908 Self::NotEqual => "NOT_EQUAL",
909 Self::LessThan => "LESS_THAN",
910 Self::LessThanOrEqual => "LESS_THAN_OR_EQUAL",
911 Self::GreaterThan => "GREATER_THAN",
912 Self::GreaterThanOrEqual => "GREATER_THAN_OR_EQUAL",
913 Self::Greatest => "GREATEST",
914 Self::Least => "LEAST",
915 Self::And => "AND",
916 Self::Or => "OR",
917 Self::Not => "NOT",
918 Self::In => "IN",
919 Self::Some => "SOME",
920 Self::All => "ALL",
921 Self::BitwiseAnd => "BITWISE_AND",
922 Self::BitwiseOr => "BITWISE_OR",
923 Self::BitwiseXor => "BITWISE_XOR",
924 Self::BitwiseNot => "BITWISE_NOT",
925 Self::BitwiseShiftLeft => "BITWISE_SHIFT_LEFT",
926 Self::BitwiseShiftRight => "BITWISE_SHIFT_RIGHT",
927 Self::Extract => "EXTRACT",
928 Self::DatePart => "DATE_PART",
929 Self::TumbleStart => "TUMBLE_START",
930 Self::MakeDate => "MAKE_DATE",
931 Self::MakeTime => "MAKE_TIME",
932 Self::MakeTimestamp => "MAKE_TIMESTAMP",
933 Self::DateBin => "DATE_BIN",
934 Self::SecToTimestamptz => "SEC_TO_TIMESTAMPTZ",
935 Self::AtTimeZone => "AT_TIME_ZONE",
936 Self::DateTrunc => "DATE_TRUNC",
937 Self::CharToTimestamptz => "CHAR_TO_TIMESTAMPTZ",
938 Self::CharToDate => "CHAR_TO_DATE",
939 Self::CastWithTimeZone => "CAST_WITH_TIME_ZONE",
940 Self::AddWithTimeZone => "ADD_WITH_TIME_ZONE",
941 Self::SubtractWithTimeZone => "SUBTRACT_WITH_TIME_ZONE",
942 Self::MakeTimestamptz => "MAKE_TIMESTAMPTZ",
943 Self::Cast => "CAST",
944 Self::Substr => "SUBSTR",
945 Self::Length => "LENGTH",
946 Self::Like => "LIKE",
947 Self::ILike => "I_LIKE",
948 Self::SimilarToEscape => "SIMILAR_TO_ESCAPE",
949 Self::Upper => "UPPER",
950 Self::Lower => "LOWER",
951 Self::Trim => "TRIM",
952 Self::Replace => "REPLACE",
953 Self::Position => "POSITION",
954 Self::Ltrim => "LTRIM",
955 Self::Rtrim => "RTRIM",
956 Self::Case => "CASE",
957 Self::ConstantLookup => "CONSTANT_LOOKUP",
958 Self::RoundDigit => "ROUND_DIGIT",
959 Self::Round => "ROUND",
960 Self::Ascii => "ASCII",
961 Self::Translate => "TRANSLATE",
962 Self::Coalesce => "COALESCE",
963 Self::ConcatWs => "CONCAT_WS",
964 Self::ConcatWsVariadic => "CONCAT_WS_VARIADIC",
965 Self::Abs => "ABS",
966 Self::SplitPart => "SPLIT_PART",
967 Self::Ceil => "CEIL",
968 Self::Floor => "FLOOR",
969 Self::ToChar => "TO_CHAR",
970 Self::Md5 => "MD5",
971 Self::CharLength => "CHAR_LENGTH",
972 Self::Repeat => "REPEAT",
973 Self::ConcatOp => "CONCAT_OP",
974 Self::ByteaConcatOp => "BYTEA_CONCAT_OP",
975 Self::Concat => "CONCAT",
976 Self::ConcatVariadic => "CONCAT_VARIADIC",
977 Self::BoolOut => "BOOL_OUT",
978 Self::OctetLength => "OCTET_LENGTH",
979 Self::BitLength => "BIT_LENGTH",
980 Self::Overlay => "OVERLAY",
981 Self::RegexpMatch => "REGEXP_MATCH",
982 Self::RegexpReplace => "REGEXP_REPLACE",
983 Self::RegexpCount => "REGEXP_COUNT",
984 Self::RegexpSplitToArray => "REGEXP_SPLIT_TO_ARRAY",
985 Self::RegexpEq => "REGEXP_EQ",
986 Self::Pow => "POW",
987 Self::Exp => "EXP",
988 Self::Chr => "CHR",
989 Self::StartsWith => "STARTS_WITH",
990 Self::Initcap => "INITCAP",
991 Self::Lpad => "LPAD",
992 Self::Rpad => "RPAD",
993 Self::Reverse => "REVERSE",
994 Self::Strpos => "STRPOS",
995 Self::ToAscii => "TO_ASCII",
996 Self::ToHex => "TO_HEX",
997 Self::QuoteIdent => "QUOTE_IDENT",
998 Self::Sin => "SIN",
999 Self::Cos => "COS",
1000 Self::Tan => "TAN",
1001 Self::Cot => "COT",
1002 Self::Asin => "ASIN",
1003 Self::Acos => "ACOS",
1004 Self::Atan => "ATAN",
1005 Self::Atan2 => "ATAN2",
1006 Self::Sind => "SIND",
1007 Self::Cosd => "COSD",
1008 Self::Cotd => "COTD",
1009 Self::Tand => "TAND",
1010 Self::Asind => "ASIND",
1011 Self::Sqrt => "SQRT",
1012 Self::Degrees => "DEGREES",
1013 Self::Radians => "RADIANS",
1014 Self::Cosh => "COSH",
1015 Self::Tanh => "TANH",
1016 Self::Coth => "COTH",
1017 Self::Asinh => "ASINH",
1018 Self::Acosh => "ACOSH",
1019 Self::Atanh => "ATANH",
1020 Self::Sinh => "SINH",
1021 Self::Acosd => "ACOSD",
1022 Self::Atand => "ATAND",
1023 Self::Atan2d => "ATAN2D",
1024 Self::Trunc => "TRUNC",
1025 Self::Ln => "LN",
1026 Self::Log10 => "LOG10",
1027 Self::Cbrt => "CBRT",
1028 Self::Sign => "SIGN",
1029 Self::Scale => "SCALE",
1030 Self::MinScale => "MIN_SCALE",
1031 Self::TrimScale => "TRIM_SCALE",
1032 Self::IsTrue => "IS_TRUE",
1033 Self::IsNotTrue => "IS_NOT_TRUE",
1034 Self::IsFalse => "IS_FALSE",
1035 Self::IsNotFalse => "IS_NOT_FALSE",
1036 Self::IsNull => "IS_NULL",
1037 Self::IsNotNull => "IS_NOT_NULL",
1038 Self::IsDistinctFrom => "IS_DISTINCT_FROM",
1039 Self::IsNotDistinctFrom => "IS_NOT_DISTINCT_FROM",
1040 Self::Encode => "ENCODE",
1041 Self::Decode => "DECODE",
1042 Self::Sha1 => "SHA1",
1043 Self::Sha224 => "SHA224",
1044 Self::Sha256 => "SHA256",
1045 Self::Sha384 => "SHA384",
1046 Self::Sha512 => "SHA512",
1047 Self::Left => "LEFT",
1048 Self::Right => "RIGHT",
1049 Self::Format => "FORMAT",
1050 Self::FormatVariadic => "FORMAT_VARIADIC",
1051 Self::PgwireSend => "PGWIRE_SEND",
1052 Self::PgwireRecv => "PGWIRE_RECV",
1053 Self::ConvertFrom => "CONVERT_FROM",
1054 Self::ConvertTo => "CONVERT_TO",
1055 Self::Decrypt => "DECRYPT",
1056 Self::Encrypt => "ENCRYPT",
1057 Self::InetAton => "INET_ATON",
1058 Self::InetNtoa => "INET_NTOA",
1059 Self::QuoteLiteral => "QUOTE_LITERAL",
1060 Self::QuoteNullable => "QUOTE_NULLABLE",
1061 Self::Hmac => "HMAC",
1062 Self::SecureCompare => "SECURE_COMPARE",
1063 Self::GetBit => "GET_BIT",
1064 Self::GetByte => "GET_BYTE",
1065 Self::SetBit => "SET_BIT",
1066 Self::SetByte => "SET_BYTE",
1067 Self::BitCount => "BIT_COUNT",
1068 Self::CheckNotNull => "CHECK_NOT_NULL",
1069 Self::Neg => "NEG",
1070 Self::Field => "FIELD",
1071 Self::Array => "ARRAY",
1072 Self::ArrayAccess => "ARRAY_ACCESS",
1073 Self::Row => "ROW",
1074 Self::ArrayToString => "ARRAY_TO_STRING",
1075 Self::ArrayRangeAccess => "ARRAY_RANGE_ACCESS",
1076 Self::ArrayCat => "ARRAY_CAT",
1077 Self::ArrayAppend => "ARRAY_APPEND",
1078 Self::ArrayPrepend => "ARRAY_PREPEND",
1079 Self::FormatType => "FORMAT_TYPE",
1080 Self::ArrayDistinct => "ARRAY_DISTINCT",
1081 Self::ArrayLength => "ARRAY_LENGTH",
1082 Self::Cardinality => "CARDINALITY",
1083 Self::ArrayRemove => "ARRAY_REMOVE",
1084 Self::ArrayPositions => "ARRAY_POSITIONS",
1085 Self::TrimArray => "TRIM_ARRAY",
1086 Self::StringToArray => "STRING_TO_ARRAY",
1087 Self::ArrayPosition => "ARRAY_POSITION",
1088 Self::ArrayReplace => "ARRAY_REPLACE",
1089 Self::ArrayDims => "ARRAY_DIMS",
1090 Self::ArrayTransform => "ARRAY_TRANSFORM",
1091 Self::ArrayMin => "ARRAY_MIN",
1092 Self::ArrayMax => "ARRAY_MAX",
1093 Self::ArraySum => "ARRAY_SUM",
1094 Self::ArraySort => "ARRAY_SORT",
1095 Self::ArrayContains => "ARRAY_CONTAINS",
1096 Self::ArrayContained => "ARRAY_CONTAINED",
1097 Self::ArrayFlatten => "ARRAY_FLATTEN",
1098 Self::HexToInt256 => "HEX_TO_INT256",
1099 Self::JsonbAccess => "JSONB_ACCESS",
1100 Self::JsonbAccessStr => "JSONB_ACCESS_STR",
1101 Self::JsonbExtractPath => "JSONB_EXTRACT_PATH",
1102 Self::JsonbExtractPathVariadic => "JSONB_EXTRACT_PATH_VARIADIC",
1103 Self::JsonbExtractPathText => "JSONB_EXTRACT_PATH_TEXT",
1104 Self::JsonbExtractPathTextVariadic => "JSONB_EXTRACT_PATH_TEXT_VARIADIC",
1105 Self::JsonbTypeof => "JSONB_TYPEOF",
1106 Self::JsonbArrayLength => "JSONB_ARRAY_LENGTH",
1107 Self::IsJson => "IS_JSON",
1108 Self::JsonbConcat => "JSONB_CONCAT",
1109 Self::JsonbObject => "JSONB_OBJECT",
1110 Self::JsonbPretty => "JSONB_PRETTY",
1111 Self::JsonbContains => "JSONB_CONTAINS",
1112 Self::JsonbContained => "JSONB_CONTAINED",
1113 Self::JsonbExists => "JSONB_EXISTS",
1114 Self::JsonbExistsAny => "JSONB_EXISTS_ANY",
1115 Self::JsonbExistsAll => "JSONB_EXISTS_ALL",
1116 Self::JsonbDeletePath => "JSONB_DELETE_PATH",
1117 Self::JsonbStripNulls => "JSONB_STRIP_NULLS",
1118 Self::ToJsonb => "TO_JSONB",
1119 Self::JsonbBuildArray => "JSONB_BUILD_ARRAY",
1120 Self::JsonbBuildArrayVariadic => "JSONB_BUILD_ARRAY_VARIADIC",
1121 Self::JsonbBuildObject => "JSONB_BUILD_OBJECT",
1122 Self::JsonbBuildObjectVariadic => "JSONB_BUILD_OBJECT_VARIADIC",
1123 Self::JsonbPathExists => "JSONB_PATH_EXISTS",
1124 Self::JsonbPathMatch => "JSONB_PATH_MATCH",
1125 Self::JsonbPathQueryArray => "JSONB_PATH_QUERY_ARRAY",
1126 Self::JsonbPathQueryFirst => "JSONB_PATH_QUERY_FIRST",
1127 Self::JsonbPopulateRecord => "JSONB_POPULATE_RECORD",
1128 Self::JsonbToRecord => "JSONB_TO_RECORD",
1129 Self::JsonbSet => "JSONB_SET",
1130 Self::JsonbPopulateMap => "JSONB_POPULATE_MAP",
1131 Self::JsonbToArray => "JSONB_TO_ARRAY",
1132 Self::MapFromEntries => "MAP_FROM_ENTRIES",
1133 Self::MapAccess => "MAP_ACCESS",
1134 Self::MapKeys => "MAP_KEYS",
1135 Self::MapValues => "MAP_VALUES",
1136 Self::MapEntries => "MAP_ENTRIES",
1137 Self::MapFromKeyValues => "MAP_FROM_KEY_VALUES",
1138 Self::MapLength => "MAP_LENGTH",
1139 Self::MapContains => "MAP_CONTAINS",
1140 Self::MapCat => "MAP_CAT",
1141 Self::MapInsert => "MAP_INSERT",
1142 Self::MapDelete => "MAP_DELETE",
1143 Self::MapFilter => "MAP_FILTER",
1144 Self::L2Distance => "L2_DISTANCE",
1145 Self::CosineDistance => "COSINE_DISTANCE",
1146 Self::L1Distance => "L1_DISTANCE",
1147 Self::InnerProduct => "INNER_PRODUCT",
1148 Self::VecConcat => "VEC_CONCAT",
1149 Self::L2Norm => "L2_NORM",
1150 Self::L2Normalize => "L2_NORMALIZE",
1151 Self::Subvector => "SUBVECTOR",
1152 Self::CompositeCast => "COMPOSITE_CAST",
1153 Self::Vnode => "VNODE",
1154 Self::TestFeature => "TEST_FEATURE",
1155 Self::VnodeUser => "VNODE_USER",
1156 Self::License => "LICENSE",
1157 Self::Proctime => "PROCTIME",
1158 Self::PgSleep => "PG_SLEEP",
1159 Self::PgSleepFor => "PG_SLEEP_FOR",
1160 Self::PgSleepUntil => "PG_SLEEP_UNTIL",
1161 Self::Random => "RANDOM",
1162 Self::CastRegclass => "CAST_REGCLASS",
1163 Self::PgGetIndexdef => "PG_GET_INDEXDEF",
1164 Self::ColDescription => "COL_DESCRIPTION",
1165 Self::PgGetViewdef => "PG_GET_VIEWDEF",
1166 Self::PgGetUserbyid => "PG_GET_USERBYID",
1167 Self::PgIndexesSize => "PG_INDEXES_SIZE",
1168 Self::PgRelationSize => "PG_RELATION_SIZE",
1169 Self::PgGetSerialSequence => "PG_GET_SERIAL_SEQUENCE",
1170 Self::PgIndexColumnHasProperty => "PG_INDEX_COLUMN_HAS_PROPERTY",
1171 Self::HasTablePrivilege => "HAS_TABLE_PRIVILEGE",
1172 Self::HasAnyColumnPrivilege => "HAS_ANY_COLUMN_PRIVILEGE",
1173 Self::HasSchemaPrivilege => "HAS_SCHEMA_PRIVILEGE",
1174 Self::PgIsInRecovery => "PG_IS_IN_RECOVERY",
1175 Self::RwRecoveryStatus => "RW_RECOVERY_STATUS",
1176 Self::RwEpochToTs => "RW_EPOCH_TO_TS",
1177 Self::PgTableIsVisible => "PG_TABLE_IS_VISIBLE",
1178 Self::HasFunctionPrivilege => "HAS_FUNCTION_PRIVILEGE",
1179 Self::HasDatabasePrivilege => "HAS_DATABASE_PRIVILEGE",
1180 Self::RwClusterId => "RW_CLUSTER_ID",
1181 Self::RwFragmentVnodes => "RW_FRAGMENT_VNODES",
1182 Self::RwActorVnodes => "RW_ACTOR_VNODES",
1183 Self::IcebergTransform => "ICEBERG_TRANSFORM",
1184 Self::OpenaiEmbedding => "OPENAI_EMBEDDING",
1185 };
1186 serializer.serialize_str(variant)
1187 }
1188}
1189impl<'de> serde::Deserialize<'de> for expr_node::Type {
1190 #[allow(deprecated)]
1191 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1192 where
1193 D: serde::Deserializer<'de>,
1194 {
1195 const FIELDS: &[&str] = &[
1196 "UNSPECIFIED",
1197 "ADD",
1198 "SUBTRACT",
1199 "MULTIPLY",
1200 "DIVIDE",
1201 "MODULUS",
1202 "EQUAL",
1203 "NOT_EQUAL",
1204 "LESS_THAN",
1205 "LESS_THAN_OR_EQUAL",
1206 "GREATER_THAN",
1207 "GREATER_THAN_OR_EQUAL",
1208 "GREATEST",
1209 "LEAST",
1210 "AND",
1211 "OR",
1212 "NOT",
1213 "IN",
1214 "SOME",
1215 "ALL",
1216 "BITWISE_AND",
1217 "BITWISE_OR",
1218 "BITWISE_XOR",
1219 "BITWISE_NOT",
1220 "BITWISE_SHIFT_LEFT",
1221 "BITWISE_SHIFT_RIGHT",
1222 "EXTRACT",
1223 "DATE_PART",
1224 "TUMBLE_START",
1225 "MAKE_DATE",
1226 "MAKE_TIME",
1227 "MAKE_TIMESTAMP",
1228 "DATE_BIN",
1229 "SEC_TO_TIMESTAMPTZ",
1230 "AT_TIME_ZONE",
1231 "DATE_TRUNC",
1232 "CHAR_TO_TIMESTAMPTZ",
1233 "CHAR_TO_DATE",
1234 "CAST_WITH_TIME_ZONE",
1235 "ADD_WITH_TIME_ZONE",
1236 "SUBTRACT_WITH_TIME_ZONE",
1237 "MAKE_TIMESTAMPTZ",
1238 "CAST",
1239 "SUBSTR",
1240 "LENGTH",
1241 "LIKE",
1242 "I_LIKE",
1243 "SIMILAR_TO_ESCAPE",
1244 "UPPER",
1245 "LOWER",
1246 "TRIM",
1247 "REPLACE",
1248 "POSITION",
1249 "LTRIM",
1250 "RTRIM",
1251 "CASE",
1252 "CONSTANT_LOOKUP",
1253 "ROUND_DIGIT",
1254 "ROUND",
1255 "ASCII",
1256 "TRANSLATE",
1257 "COALESCE",
1258 "CONCAT_WS",
1259 "CONCAT_WS_VARIADIC",
1260 "ABS",
1261 "SPLIT_PART",
1262 "CEIL",
1263 "FLOOR",
1264 "TO_CHAR",
1265 "MD5",
1266 "CHAR_LENGTH",
1267 "REPEAT",
1268 "CONCAT_OP",
1269 "BYTEA_CONCAT_OP",
1270 "CONCAT",
1271 "CONCAT_VARIADIC",
1272 "BOOL_OUT",
1273 "OCTET_LENGTH",
1274 "BIT_LENGTH",
1275 "OVERLAY",
1276 "REGEXP_MATCH",
1277 "REGEXP_REPLACE",
1278 "REGEXP_COUNT",
1279 "REGEXP_SPLIT_TO_ARRAY",
1280 "REGEXP_EQ",
1281 "POW",
1282 "EXP",
1283 "CHR",
1284 "STARTS_WITH",
1285 "INITCAP",
1286 "LPAD",
1287 "RPAD",
1288 "REVERSE",
1289 "STRPOS",
1290 "TO_ASCII",
1291 "TO_HEX",
1292 "QUOTE_IDENT",
1293 "SIN",
1294 "COS",
1295 "TAN",
1296 "COT",
1297 "ASIN",
1298 "ACOS",
1299 "ATAN",
1300 "ATAN2",
1301 "SIND",
1302 "COSD",
1303 "COTD",
1304 "TAND",
1305 "ASIND",
1306 "SQRT",
1307 "DEGREES",
1308 "RADIANS",
1309 "COSH",
1310 "TANH",
1311 "COTH",
1312 "ASINH",
1313 "ACOSH",
1314 "ATANH",
1315 "SINH",
1316 "ACOSD",
1317 "ATAND",
1318 "ATAN2D",
1319 "TRUNC",
1320 "LN",
1321 "LOG10",
1322 "CBRT",
1323 "SIGN",
1324 "SCALE",
1325 "MIN_SCALE",
1326 "TRIM_SCALE",
1327 "IS_TRUE",
1328 "IS_NOT_TRUE",
1329 "IS_FALSE",
1330 "IS_NOT_FALSE",
1331 "IS_NULL",
1332 "IS_NOT_NULL",
1333 "IS_DISTINCT_FROM",
1334 "IS_NOT_DISTINCT_FROM",
1335 "ENCODE",
1336 "DECODE",
1337 "SHA1",
1338 "SHA224",
1339 "SHA256",
1340 "SHA384",
1341 "SHA512",
1342 "LEFT",
1343 "RIGHT",
1344 "FORMAT",
1345 "FORMAT_VARIADIC",
1346 "PGWIRE_SEND",
1347 "PGWIRE_RECV",
1348 "CONVERT_FROM",
1349 "CONVERT_TO",
1350 "DECRYPT",
1351 "ENCRYPT",
1352 "INET_ATON",
1353 "INET_NTOA",
1354 "QUOTE_LITERAL",
1355 "QUOTE_NULLABLE",
1356 "HMAC",
1357 "SECURE_COMPARE",
1358 "GET_BIT",
1359 "GET_BYTE",
1360 "SET_BIT",
1361 "SET_BYTE",
1362 "BIT_COUNT",
1363 "CHECK_NOT_NULL",
1364 "NEG",
1365 "FIELD",
1366 "ARRAY",
1367 "ARRAY_ACCESS",
1368 "ROW",
1369 "ARRAY_TO_STRING",
1370 "ARRAY_RANGE_ACCESS",
1371 "ARRAY_CAT",
1372 "ARRAY_APPEND",
1373 "ARRAY_PREPEND",
1374 "FORMAT_TYPE",
1375 "ARRAY_DISTINCT",
1376 "ARRAY_LENGTH",
1377 "CARDINALITY",
1378 "ARRAY_REMOVE",
1379 "ARRAY_POSITIONS",
1380 "TRIM_ARRAY",
1381 "STRING_TO_ARRAY",
1382 "ARRAY_POSITION",
1383 "ARRAY_REPLACE",
1384 "ARRAY_DIMS",
1385 "ARRAY_TRANSFORM",
1386 "ARRAY_MIN",
1387 "ARRAY_MAX",
1388 "ARRAY_SUM",
1389 "ARRAY_SORT",
1390 "ARRAY_CONTAINS",
1391 "ARRAY_CONTAINED",
1392 "ARRAY_FLATTEN",
1393 "HEX_TO_INT256",
1394 "JSONB_ACCESS",
1395 "JSONB_ACCESS_STR",
1396 "JSONB_EXTRACT_PATH",
1397 "JSONB_EXTRACT_PATH_VARIADIC",
1398 "JSONB_EXTRACT_PATH_TEXT",
1399 "JSONB_EXTRACT_PATH_TEXT_VARIADIC",
1400 "JSONB_TYPEOF",
1401 "JSONB_ARRAY_LENGTH",
1402 "IS_JSON",
1403 "JSONB_CONCAT",
1404 "JSONB_OBJECT",
1405 "JSONB_PRETTY",
1406 "JSONB_CONTAINS",
1407 "JSONB_CONTAINED",
1408 "JSONB_EXISTS",
1409 "JSONB_EXISTS_ANY",
1410 "JSONB_EXISTS_ALL",
1411 "JSONB_DELETE_PATH",
1412 "JSONB_STRIP_NULLS",
1413 "TO_JSONB",
1414 "JSONB_BUILD_ARRAY",
1415 "JSONB_BUILD_ARRAY_VARIADIC",
1416 "JSONB_BUILD_OBJECT",
1417 "JSONB_BUILD_OBJECT_VARIADIC",
1418 "JSONB_PATH_EXISTS",
1419 "JSONB_PATH_MATCH",
1420 "JSONB_PATH_QUERY_ARRAY",
1421 "JSONB_PATH_QUERY_FIRST",
1422 "JSONB_POPULATE_RECORD",
1423 "JSONB_TO_RECORD",
1424 "JSONB_SET",
1425 "JSONB_POPULATE_MAP",
1426 "JSONB_TO_ARRAY",
1427 "MAP_FROM_ENTRIES",
1428 "MAP_ACCESS",
1429 "MAP_KEYS",
1430 "MAP_VALUES",
1431 "MAP_ENTRIES",
1432 "MAP_FROM_KEY_VALUES",
1433 "MAP_LENGTH",
1434 "MAP_CONTAINS",
1435 "MAP_CAT",
1436 "MAP_INSERT",
1437 "MAP_DELETE",
1438 "MAP_FILTER",
1439 "L2_DISTANCE",
1440 "COSINE_DISTANCE",
1441 "L1_DISTANCE",
1442 "INNER_PRODUCT",
1443 "VEC_CONCAT",
1444 "L2_NORM",
1445 "L2_NORMALIZE",
1446 "SUBVECTOR",
1447 "COMPOSITE_CAST",
1448 "VNODE",
1449 "TEST_FEATURE",
1450 "VNODE_USER",
1451 "LICENSE",
1452 "PROCTIME",
1453 "PG_SLEEP",
1454 "PG_SLEEP_FOR",
1455 "PG_SLEEP_UNTIL",
1456 "RANDOM",
1457 "CAST_REGCLASS",
1458 "PG_GET_INDEXDEF",
1459 "COL_DESCRIPTION",
1460 "PG_GET_VIEWDEF",
1461 "PG_GET_USERBYID",
1462 "PG_INDEXES_SIZE",
1463 "PG_RELATION_SIZE",
1464 "PG_GET_SERIAL_SEQUENCE",
1465 "PG_INDEX_COLUMN_HAS_PROPERTY",
1466 "HAS_TABLE_PRIVILEGE",
1467 "HAS_ANY_COLUMN_PRIVILEGE",
1468 "HAS_SCHEMA_PRIVILEGE",
1469 "PG_IS_IN_RECOVERY",
1470 "RW_RECOVERY_STATUS",
1471 "RW_EPOCH_TO_TS",
1472 "PG_TABLE_IS_VISIBLE",
1473 "HAS_FUNCTION_PRIVILEGE",
1474 "HAS_DATABASE_PRIVILEGE",
1475 "RW_CLUSTER_ID",
1476 "RW_FRAGMENT_VNODES",
1477 "RW_ACTOR_VNODES",
1478 "ICEBERG_TRANSFORM",
1479 "OPENAI_EMBEDDING",
1480 ];
1481
1482 struct GeneratedVisitor;
1483
1484 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1485 type Value = expr_node::Type;
1486
1487 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1488 write!(formatter, "expected one of: {:?}", &FIELDS)
1489 }
1490
1491 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1492 where
1493 E: serde::de::Error,
1494 {
1495 i32::try_from(v)
1496 .ok()
1497 .and_then(|x| x.try_into().ok())
1498 .ok_or_else(|| {
1499 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1500 })
1501 }
1502
1503 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1504 where
1505 E: serde::de::Error,
1506 {
1507 i32::try_from(v)
1508 .ok()
1509 .and_then(|x| x.try_into().ok())
1510 .ok_or_else(|| {
1511 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1512 })
1513 }
1514
1515 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1516 where
1517 E: serde::de::Error,
1518 {
1519 match value {
1520 "UNSPECIFIED" => Ok(expr_node::Type::Unspecified),
1521 "ADD" => Ok(expr_node::Type::Add),
1522 "SUBTRACT" => Ok(expr_node::Type::Subtract),
1523 "MULTIPLY" => Ok(expr_node::Type::Multiply),
1524 "DIVIDE" => Ok(expr_node::Type::Divide),
1525 "MODULUS" => Ok(expr_node::Type::Modulus),
1526 "EQUAL" => Ok(expr_node::Type::Equal),
1527 "NOT_EQUAL" => Ok(expr_node::Type::NotEqual),
1528 "LESS_THAN" => Ok(expr_node::Type::LessThan),
1529 "LESS_THAN_OR_EQUAL" => Ok(expr_node::Type::LessThanOrEqual),
1530 "GREATER_THAN" => Ok(expr_node::Type::GreaterThan),
1531 "GREATER_THAN_OR_EQUAL" => Ok(expr_node::Type::GreaterThanOrEqual),
1532 "GREATEST" => Ok(expr_node::Type::Greatest),
1533 "LEAST" => Ok(expr_node::Type::Least),
1534 "AND" => Ok(expr_node::Type::And),
1535 "OR" => Ok(expr_node::Type::Or),
1536 "NOT" => Ok(expr_node::Type::Not),
1537 "IN" => Ok(expr_node::Type::In),
1538 "SOME" => Ok(expr_node::Type::Some),
1539 "ALL" => Ok(expr_node::Type::All),
1540 "BITWISE_AND" => Ok(expr_node::Type::BitwiseAnd),
1541 "BITWISE_OR" => Ok(expr_node::Type::BitwiseOr),
1542 "BITWISE_XOR" => Ok(expr_node::Type::BitwiseXor),
1543 "BITWISE_NOT" => Ok(expr_node::Type::BitwiseNot),
1544 "BITWISE_SHIFT_LEFT" => Ok(expr_node::Type::BitwiseShiftLeft),
1545 "BITWISE_SHIFT_RIGHT" => Ok(expr_node::Type::BitwiseShiftRight),
1546 "EXTRACT" => Ok(expr_node::Type::Extract),
1547 "DATE_PART" => Ok(expr_node::Type::DatePart),
1548 "TUMBLE_START" => Ok(expr_node::Type::TumbleStart),
1549 "MAKE_DATE" => Ok(expr_node::Type::MakeDate),
1550 "MAKE_TIME" => Ok(expr_node::Type::MakeTime),
1551 "MAKE_TIMESTAMP" => Ok(expr_node::Type::MakeTimestamp),
1552 "DATE_BIN" => Ok(expr_node::Type::DateBin),
1553 "SEC_TO_TIMESTAMPTZ" => Ok(expr_node::Type::SecToTimestamptz),
1554 "AT_TIME_ZONE" => Ok(expr_node::Type::AtTimeZone),
1555 "DATE_TRUNC" => Ok(expr_node::Type::DateTrunc),
1556 "CHAR_TO_TIMESTAMPTZ" => Ok(expr_node::Type::CharToTimestamptz),
1557 "CHAR_TO_DATE" => Ok(expr_node::Type::CharToDate),
1558 "CAST_WITH_TIME_ZONE" => Ok(expr_node::Type::CastWithTimeZone),
1559 "ADD_WITH_TIME_ZONE" => Ok(expr_node::Type::AddWithTimeZone),
1560 "SUBTRACT_WITH_TIME_ZONE" => Ok(expr_node::Type::SubtractWithTimeZone),
1561 "MAKE_TIMESTAMPTZ" => Ok(expr_node::Type::MakeTimestamptz),
1562 "CAST" => Ok(expr_node::Type::Cast),
1563 "SUBSTR" => Ok(expr_node::Type::Substr),
1564 "LENGTH" => Ok(expr_node::Type::Length),
1565 "LIKE" => Ok(expr_node::Type::Like),
1566 "I_LIKE" => Ok(expr_node::Type::ILike),
1567 "SIMILAR_TO_ESCAPE" => Ok(expr_node::Type::SimilarToEscape),
1568 "UPPER" => Ok(expr_node::Type::Upper),
1569 "LOWER" => Ok(expr_node::Type::Lower),
1570 "TRIM" => Ok(expr_node::Type::Trim),
1571 "REPLACE" => Ok(expr_node::Type::Replace),
1572 "POSITION" => Ok(expr_node::Type::Position),
1573 "LTRIM" => Ok(expr_node::Type::Ltrim),
1574 "RTRIM" => Ok(expr_node::Type::Rtrim),
1575 "CASE" => Ok(expr_node::Type::Case),
1576 "CONSTANT_LOOKUP" => Ok(expr_node::Type::ConstantLookup),
1577 "ROUND_DIGIT" => Ok(expr_node::Type::RoundDigit),
1578 "ROUND" => Ok(expr_node::Type::Round),
1579 "ASCII" => Ok(expr_node::Type::Ascii),
1580 "TRANSLATE" => Ok(expr_node::Type::Translate),
1581 "COALESCE" => Ok(expr_node::Type::Coalesce),
1582 "CONCAT_WS" => Ok(expr_node::Type::ConcatWs),
1583 "CONCAT_WS_VARIADIC" => Ok(expr_node::Type::ConcatWsVariadic),
1584 "ABS" => Ok(expr_node::Type::Abs),
1585 "SPLIT_PART" => Ok(expr_node::Type::SplitPart),
1586 "CEIL" => Ok(expr_node::Type::Ceil),
1587 "FLOOR" => Ok(expr_node::Type::Floor),
1588 "TO_CHAR" => Ok(expr_node::Type::ToChar),
1589 "MD5" => Ok(expr_node::Type::Md5),
1590 "CHAR_LENGTH" => Ok(expr_node::Type::CharLength),
1591 "REPEAT" => Ok(expr_node::Type::Repeat),
1592 "CONCAT_OP" => Ok(expr_node::Type::ConcatOp),
1593 "BYTEA_CONCAT_OP" => Ok(expr_node::Type::ByteaConcatOp),
1594 "CONCAT" => Ok(expr_node::Type::Concat),
1595 "CONCAT_VARIADIC" => Ok(expr_node::Type::ConcatVariadic),
1596 "BOOL_OUT" => Ok(expr_node::Type::BoolOut),
1597 "OCTET_LENGTH" => Ok(expr_node::Type::OctetLength),
1598 "BIT_LENGTH" => Ok(expr_node::Type::BitLength),
1599 "OVERLAY" => Ok(expr_node::Type::Overlay),
1600 "REGEXP_MATCH" => Ok(expr_node::Type::RegexpMatch),
1601 "REGEXP_REPLACE" => Ok(expr_node::Type::RegexpReplace),
1602 "REGEXP_COUNT" => Ok(expr_node::Type::RegexpCount),
1603 "REGEXP_SPLIT_TO_ARRAY" => Ok(expr_node::Type::RegexpSplitToArray),
1604 "REGEXP_EQ" => Ok(expr_node::Type::RegexpEq),
1605 "POW" => Ok(expr_node::Type::Pow),
1606 "EXP" => Ok(expr_node::Type::Exp),
1607 "CHR" => Ok(expr_node::Type::Chr),
1608 "STARTS_WITH" => Ok(expr_node::Type::StartsWith),
1609 "INITCAP" => Ok(expr_node::Type::Initcap),
1610 "LPAD" => Ok(expr_node::Type::Lpad),
1611 "RPAD" => Ok(expr_node::Type::Rpad),
1612 "REVERSE" => Ok(expr_node::Type::Reverse),
1613 "STRPOS" => Ok(expr_node::Type::Strpos),
1614 "TO_ASCII" => Ok(expr_node::Type::ToAscii),
1615 "TO_HEX" => Ok(expr_node::Type::ToHex),
1616 "QUOTE_IDENT" => Ok(expr_node::Type::QuoteIdent),
1617 "SIN" => Ok(expr_node::Type::Sin),
1618 "COS" => Ok(expr_node::Type::Cos),
1619 "TAN" => Ok(expr_node::Type::Tan),
1620 "COT" => Ok(expr_node::Type::Cot),
1621 "ASIN" => Ok(expr_node::Type::Asin),
1622 "ACOS" => Ok(expr_node::Type::Acos),
1623 "ATAN" => Ok(expr_node::Type::Atan),
1624 "ATAN2" => Ok(expr_node::Type::Atan2),
1625 "SIND" => Ok(expr_node::Type::Sind),
1626 "COSD" => Ok(expr_node::Type::Cosd),
1627 "COTD" => Ok(expr_node::Type::Cotd),
1628 "TAND" => Ok(expr_node::Type::Tand),
1629 "ASIND" => Ok(expr_node::Type::Asind),
1630 "SQRT" => Ok(expr_node::Type::Sqrt),
1631 "DEGREES" => Ok(expr_node::Type::Degrees),
1632 "RADIANS" => Ok(expr_node::Type::Radians),
1633 "COSH" => Ok(expr_node::Type::Cosh),
1634 "TANH" => Ok(expr_node::Type::Tanh),
1635 "COTH" => Ok(expr_node::Type::Coth),
1636 "ASINH" => Ok(expr_node::Type::Asinh),
1637 "ACOSH" => Ok(expr_node::Type::Acosh),
1638 "ATANH" => Ok(expr_node::Type::Atanh),
1639 "SINH" => Ok(expr_node::Type::Sinh),
1640 "ACOSD" => Ok(expr_node::Type::Acosd),
1641 "ATAND" => Ok(expr_node::Type::Atand),
1642 "ATAN2D" => Ok(expr_node::Type::Atan2d),
1643 "TRUNC" => Ok(expr_node::Type::Trunc),
1644 "LN" => Ok(expr_node::Type::Ln),
1645 "LOG10" => Ok(expr_node::Type::Log10),
1646 "CBRT" => Ok(expr_node::Type::Cbrt),
1647 "SIGN" => Ok(expr_node::Type::Sign),
1648 "SCALE" => Ok(expr_node::Type::Scale),
1649 "MIN_SCALE" => Ok(expr_node::Type::MinScale),
1650 "TRIM_SCALE" => Ok(expr_node::Type::TrimScale),
1651 "IS_TRUE" => Ok(expr_node::Type::IsTrue),
1652 "IS_NOT_TRUE" => Ok(expr_node::Type::IsNotTrue),
1653 "IS_FALSE" => Ok(expr_node::Type::IsFalse),
1654 "IS_NOT_FALSE" => Ok(expr_node::Type::IsNotFalse),
1655 "IS_NULL" => Ok(expr_node::Type::IsNull),
1656 "IS_NOT_NULL" => Ok(expr_node::Type::IsNotNull),
1657 "IS_DISTINCT_FROM" => Ok(expr_node::Type::IsDistinctFrom),
1658 "IS_NOT_DISTINCT_FROM" => Ok(expr_node::Type::IsNotDistinctFrom),
1659 "ENCODE" => Ok(expr_node::Type::Encode),
1660 "DECODE" => Ok(expr_node::Type::Decode),
1661 "SHA1" => Ok(expr_node::Type::Sha1),
1662 "SHA224" => Ok(expr_node::Type::Sha224),
1663 "SHA256" => Ok(expr_node::Type::Sha256),
1664 "SHA384" => Ok(expr_node::Type::Sha384),
1665 "SHA512" => Ok(expr_node::Type::Sha512),
1666 "LEFT" => Ok(expr_node::Type::Left),
1667 "RIGHT" => Ok(expr_node::Type::Right),
1668 "FORMAT" => Ok(expr_node::Type::Format),
1669 "FORMAT_VARIADIC" => Ok(expr_node::Type::FormatVariadic),
1670 "PGWIRE_SEND" => Ok(expr_node::Type::PgwireSend),
1671 "PGWIRE_RECV" => Ok(expr_node::Type::PgwireRecv),
1672 "CONVERT_FROM" => Ok(expr_node::Type::ConvertFrom),
1673 "CONVERT_TO" => Ok(expr_node::Type::ConvertTo),
1674 "DECRYPT" => Ok(expr_node::Type::Decrypt),
1675 "ENCRYPT" => Ok(expr_node::Type::Encrypt),
1676 "INET_ATON" => Ok(expr_node::Type::InetAton),
1677 "INET_NTOA" => Ok(expr_node::Type::InetNtoa),
1678 "QUOTE_LITERAL" => Ok(expr_node::Type::QuoteLiteral),
1679 "QUOTE_NULLABLE" => Ok(expr_node::Type::QuoteNullable),
1680 "HMAC" => Ok(expr_node::Type::Hmac),
1681 "SECURE_COMPARE" => Ok(expr_node::Type::SecureCompare),
1682 "GET_BIT" => Ok(expr_node::Type::GetBit),
1683 "GET_BYTE" => Ok(expr_node::Type::GetByte),
1684 "SET_BIT" => Ok(expr_node::Type::SetBit),
1685 "SET_BYTE" => Ok(expr_node::Type::SetByte),
1686 "BIT_COUNT" => Ok(expr_node::Type::BitCount),
1687 "CHECK_NOT_NULL" => Ok(expr_node::Type::CheckNotNull),
1688 "NEG" => Ok(expr_node::Type::Neg),
1689 "FIELD" => Ok(expr_node::Type::Field),
1690 "ARRAY" => Ok(expr_node::Type::Array),
1691 "ARRAY_ACCESS" => Ok(expr_node::Type::ArrayAccess),
1692 "ROW" => Ok(expr_node::Type::Row),
1693 "ARRAY_TO_STRING" => Ok(expr_node::Type::ArrayToString),
1694 "ARRAY_RANGE_ACCESS" => Ok(expr_node::Type::ArrayRangeAccess),
1695 "ARRAY_CAT" => Ok(expr_node::Type::ArrayCat),
1696 "ARRAY_APPEND" => Ok(expr_node::Type::ArrayAppend),
1697 "ARRAY_PREPEND" => Ok(expr_node::Type::ArrayPrepend),
1698 "FORMAT_TYPE" => Ok(expr_node::Type::FormatType),
1699 "ARRAY_DISTINCT" => Ok(expr_node::Type::ArrayDistinct),
1700 "ARRAY_LENGTH" => Ok(expr_node::Type::ArrayLength),
1701 "CARDINALITY" => Ok(expr_node::Type::Cardinality),
1702 "ARRAY_REMOVE" => Ok(expr_node::Type::ArrayRemove),
1703 "ARRAY_POSITIONS" => Ok(expr_node::Type::ArrayPositions),
1704 "TRIM_ARRAY" => Ok(expr_node::Type::TrimArray),
1705 "STRING_TO_ARRAY" => Ok(expr_node::Type::StringToArray),
1706 "ARRAY_POSITION" => Ok(expr_node::Type::ArrayPosition),
1707 "ARRAY_REPLACE" => Ok(expr_node::Type::ArrayReplace),
1708 "ARRAY_DIMS" => Ok(expr_node::Type::ArrayDims),
1709 "ARRAY_TRANSFORM" => Ok(expr_node::Type::ArrayTransform),
1710 "ARRAY_MIN" => Ok(expr_node::Type::ArrayMin),
1711 "ARRAY_MAX" => Ok(expr_node::Type::ArrayMax),
1712 "ARRAY_SUM" => Ok(expr_node::Type::ArraySum),
1713 "ARRAY_SORT" => Ok(expr_node::Type::ArraySort),
1714 "ARRAY_CONTAINS" => Ok(expr_node::Type::ArrayContains),
1715 "ARRAY_CONTAINED" => Ok(expr_node::Type::ArrayContained),
1716 "ARRAY_FLATTEN" => Ok(expr_node::Type::ArrayFlatten),
1717 "HEX_TO_INT256" => Ok(expr_node::Type::HexToInt256),
1718 "JSONB_ACCESS" => Ok(expr_node::Type::JsonbAccess),
1719 "JSONB_ACCESS_STR" => Ok(expr_node::Type::JsonbAccessStr),
1720 "JSONB_EXTRACT_PATH" => Ok(expr_node::Type::JsonbExtractPath),
1721 "JSONB_EXTRACT_PATH_VARIADIC" => Ok(expr_node::Type::JsonbExtractPathVariadic),
1722 "JSONB_EXTRACT_PATH_TEXT" => Ok(expr_node::Type::JsonbExtractPathText),
1723 "JSONB_EXTRACT_PATH_TEXT_VARIADIC" => Ok(expr_node::Type::JsonbExtractPathTextVariadic),
1724 "JSONB_TYPEOF" => Ok(expr_node::Type::JsonbTypeof),
1725 "JSONB_ARRAY_LENGTH" => Ok(expr_node::Type::JsonbArrayLength),
1726 "IS_JSON" => Ok(expr_node::Type::IsJson),
1727 "JSONB_CONCAT" => Ok(expr_node::Type::JsonbConcat),
1728 "JSONB_OBJECT" => Ok(expr_node::Type::JsonbObject),
1729 "JSONB_PRETTY" => Ok(expr_node::Type::JsonbPretty),
1730 "JSONB_CONTAINS" => Ok(expr_node::Type::JsonbContains),
1731 "JSONB_CONTAINED" => Ok(expr_node::Type::JsonbContained),
1732 "JSONB_EXISTS" => Ok(expr_node::Type::JsonbExists),
1733 "JSONB_EXISTS_ANY" => Ok(expr_node::Type::JsonbExistsAny),
1734 "JSONB_EXISTS_ALL" => Ok(expr_node::Type::JsonbExistsAll),
1735 "JSONB_DELETE_PATH" => Ok(expr_node::Type::JsonbDeletePath),
1736 "JSONB_STRIP_NULLS" => Ok(expr_node::Type::JsonbStripNulls),
1737 "TO_JSONB" => Ok(expr_node::Type::ToJsonb),
1738 "JSONB_BUILD_ARRAY" => Ok(expr_node::Type::JsonbBuildArray),
1739 "JSONB_BUILD_ARRAY_VARIADIC" => Ok(expr_node::Type::JsonbBuildArrayVariadic),
1740 "JSONB_BUILD_OBJECT" => Ok(expr_node::Type::JsonbBuildObject),
1741 "JSONB_BUILD_OBJECT_VARIADIC" => Ok(expr_node::Type::JsonbBuildObjectVariadic),
1742 "JSONB_PATH_EXISTS" => Ok(expr_node::Type::JsonbPathExists),
1743 "JSONB_PATH_MATCH" => Ok(expr_node::Type::JsonbPathMatch),
1744 "JSONB_PATH_QUERY_ARRAY" => Ok(expr_node::Type::JsonbPathQueryArray),
1745 "JSONB_PATH_QUERY_FIRST" => Ok(expr_node::Type::JsonbPathQueryFirst),
1746 "JSONB_POPULATE_RECORD" => Ok(expr_node::Type::JsonbPopulateRecord),
1747 "JSONB_TO_RECORD" => Ok(expr_node::Type::JsonbToRecord),
1748 "JSONB_SET" => Ok(expr_node::Type::JsonbSet),
1749 "JSONB_POPULATE_MAP" => Ok(expr_node::Type::JsonbPopulateMap),
1750 "JSONB_TO_ARRAY" => Ok(expr_node::Type::JsonbToArray),
1751 "MAP_FROM_ENTRIES" => Ok(expr_node::Type::MapFromEntries),
1752 "MAP_ACCESS" => Ok(expr_node::Type::MapAccess),
1753 "MAP_KEYS" => Ok(expr_node::Type::MapKeys),
1754 "MAP_VALUES" => Ok(expr_node::Type::MapValues),
1755 "MAP_ENTRIES" => Ok(expr_node::Type::MapEntries),
1756 "MAP_FROM_KEY_VALUES" => Ok(expr_node::Type::MapFromKeyValues),
1757 "MAP_LENGTH" => Ok(expr_node::Type::MapLength),
1758 "MAP_CONTAINS" => Ok(expr_node::Type::MapContains),
1759 "MAP_CAT" => Ok(expr_node::Type::MapCat),
1760 "MAP_INSERT" => Ok(expr_node::Type::MapInsert),
1761 "MAP_DELETE" => Ok(expr_node::Type::MapDelete),
1762 "MAP_FILTER" => Ok(expr_node::Type::MapFilter),
1763 "L2_DISTANCE" => Ok(expr_node::Type::L2Distance),
1764 "COSINE_DISTANCE" => Ok(expr_node::Type::CosineDistance),
1765 "L1_DISTANCE" => Ok(expr_node::Type::L1Distance),
1766 "INNER_PRODUCT" => Ok(expr_node::Type::InnerProduct),
1767 "VEC_CONCAT" => Ok(expr_node::Type::VecConcat),
1768 "L2_NORM" => Ok(expr_node::Type::L2Norm),
1769 "L2_NORMALIZE" => Ok(expr_node::Type::L2Normalize),
1770 "SUBVECTOR" => Ok(expr_node::Type::Subvector),
1771 "COMPOSITE_CAST" => Ok(expr_node::Type::CompositeCast),
1772 "VNODE" => Ok(expr_node::Type::Vnode),
1773 "TEST_FEATURE" => Ok(expr_node::Type::TestFeature),
1774 "VNODE_USER" => Ok(expr_node::Type::VnodeUser),
1775 "LICENSE" => Ok(expr_node::Type::License),
1776 "PROCTIME" => Ok(expr_node::Type::Proctime),
1777 "PG_SLEEP" => Ok(expr_node::Type::PgSleep),
1778 "PG_SLEEP_FOR" => Ok(expr_node::Type::PgSleepFor),
1779 "PG_SLEEP_UNTIL" => Ok(expr_node::Type::PgSleepUntil),
1780 "RANDOM" => Ok(expr_node::Type::Random),
1781 "CAST_REGCLASS" => Ok(expr_node::Type::CastRegclass),
1782 "PG_GET_INDEXDEF" => Ok(expr_node::Type::PgGetIndexdef),
1783 "COL_DESCRIPTION" => Ok(expr_node::Type::ColDescription),
1784 "PG_GET_VIEWDEF" => Ok(expr_node::Type::PgGetViewdef),
1785 "PG_GET_USERBYID" => Ok(expr_node::Type::PgGetUserbyid),
1786 "PG_INDEXES_SIZE" => Ok(expr_node::Type::PgIndexesSize),
1787 "PG_RELATION_SIZE" => Ok(expr_node::Type::PgRelationSize),
1788 "PG_GET_SERIAL_SEQUENCE" => Ok(expr_node::Type::PgGetSerialSequence),
1789 "PG_INDEX_COLUMN_HAS_PROPERTY" => Ok(expr_node::Type::PgIndexColumnHasProperty),
1790 "HAS_TABLE_PRIVILEGE" => Ok(expr_node::Type::HasTablePrivilege),
1791 "HAS_ANY_COLUMN_PRIVILEGE" => Ok(expr_node::Type::HasAnyColumnPrivilege),
1792 "HAS_SCHEMA_PRIVILEGE" => Ok(expr_node::Type::HasSchemaPrivilege),
1793 "PG_IS_IN_RECOVERY" => Ok(expr_node::Type::PgIsInRecovery),
1794 "RW_RECOVERY_STATUS" => Ok(expr_node::Type::RwRecoveryStatus),
1795 "RW_EPOCH_TO_TS" => Ok(expr_node::Type::RwEpochToTs),
1796 "PG_TABLE_IS_VISIBLE" => Ok(expr_node::Type::PgTableIsVisible),
1797 "HAS_FUNCTION_PRIVILEGE" => Ok(expr_node::Type::HasFunctionPrivilege),
1798 "HAS_DATABASE_PRIVILEGE" => Ok(expr_node::Type::HasDatabasePrivilege),
1799 "RW_CLUSTER_ID" => Ok(expr_node::Type::RwClusterId),
1800 "RW_FRAGMENT_VNODES" => Ok(expr_node::Type::RwFragmentVnodes),
1801 "RW_ACTOR_VNODES" => Ok(expr_node::Type::RwActorVnodes),
1802 "ICEBERG_TRANSFORM" => Ok(expr_node::Type::IcebergTransform),
1803 "OPENAI_EMBEDDING" => Ok(expr_node::Type::OpenaiEmbedding),
1804 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1805 }
1806 }
1807 }
1808 deserializer.deserialize_any(GeneratedVisitor)
1809 }
1810}
1811impl serde::Serialize for FunctionCall {
1812 #[allow(deprecated)]
1813 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1814 where
1815 S: serde::Serializer,
1816 {
1817 use serde::ser::SerializeStruct;
1818 let mut len = 0;
1819 if !self.children.is_empty() {
1820 len += 1;
1821 }
1822 let mut struct_ser = serializer.serialize_struct("expr.FunctionCall", len)?;
1823 if !self.children.is_empty() {
1824 struct_ser.serialize_field("children", &self.children)?;
1825 }
1826 struct_ser.end()
1827 }
1828}
1829impl<'de> serde::Deserialize<'de> for FunctionCall {
1830 #[allow(deprecated)]
1831 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1832 where
1833 D: serde::Deserializer<'de>,
1834 {
1835 const FIELDS: &[&str] = &[
1836 "children",
1837 ];
1838
1839 #[allow(clippy::enum_variant_names)]
1840 enum GeneratedField {
1841 Children,
1842 }
1843 impl<'de> serde::Deserialize<'de> for GeneratedField {
1844 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1845 where
1846 D: serde::Deserializer<'de>,
1847 {
1848 struct GeneratedVisitor;
1849
1850 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1851 type Value = GeneratedField;
1852
1853 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1854 write!(formatter, "expected one of: {:?}", &FIELDS)
1855 }
1856
1857 #[allow(unused_variables)]
1858 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1859 where
1860 E: serde::de::Error,
1861 {
1862 match value {
1863 "children" => Ok(GeneratedField::Children),
1864 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1865 }
1866 }
1867 }
1868 deserializer.deserialize_identifier(GeneratedVisitor)
1869 }
1870 }
1871 struct GeneratedVisitor;
1872 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1873 type Value = FunctionCall;
1874
1875 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1876 formatter.write_str("struct expr.FunctionCall")
1877 }
1878
1879 fn visit_map<V>(self, mut map_: V) -> std::result::Result<FunctionCall, V::Error>
1880 where
1881 V: serde::de::MapAccess<'de>,
1882 {
1883 let mut children__ = None;
1884 while let Some(k) = map_.next_key()? {
1885 match k {
1886 GeneratedField::Children => {
1887 if children__.is_some() {
1888 return Err(serde::de::Error::duplicate_field("children"));
1889 }
1890 children__ = Some(map_.next_value()?);
1891 }
1892 }
1893 }
1894 Ok(FunctionCall {
1895 children: children__.unwrap_or_default(),
1896 })
1897 }
1898 }
1899 deserializer.deserialize_struct("expr.FunctionCall", FIELDS, GeneratedVisitor)
1900 }
1901}
1902impl serde::Serialize for InputRef {
1903 #[allow(deprecated)]
1904 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1905 where
1906 S: serde::Serializer,
1907 {
1908 use serde::ser::SerializeStruct;
1909 let mut len = 0;
1910 if self.index != 0 {
1911 len += 1;
1912 }
1913 if self.r#type.is_some() {
1914 len += 1;
1915 }
1916 let mut struct_ser = serializer.serialize_struct("expr.InputRef", len)?;
1917 if self.index != 0 {
1918 struct_ser.serialize_field("index", &self.index)?;
1919 }
1920 if let Some(v) = self.r#type.as_ref() {
1921 struct_ser.serialize_field("type", v)?;
1922 }
1923 struct_ser.end()
1924 }
1925}
1926impl<'de> serde::Deserialize<'de> for InputRef {
1927 #[allow(deprecated)]
1928 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1929 where
1930 D: serde::Deserializer<'de>,
1931 {
1932 const FIELDS: &[&str] = &[
1933 "index",
1934 "type",
1935 ];
1936
1937 #[allow(clippy::enum_variant_names)]
1938 enum GeneratedField {
1939 Index,
1940 Type,
1941 }
1942 impl<'de> serde::Deserialize<'de> for GeneratedField {
1943 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1944 where
1945 D: serde::Deserializer<'de>,
1946 {
1947 struct GeneratedVisitor;
1948
1949 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1950 type Value = GeneratedField;
1951
1952 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1953 write!(formatter, "expected one of: {:?}", &FIELDS)
1954 }
1955
1956 #[allow(unused_variables)]
1957 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1958 where
1959 E: serde::de::Error,
1960 {
1961 match value {
1962 "index" => Ok(GeneratedField::Index),
1963 "type" => Ok(GeneratedField::Type),
1964 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1965 }
1966 }
1967 }
1968 deserializer.deserialize_identifier(GeneratedVisitor)
1969 }
1970 }
1971 struct GeneratedVisitor;
1972 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1973 type Value = InputRef;
1974
1975 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1976 formatter.write_str("struct expr.InputRef")
1977 }
1978
1979 fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputRef, V::Error>
1980 where
1981 V: serde::de::MapAccess<'de>,
1982 {
1983 let mut index__ = None;
1984 let mut r#type__ = None;
1985 while let Some(k) = map_.next_key()? {
1986 match k {
1987 GeneratedField::Index => {
1988 if index__.is_some() {
1989 return Err(serde::de::Error::duplicate_field("index"));
1990 }
1991 index__ =
1992 Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1993 ;
1994 }
1995 GeneratedField::Type => {
1996 if r#type__.is_some() {
1997 return Err(serde::de::Error::duplicate_field("type"));
1998 }
1999 r#type__ = map_.next_value()?;
2000 }
2001 }
2002 }
2003 Ok(InputRef {
2004 index: index__.unwrap_or_default(),
2005 r#type: r#type__,
2006 })
2007 }
2008 }
2009 deserializer.deserialize_struct("expr.InputRef", FIELDS, GeneratedVisitor)
2010 }
2011}
2012impl serde::Serialize for ProjectSetSelectItem {
2013 #[allow(deprecated)]
2014 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2015 where
2016 S: serde::Serializer,
2017 {
2018 use serde::ser::SerializeStruct;
2019 let mut len = 0;
2020 if self.select_item.is_some() {
2021 len += 1;
2022 }
2023 let mut struct_ser = serializer.serialize_struct("expr.ProjectSetSelectItem", len)?;
2024 if let Some(v) = self.select_item.as_ref() {
2025 match v {
2026 project_set_select_item::SelectItem::Expr(v) => {
2027 struct_ser.serialize_field("expr", v)?;
2028 }
2029 project_set_select_item::SelectItem::TableFunction(v) => {
2030 struct_ser.serialize_field("tableFunction", v)?;
2031 }
2032 }
2033 }
2034 struct_ser.end()
2035 }
2036}
2037impl<'de> serde::Deserialize<'de> for ProjectSetSelectItem {
2038 #[allow(deprecated)]
2039 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2040 where
2041 D: serde::Deserializer<'de>,
2042 {
2043 const FIELDS: &[&str] = &[
2044 "expr",
2045 "table_function",
2046 "tableFunction",
2047 ];
2048
2049 #[allow(clippy::enum_variant_names)]
2050 enum GeneratedField {
2051 Expr,
2052 TableFunction,
2053 }
2054 impl<'de> serde::Deserialize<'de> for GeneratedField {
2055 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2056 where
2057 D: serde::Deserializer<'de>,
2058 {
2059 struct GeneratedVisitor;
2060
2061 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2062 type Value = GeneratedField;
2063
2064 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2065 write!(formatter, "expected one of: {:?}", &FIELDS)
2066 }
2067
2068 #[allow(unused_variables)]
2069 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2070 where
2071 E: serde::de::Error,
2072 {
2073 match value {
2074 "expr" => Ok(GeneratedField::Expr),
2075 "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
2076 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2077 }
2078 }
2079 }
2080 deserializer.deserialize_identifier(GeneratedVisitor)
2081 }
2082 }
2083 struct GeneratedVisitor;
2084 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2085 type Value = ProjectSetSelectItem;
2086
2087 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2088 formatter.write_str("struct expr.ProjectSetSelectItem")
2089 }
2090
2091 fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetSelectItem, V::Error>
2092 where
2093 V: serde::de::MapAccess<'de>,
2094 {
2095 let mut select_item__ = None;
2096 while let Some(k) = map_.next_key()? {
2097 match k {
2098 GeneratedField::Expr => {
2099 if select_item__.is_some() {
2100 return Err(serde::de::Error::duplicate_field("expr"));
2101 }
2102 select_item__ = map_.next_value::<::std::option::Option<_>>()?.map(project_set_select_item::SelectItem::Expr)
2103;
2104 }
2105 GeneratedField::TableFunction => {
2106 if select_item__.is_some() {
2107 return Err(serde::de::Error::duplicate_field("tableFunction"));
2108 }
2109 select_item__ = map_.next_value::<::std::option::Option<_>>()?.map(project_set_select_item::SelectItem::TableFunction)
2110;
2111 }
2112 }
2113 }
2114 Ok(ProjectSetSelectItem {
2115 select_item: select_item__,
2116 })
2117 }
2118 }
2119 deserializer.deserialize_struct("expr.ProjectSetSelectItem", FIELDS, GeneratedVisitor)
2120 }
2121}
2122impl serde::Serialize for TableFunction {
2123 #[allow(deprecated)]
2124 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2125 where
2126 S: serde::Serializer,
2127 {
2128 use serde::ser::SerializeStruct;
2129 let mut len = 0;
2130 if self.function_type != 0 {
2131 len += 1;
2132 }
2133 if !self.args.is_empty() {
2134 len += 1;
2135 }
2136 if self.return_type.is_some() {
2137 len += 1;
2138 }
2139 if self.udf.is_some() {
2140 len += 1;
2141 }
2142 let mut struct_ser = serializer.serialize_struct("expr.TableFunction", len)?;
2143 if self.function_type != 0 {
2144 let v = table_function::Type::try_from(self.function_type)
2145 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.function_type)))?;
2146 struct_ser.serialize_field("functionType", &v)?;
2147 }
2148 if !self.args.is_empty() {
2149 struct_ser.serialize_field("args", &self.args)?;
2150 }
2151 if let Some(v) = self.return_type.as_ref() {
2152 struct_ser.serialize_field("returnType", v)?;
2153 }
2154 if let Some(v) = self.udf.as_ref() {
2155 struct_ser.serialize_field("udf", v)?;
2156 }
2157 struct_ser.end()
2158 }
2159}
2160impl<'de> serde::Deserialize<'de> for TableFunction {
2161 #[allow(deprecated)]
2162 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2163 where
2164 D: serde::Deserializer<'de>,
2165 {
2166 const FIELDS: &[&str] = &[
2167 "function_type",
2168 "functionType",
2169 "args",
2170 "return_type",
2171 "returnType",
2172 "udf",
2173 ];
2174
2175 #[allow(clippy::enum_variant_names)]
2176 enum GeneratedField {
2177 FunctionType,
2178 Args,
2179 ReturnType,
2180 Udf,
2181 }
2182 impl<'de> serde::Deserialize<'de> for GeneratedField {
2183 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2184 where
2185 D: serde::Deserializer<'de>,
2186 {
2187 struct GeneratedVisitor;
2188
2189 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2190 type Value = GeneratedField;
2191
2192 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2193 write!(formatter, "expected one of: {:?}", &FIELDS)
2194 }
2195
2196 #[allow(unused_variables)]
2197 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2198 where
2199 E: serde::de::Error,
2200 {
2201 match value {
2202 "functionType" | "function_type" => Ok(GeneratedField::FunctionType),
2203 "args" => Ok(GeneratedField::Args),
2204 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
2205 "udf" => Ok(GeneratedField::Udf),
2206 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2207 }
2208 }
2209 }
2210 deserializer.deserialize_identifier(GeneratedVisitor)
2211 }
2212 }
2213 struct GeneratedVisitor;
2214 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2215 type Value = TableFunction;
2216
2217 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2218 formatter.write_str("struct expr.TableFunction")
2219 }
2220
2221 fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunction, V::Error>
2222 where
2223 V: serde::de::MapAccess<'de>,
2224 {
2225 let mut function_type__ = None;
2226 let mut args__ = None;
2227 let mut return_type__ = None;
2228 let mut udf__ = None;
2229 while let Some(k) = map_.next_key()? {
2230 match k {
2231 GeneratedField::FunctionType => {
2232 if function_type__.is_some() {
2233 return Err(serde::de::Error::duplicate_field("functionType"));
2234 }
2235 function_type__ = Some(map_.next_value::<table_function::Type>()? as i32);
2236 }
2237 GeneratedField::Args => {
2238 if args__.is_some() {
2239 return Err(serde::de::Error::duplicate_field("args"));
2240 }
2241 args__ = Some(map_.next_value()?);
2242 }
2243 GeneratedField::ReturnType => {
2244 if return_type__.is_some() {
2245 return Err(serde::de::Error::duplicate_field("returnType"));
2246 }
2247 return_type__ = map_.next_value()?;
2248 }
2249 GeneratedField::Udf => {
2250 if udf__.is_some() {
2251 return Err(serde::de::Error::duplicate_field("udf"));
2252 }
2253 udf__ = map_.next_value()?;
2254 }
2255 }
2256 }
2257 Ok(TableFunction {
2258 function_type: function_type__.unwrap_or_default(),
2259 args: args__.unwrap_or_default(),
2260 return_type: return_type__,
2261 udf: udf__,
2262 })
2263 }
2264 }
2265 deserializer.deserialize_struct("expr.TableFunction", FIELDS, GeneratedVisitor)
2266 }
2267}
2268impl serde::Serialize for table_function::Type {
2269 #[allow(deprecated)]
2270 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2271 where
2272 S: serde::Serializer,
2273 {
2274 let variant = match self {
2275 Self::Unspecified => "UNSPECIFIED",
2276 Self::GenerateSeries => "GENERATE_SERIES",
2277 Self::Unnest => "UNNEST",
2278 Self::RegexpMatches => "REGEXP_MATCHES",
2279 Self::Range => "RANGE",
2280 Self::GenerateSubscripts => "GENERATE_SUBSCRIPTS",
2281 Self::PgExpandarray => "_PG_EXPANDARRAY",
2282 Self::PgGetKeywords => "PG_GET_KEYWORDS",
2283 Self::JsonbArrayElements => "JSONB_ARRAY_ELEMENTS",
2284 Self::JsonbArrayElementsText => "JSONB_ARRAY_ELEMENTS_TEXT",
2285 Self::JsonbEach => "JSONB_EACH",
2286 Self::JsonbEachText => "JSONB_EACH_TEXT",
2287 Self::JsonbObjectKeys => "JSONB_OBJECT_KEYS",
2288 Self::JsonbPathQuery => "JSONB_PATH_QUERY",
2289 Self::JsonbPopulateRecordset => "JSONB_POPULATE_RECORDSET",
2290 Self::JsonbToRecordset => "JSONB_TO_RECORDSET",
2291 Self::FileScan => "FILE_SCAN",
2292 Self::PostgresQuery => "POSTGRES_QUERY",
2293 Self::MysqlQuery => "MYSQL_QUERY",
2294 Self::InternalBackfillProgress => "INTERNAL_BACKFILL_PROGRESS",
2295 Self::InternalSourceBackfillProgress => "INTERNAL_SOURCE_BACKFILL_PROGRESS",
2296 Self::InternalGetChannelDeltaStats => "INTERNAL_GET_CHANNEL_DELTA_STATS",
2297 Self::UserDefined => "USER_DEFINED",
2298 };
2299 serializer.serialize_str(variant)
2300 }
2301}
2302impl<'de> serde::Deserialize<'de> for table_function::Type {
2303 #[allow(deprecated)]
2304 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2305 where
2306 D: serde::Deserializer<'de>,
2307 {
2308 const FIELDS: &[&str] = &[
2309 "UNSPECIFIED",
2310 "GENERATE_SERIES",
2311 "UNNEST",
2312 "REGEXP_MATCHES",
2313 "RANGE",
2314 "GENERATE_SUBSCRIPTS",
2315 "_PG_EXPANDARRAY",
2316 "PG_GET_KEYWORDS",
2317 "JSONB_ARRAY_ELEMENTS",
2318 "JSONB_ARRAY_ELEMENTS_TEXT",
2319 "JSONB_EACH",
2320 "JSONB_EACH_TEXT",
2321 "JSONB_OBJECT_KEYS",
2322 "JSONB_PATH_QUERY",
2323 "JSONB_POPULATE_RECORDSET",
2324 "JSONB_TO_RECORDSET",
2325 "FILE_SCAN",
2326 "POSTGRES_QUERY",
2327 "MYSQL_QUERY",
2328 "INTERNAL_BACKFILL_PROGRESS",
2329 "INTERNAL_SOURCE_BACKFILL_PROGRESS",
2330 "INTERNAL_GET_CHANNEL_DELTA_STATS",
2331 "USER_DEFINED",
2332 ];
2333
2334 struct GeneratedVisitor;
2335
2336 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2337 type Value = table_function::Type;
2338
2339 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2340 write!(formatter, "expected one of: {:?}", &FIELDS)
2341 }
2342
2343 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2344 where
2345 E: serde::de::Error,
2346 {
2347 i32::try_from(v)
2348 .ok()
2349 .and_then(|x| x.try_into().ok())
2350 .ok_or_else(|| {
2351 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2352 })
2353 }
2354
2355 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2356 where
2357 E: serde::de::Error,
2358 {
2359 i32::try_from(v)
2360 .ok()
2361 .and_then(|x| x.try_into().ok())
2362 .ok_or_else(|| {
2363 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2364 })
2365 }
2366
2367 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2368 where
2369 E: serde::de::Error,
2370 {
2371 match value {
2372 "UNSPECIFIED" => Ok(table_function::Type::Unspecified),
2373 "GENERATE_SERIES" => Ok(table_function::Type::GenerateSeries),
2374 "UNNEST" => Ok(table_function::Type::Unnest),
2375 "REGEXP_MATCHES" => Ok(table_function::Type::RegexpMatches),
2376 "RANGE" => Ok(table_function::Type::Range),
2377 "GENERATE_SUBSCRIPTS" => Ok(table_function::Type::GenerateSubscripts),
2378 "_PG_EXPANDARRAY" => Ok(table_function::Type::PgExpandarray),
2379 "PG_GET_KEYWORDS" => Ok(table_function::Type::PgGetKeywords),
2380 "JSONB_ARRAY_ELEMENTS" => Ok(table_function::Type::JsonbArrayElements),
2381 "JSONB_ARRAY_ELEMENTS_TEXT" => Ok(table_function::Type::JsonbArrayElementsText),
2382 "JSONB_EACH" => Ok(table_function::Type::JsonbEach),
2383 "JSONB_EACH_TEXT" => Ok(table_function::Type::JsonbEachText),
2384 "JSONB_OBJECT_KEYS" => Ok(table_function::Type::JsonbObjectKeys),
2385 "JSONB_PATH_QUERY" => Ok(table_function::Type::JsonbPathQuery),
2386 "JSONB_POPULATE_RECORDSET" => Ok(table_function::Type::JsonbPopulateRecordset),
2387 "JSONB_TO_RECORDSET" => Ok(table_function::Type::JsonbToRecordset),
2388 "FILE_SCAN" => Ok(table_function::Type::FileScan),
2389 "POSTGRES_QUERY" => Ok(table_function::Type::PostgresQuery),
2390 "MYSQL_QUERY" => Ok(table_function::Type::MysqlQuery),
2391 "INTERNAL_BACKFILL_PROGRESS" => Ok(table_function::Type::InternalBackfillProgress),
2392 "INTERNAL_SOURCE_BACKFILL_PROGRESS" => Ok(table_function::Type::InternalSourceBackfillProgress),
2393 "INTERNAL_GET_CHANNEL_DELTA_STATS" => Ok(table_function::Type::InternalGetChannelDeltaStats),
2394 "USER_DEFINED" => Ok(table_function::Type::UserDefined),
2395 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2396 }
2397 }
2398 }
2399 deserializer.deserialize_any(GeneratedVisitor)
2400 }
2401}
2402impl serde::Serialize for UdfExprVersion {
2403 #[allow(deprecated)]
2404 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2405 where
2406 S: serde::Serializer,
2407 {
2408 let variant = match self {
2409 Self::Unspecified => "UDF_EXPR_VERSION_UNSPECIFIED",
2410 Self::NameInRuntime => "UDF_EXPR_VERSION_NAME_IN_RUNTIME",
2411 };
2412 serializer.serialize_str(variant)
2413 }
2414}
2415impl<'de> serde::Deserialize<'de> for UdfExprVersion {
2416 #[allow(deprecated)]
2417 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2418 where
2419 D: serde::Deserializer<'de>,
2420 {
2421 const FIELDS: &[&str] = &[
2422 "UDF_EXPR_VERSION_UNSPECIFIED",
2423 "UDF_EXPR_VERSION_NAME_IN_RUNTIME",
2424 ];
2425
2426 struct GeneratedVisitor;
2427
2428 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2429 type Value = UdfExprVersion;
2430
2431 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2432 write!(formatter, "expected one of: {:?}", &FIELDS)
2433 }
2434
2435 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2436 where
2437 E: serde::de::Error,
2438 {
2439 i32::try_from(v)
2440 .ok()
2441 .and_then(|x| x.try_into().ok())
2442 .ok_or_else(|| {
2443 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2444 })
2445 }
2446
2447 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2448 where
2449 E: serde::de::Error,
2450 {
2451 i32::try_from(v)
2452 .ok()
2453 .and_then(|x| x.try_into().ok())
2454 .ok_or_else(|| {
2455 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2456 })
2457 }
2458
2459 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2460 where
2461 E: serde::de::Error,
2462 {
2463 match value {
2464 "UDF_EXPR_VERSION_UNSPECIFIED" => Ok(UdfExprVersion::Unspecified),
2465 "UDF_EXPR_VERSION_NAME_IN_RUNTIME" => Ok(UdfExprVersion::NameInRuntime),
2466 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2467 }
2468 }
2469 }
2470 deserializer.deserialize_any(GeneratedVisitor)
2471 }
2472}
2473impl serde::Serialize for UserDefinedFunction {
2474 #[allow(deprecated)]
2475 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2476 where
2477 S: serde::Serializer,
2478 {
2479 use serde::ser::SerializeStruct;
2480 let mut len = 0;
2481 if !self.children.is_empty() {
2482 len += 1;
2483 }
2484 if !self.name.is_empty() {
2485 len += 1;
2486 }
2487 if !self.arg_names.is_empty() {
2488 len += 1;
2489 }
2490 if !self.arg_types.is_empty() {
2491 len += 1;
2492 }
2493 if !self.language.is_empty() {
2494 len += 1;
2495 }
2496 if self.link.is_some() {
2497 len += 1;
2498 }
2499 if self.identifier.is_some() {
2500 len += 1;
2501 }
2502 if self.body.is_some() {
2503 len += 1;
2504 }
2505 if self.compressed_binary.is_some() {
2506 len += 1;
2507 }
2508 if self.always_retry_on_network_error {
2509 len += 1;
2510 }
2511 if self.runtime.is_some() {
2512 len += 1;
2513 }
2514 if self.is_async.is_some() {
2515 len += 1;
2516 }
2517 if self.is_batched.is_some() {
2518 len += 1;
2519 }
2520 if self.version != 0 {
2521 len += 1;
2522 }
2523 let mut struct_ser = serializer.serialize_struct("expr.UserDefinedFunction", len)?;
2524 if !self.children.is_empty() {
2525 struct_ser.serialize_field("children", &self.children)?;
2526 }
2527 if !self.name.is_empty() {
2528 struct_ser.serialize_field("name", &self.name)?;
2529 }
2530 if !self.arg_names.is_empty() {
2531 struct_ser.serialize_field("argNames", &self.arg_names)?;
2532 }
2533 if !self.arg_types.is_empty() {
2534 struct_ser.serialize_field("argTypes", &self.arg_types)?;
2535 }
2536 if !self.language.is_empty() {
2537 struct_ser.serialize_field("language", &self.language)?;
2538 }
2539 if let Some(v) = self.link.as_ref() {
2540 struct_ser.serialize_field("link", v)?;
2541 }
2542 if let Some(v) = self.identifier.as_ref() {
2543 struct_ser.serialize_field("identifier", v)?;
2544 }
2545 if let Some(v) = self.body.as_ref() {
2546 struct_ser.serialize_field("body", v)?;
2547 }
2548 if let Some(v) = self.compressed_binary.as_ref() {
2549 #[allow(clippy::needless_borrow)]
2550 #[allow(clippy::needless_borrows_for_generic_args)]
2551 struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
2552 }
2553 if self.always_retry_on_network_error {
2554 struct_ser.serialize_field("alwaysRetryOnNetworkError", &self.always_retry_on_network_error)?;
2555 }
2556 if let Some(v) = self.runtime.as_ref() {
2557 struct_ser.serialize_field("runtime", v)?;
2558 }
2559 if let Some(v) = self.is_async.as_ref() {
2560 struct_ser.serialize_field("isAsync", v)?;
2561 }
2562 if let Some(v) = self.is_batched.as_ref() {
2563 struct_ser.serialize_field("isBatched", v)?;
2564 }
2565 if self.version != 0 {
2566 let v = UdfExprVersion::try_from(self.version)
2567 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
2568 struct_ser.serialize_field("version", &v)?;
2569 }
2570 struct_ser.end()
2571 }
2572}
2573impl<'de> serde::Deserialize<'de> for UserDefinedFunction {
2574 #[allow(deprecated)]
2575 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2576 where
2577 D: serde::Deserializer<'de>,
2578 {
2579 const FIELDS: &[&str] = &[
2580 "children",
2581 "name",
2582 "arg_names",
2583 "argNames",
2584 "arg_types",
2585 "argTypes",
2586 "language",
2587 "link",
2588 "identifier",
2589 "body",
2590 "compressed_binary",
2591 "compressedBinary",
2592 "always_retry_on_network_error",
2593 "alwaysRetryOnNetworkError",
2594 "runtime",
2595 "is_async",
2596 "isAsync",
2597 "is_batched",
2598 "isBatched",
2599 "version",
2600 ];
2601
2602 #[allow(clippy::enum_variant_names)]
2603 enum GeneratedField {
2604 Children,
2605 Name,
2606 ArgNames,
2607 ArgTypes,
2608 Language,
2609 Link,
2610 Identifier,
2611 Body,
2612 CompressedBinary,
2613 AlwaysRetryOnNetworkError,
2614 Runtime,
2615 IsAsync,
2616 IsBatched,
2617 Version,
2618 }
2619 impl<'de> serde::Deserialize<'de> for GeneratedField {
2620 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2621 where
2622 D: serde::Deserializer<'de>,
2623 {
2624 struct GeneratedVisitor;
2625
2626 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2627 type Value = GeneratedField;
2628
2629 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2630 write!(formatter, "expected one of: {:?}", &FIELDS)
2631 }
2632
2633 #[allow(unused_variables)]
2634 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2635 where
2636 E: serde::de::Error,
2637 {
2638 match value {
2639 "children" => Ok(GeneratedField::Children),
2640 "name" => Ok(GeneratedField::Name),
2641 "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
2642 "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
2643 "language" => Ok(GeneratedField::Language),
2644 "link" => Ok(GeneratedField::Link),
2645 "identifier" => Ok(GeneratedField::Identifier),
2646 "body" => Ok(GeneratedField::Body),
2647 "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
2648 "alwaysRetryOnNetworkError" | "always_retry_on_network_error" => Ok(GeneratedField::AlwaysRetryOnNetworkError),
2649 "runtime" => Ok(GeneratedField::Runtime),
2650 "isAsync" | "is_async" => Ok(GeneratedField::IsAsync),
2651 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
2652 "version" => Ok(GeneratedField::Version),
2653 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2654 }
2655 }
2656 }
2657 deserializer.deserialize_identifier(GeneratedVisitor)
2658 }
2659 }
2660 struct GeneratedVisitor;
2661 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2662 type Value = UserDefinedFunction;
2663
2664 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2665 formatter.write_str("struct expr.UserDefinedFunction")
2666 }
2667
2668 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserDefinedFunction, V::Error>
2669 where
2670 V: serde::de::MapAccess<'de>,
2671 {
2672 let mut children__ = None;
2673 let mut name__ = None;
2674 let mut arg_names__ = None;
2675 let mut arg_types__ = None;
2676 let mut language__ = None;
2677 let mut link__ = None;
2678 let mut identifier__ = None;
2679 let mut body__ = None;
2680 let mut compressed_binary__ = None;
2681 let mut always_retry_on_network_error__ = None;
2682 let mut runtime__ = None;
2683 let mut is_async__ = None;
2684 let mut is_batched__ = None;
2685 let mut version__ = None;
2686 while let Some(k) = map_.next_key()? {
2687 match k {
2688 GeneratedField::Children => {
2689 if children__.is_some() {
2690 return Err(serde::de::Error::duplicate_field("children"));
2691 }
2692 children__ = Some(map_.next_value()?);
2693 }
2694 GeneratedField::Name => {
2695 if name__.is_some() {
2696 return Err(serde::de::Error::duplicate_field("name"));
2697 }
2698 name__ = Some(map_.next_value()?);
2699 }
2700 GeneratedField::ArgNames => {
2701 if arg_names__.is_some() {
2702 return Err(serde::de::Error::duplicate_field("argNames"));
2703 }
2704 arg_names__ = Some(map_.next_value()?);
2705 }
2706 GeneratedField::ArgTypes => {
2707 if arg_types__.is_some() {
2708 return Err(serde::de::Error::duplicate_field("argTypes"));
2709 }
2710 arg_types__ = Some(map_.next_value()?);
2711 }
2712 GeneratedField::Language => {
2713 if language__.is_some() {
2714 return Err(serde::de::Error::duplicate_field("language"));
2715 }
2716 language__ = Some(map_.next_value()?);
2717 }
2718 GeneratedField::Link => {
2719 if link__.is_some() {
2720 return Err(serde::de::Error::duplicate_field("link"));
2721 }
2722 link__ = map_.next_value()?;
2723 }
2724 GeneratedField::Identifier => {
2725 if identifier__.is_some() {
2726 return Err(serde::de::Error::duplicate_field("identifier"));
2727 }
2728 identifier__ = map_.next_value()?;
2729 }
2730 GeneratedField::Body => {
2731 if body__.is_some() {
2732 return Err(serde::de::Error::duplicate_field("body"));
2733 }
2734 body__ = map_.next_value()?;
2735 }
2736 GeneratedField::CompressedBinary => {
2737 if compressed_binary__.is_some() {
2738 return Err(serde::de::Error::duplicate_field("compressedBinary"));
2739 }
2740 compressed_binary__ =
2741 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
2742 ;
2743 }
2744 GeneratedField::AlwaysRetryOnNetworkError => {
2745 if always_retry_on_network_error__.is_some() {
2746 return Err(serde::de::Error::duplicate_field("alwaysRetryOnNetworkError"));
2747 }
2748 always_retry_on_network_error__ = Some(map_.next_value()?);
2749 }
2750 GeneratedField::Runtime => {
2751 if runtime__.is_some() {
2752 return Err(serde::de::Error::duplicate_field("runtime"));
2753 }
2754 runtime__ = map_.next_value()?;
2755 }
2756 GeneratedField::IsAsync => {
2757 if is_async__.is_some() {
2758 return Err(serde::de::Error::duplicate_field("isAsync"));
2759 }
2760 is_async__ = map_.next_value()?;
2761 }
2762 GeneratedField::IsBatched => {
2763 if is_batched__.is_some() {
2764 return Err(serde::de::Error::duplicate_field("isBatched"));
2765 }
2766 is_batched__ = map_.next_value()?;
2767 }
2768 GeneratedField::Version => {
2769 if version__.is_some() {
2770 return Err(serde::de::Error::duplicate_field("version"));
2771 }
2772 version__ = Some(map_.next_value::<UdfExprVersion>()? as i32);
2773 }
2774 }
2775 }
2776 Ok(UserDefinedFunction {
2777 children: children__.unwrap_or_default(),
2778 name: name__.unwrap_or_default(),
2779 arg_names: arg_names__.unwrap_or_default(),
2780 arg_types: arg_types__.unwrap_or_default(),
2781 language: language__.unwrap_or_default(),
2782 link: link__,
2783 identifier: identifier__,
2784 body: body__,
2785 compressed_binary: compressed_binary__,
2786 always_retry_on_network_error: always_retry_on_network_error__.unwrap_or_default(),
2787 runtime: runtime__,
2788 is_async: is_async__,
2789 is_batched: is_batched__,
2790 version: version__.unwrap_or_default(),
2791 })
2792 }
2793 }
2794 deserializer.deserialize_struct("expr.UserDefinedFunction", FIELDS, GeneratedVisitor)
2795 }
2796}
2797impl serde::Serialize for UserDefinedFunctionMetadata {
2798 #[allow(deprecated)]
2799 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2800 where
2801 S: serde::Serializer,
2802 {
2803 use serde::ser::SerializeStruct;
2804 let mut len = 0;
2805 if !self.arg_names.is_empty() {
2806 len += 1;
2807 }
2808 if !self.arg_types.is_empty() {
2809 len += 1;
2810 }
2811 if self.return_type.is_some() {
2812 len += 1;
2813 }
2814 if !self.language.is_empty() {
2815 len += 1;
2816 }
2817 if self.link.is_some() {
2818 len += 1;
2819 }
2820 if self.identifier.is_some() {
2821 len += 1;
2822 }
2823 if self.body.is_some() {
2824 len += 1;
2825 }
2826 if self.compressed_binary.is_some() {
2827 len += 1;
2828 }
2829 if self.runtime.is_some() {
2830 len += 1;
2831 }
2832 if self.version != 0 {
2833 len += 1;
2834 }
2835 let mut struct_ser = serializer.serialize_struct("expr.UserDefinedFunctionMetadata", len)?;
2836 if !self.arg_names.is_empty() {
2837 struct_ser.serialize_field("argNames", &self.arg_names)?;
2838 }
2839 if !self.arg_types.is_empty() {
2840 struct_ser.serialize_field("argTypes", &self.arg_types)?;
2841 }
2842 if let Some(v) = self.return_type.as_ref() {
2843 struct_ser.serialize_field("returnType", v)?;
2844 }
2845 if !self.language.is_empty() {
2846 struct_ser.serialize_field("language", &self.language)?;
2847 }
2848 if let Some(v) = self.link.as_ref() {
2849 struct_ser.serialize_field("link", v)?;
2850 }
2851 if let Some(v) = self.identifier.as_ref() {
2852 struct_ser.serialize_field("identifier", v)?;
2853 }
2854 if let Some(v) = self.body.as_ref() {
2855 struct_ser.serialize_field("body", v)?;
2856 }
2857 if let Some(v) = self.compressed_binary.as_ref() {
2858 #[allow(clippy::needless_borrow)]
2859 #[allow(clippy::needless_borrows_for_generic_args)]
2860 struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
2861 }
2862 if let Some(v) = self.runtime.as_ref() {
2863 struct_ser.serialize_field("runtime", v)?;
2864 }
2865 if self.version != 0 {
2866 let v = UdfExprVersion::try_from(self.version)
2867 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
2868 struct_ser.serialize_field("version", &v)?;
2869 }
2870 struct_ser.end()
2871 }
2872}
2873impl<'de> serde::Deserialize<'de> for UserDefinedFunctionMetadata {
2874 #[allow(deprecated)]
2875 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2876 where
2877 D: serde::Deserializer<'de>,
2878 {
2879 const FIELDS: &[&str] = &[
2880 "arg_names",
2881 "argNames",
2882 "arg_types",
2883 "argTypes",
2884 "return_type",
2885 "returnType",
2886 "language",
2887 "link",
2888 "identifier",
2889 "body",
2890 "compressed_binary",
2891 "compressedBinary",
2892 "runtime",
2893 "version",
2894 ];
2895
2896 #[allow(clippy::enum_variant_names)]
2897 enum GeneratedField {
2898 ArgNames,
2899 ArgTypes,
2900 ReturnType,
2901 Language,
2902 Link,
2903 Identifier,
2904 Body,
2905 CompressedBinary,
2906 Runtime,
2907 Version,
2908 }
2909 impl<'de> serde::Deserialize<'de> for GeneratedField {
2910 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2911 where
2912 D: serde::Deserializer<'de>,
2913 {
2914 struct GeneratedVisitor;
2915
2916 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2917 type Value = GeneratedField;
2918
2919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2920 write!(formatter, "expected one of: {:?}", &FIELDS)
2921 }
2922
2923 #[allow(unused_variables)]
2924 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2925 where
2926 E: serde::de::Error,
2927 {
2928 match value {
2929 "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
2930 "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
2931 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
2932 "language" => Ok(GeneratedField::Language),
2933 "link" => Ok(GeneratedField::Link),
2934 "identifier" => Ok(GeneratedField::Identifier),
2935 "body" => Ok(GeneratedField::Body),
2936 "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
2937 "runtime" => Ok(GeneratedField::Runtime),
2938 "version" => Ok(GeneratedField::Version),
2939 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2940 }
2941 }
2942 }
2943 deserializer.deserialize_identifier(GeneratedVisitor)
2944 }
2945 }
2946 struct GeneratedVisitor;
2947 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2948 type Value = UserDefinedFunctionMetadata;
2949
2950 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2951 formatter.write_str("struct expr.UserDefinedFunctionMetadata")
2952 }
2953
2954 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserDefinedFunctionMetadata, V::Error>
2955 where
2956 V: serde::de::MapAccess<'de>,
2957 {
2958 let mut arg_names__ = None;
2959 let mut arg_types__ = None;
2960 let mut return_type__ = None;
2961 let mut language__ = None;
2962 let mut link__ = None;
2963 let mut identifier__ = None;
2964 let mut body__ = None;
2965 let mut compressed_binary__ = None;
2966 let mut runtime__ = None;
2967 let mut version__ = None;
2968 while let Some(k) = map_.next_key()? {
2969 match k {
2970 GeneratedField::ArgNames => {
2971 if arg_names__.is_some() {
2972 return Err(serde::de::Error::duplicate_field("argNames"));
2973 }
2974 arg_names__ = Some(map_.next_value()?);
2975 }
2976 GeneratedField::ArgTypes => {
2977 if arg_types__.is_some() {
2978 return Err(serde::de::Error::duplicate_field("argTypes"));
2979 }
2980 arg_types__ = Some(map_.next_value()?);
2981 }
2982 GeneratedField::ReturnType => {
2983 if return_type__.is_some() {
2984 return Err(serde::de::Error::duplicate_field("returnType"));
2985 }
2986 return_type__ = map_.next_value()?;
2987 }
2988 GeneratedField::Language => {
2989 if language__.is_some() {
2990 return Err(serde::de::Error::duplicate_field("language"));
2991 }
2992 language__ = Some(map_.next_value()?);
2993 }
2994 GeneratedField::Link => {
2995 if link__.is_some() {
2996 return Err(serde::de::Error::duplicate_field("link"));
2997 }
2998 link__ = map_.next_value()?;
2999 }
3000 GeneratedField::Identifier => {
3001 if identifier__.is_some() {
3002 return Err(serde::de::Error::duplicate_field("identifier"));
3003 }
3004 identifier__ = map_.next_value()?;
3005 }
3006 GeneratedField::Body => {
3007 if body__.is_some() {
3008 return Err(serde::de::Error::duplicate_field("body"));
3009 }
3010 body__ = map_.next_value()?;
3011 }
3012 GeneratedField::CompressedBinary => {
3013 if compressed_binary__.is_some() {
3014 return Err(serde::de::Error::duplicate_field("compressedBinary"));
3015 }
3016 compressed_binary__ =
3017 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
3018 ;
3019 }
3020 GeneratedField::Runtime => {
3021 if runtime__.is_some() {
3022 return Err(serde::de::Error::duplicate_field("runtime"));
3023 }
3024 runtime__ = map_.next_value()?;
3025 }
3026 GeneratedField::Version => {
3027 if version__.is_some() {
3028 return Err(serde::de::Error::duplicate_field("version"));
3029 }
3030 version__ = Some(map_.next_value::<UdfExprVersion>()? as i32);
3031 }
3032 }
3033 }
3034 Ok(UserDefinedFunctionMetadata {
3035 arg_names: arg_names__.unwrap_or_default(),
3036 arg_types: arg_types__.unwrap_or_default(),
3037 return_type: return_type__,
3038 language: language__.unwrap_or_default(),
3039 link: link__,
3040 identifier: identifier__,
3041 body: body__,
3042 compressed_binary: compressed_binary__,
3043 runtime: runtime__,
3044 version: version__.unwrap_or_default(),
3045 })
3046 }
3047 }
3048 deserializer.deserialize_struct("expr.UserDefinedFunctionMetadata", FIELDS, GeneratedVisitor)
3049 }
3050}
3051impl serde::Serialize for WindowFrame {
3052 #[allow(deprecated)]
3053 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3054 where
3055 S: serde::Serializer,
3056 {
3057 use serde::ser::SerializeStruct;
3058 let mut len = 0;
3059 if self.r#type != 0 {
3060 len += 1;
3061 }
3062 if self.start.is_some() {
3063 len += 1;
3064 }
3065 if self.end.is_some() {
3066 len += 1;
3067 }
3068 if self.exclusion != 0 {
3069 len += 1;
3070 }
3071 if self.bounds.is_some() {
3072 len += 1;
3073 }
3074 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame", len)?;
3075 if self.r#type != 0 {
3076 let v = window_frame::Type::try_from(self.r#type)
3077 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3078 struct_ser.serialize_field("type", &v)?;
3079 }
3080 if let Some(v) = self.start.as_ref() {
3081 struct_ser.serialize_field("start", v)?;
3082 }
3083 if let Some(v) = self.end.as_ref() {
3084 struct_ser.serialize_field("end", v)?;
3085 }
3086 if self.exclusion != 0 {
3087 let v = window_frame::Exclusion::try_from(self.exclusion)
3088 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.exclusion)))?;
3089 struct_ser.serialize_field("exclusion", &v)?;
3090 }
3091 if let Some(v) = self.bounds.as_ref() {
3092 match v {
3093 window_frame::Bounds::Rows(v) => {
3094 struct_ser.serialize_field("rows", v)?;
3095 }
3096 window_frame::Bounds::Range(v) => {
3097 struct_ser.serialize_field("range", v)?;
3098 }
3099 window_frame::Bounds::Session(v) => {
3100 struct_ser.serialize_field("session", v)?;
3101 }
3102 }
3103 }
3104 struct_ser.end()
3105 }
3106}
3107impl<'de> serde::Deserialize<'de> for WindowFrame {
3108 #[allow(deprecated)]
3109 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3110 where
3111 D: serde::Deserializer<'de>,
3112 {
3113 const FIELDS: &[&str] = &[
3114 "type",
3115 "start",
3116 "end",
3117 "exclusion",
3118 "rows",
3119 "range",
3120 "session",
3121 ];
3122
3123 #[allow(clippy::enum_variant_names)]
3124 enum GeneratedField {
3125 Type,
3126 Start,
3127 End,
3128 Exclusion,
3129 Rows,
3130 Range,
3131 Session,
3132 }
3133 impl<'de> serde::Deserialize<'de> for GeneratedField {
3134 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3135 where
3136 D: serde::Deserializer<'de>,
3137 {
3138 struct GeneratedVisitor;
3139
3140 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3141 type Value = GeneratedField;
3142
3143 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3144 write!(formatter, "expected one of: {:?}", &FIELDS)
3145 }
3146
3147 #[allow(unused_variables)]
3148 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3149 where
3150 E: serde::de::Error,
3151 {
3152 match value {
3153 "type" => Ok(GeneratedField::Type),
3154 "start" => Ok(GeneratedField::Start),
3155 "end" => Ok(GeneratedField::End),
3156 "exclusion" => Ok(GeneratedField::Exclusion),
3157 "rows" => Ok(GeneratedField::Rows),
3158 "range" => Ok(GeneratedField::Range),
3159 "session" => Ok(GeneratedField::Session),
3160 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3161 }
3162 }
3163 }
3164 deserializer.deserialize_identifier(GeneratedVisitor)
3165 }
3166 }
3167 struct GeneratedVisitor;
3168 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3169 type Value = WindowFrame;
3170
3171 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3172 formatter.write_str("struct expr.WindowFrame")
3173 }
3174
3175 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WindowFrame, V::Error>
3176 where
3177 V: serde::de::MapAccess<'de>,
3178 {
3179 let mut r#type__ = None;
3180 let mut start__ = None;
3181 let mut end__ = None;
3182 let mut exclusion__ = None;
3183 let mut bounds__ = None;
3184 while let Some(k) = map_.next_key()? {
3185 match k {
3186 GeneratedField::Type => {
3187 if r#type__.is_some() {
3188 return Err(serde::de::Error::duplicate_field("type"));
3189 }
3190 r#type__ = Some(map_.next_value::<window_frame::Type>()? as i32);
3191 }
3192 GeneratedField::Start => {
3193 if start__.is_some() {
3194 return Err(serde::de::Error::duplicate_field("start"));
3195 }
3196 start__ = map_.next_value()?;
3197 }
3198 GeneratedField::End => {
3199 if end__.is_some() {
3200 return Err(serde::de::Error::duplicate_field("end"));
3201 }
3202 end__ = map_.next_value()?;
3203 }
3204 GeneratedField::Exclusion => {
3205 if exclusion__.is_some() {
3206 return Err(serde::de::Error::duplicate_field("exclusion"));
3207 }
3208 exclusion__ = Some(map_.next_value::<window_frame::Exclusion>()? as i32);
3209 }
3210 GeneratedField::Rows => {
3211 if bounds__.is_some() {
3212 return Err(serde::de::Error::duplicate_field("rows"));
3213 }
3214 bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Rows)
3215;
3216 }
3217 GeneratedField::Range => {
3218 if bounds__.is_some() {
3219 return Err(serde::de::Error::duplicate_field("range"));
3220 }
3221 bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Range)
3222;
3223 }
3224 GeneratedField::Session => {
3225 if bounds__.is_some() {
3226 return Err(serde::de::Error::duplicate_field("session"));
3227 }
3228 bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Session)
3229;
3230 }
3231 }
3232 }
3233 Ok(WindowFrame {
3234 r#type: r#type__.unwrap_or_default(),
3235 start: start__,
3236 end: end__,
3237 exclusion: exclusion__.unwrap_or_default(),
3238 bounds: bounds__,
3239 })
3240 }
3241 }
3242 deserializer.deserialize_struct("expr.WindowFrame", FIELDS, GeneratedVisitor)
3243 }
3244}
3245impl serde::Serialize for window_frame::Bound {
3246 #[allow(deprecated)]
3247 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3248 where
3249 S: serde::Serializer,
3250 {
3251 use serde::ser::SerializeStruct;
3252 let mut len = 0;
3253 if self.r#type != 0 {
3254 len += 1;
3255 }
3256 if self.offset.is_some() {
3257 len += 1;
3258 }
3259 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.Bound", len)?;
3260 if self.r#type != 0 {
3261 let v = window_frame::BoundType::try_from(self.r#type)
3262 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3263 struct_ser.serialize_field("type", &v)?;
3264 }
3265 if let Some(v) = self.offset.as_ref() {
3266 match v {
3267 window_frame::bound::Offset::Integer(v) => {
3268 #[allow(clippy::needless_borrow)]
3269 #[allow(clippy::needless_borrows_for_generic_args)]
3270 struct_ser.serialize_field("integer", ToString::to_string(&v).as_str())?;
3271 }
3272 window_frame::bound::Offset::Datum(v) => {
3273 struct_ser.serialize_field("datum", v)?;
3274 }
3275 }
3276 }
3277 struct_ser.end()
3278 }
3279}
3280impl<'de> serde::Deserialize<'de> for window_frame::Bound {
3281 #[allow(deprecated)]
3282 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3283 where
3284 D: serde::Deserializer<'de>,
3285 {
3286 const FIELDS: &[&str] = &[
3287 "type",
3288 "integer",
3289 "datum",
3290 ];
3291
3292 #[allow(clippy::enum_variant_names)]
3293 enum GeneratedField {
3294 Type,
3295 Integer,
3296 Datum,
3297 }
3298 impl<'de> serde::Deserialize<'de> for GeneratedField {
3299 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3300 where
3301 D: serde::Deserializer<'de>,
3302 {
3303 struct GeneratedVisitor;
3304
3305 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3306 type Value = GeneratedField;
3307
3308 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3309 write!(formatter, "expected one of: {:?}", &FIELDS)
3310 }
3311
3312 #[allow(unused_variables)]
3313 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3314 where
3315 E: serde::de::Error,
3316 {
3317 match value {
3318 "type" => Ok(GeneratedField::Type),
3319 "integer" => Ok(GeneratedField::Integer),
3320 "datum" => Ok(GeneratedField::Datum),
3321 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3322 }
3323 }
3324 }
3325 deserializer.deserialize_identifier(GeneratedVisitor)
3326 }
3327 }
3328 struct GeneratedVisitor;
3329 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3330 type Value = window_frame::Bound;
3331
3332 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3333 formatter.write_str("struct expr.WindowFrame.Bound")
3334 }
3335
3336 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::Bound, V::Error>
3337 where
3338 V: serde::de::MapAccess<'de>,
3339 {
3340 let mut r#type__ = None;
3341 let mut offset__ = None;
3342 while let Some(k) = map_.next_key()? {
3343 match k {
3344 GeneratedField::Type => {
3345 if r#type__.is_some() {
3346 return Err(serde::de::Error::duplicate_field("type"));
3347 }
3348 r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3349 }
3350 GeneratedField::Integer => {
3351 if offset__.is_some() {
3352 return Err(serde::de::Error::duplicate_field("integer"));
3353 }
3354 offset__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| window_frame::bound::Offset::Integer(x.0));
3355 }
3356 GeneratedField::Datum => {
3357 if offset__.is_some() {
3358 return Err(serde::de::Error::duplicate_field("datum"));
3359 }
3360 offset__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::bound::Offset::Datum)
3361;
3362 }
3363 }
3364 }
3365 Ok(window_frame::Bound {
3366 r#type: r#type__.unwrap_or_default(),
3367 offset: offset__,
3368 })
3369 }
3370 }
3371 deserializer.deserialize_struct("expr.WindowFrame.Bound", FIELDS, GeneratedVisitor)
3372 }
3373}
3374impl serde::Serialize for window_frame::BoundType {
3375 #[allow(deprecated)]
3376 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3377 where
3378 S: serde::Serializer,
3379 {
3380 let variant = match self {
3381 Self::Unspecified => "BOUND_TYPE_UNSPECIFIED",
3382 Self::UnboundedPreceding => "BOUND_TYPE_UNBOUNDED_PRECEDING",
3383 Self::Preceding => "BOUND_TYPE_PRECEDING",
3384 Self::CurrentRow => "BOUND_TYPE_CURRENT_ROW",
3385 Self::Following => "BOUND_TYPE_FOLLOWING",
3386 Self::UnboundedFollowing => "BOUND_TYPE_UNBOUNDED_FOLLOWING",
3387 };
3388 serializer.serialize_str(variant)
3389 }
3390}
3391impl<'de> serde::Deserialize<'de> for window_frame::BoundType {
3392 #[allow(deprecated)]
3393 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3394 where
3395 D: serde::Deserializer<'de>,
3396 {
3397 const FIELDS: &[&str] = &[
3398 "BOUND_TYPE_UNSPECIFIED",
3399 "BOUND_TYPE_UNBOUNDED_PRECEDING",
3400 "BOUND_TYPE_PRECEDING",
3401 "BOUND_TYPE_CURRENT_ROW",
3402 "BOUND_TYPE_FOLLOWING",
3403 "BOUND_TYPE_UNBOUNDED_FOLLOWING",
3404 ];
3405
3406 struct GeneratedVisitor;
3407
3408 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3409 type Value = window_frame::BoundType;
3410
3411 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3412 write!(formatter, "expected one of: {:?}", &FIELDS)
3413 }
3414
3415 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3416 where
3417 E: serde::de::Error,
3418 {
3419 i32::try_from(v)
3420 .ok()
3421 .and_then(|x| x.try_into().ok())
3422 .ok_or_else(|| {
3423 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3424 })
3425 }
3426
3427 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3428 where
3429 E: serde::de::Error,
3430 {
3431 i32::try_from(v)
3432 .ok()
3433 .and_then(|x| x.try_into().ok())
3434 .ok_or_else(|| {
3435 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3436 })
3437 }
3438
3439 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3440 where
3441 E: serde::de::Error,
3442 {
3443 match value {
3444 "BOUND_TYPE_UNSPECIFIED" => Ok(window_frame::BoundType::Unspecified),
3445 "BOUND_TYPE_UNBOUNDED_PRECEDING" => Ok(window_frame::BoundType::UnboundedPreceding),
3446 "BOUND_TYPE_PRECEDING" => Ok(window_frame::BoundType::Preceding),
3447 "BOUND_TYPE_CURRENT_ROW" => Ok(window_frame::BoundType::CurrentRow),
3448 "BOUND_TYPE_FOLLOWING" => Ok(window_frame::BoundType::Following),
3449 "BOUND_TYPE_UNBOUNDED_FOLLOWING" => Ok(window_frame::BoundType::UnboundedFollowing),
3450 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3451 }
3452 }
3453 }
3454 deserializer.deserialize_any(GeneratedVisitor)
3455 }
3456}
3457impl serde::Serialize for window_frame::Exclusion {
3458 #[allow(deprecated)]
3459 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3460 where
3461 S: serde::Serializer,
3462 {
3463 let variant = match self {
3464 Self::Unspecified => "EXCLUSION_UNSPECIFIED",
3465 Self::CurrentRow => "EXCLUSION_CURRENT_ROW",
3466 Self::NoOthers => "EXCLUSION_NO_OTHERS",
3467 };
3468 serializer.serialize_str(variant)
3469 }
3470}
3471impl<'de> serde::Deserialize<'de> for window_frame::Exclusion {
3472 #[allow(deprecated)]
3473 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3474 where
3475 D: serde::Deserializer<'de>,
3476 {
3477 const FIELDS: &[&str] = &[
3478 "EXCLUSION_UNSPECIFIED",
3479 "EXCLUSION_CURRENT_ROW",
3480 "EXCLUSION_NO_OTHERS",
3481 ];
3482
3483 struct GeneratedVisitor;
3484
3485 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3486 type Value = window_frame::Exclusion;
3487
3488 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3489 write!(formatter, "expected one of: {:?}", &FIELDS)
3490 }
3491
3492 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3493 where
3494 E: serde::de::Error,
3495 {
3496 i32::try_from(v)
3497 .ok()
3498 .and_then(|x| x.try_into().ok())
3499 .ok_or_else(|| {
3500 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3501 })
3502 }
3503
3504 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3505 where
3506 E: serde::de::Error,
3507 {
3508 i32::try_from(v)
3509 .ok()
3510 .and_then(|x| x.try_into().ok())
3511 .ok_or_else(|| {
3512 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3513 })
3514 }
3515
3516 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3517 where
3518 E: serde::de::Error,
3519 {
3520 match value {
3521 "EXCLUSION_UNSPECIFIED" => Ok(window_frame::Exclusion::Unspecified),
3522 "EXCLUSION_CURRENT_ROW" => Ok(window_frame::Exclusion::CurrentRow),
3523 "EXCLUSION_NO_OTHERS" => Ok(window_frame::Exclusion::NoOthers),
3524 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3525 }
3526 }
3527 }
3528 deserializer.deserialize_any(GeneratedVisitor)
3529 }
3530}
3531impl serde::Serialize for window_frame::RangeFrameBound {
3532 #[allow(deprecated)]
3533 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3534 where
3535 S: serde::Serializer,
3536 {
3537 use serde::ser::SerializeStruct;
3538 let mut len = 0;
3539 if self.r#type != 0 {
3540 len += 1;
3541 }
3542 if self.offset.is_some() {
3543 len += 1;
3544 }
3545 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RangeFrameBound", len)?;
3546 if self.r#type != 0 {
3547 let v = window_frame::BoundType::try_from(self.r#type)
3548 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3549 struct_ser.serialize_field("type", &v)?;
3550 }
3551 if let Some(v) = self.offset.as_ref() {
3552 struct_ser.serialize_field("offset", v)?;
3553 }
3554 struct_ser.end()
3555 }
3556}
3557impl<'de> serde::Deserialize<'de> for window_frame::RangeFrameBound {
3558 #[allow(deprecated)]
3559 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3560 where
3561 D: serde::Deserializer<'de>,
3562 {
3563 const FIELDS: &[&str] = &[
3564 "type",
3565 "offset",
3566 ];
3567
3568 #[allow(clippy::enum_variant_names)]
3569 enum GeneratedField {
3570 Type,
3571 Offset,
3572 }
3573 impl<'de> serde::Deserialize<'de> for GeneratedField {
3574 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3575 where
3576 D: serde::Deserializer<'de>,
3577 {
3578 struct GeneratedVisitor;
3579
3580 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3581 type Value = GeneratedField;
3582
3583 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3584 write!(formatter, "expected one of: {:?}", &FIELDS)
3585 }
3586
3587 #[allow(unused_variables)]
3588 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3589 where
3590 E: serde::de::Error,
3591 {
3592 match value {
3593 "type" => Ok(GeneratedField::Type),
3594 "offset" => Ok(GeneratedField::Offset),
3595 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3596 }
3597 }
3598 }
3599 deserializer.deserialize_identifier(GeneratedVisitor)
3600 }
3601 }
3602 struct GeneratedVisitor;
3603 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3604 type Value = window_frame::RangeFrameBound;
3605
3606 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3607 formatter.write_str("struct expr.WindowFrame.RangeFrameBound")
3608 }
3609
3610 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RangeFrameBound, V::Error>
3611 where
3612 V: serde::de::MapAccess<'de>,
3613 {
3614 let mut r#type__ = None;
3615 let mut offset__ = None;
3616 while let Some(k) = map_.next_key()? {
3617 match k {
3618 GeneratedField::Type => {
3619 if r#type__.is_some() {
3620 return Err(serde::de::Error::duplicate_field("type"));
3621 }
3622 r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3623 }
3624 GeneratedField::Offset => {
3625 if offset__.is_some() {
3626 return Err(serde::de::Error::duplicate_field("offset"));
3627 }
3628 offset__ = map_.next_value()?;
3629 }
3630 }
3631 }
3632 Ok(window_frame::RangeFrameBound {
3633 r#type: r#type__.unwrap_or_default(),
3634 offset: offset__,
3635 })
3636 }
3637 }
3638 deserializer.deserialize_struct("expr.WindowFrame.RangeFrameBound", FIELDS, GeneratedVisitor)
3639 }
3640}
3641impl serde::Serialize for window_frame::RangeFrameBounds {
3642 #[allow(deprecated)]
3643 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3644 where
3645 S: serde::Serializer,
3646 {
3647 use serde::ser::SerializeStruct;
3648 let mut len = 0;
3649 if self.start.is_some() {
3650 len += 1;
3651 }
3652 if self.end.is_some() {
3653 len += 1;
3654 }
3655 if self.order_data_type.is_some() {
3656 len += 1;
3657 }
3658 if self.order_type.is_some() {
3659 len += 1;
3660 }
3661 if self.offset_data_type.is_some() {
3662 len += 1;
3663 }
3664 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RangeFrameBounds", len)?;
3665 if let Some(v) = self.start.as_ref() {
3666 struct_ser.serialize_field("start", v)?;
3667 }
3668 if let Some(v) = self.end.as_ref() {
3669 struct_ser.serialize_field("end", v)?;
3670 }
3671 if let Some(v) = self.order_data_type.as_ref() {
3672 struct_ser.serialize_field("orderDataType", v)?;
3673 }
3674 if let Some(v) = self.order_type.as_ref() {
3675 struct_ser.serialize_field("orderType", v)?;
3676 }
3677 if let Some(v) = self.offset_data_type.as_ref() {
3678 struct_ser.serialize_field("offsetDataType", v)?;
3679 }
3680 struct_ser.end()
3681 }
3682}
3683impl<'de> serde::Deserialize<'de> for window_frame::RangeFrameBounds {
3684 #[allow(deprecated)]
3685 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3686 where
3687 D: serde::Deserializer<'de>,
3688 {
3689 const FIELDS: &[&str] = &[
3690 "start",
3691 "end",
3692 "order_data_type",
3693 "orderDataType",
3694 "order_type",
3695 "orderType",
3696 "offset_data_type",
3697 "offsetDataType",
3698 ];
3699
3700 #[allow(clippy::enum_variant_names)]
3701 enum GeneratedField {
3702 Start,
3703 End,
3704 OrderDataType,
3705 OrderType,
3706 OffsetDataType,
3707 }
3708 impl<'de> serde::Deserialize<'de> for GeneratedField {
3709 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3710 where
3711 D: serde::Deserializer<'de>,
3712 {
3713 struct GeneratedVisitor;
3714
3715 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3716 type Value = GeneratedField;
3717
3718 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3719 write!(formatter, "expected one of: {:?}", &FIELDS)
3720 }
3721
3722 #[allow(unused_variables)]
3723 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3724 where
3725 E: serde::de::Error,
3726 {
3727 match value {
3728 "start" => Ok(GeneratedField::Start),
3729 "end" => Ok(GeneratedField::End),
3730 "orderDataType" | "order_data_type" => Ok(GeneratedField::OrderDataType),
3731 "orderType" | "order_type" => Ok(GeneratedField::OrderType),
3732 "offsetDataType" | "offset_data_type" => Ok(GeneratedField::OffsetDataType),
3733 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3734 }
3735 }
3736 }
3737 deserializer.deserialize_identifier(GeneratedVisitor)
3738 }
3739 }
3740 struct GeneratedVisitor;
3741 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3742 type Value = window_frame::RangeFrameBounds;
3743
3744 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3745 formatter.write_str("struct expr.WindowFrame.RangeFrameBounds")
3746 }
3747
3748 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RangeFrameBounds, V::Error>
3749 where
3750 V: serde::de::MapAccess<'de>,
3751 {
3752 let mut start__ = None;
3753 let mut end__ = None;
3754 let mut order_data_type__ = None;
3755 let mut order_type__ = None;
3756 let mut offset_data_type__ = None;
3757 while let Some(k) = map_.next_key()? {
3758 match k {
3759 GeneratedField::Start => {
3760 if start__.is_some() {
3761 return Err(serde::de::Error::duplicate_field("start"));
3762 }
3763 start__ = map_.next_value()?;
3764 }
3765 GeneratedField::End => {
3766 if end__.is_some() {
3767 return Err(serde::de::Error::duplicate_field("end"));
3768 }
3769 end__ = map_.next_value()?;
3770 }
3771 GeneratedField::OrderDataType => {
3772 if order_data_type__.is_some() {
3773 return Err(serde::de::Error::duplicate_field("orderDataType"));
3774 }
3775 order_data_type__ = map_.next_value()?;
3776 }
3777 GeneratedField::OrderType => {
3778 if order_type__.is_some() {
3779 return Err(serde::de::Error::duplicate_field("orderType"));
3780 }
3781 order_type__ = map_.next_value()?;
3782 }
3783 GeneratedField::OffsetDataType => {
3784 if offset_data_type__.is_some() {
3785 return Err(serde::de::Error::duplicate_field("offsetDataType"));
3786 }
3787 offset_data_type__ = map_.next_value()?;
3788 }
3789 }
3790 }
3791 Ok(window_frame::RangeFrameBounds {
3792 start: start__,
3793 end: end__,
3794 order_data_type: order_data_type__,
3795 order_type: order_type__,
3796 offset_data_type: offset_data_type__,
3797 })
3798 }
3799 }
3800 deserializer.deserialize_struct("expr.WindowFrame.RangeFrameBounds", FIELDS, GeneratedVisitor)
3801 }
3802}
3803impl serde::Serialize for window_frame::RowsFrameBound {
3804 #[allow(deprecated)]
3805 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3806 where
3807 S: serde::Serializer,
3808 {
3809 use serde::ser::SerializeStruct;
3810 let mut len = 0;
3811 if self.r#type != 0 {
3812 len += 1;
3813 }
3814 if self.offset.is_some() {
3815 len += 1;
3816 }
3817 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RowsFrameBound", len)?;
3818 if self.r#type != 0 {
3819 let v = window_frame::BoundType::try_from(self.r#type)
3820 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3821 struct_ser.serialize_field("type", &v)?;
3822 }
3823 if let Some(v) = self.offset.as_ref() {
3824 #[allow(clippy::needless_borrow)]
3825 #[allow(clippy::needless_borrows_for_generic_args)]
3826 struct_ser.serialize_field("offset", ToString::to_string(&v).as_str())?;
3827 }
3828 struct_ser.end()
3829 }
3830}
3831impl<'de> serde::Deserialize<'de> for window_frame::RowsFrameBound {
3832 #[allow(deprecated)]
3833 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3834 where
3835 D: serde::Deserializer<'de>,
3836 {
3837 const FIELDS: &[&str] = &[
3838 "type",
3839 "offset",
3840 ];
3841
3842 #[allow(clippy::enum_variant_names)]
3843 enum GeneratedField {
3844 Type,
3845 Offset,
3846 }
3847 impl<'de> serde::Deserialize<'de> for GeneratedField {
3848 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3849 where
3850 D: serde::Deserializer<'de>,
3851 {
3852 struct GeneratedVisitor;
3853
3854 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3855 type Value = GeneratedField;
3856
3857 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3858 write!(formatter, "expected one of: {:?}", &FIELDS)
3859 }
3860
3861 #[allow(unused_variables)]
3862 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3863 where
3864 E: serde::de::Error,
3865 {
3866 match value {
3867 "type" => Ok(GeneratedField::Type),
3868 "offset" => Ok(GeneratedField::Offset),
3869 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3870 }
3871 }
3872 }
3873 deserializer.deserialize_identifier(GeneratedVisitor)
3874 }
3875 }
3876 struct GeneratedVisitor;
3877 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3878 type Value = window_frame::RowsFrameBound;
3879
3880 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3881 formatter.write_str("struct expr.WindowFrame.RowsFrameBound")
3882 }
3883
3884 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RowsFrameBound, V::Error>
3885 where
3886 V: serde::de::MapAccess<'de>,
3887 {
3888 let mut r#type__ = None;
3889 let mut offset__ = None;
3890 while let Some(k) = map_.next_key()? {
3891 match k {
3892 GeneratedField::Type => {
3893 if r#type__.is_some() {
3894 return Err(serde::de::Error::duplicate_field("type"));
3895 }
3896 r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3897 }
3898 GeneratedField::Offset => {
3899 if offset__.is_some() {
3900 return Err(serde::de::Error::duplicate_field("offset"));
3901 }
3902 offset__ =
3903 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3904 ;
3905 }
3906 }
3907 }
3908 Ok(window_frame::RowsFrameBound {
3909 r#type: r#type__.unwrap_or_default(),
3910 offset: offset__,
3911 })
3912 }
3913 }
3914 deserializer.deserialize_struct("expr.WindowFrame.RowsFrameBound", FIELDS, GeneratedVisitor)
3915 }
3916}
3917impl serde::Serialize for window_frame::RowsFrameBounds {
3918 #[allow(deprecated)]
3919 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3920 where
3921 S: serde::Serializer,
3922 {
3923 use serde::ser::SerializeStruct;
3924 let mut len = 0;
3925 if self.start.is_some() {
3926 len += 1;
3927 }
3928 if self.end.is_some() {
3929 len += 1;
3930 }
3931 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RowsFrameBounds", len)?;
3932 if let Some(v) = self.start.as_ref() {
3933 struct_ser.serialize_field("start", v)?;
3934 }
3935 if let Some(v) = self.end.as_ref() {
3936 struct_ser.serialize_field("end", v)?;
3937 }
3938 struct_ser.end()
3939 }
3940}
3941impl<'de> serde::Deserialize<'de> for window_frame::RowsFrameBounds {
3942 #[allow(deprecated)]
3943 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3944 where
3945 D: serde::Deserializer<'de>,
3946 {
3947 const FIELDS: &[&str] = &[
3948 "start",
3949 "end",
3950 ];
3951
3952 #[allow(clippy::enum_variant_names)]
3953 enum GeneratedField {
3954 Start,
3955 End,
3956 }
3957 impl<'de> serde::Deserialize<'de> for GeneratedField {
3958 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3959 where
3960 D: serde::Deserializer<'de>,
3961 {
3962 struct GeneratedVisitor;
3963
3964 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3965 type Value = GeneratedField;
3966
3967 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3968 write!(formatter, "expected one of: {:?}", &FIELDS)
3969 }
3970
3971 #[allow(unused_variables)]
3972 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3973 where
3974 E: serde::de::Error,
3975 {
3976 match value {
3977 "start" => Ok(GeneratedField::Start),
3978 "end" => Ok(GeneratedField::End),
3979 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3980 }
3981 }
3982 }
3983 deserializer.deserialize_identifier(GeneratedVisitor)
3984 }
3985 }
3986 struct GeneratedVisitor;
3987 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3988 type Value = window_frame::RowsFrameBounds;
3989
3990 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3991 formatter.write_str("struct expr.WindowFrame.RowsFrameBounds")
3992 }
3993
3994 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RowsFrameBounds, V::Error>
3995 where
3996 V: serde::de::MapAccess<'de>,
3997 {
3998 let mut start__ = None;
3999 let mut end__ = None;
4000 while let Some(k) = map_.next_key()? {
4001 match k {
4002 GeneratedField::Start => {
4003 if start__.is_some() {
4004 return Err(serde::de::Error::duplicate_field("start"));
4005 }
4006 start__ = map_.next_value()?;
4007 }
4008 GeneratedField::End => {
4009 if end__.is_some() {
4010 return Err(serde::de::Error::duplicate_field("end"));
4011 }
4012 end__ = map_.next_value()?;
4013 }
4014 }
4015 }
4016 Ok(window_frame::RowsFrameBounds {
4017 start: start__,
4018 end: end__,
4019 })
4020 }
4021 }
4022 deserializer.deserialize_struct("expr.WindowFrame.RowsFrameBounds", FIELDS, GeneratedVisitor)
4023 }
4024}
4025impl serde::Serialize for window_frame::SessionFrameBounds {
4026 #[allow(deprecated)]
4027 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4028 where
4029 S: serde::Serializer,
4030 {
4031 use serde::ser::SerializeStruct;
4032 let mut len = 0;
4033 if self.gap.is_some() {
4034 len += 1;
4035 }
4036 if self.order_data_type.is_some() {
4037 len += 1;
4038 }
4039 if self.order_type.is_some() {
4040 len += 1;
4041 }
4042 if self.gap_data_type.is_some() {
4043 len += 1;
4044 }
4045 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.SessionFrameBounds", len)?;
4046 if let Some(v) = self.gap.as_ref() {
4047 struct_ser.serialize_field("gap", v)?;
4048 }
4049 if let Some(v) = self.order_data_type.as_ref() {
4050 struct_ser.serialize_field("orderDataType", v)?;
4051 }
4052 if let Some(v) = self.order_type.as_ref() {
4053 struct_ser.serialize_field("orderType", v)?;
4054 }
4055 if let Some(v) = self.gap_data_type.as_ref() {
4056 struct_ser.serialize_field("gapDataType", v)?;
4057 }
4058 struct_ser.end()
4059 }
4060}
4061impl<'de> serde::Deserialize<'de> for window_frame::SessionFrameBounds {
4062 #[allow(deprecated)]
4063 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4064 where
4065 D: serde::Deserializer<'de>,
4066 {
4067 const FIELDS: &[&str] = &[
4068 "gap",
4069 "order_data_type",
4070 "orderDataType",
4071 "order_type",
4072 "orderType",
4073 "gap_data_type",
4074 "gapDataType",
4075 ];
4076
4077 #[allow(clippy::enum_variant_names)]
4078 enum GeneratedField {
4079 Gap,
4080 OrderDataType,
4081 OrderType,
4082 GapDataType,
4083 }
4084 impl<'de> serde::Deserialize<'de> for GeneratedField {
4085 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4086 where
4087 D: serde::Deserializer<'de>,
4088 {
4089 struct GeneratedVisitor;
4090
4091 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4092 type Value = GeneratedField;
4093
4094 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4095 write!(formatter, "expected one of: {:?}", &FIELDS)
4096 }
4097
4098 #[allow(unused_variables)]
4099 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4100 where
4101 E: serde::de::Error,
4102 {
4103 match value {
4104 "gap" => Ok(GeneratedField::Gap),
4105 "orderDataType" | "order_data_type" => Ok(GeneratedField::OrderDataType),
4106 "orderType" | "order_type" => Ok(GeneratedField::OrderType),
4107 "gapDataType" | "gap_data_type" => Ok(GeneratedField::GapDataType),
4108 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4109 }
4110 }
4111 }
4112 deserializer.deserialize_identifier(GeneratedVisitor)
4113 }
4114 }
4115 struct GeneratedVisitor;
4116 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4117 type Value = window_frame::SessionFrameBounds;
4118
4119 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4120 formatter.write_str("struct expr.WindowFrame.SessionFrameBounds")
4121 }
4122
4123 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::SessionFrameBounds, V::Error>
4124 where
4125 V: serde::de::MapAccess<'de>,
4126 {
4127 let mut gap__ = None;
4128 let mut order_data_type__ = None;
4129 let mut order_type__ = None;
4130 let mut gap_data_type__ = None;
4131 while let Some(k) = map_.next_key()? {
4132 match k {
4133 GeneratedField::Gap => {
4134 if gap__.is_some() {
4135 return Err(serde::de::Error::duplicate_field("gap"));
4136 }
4137 gap__ = map_.next_value()?;
4138 }
4139 GeneratedField::OrderDataType => {
4140 if order_data_type__.is_some() {
4141 return Err(serde::de::Error::duplicate_field("orderDataType"));
4142 }
4143 order_data_type__ = map_.next_value()?;
4144 }
4145 GeneratedField::OrderType => {
4146 if order_type__.is_some() {
4147 return Err(serde::de::Error::duplicate_field("orderType"));
4148 }
4149 order_type__ = map_.next_value()?;
4150 }
4151 GeneratedField::GapDataType => {
4152 if gap_data_type__.is_some() {
4153 return Err(serde::de::Error::duplicate_field("gapDataType"));
4154 }
4155 gap_data_type__ = map_.next_value()?;
4156 }
4157 }
4158 }
4159 Ok(window_frame::SessionFrameBounds {
4160 gap: gap__,
4161 order_data_type: order_data_type__,
4162 order_type: order_type__,
4163 gap_data_type: gap_data_type__,
4164 })
4165 }
4166 }
4167 deserializer.deserialize_struct("expr.WindowFrame.SessionFrameBounds", FIELDS, GeneratedVisitor)
4168 }
4169}
4170impl serde::Serialize for window_frame::Type {
4171 #[allow(deprecated)]
4172 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4173 where
4174 S: serde::Serializer,
4175 {
4176 let variant = match self {
4177 Self::Unspecified => "TYPE_UNSPECIFIED",
4178 Self::RowsLegacy => "TYPE_ROWS_LEGACY",
4179 Self::Rows => "TYPE_ROWS",
4180 Self::Range => "TYPE_RANGE",
4181 Self::Session => "TYPE_SESSION",
4182 };
4183 serializer.serialize_str(variant)
4184 }
4185}
4186impl<'de> serde::Deserialize<'de> for window_frame::Type {
4187 #[allow(deprecated)]
4188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4189 where
4190 D: serde::Deserializer<'de>,
4191 {
4192 const FIELDS: &[&str] = &[
4193 "TYPE_UNSPECIFIED",
4194 "TYPE_ROWS_LEGACY",
4195 "TYPE_ROWS",
4196 "TYPE_RANGE",
4197 "TYPE_SESSION",
4198 ];
4199
4200 struct GeneratedVisitor;
4201
4202 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4203 type Value = window_frame::Type;
4204
4205 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4206 write!(formatter, "expected one of: {:?}", &FIELDS)
4207 }
4208
4209 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4210 where
4211 E: serde::de::Error,
4212 {
4213 i32::try_from(v)
4214 .ok()
4215 .and_then(|x| x.try_into().ok())
4216 .ok_or_else(|| {
4217 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4218 })
4219 }
4220
4221 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4222 where
4223 E: serde::de::Error,
4224 {
4225 i32::try_from(v)
4226 .ok()
4227 .and_then(|x| x.try_into().ok())
4228 .ok_or_else(|| {
4229 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4230 })
4231 }
4232
4233 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4234 where
4235 E: serde::de::Error,
4236 {
4237 match value {
4238 "TYPE_UNSPECIFIED" => Ok(window_frame::Type::Unspecified),
4239 "TYPE_ROWS_LEGACY" => Ok(window_frame::Type::RowsLegacy),
4240 "TYPE_ROWS" => Ok(window_frame::Type::Rows),
4241 "TYPE_RANGE" => Ok(window_frame::Type::Range),
4242 "TYPE_SESSION" => Ok(window_frame::Type::Session),
4243 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4244 }
4245 }
4246 }
4247 deserializer.deserialize_any(GeneratedVisitor)
4248 }
4249}
4250impl serde::Serialize for WindowFunction {
4251 #[allow(deprecated)]
4252 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4253 where
4254 S: serde::Serializer,
4255 {
4256 use serde::ser::SerializeStruct;
4257 let mut len = 0;
4258 if !self.args.is_empty() {
4259 len += 1;
4260 }
4261 if self.return_type.is_some() {
4262 len += 1;
4263 }
4264 if self.frame.is_some() {
4265 len += 1;
4266 }
4267 if self.ignore_nulls {
4268 len += 1;
4269 }
4270 if self.r#type.is_some() {
4271 len += 1;
4272 }
4273 let mut struct_ser = serializer.serialize_struct("expr.WindowFunction", len)?;
4274 if !self.args.is_empty() {
4275 struct_ser.serialize_field("args", &self.args)?;
4276 }
4277 if let Some(v) = self.return_type.as_ref() {
4278 struct_ser.serialize_field("returnType", v)?;
4279 }
4280 if let Some(v) = self.frame.as_ref() {
4281 struct_ser.serialize_field("frame", v)?;
4282 }
4283 if self.ignore_nulls {
4284 struct_ser.serialize_field("ignoreNulls", &self.ignore_nulls)?;
4285 }
4286 if let Some(v) = self.r#type.as_ref() {
4287 match v {
4288 window_function::Type::General(v) => {
4289 let v = window_function::GeneralType::try_from(*v)
4290 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
4291 struct_ser.serialize_field("general", &v)?;
4292 }
4293 window_function::Type::Aggregate(v) => {
4294 let v = agg_call::Kind::try_from(*v)
4295 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
4296 struct_ser.serialize_field("aggregate", &v)?;
4297 }
4298 window_function::Type::Aggregate2(v) => {
4299 struct_ser.serialize_field("aggregate2", v)?;
4300 }
4301 }
4302 }
4303 struct_ser.end()
4304 }
4305}
4306impl<'de> serde::Deserialize<'de> for WindowFunction {
4307 #[allow(deprecated)]
4308 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4309 where
4310 D: serde::Deserializer<'de>,
4311 {
4312 const FIELDS: &[&str] = &[
4313 "args",
4314 "return_type",
4315 "returnType",
4316 "frame",
4317 "ignore_nulls",
4318 "ignoreNulls",
4319 "general",
4320 "aggregate",
4321 "aggregate2",
4322 ];
4323
4324 #[allow(clippy::enum_variant_names)]
4325 enum GeneratedField {
4326 Args,
4327 ReturnType,
4328 Frame,
4329 IgnoreNulls,
4330 General,
4331 Aggregate,
4332 Aggregate2,
4333 }
4334 impl<'de> serde::Deserialize<'de> for GeneratedField {
4335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4336 where
4337 D: serde::Deserializer<'de>,
4338 {
4339 struct GeneratedVisitor;
4340
4341 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4342 type Value = GeneratedField;
4343
4344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4345 write!(formatter, "expected one of: {:?}", &FIELDS)
4346 }
4347
4348 #[allow(unused_variables)]
4349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4350 where
4351 E: serde::de::Error,
4352 {
4353 match value {
4354 "args" => Ok(GeneratedField::Args),
4355 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
4356 "frame" => Ok(GeneratedField::Frame),
4357 "ignoreNulls" | "ignore_nulls" => Ok(GeneratedField::IgnoreNulls),
4358 "general" => Ok(GeneratedField::General),
4359 "aggregate" => Ok(GeneratedField::Aggregate),
4360 "aggregate2" => Ok(GeneratedField::Aggregate2),
4361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4362 }
4363 }
4364 }
4365 deserializer.deserialize_identifier(GeneratedVisitor)
4366 }
4367 }
4368 struct GeneratedVisitor;
4369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4370 type Value = WindowFunction;
4371
4372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4373 formatter.write_str("struct expr.WindowFunction")
4374 }
4375
4376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WindowFunction, V::Error>
4377 where
4378 V: serde::de::MapAccess<'de>,
4379 {
4380 let mut args__ = None;
4381 let mut return_type__ = None;
4382 let mut frame__ = None;
4383 let mut ignore_nulls__ = None;
4384 let mut r#type__ = None;
4385 while let Some(k) = map_.next_key()? {
4386 match k {
4387 GeneratedField::Args => {
4388 if args__.is_some() {
4389 return Err(serde::de::Error::duplicate_field("args"));
4390 }
4391 args__ = Some(map_.next_value()?);
4392 }
4393 GeneratedField::ReturnType => {
4394 if return_type__.is_some() {
4395 return Err(serde::de::Error::duplicate_field("returnType"));
4396 }
4397 return_type__ = map_.next_value()?;
4398 }
4399 GeneratedField::Frame => {
4400 if frame__.is_some() {
4401 return Err(serde::de::Error::duplicate_field("frame"));
4402 }
4403 frame__ = map_.next_value()?;
4404 }
4405 GeneratedField::IgnoreNulls => {
4406 if ignore_nulls__.is_some() {
4407 return Err(serde::de::Error::duplicate_field("ignoreNulls"));
4408 }
4409 ignore_nulls__ = Some(map_.next_value()?);
4410 }
4411 GeneratedField::General => {
4412 if r#type__.is_some() {
4413 return Err(serde::de::Error::duplicate_field("general"));
4414 }
4415 r#type__ = map_.next_value::<::std::option::Option<window_function::GeneralType>>()?.map(|x| window_function::Type::General(x as i32));
4416 }
4417 GeneratedField::Aggregate => {
4418 if r#type__.is_some() {
4419 return Err(serde::de::Error::duplicate_field("aggregate"));
4420 }
4421 r#type__ = map_.next_value::<::std::option::Option<agg_call::Kind>>()?.map(|x| window_function::Type::Aggregate(x as i32));
4422 }
4423 GeneratedField::Aggregate2 => {
4424 if r#type__.is_some() {
4425 return Err(serde::de::Error::duplicate_field("aggregate2"));
4426 }
4427 r#type__ = map_.next_value::<::std::option::Option<_>>()?.map(window_function::Type::Aggregate2)
4428;
4429 }
4430 }
4431 }
4432 Ok(WindowFunction {
4433 args: args__.unwrap_or_default(),
4434 return_type: return_type__,
4435 frame: frame__,
4436 ignore_nulls: ignore_nulls__.unwrap_or_default(),
4437 r#type: r#type__,
4438 })
4439 }
4440 }
4441 deserializer.deserialize_struct("expr.WindowFunction", FIELDS, GeneratedVisitor)
4442 }
4443}
4444impl serde::Serialize for window_function::GeneralType {
4445 #[allow(deprecated)]
4446 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4447 where
4448 S: serde::Serializer,
4449 {
4450 let variant = match self {
4451 Self::Unspecified => "UNSPECIFIED",
4452 Self::RowNumber => "ROW_NUMBER",
4453 Self::Rank => "RANK",
4454 Self::DenseRank => "DENSE_RANK",
4455 Self::Lag => "LAG",
4456 Self::Lead => "LEAD",
4457 };
4458 serializer.serialize_str(variant)
4459 }
4460}
4461impl<'de> serde::Deserialize<'de> for window_function::GeneralType {
4462 #[allow(deprecated)]
4463 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4464 where
4465 D: serde::Deserializer<'de>,
4466 {
4467 const FIELDS: &[&str] = &[
4468 "UNSPECIFIED",
4469 "ROW_NUMBER",
4470 "RANK",
4471 "DENSE_RANK",
4472 "LAG",
4473 "LEAD",
4474 ];
4475
4476 struct GeneratedVisitor;
4477
4478 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4479 type Value = window_function::GeneralType;
4480
4481 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4482 write!(formatter, "expected one of: {:?}", &FIELDS)
4483 }
4484
4485 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4486 where
4487 E: serde::de::Error,
4488 {
4489 i32::try_from(v)
4490 .ok()
4491 .and_then(|x| x.try_into().ok())
4492 .ok_or_else(|| {
4493 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4494 })
4495 }
4496
4497 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4498 where
4499 E: serde::de::Error,
4500 {
4501 i32::try_from(v)
4502 .ok()
4503 .and_then(|x| x.try_into().ok())
4504 .ok_or_else(|| {
4505 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4506 })
4507 }
4508
4509 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4510 where
4511 E: serde::de::Error,
4512 {
4513 match value {
4514 "UNSPECIFIED" => Ok(window_function::GeneralType::Unspecified),
4515 "ROW_NUMBER" => Ok(window_function::GeneralType::RowNumber),
4516 "RANK" => Ok(window_function::GeneralType::Rank),
4517 "DENSE_RANK" => Ok(window_function::GeneralType::DenseRank),
4518 "LAG" => Ok(window_function::GeneralType::Lag),
4519 "LEAD" => Ok(window_function::GeneralType::Lead),
4520 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4521 }
4522 }
4523 }
4524 deserializer.deserialize_any(GeneratedVisitor)
4525 }
4526}