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