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