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