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