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