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