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