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