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