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