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::InternalBackfillProgress => "INTERNAL_BACKFILL_PROGRESS",
2460 Self::InternalSourceBackfillProgress => "INTERNAL_SOURCE_BACKFILL_PROGRESS",
2461 Self::InternalGetChannelDeltaStats => "INTERNAL_GET_CHANNEL_DELTA_STATS",
2462 Self::UserDefined => "USER_DEFINED",
2463 };
2464 serializer.serialize_str(variant)
2465 }
2466}
2467impl<'de> serde::Deserialize<'de> for table_function::Type {
2468 #[allow(deprecated)]
2469 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2470 where
2471 D: serde::Deserializer<'de>,
2472 {
2473 const FIELDS: &[&str] = &[
2474 "UNSPECIFIED",
2475 "GENERATE_SERIES",
2476 "UNNEST",
2477 "REGEXP_MATCHES",
2478 "RANGE",
2479 "GENERATE_SUBSCRIPTS",
2480 "_PG_EXPANDARRAY",
2481 "PG_GET_KEYWORDS",
2482 "JSONB_ARRAY_ELEMENTS",
2483 "JSONB_ARRAY_ELEMENTS_TEXT",
2484 "JSONB_EACH",
2485 "JSONB_EACH_TEXT",
2486 "JSONB_OBJECT_KEYS",
2487 "JSONB_PATH_QUERY",
2488 "JSONB_POPULATE_RECORDSET",
2489 "JSONB_TO_RECORDSET",
2490 "FILE_SCAN",
2491 "POSTGRES_QUERY",
2492 "MYSQL_QUERY",
2493 "INTERNAL_BACKFILL_PROGRESS",
2494 "INTERNAL_SOURCE_BACKFILL_PROGRESS",
2495 "INTERNAL_GET_CHANNEL_DELTA_STATS",
2496 "USER_DEFINED",
2497 ];
2498
2499 struct GeneratedVisitor;
2500
2501 impl serde::de::Visitor<'_> for GeneratedVisitor {
2502 type Value = table_function::Type;
2503
2504 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2505 write!(formatter, "expected one of: {:?}", &FIELDS)
2506 }
2507
2508 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2509 where
2510 E: serde::de::Error,
2511 {
2512 i32::try_from(v)
2513 .ok()
2514 .and_then(|x| x.try_into().ok())
2515 .ok_or_else(|| {
2516 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2517 })
2518 }
2519
2520 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2521 where
2522 E: serde::de::Error,
2523 {
2524 i32::try_from(v)
2525 .ok()
2526 .and_then(|x| x.try_into().ok())
2527 .ok_or_else(|| {
2528 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2529 })
2530 }
2531
2532 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2533 where
2534 E: serde::de::Error,
2535 {
2536 match value {
2537 "UNSPECIFIED" => Ok(table_function::Type::Unspecified),
2538 "GENERATE_SERIES" => Ok(table_function::Type::GenerateSeries),
2539 "UNNEST" => Ok(table_function::Type::Unnest),
2540 "REGEXP_MATCHES" => Ok(table_function::Type::RegexpMatches),
2541 "RANGE" => Ok(table_function::Type::Range),
2542 "GENERATE_SUBSCRIPTS" => Ok(table_function::Type::GenerateSubscripts),
2543 "_PG_EXPANDARRAY" => Ok(table_function::Type::PgExpandarray),
2544 "PG_GET_KEYWORDS" => Ok(table_function::Type::PgGetKeywords),
2545 "JSONB_ARRAY_ELEMENTS" => Ok(table_function::Type::JsonbArrayElements),
2546 "JSONB_ARRAY_ELEMENTS_TEXT" => Ok(table_function::Type::JsonbArrayElementsText),
2547 "JSONB_EACH" => Ok(table_function::Type::JsonbEach),
2548 "JSONB_EACH_TEXT" => Ok(table_function::Type::JsonbEachText),
2549 "JSONB_OBJECT_KEYS" => Ok(table_function::Type::JsonbObjectKeys),
2550 "JSONB_PATH_QUERY" => Ok(table_function::Type::JsonbPathQuery),
2551 "JSONB_POPULATE_RECORDSET" => Ok(table_function::Type::JsonbPopulateRecordset),
2552 "JSONB_TO_RECORDSET" => Ok(table_function::Type::JsonbToRecordset),
2553 "FILE_SCAN" => Ok(table_function::Type::FileScan),
2554 "POSTGRES_QUERY" => Ok(table_function::Type::PostgresQuery),
2555 "MYSQL_QUERY" => Ok(table_function::Type::MysqlQuery),
2556 "INTERNAL_BACKFILL_PROGRESS" => Ok(table_function::Type::InternalBackfillProgress),
2557 "INTERNAL_SOURCE_BACKFILL_PROGRESS" => Ok(table_function::Type::InternalSourceBackfillProgress),
2558 "INTERNAL_GET_CHANNEL_DELTA_STATS" => Ok(table_function::Type::InternalGetChannelDeltaStats),
2559 "USER_DEFINED" => Ok(table_function::Type::UserDefined),
2560 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2561 }
2562 }
2563 }
2564 deserializer.deserialize_any(GeneratedVisitor)
2565 }
2566}
2567impl serde::Serialize for UdfExprVersion {
2568 #[allow(deprecated)]
2569 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2570 where
2571 S: serde::Serializer,
2572 {
2573 let variant = match self {
2574 Self::Unspecified => "UDF_EXPR_VERSION_UNSPECIFIED",
2575 Self::NameInRuntime => "UDF_EXPR_VERSION_NAME_IN_RUNTIME",
2576 };
2577 serializer.serialize_str(variant)
2578 }
2579}
2580impl<'de> serde::Deserialize<'de> for UdfExprVersion {
2581 #[allow(deprecated)]
2582 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2583 where
2584 D: serde::Deserializer<'de>,
2585 {
2586 const FIELDS: &[&str] = &[
2587 "UDF_EXPR_VERSION_UNSPECIFIED",
2588 "UDF_EXPR_VERSION_NAME_IN_RUNTIME",
2589 ];
2590
2591 struct GeneratedVisitor;
2592
2593 impl serde::de::Visitor<'_> for GeneratedVisitor {
2594 type Value = UdfExprVersion;
2595
2596 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2597 write!(formatter, "expected one of: {:?}", &FIELDS)
2598 }
2599
2600 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2601 where
2602 E: serde::de::Error,
2603 {
2604 i32::try_from(v)
2605 .ok()
2606 .and_then(|x| x.try_into().ok())
2607 .ok_or_else(|| {
2608 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2609 })
2610 }
2611
2612 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2613 where
2614 E: serde::de::Error,
2615 {
2616 i32::try_from(v)
2617 .ok()
2618 .and_then(|x| x.try_into().ok())
2619 .ok_or_else(|| {
2620 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2621 })
2622 }
2623
2624 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2625 where
2626 E: serde::de::Error,
2627 {
2628 match value {
2629 "UDF_EXPR_VERSION_UNSPECIFIED" => Ok(UdfExprVersion::Unspecified),
2630 "UDF_EXPR_VERSION_NAME_IN_RUNTIME" => Ok(UdfExprVersion::NameInRuntime),
2631 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2632 }
2633 }
2634 }
2635 deserializer.deserialize_any(GeneratedVisitor)
2636 }
2637}
2638impl serde::Serialize for UserDefinedFunction {
2639 #[allow(deprecated)]
2640 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2641 where
2642 S: serde::Serializer,
2643 {
2644 use serde::ser::SerializeStruct;
2645 let mut len = 0;
2646 if !self.children.is_empty() {
2647 len += 1;
2648 }
2649 if !self.name.is_empty() {
2650 len += 1;
2651 }
2652 if !self.arg_names.is_empty() {
2653 len += 1;
2654 }
2655 if !self.arg_types.is_empty() {
2656 len += 1;
2657 }
2658 if !self.language.is_empty() {
2659 len += 1;
2660 }
2661 if self.link.is_some() {
2662 len += 1;
2663 }
2664 if self.identifier.is_some() {
2665 len += 1;
2666 }
2667 if self.body.is_some() {
2668 len += 1;
2669 }
2670 if self.compressed_binary.is_some() {
2671 len += 1;
2672 }
2673 if self.always_retry_on_network_error {
2674 len += 1;
2675 }
2676 if self.runtime.is_some() {
2677 len += 1;
2678 }
2679 if self.is_async.is_some() {
2680 len += 1;
2681 }
2682 if self.is_batched.is_some() {
2683 len += 1;
2684 }
2685 if self.version != 0 {
2686 len += 1;
2687 }
2688 let mut struct_ser = serializer.serialize_struct("expr.UserDefinedFunction", len)?;
2689 if !self.children.is_empty() {
2690 struct_ser.serialize_field("children", &self.children)?;
2691 }
2692 if !self.name.is_empty() {
2693 struct_ser.serialize_field("name", &self.name)?;
2694 }
2695 if !self.arg_names.is_empty() {
2696 struct_ser.serialize_field("argNames", &self.arg_names)?;
2697 }
2698 if !self.arg_types.is_empty() {
2699 struct_ser.serialize_field("argTypes", &self.arg_types)?;
2700 }
2701 if !self.language.is_empty() {
2702 struct_ser.serialize_field("language", &self.language)?;
2703 }
2704 if let Some(v) = self.link.as_ref() {
2705 struct_ser.serialize_field("link", v)?;
2706 }
2707 if let Some(v) = self.identifier.as_ref() {
2708 struct_ser.serialize_field("identifier", v)?;
2709 }
2710 if let Some(v) = self.body.as_ref() {
2711 struct_ser.serialize_field("body", v)?;
2712 }
2713 if let Some(v) = self.compressed_binary.as_ref() {
2714 #[allow(clippy::needless_borrow)]
2715 #[allow(clippy::needless_borrows_for_generic_args)]
2716 struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
2717 }
2718 if self.always_retry_on_network_error {
2719 struct_ser.serialize_field("alwaysRetryOnNetworkError", &self.always_retry_on_network_error)?;
2720 }
2721 if let Some(v) = self.runtime.as_ref() {
2722 struct_ser.serialize_field("runtime", v)?;
2723 }
2724 if let Some(v) = self.is_async.as_ref() {
2725 struct_ser.serialize_field("isAsync", v)?;
2726 }
2727 if let Some(v) = self.is_batched.as_ref() {
2728 struct_ser.serialize_field("isBatched", v)?;
2729 }
2730 if self.version != 0 {
2731 let v = UdfExprVersion::try_from(self.version)
2732 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
2733 struct_ser.serialize_field("version", &v)?;
2734 }
2735 struct_ser.end()
2736 }
2737}
2738impl<'de> serde::Deserialize<'de> for UserDefinedFunction {
2739 #[allow(deprecated)]
2740 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2741 where
2742 D: serde::Deserializer<'de>,
2743 {
2744 const FIELDS: &[&str] = &[
2745 "children",
2746 "name",
2747 "arg_names",
2748 "argNames",
2749 "arg_types",
2750 "argTypes",
2751 "language",
2752 "link",
2753 "identifier",
2754 "body",
2755 "compressed_binary",
2756 "compressedBinary",
2757 "always_retry_on_network_error",
2758 "alwaysRetryOnNetworkError",
2759 "runtime",
2760 "is_async",
2761 "isAsync",
2762 "is_batched",
2763 "isBatched",
2764 "version",
2765 ];
2766
2767 #[allow(clippy::enum_variant_names)]
2768 enum GeneratedField {
2769 Children,
2770 Name,
2771 ArgNames,
2772 ArgTypes,
2773 Language,
2774 Link,
2775 Identifier,
2776 Body,
2777 CompressedBinary,
2778 AlwaysRetryOnNetworkError,
2779 Runtime,
2780 IsAsync,
2781 IsBatched,
2782 Version,
2783 }
2784 impl<'de> serde::Deserialize<'de> for GeneratedField {
2785 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2786 where
2787 D: serde::Deserializer<'de>,
2788 {
2789 struct GeneratedVisitor;
2790
2791 impl serde::de::Visitor<'_> for GeneratedVisitor {
2792 type Value = GeneratedField;
2793
2794 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2795 write!(formatter, "expected one of: {:?}", &FIELDS)
2796 }
2797
2798 #[allow(unused_variables)]
2799 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2800 where
2801 E: serde::de::Error,
2802 {
2803 match value {
2804 "children" => Ok(GeneratedField::Children),
2805 "name" => Ok(GeneratedField::Name),
2806 "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
2807 "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
2808 "language" => Ok(GeneratedField::Language),
2809 "link" => Ok(GeneratedField::Link),
2810 "identifier" => Ok(GeneratedField::Identifier),
2811 "body" => Ok(GeneratedField::Body),
2812 "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
2813 "alwaysRetryOnNetworkError" | "always_retry_on_network_error" => Ok(GeneratedField::AlwaysRetryOnNetworkError),
2814 "runtime" => Ok(GeneratedField::Runtime),
2815 "isAsync" | "is_async" => Ok(GeneratedField::IsAsync),
2816 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
2817 "version" => Ok(GeneratedField::Version),
2818 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2819 }
2820 }
2821 }
2822 deserializer.deserialize_identifier(GeneratedVisitor)
2823 }
2824 }
2825 struct GeneratedVisitor;
2826 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2827 type Value = UserDefinedFunction;
2828
2829 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2830 formatter.write_str("struct expr.UserDefinedFunction")
2831 }
2832
2833 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserDefinedFunction, V::Error>
2834 where
2835 V: serde::de::MapAccess<'de>,
2836 {
2837 let mut children__ = None;
2838 let mut name__ = None;
2839 let mut arg_names__ = None;
2840 let mut arg_types__ = None;
2841 let mut language__ = None;
2842 let mut link__ = None;
2843 let mut identifier__ = None;
2844 let mut body__ = None;
2845 let mut compressed_binary__ = None;
2846 let mut always_retry_on_network_error__ = None;
2847 let mut runtime__ = None;
2848 let mut is_async__ = None;
2849 let mut is_batched__ = None;
2850 let mut version__ = None;
2851 while let Some(k) = map_.next_key()? {
2852 match k {
2853 GeneratedField::Children => {
2854 if children__.is_some() {
2855 return Err(serde::de::Error::duplicate_field("children"));
2856 }
2857 children__ = Some(map_.next_value()?);
2858 }
2859 GeneratedField::Name => {
2860 if name__.is_some() {
2861 return Err(serde::de::Error::duplicate_field("name"));
2862 }
2863 name__ = Some(map_.next_value()?);
2864 }
2865 GeneratedField::ArgNames => {
2866 if arg_names__.is_some() {
2867 return Err(serde::de::Error::duplicate_field("argNames"));
2868 }
2869 arg_names__ = Some(map_.next_value()?);
2870 }
2871 GeneratedField::ArgTypes => {
2872 if arg_types__.is_some() {
2873 return Err(serde::de::Error::duplicate_field("argTypes"));
2874 }
2875 arg_types__ = Some(map_.next_value()?);
2876 }
2877 GeneratedField::Language => {
2878 if language__.is_some() {
2879 return Err(serde::de::Error::duplicate_field("language"));
2880 }
2881 language__ = Some(map_.next_value()?);
2882 }
2883 GeneratedField::Link => {
2884 if link__.is_some() {
2885 return Err(serde::de::Error::duplicate_field("link"));
2886 }
2887 link__ = map_.next_value()?;
2888 }
2889 GeneratedField::Identifier => {
2890 if identifier__.is_some() {
2891 return Err(serde::de::Error::duplicate_field("identifier"));
2892 }
2893 identifier__ = map_.next_value()?;
2894 }
2895 GeneratedField::Body => {
2896 if body__.is_some() {
2897 return Err(serde::de::Error::duplicate_field("body"));
2898 }
2899 body__ = map_.next_value()?;
2900 }
2901 GeneratedField::CompressedBinary => {
2902 if compressed_binary__.is_some() {
2903 return Err(serde::de::Error::duplicate_field("compressedBinary"));
2904 }
2905 compressed_binary__ =
2906 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
2907 ;
2908 }
2909 GeneratedField::AlwaysRetryOnNetworkError => {
2910 if always_retry_on_network_error__.is_some() {
2911 return Err(serde::de::Error::duplicate_field("alwaysRetryOnNetworkError"));
2912 }
2913 always_retry_on_network_error__ = Some(map_.next_value()?);
2914 }
2915 GeneratedField::Runtime => {
2916 if runtime__.is_some() {
2917 return Err(serde::de::Error::duplicate_field("runtime"));
2918 }
2919 runtime__ = map_.next_value()?;
2920 }
2921 GeneratedField::IsAsync => {
2922 if is_async__.is_some() {
2923 return Err(serde::de::Error::duplicate_field("isAsync"));
2924 }
2925 is_async__ = map_.next_value()?;
2926 }
2927 GeneratedField::IsBatched => {
2928 if is_batched__.is_some() {
2929 return Err(serde::de::Error::duplicate_field("isBatched"));
2930 }
2931 is_batched__ = map_.next_value()?;
2932 }
2933 GeneratedField::Version => {
2934 if version__.is_some() {
2935 return Err(serde::de::Error::duplicate_field("version"));
2936 }
2937 version__ = Some(map_.next_value::<UdfExprVersion>()? as i32);
2938 }
2939 }
2940 }
2941 Ok(UserDefinedFunction {
2942 children: children__.unwrap_or_default(),
2943 name: name__.unwrap_or_default(),
2944 arg_names: arg_names__.unwrap_or_default(),
2945 arg_types: arg_types__.unwrap_or_default(),
2946 language: language__.unwrap_or_default(),
2947 link: link__,
2948 identifier: identifier__,
2949 body: body__,
2950 compressed_binary: compressed_binary__,
2951 always_retry_on_network_error: always_retry_on_network_error__.unwrap_or_default(),
2952 runtime: runtime__,
2953 is_async: is_async__,
2954 is_batched: is_batched__,
2955 version: version__.unwrap_or_default(),
2956 })
2957 }
2958 }
2959 deserializer.deserialize_struct("expr.UserDefinedFunction", FIELDS, GeneratedVisitor)
2960 }
2961}
2962impl serde::Serialize for UserDefinedFunctionMetadata {
2963 #[allow(deprecated)]
2964 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2965 where
2966 S: serde::Serializer,
2967 {
2968 use serde::ser::SerializeStruct;
2969 let mut len = 0;
2970 if !self.arg_names.is_empty() {
2971 len += 1;
2972 }
2973 if !self.arg_types.is_empty() {
2974 len += 1;
2975 }
2976 if self.return_type.is_some() {
2977 len += 1;
2978 }
2979 if !self.language.is_empty() {
2980 len += 1;
2981 }
2982 if self.link.is_some() {
2983 len += 1;
2984 }
2985 if self.identifier.is_some() {
2986 len += 1;
2987 }
2988 if self.body.is_some() {
2989 len += 1;
2990 }
2991 if self.compressed_binary.is_some() {
2992 len += 1;
2993 }
2994 if self.runtime.is_some() {
2995 len += 1;
2996 }
2997 if self.is_async.is_some() {
2998 len += 1;
2999 }
3000 if self.is_batched.is_some() {
3001 len += 1;
3002 }
3003 if self.version != 0 {
3004 len += 1;
3005 }
3006 let mut struct_ser = serializer.serialize_struct("expr.UserDefinedFunctionMetadata", len)?;
3007 if !self.arg_names.is_empty() {
3008 struct_ser.serialize_field("argNames", &self.arg_names)?;
3009 }
3010 if !self.arg_types.is_empty() {
3011 struct_ser.serialize_field("argTypes", &self.arg_types)?;
3012 }
3013 if let Some(v) = self.return_type.as_ref() {
3014 struct_ser.serialize_field("returnType", v)?;
3015 }
3016 if !self.language.is_empty() {
3017 struct_ser.serialize_field("language", &self.language)?;
3018 }
3019 if let Some(v) = self.link.as_ref() {
3020 struct_ser.serialize_field("link", v)?;
3021 }
3022 if let Some(v) = self.identifier.as_ref() {
3023 struct_ser.serialize_field("identifier", v)?;
3024 }
3025 if let Some(v) = self.body.as_ref() {
3026 struct_ser.serialize_field("body", v)?;
3027 }
3028 if let Some(v) = self.compressed_binary.as_ref() {
3029 #[allow(clippy::needless_borrow)]
3030 #[allow(clippy::needless_borrows_for_generic_args)]
3031 struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
3032 }
3033 if let Some(v) = self.runtime.as_ref() {
3034 struct_ser.serialize_field("runtime", v)?;
3035 }
3036 if let Some(v) = self.is_async.as_ref() {
3037 struct_ser.serialize_field("isAsync", v)?;
3038 }
3039 if let Some(v) = self.is_batched.as_ref() {
3040 struct_ser.serialize_field("isBatched", v)?;
3041 }
3042 if self.version != 0 {
3043 let v = UdfExprVersion::try_from(self.version)
3044 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
3045 struct_ser.serialize_field("version", &v)?;
3046 }
3047 struct_ser.end()
3048 }
3049}
3050impl<'de> serde::Deserialize<'de> for UserDefinedFunctionMetadata {
3051 #[allow(deprecated)]
3052 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3053 where
3054 D: serde::Deserializer<'de>,
3055 {
3056 const FIELDS: &[&str] = &[
3057 "arg_names",
3058 "argNames",
3059 "arg_types",
3060 "argTypes",
3061 "return_type",
3062 "returnType",
3063 "language",
3064 "link",
3065 "identifier",
3066 "body",
3067 "compressed_binary",
3068 "compressedBinary",
3069 "runtime",
3070 "is_async",
3071 "isAsync",
3072 "is_batched",
3073 "isBatched",
3074 "version",
3075 ];
3076
3077 #[allow(clippy::enum_variant_names)]
3078 enum GeneratedField {
3079 ArgNames,
3080 ArgTypes,
3081 ReturnType,
3082 Language,
3083 Link,
3084 Identifier,
3085 Body,
3086 CompressedBinary,
3087 Runtime,
3088 IsAsync,
3089 IsBatched,
3090 Version,
3091 }
3092 impl<'de> serde::Deserialize<'de> for GeneratedField {
3093 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3094 where
3095 D: serde::Deserializer<'de>,
3096 {
3097 struct GeneratedVisitor;
3098
3099 impl serde::de::Visitor<'_> for GeneratedVisitor {
3100 type Value = GeneratedField;
3101
3102 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3103 write!(formatter, "expected one of: {:?}", &FIELDS)
3104 }
3105
3106 #[allow(unused_variables)]
3107 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3108 where
3109 E: serde::de::Error,
3110 {
3111 match value {
3112 "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
3113 "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
3114 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
3115 "language" => Ok(GeneratedField::Language),
3116 "link" => Ok(GeneratedField::Link),
3117 "identifier" => Ok(GeneratedField::Identifier),
3118 "body" => Ok(GeneratedField::Body),
3119 "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
3120 "runtime" => Ok(GeneratedField::Runtime),
3121 "isAsync" | "is_async" => Ok(GeneratedField::IsAsync),
3122 "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
3123 "version" => Ok(GeneratedField::Version),
3124 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3125 }
3126 }
3127 }
3128 deserializer.deserialize_identifier(GeneratedVisitor)
3129 }
3130 }
3131 struct GeneratedVisitor;
3132 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3133 type Value = UserDefinedFunctionMetadata;
3134
3135 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3136 formatter.write_str("struct expr.UserDefinedFunctionMetadata")
3137 }
3138
3139 fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserDefinedFunctionMetadata, V::Error>
3140 where
3141 V: serde::de::MapAccess<'de>,
3142 {
3143 let mut arg_names__ = None;
3144 let mut arg_types__ = None;
3145 let mut return_type__ = None;
3146 let mut language__ = None;
3147 let mut link__ = None;
3148 let mut identifier__ = None;
3149 let mut body__ = None;
3150 let mut compressed_binary__ = None;
3151 let mut runtime__ = None;
3152 let mut is_async__ = None;
3153 let mut is_batched__ = None;
3154 let mut version__ = None;
3155 while let Some(k) = map_.next_key()? {
3156 match k {
3157 GeneratedField::ArgNames => {
3158 if arg_names__.is_some() {
3159 return Err(serde::de::Error::duplicate_field("argNames"));
3160 }
3161 arg_names__ = Some(map_.next_value()?);
3162 }
3163 GeneratedField::ArgTypes => {
3164 if arg_types__.is_some() {
3165 return Err(serde::de::Error::duplicate_field("argTypes"));
3166 }
3167 arg_types__ = Some(map_.next_value()?);
3168 }
3169 GeneratedField::ReturnType => {
3170 if return_type__.is_some() {
3171 return Err(serde::de::Error::duplicate_field("returnType"));
3172 }
3173 return_type__ = map_.next_value()?;
3174 }
3175 GeneratedField::Language => {
3176 if language__.is_some() {
3177 return Err(serde::de::Error::duplicate_field("language"));
3178 }
3179 language__ = Some(map_.next_value()?);
3180 }
3181 GeneratedField::Link => {
3182 if link__.is_some() {
3183 return Err(serde::de::Error::duplicate_field("link"));
3184 }
3185 link__ = map_.next_value()?;
3186 }
3187 GeneratedField::Identifier => {
3188 if identifier__.is_some() {
3189 return Err(serde::de::Error::duplicate_field("identifier"));
3190 }
3191 identifier__ = map_.next_value()?;
3192 }
3193 GeneratedField::Body => {
3194 if body__.is_some() {
3195 return Err(serde::de::Error::duplicate_field("body"));
3196 }
3197 body__ = map_.next_value()?;
3198 }
3199 GeneratedField::CompressedBinary => {
3200 if compressed_binary__.is_some() {
3201 return Err(serde::de::Error::duplicate_field("compressedBinary"));
3202 }
3203 compressed_binary__ =
3204 map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
3205 ;
3206 }
3207 GeneratedField::Runtime => {
3208 if runtime__.is_some() {
3209 return Err(serde::de::Error::duplicate_field("runtime"));
3210 }
3211 runtime__ = map_.next_value()?;
3212 }
3213 GeneratedField::IsAsync => {
3214 if is_async__.is_some() {
3215 return Err(serde::de::Error::duplicate_field("isAsync"));
3216 }
3217 is_async__ = map_.next_value()?;
3218 }
3219 GeneratedField::IsBatched => {
3220 if is_batched__.is_some() {
3221 return Err(serde::de::Error::duplicate_field("isBatched"));
3222 }
3223 is_batched__ = map_.next_value()?;
3224 }
3225 GeneratedField::Version => {
3226 if version__.is_some() {
3227 return Err(serde::de::Error::duplicate_field("version"));
3228 }
3229 version__ = Some(map_.next_value::<UdfExprVersion>()? as i32);
3230 }
3231 }
3232 }
3233 Ok(UserDefinedFunctionMetadata {
3234 arg_names: arg_names__.unwrap_or_default(),
3235 arg_types: arg_types__.unwrap_or_default(),
3236 return_type: return_type__,
3237 language: language__.unwrap_or_default(),
3238 link: link__,
3239 identifier: identifier__,
3240 body: body__,
3241 compressed_binary: compressed_binary__,
3242 runtime: runtime__,
3243 is_async: is_async__,
3244 is_batched: is_batched__,
3245 version: version__.unwrap_or_default(),
3246 })
3247 }
3248 }
3249 deserializer.deserialize_struct("expr.UserDefinedFunctionMetadata", FIELDS, GeneratedVisitor)
3250 }
3251}
3252impl serde::Serialize for WindowFrame {
3253 #[allow(deprecated)]
3254 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3255 where
3256 S: serde::Serializer,
3257 {
3258 use serde::ser::SerializeStruct;
3259 let mut len = 0;
3260 if self.r#type != 0 {
3261 len += 1;
3262 }
3263 if self.start.is_some() {
3264 len += 1;
3265 }
3266 if self.end.is_some() {
3267 len += 1;
3268 }
3269 if self.exclusion != 0 {
3270 len += 1;
3271 }
3272 if self.bounds.is_some() {
3273 len += 1;
3274 }
3275 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame", len)?;
3276 if self.r#type != 0 {
3277 let v = window_frame::Type::try_from(self.r#type)
3278 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3279 struct_ser.serialize_field("type", &v)?;
3280 }
3281 if let Some(v) = self.start.as_ref() {
3282 struct_ser.serialize_field("start", v)?;
3283 }
3284 if let Some(v) = self.end.as_ref() {
3285 struct_ser.serialize_field("end", v)?;
3286 }
3287 if self.exclusion != 0 {
3288 let v = window_frame::Exclusion::try_from(self.exclusion)
3289 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.exclusion)))?;
3290 struct_ser.serialize_field("exclusion", &v)?;
3291 }
3292 if let Some(v) = self.bounds.as_ref() {
3293 match v {
3294 window_frame::Bounds::Rows(v) => {
3295 struct_ser.serialize_field("rows", v)?;
3296 }
3297 window_frame::Bounds::Range(v) => {
3298 struct_ser.serialize_field("range", v)?;
3299 }
3300 window_frame::Bounds::Session(v) => {
3301 struct_ser.serialize_field("session", v)?;
3302 }
3303 }
3304 }
3305 struct_ser.end()
3306 }
3307}
3308impl<'de> serde::Deserialize<'de> for WindowFrame {
3309 #[allow(deprecated)]
3310 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3311 where
3312 D: serde::Deserializer<'de>,
3313 {
3314 const FIELDS: &[&str] = &[
3315 "type",
3316 "start",
3317 "end",
3318 "exclusion",
3319 "rows",
3320 "range",
3321 "session",
3322 ];
3323
3324 #[allow(clippy::enum_variant_names)]
3325 enum GeneratedField {
3326 Type,
3327 Start,
3328 End,
3329 Exclusion,
3330 Rows,
3331 Range,
3332 Session,
3333 }
3334 impl<'de> serde::Deserialize<'de> for GeneratedField {
3335 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3336 where
3337 D: serde::Deserializer<'de>,
3338 {
3339 struct GeneratedVisitor;
3340
3341 impl serde::de::Visitor<'_> for GeneratedVisitor {
3342 type Value = GeneratedField;
3343
3344 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3345 write!(formatter, "expected one of: {:?}", &FIELDS)
3346 }
3347
3348 #[allow(unused_variables)]
3349 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3350 where
3351 E: serde::de::Error,
3352 {
3353 match value {
3354 "type" => Ok(GeneratedField::Type),
3355 "start" => Ok(GeneratedField::Start),
3356 "end" => Ok(GeneratedField::End),
3357 "exclusion" => Ok(GeneratedField::Exclusion),
3358 "rows" => Ok(GeneratedField::Rows),
3359 "range" => Ok(GeneratedField::Range),
3360 "session" => Ok(GeneratedField::Session),
3361 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3362 }
3363 }
3364 }
3365 deserializer.deserialize_identifier(GeneratedVisitor)
3366 }
3367 }
3368 struct GeneratedVisitor;
3369 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3370 type Value = WindowFrame;
3371
3372 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3373 formatter.write_str("struct expr.WindowFrame")
3374 }
3375
3376 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WindowFrame, V::Error>
3377 where
3378 V: serde::de::MapAccess<'de>,
3379 {
3380 let mut r#type__ = None;
3381 let mut start__ = None;
3382 let mut end__ = None;
3383 let mut exclusion__ = None;
3384 let mut bounds__ = None;
3385 while let Some(k) = map_.next_key()? {
3386 match k {
3387 GeneratedField::Type => {
3388 if r#type__.is_some() {
3389 return Err(serde::de::Error::duplicate_field("type"));
3390 }
3391 r#type__ = Some(map_.next_value::<window_frame::Type>()? as i32);
3392 }
3393 GeneratedField::Start => {
3394 if start__.is_some() {
3395 return Err(serde::de::Error::duplicate_field("start"));
3396 }
3397 start__ = map_.next_value()?;
3398 }
3399 GeneratedField::End => {
3400 if end__.is_some() {
3401 return Err(serde::de::Error::duplicate_field("end"));
3402 }
3403 end__ = map_.next_value()?;
3404 }
3405 GeneratedField::Exclusion => {
3406 if exclusion__.is_some() {
3407 return Err(serde::de::Error::duplicate_field("exclusion"));
3408 }
3409 exclusion__ = Some(map_.next_value::<window_frame::Exclusion>()? as i32);
3410 }
3411 GeneratedField::Rows => {
3412 if bounds__.is_some() {
3413 return Err(serde::de::Error::duplicate_field("rows"));
3414 }
3415 bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Rows)
3416;
3417 }
3418 GeneratedField::Range => {
3419 if bounds__.is_some() {
3420 return Err(serde::de::Error::duplicate_field("range"));
3421 }
3422 bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Range)
3423;
3424 }
3425 GeneratedField::Session => {
3426 if bounds__.is_some() {
3427 return Err(serde::de::Error::duplicate_field("session"));
3428 }
3429 bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Session)
3430;
3431 }
3432 }
3433 }
3434 Ok(WindowFrame {
3435 r#type: r#type__.unwrap_or_default(),
3436 start: start__,
3437 end: end__,
3438 exclusion: exclusion__.unwrap_or_default(),
3439 bounds: bounds__,
3440 })
3441 }
3442 }
3443 deserializer.deserialize_struct("expr.WindowFrame", FIELDS, GeneratedVisitor)
3444 }
3445}
3446impl serde::Serialize for window_frame::Bound {
3447 #[allow(deprecated)]
3448 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3449 where
3450 S: serde::Serializer,
3451 {
3452 use serde::ser::SerializeStruct;
3453 let mut len = 0;
3454 if self.r#type != 0 {
3455 len += 1;
3456 }
3457 if self.offset.is_some() {
3458 len += 1;
3459 }
3460 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.Bound", len)?;
3461 if self.r#type != 0 {
3462 let v = window_frame::BoundType::try_from(self.r#type)
3463 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3464 struct_ser.serialize_field("type", &v)?;
3465 }
3466 if let Some(v) = self.offset.as_ref() {
3467 match v {
3468 window_frame::bound::Offset::Integer(v) => {
3469 #[allow(clippy::needless_borrow)]
3470 #[allow(clippy::needless_borrows_for_generic_args)]
3471 struct_ser.serialize_field("integer", ToString::to_string(&v).as_str())?;
3472 }
3473 window_frame::bound::Offset::Datum(v) => {
3474 struct_ser.serialize_field("datum", v)?;
3475 }
3476 }
3477 }
3478 struct_ser.end()
3479 }
3480}
3481impl<'de> serde::Deserialize<'de> for window_frame::Bound {
3482 #[allow(deprecated)]
3483 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3484 where
3485 D: serde::Deserializer<'de>,
3486 {
3487 const FIELDS: &[&str] = &[
3488 "type",
3489 "integer",
3490 "datum",
3491 ];
3492
3493 #[allow(clippy::enum_variant_names)]
3494 enum GeneratedField {
3495 Type,
3496 Integer,
3497 Datum,
3498 }
3499 impl<'de> serde::Deserialize<'de> for GeneratedField {
3500 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3501 where
3502 D: serde::Deserializer<'de>,
3503 {
3504 struct GeneratedVisitor;
3505
3506 impl serde::de::Visitor<'_> for GeneratedVisitor {
3507 type Value = GeneratedField;
3508
3509 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3510 write!(formatter, "expected one of: {:?}", &FIELDS)
3511 }
3512
3513 #[allow(unused_variables)]
3514 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3515 where
3516 E: serde::de::Error,
3517 {
3518 match value {
3519 "type" => Ok(GeneratedField::Type),
3520 "integer" => Ok(GeneratedField::Integer),
3521 "datum" => Ok(GeneratedField::Datum),
3522 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3523 }
3524 }
3525 }
3526 deserializer.deserialize_identifier(GeneratedVisitor)
3527 }
3528 }
3529 struct GeneratedVisitor;
3530 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3531 type Value = window_frame::Bound;
3532
3533 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3534 formatter.write_str("struct expr.WindowFrame.Bound")
3535 }
3536
3537 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::Bound, V::Error>
3538 where
3539 V: serde::de::MapAccess<'de>,
3540 {
3541 let mut r#type__ = None;
3542 let mut offset__ = None;
3543 while let Some(k) = map_.next_key()? {
3544 match k {
3545 GeneratedField::Type => {
3546 if r#type__.is_some() {
3547 return Err(serde::de::Error::duplicate_field("type"));
3548 }
3549 r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3550 }
3551 GeneratedField::Integer => {
3552 if offset__.is_some() {
3553 return Err(serde::de::Error::duplicate_field("integer"));
3554 }
3555 offset__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| window_frame::bound::Offset::Integer(x.0));
3556 }
3557 GeneratedField::Datum => {
3558 if offset__.is_some() {
3559 return Err(serde::de::Error::duplicate_field("datum"));
3560 }
3561 offset__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::bound::Offset::Datum)
3562;
3563 }
3564 }
3565 }
3566 Ok(window_frame::Bound {
3567 r#type: r#type__.unwrap_or_default(),
3568 offset: offset__,
3569 })
3570 }
3571 }
3572 deserializer.deserialize_struct("expr.WindowFrame.Bound", FIELDS, GeneratedVisitor)
3573 }
3574}
3575impl serde::Serialize for window_frame::BoundType {
3576 #[allow(deprecated)]
3577 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3578 where
3579 S: serde::Serializer,
3580 {
3581 let variant = match self {
3582 Self::Unspecified => "BOUND_TYPE_UNSPECIFIED",
3583 Self::UnboundedPreceding => "BOUND_TYPE_UNBOUNDED_PRECEDING",
3584 Self::Preceding => "BOUND_TYPE_PRECEDING",
3585 Self::CurrentRow => "BOUND_TYPE_CURRENT_ROW",
3586 Self::Following => "BOUND_TYPE_FOLLOWING",
3587 Self::UnboundedFollowing => "BOUND_TYPE_UNBOUNDED_FOLLOWING",
3588 };
3589 serializer.serialize_str(variant)
3590 }
3591}
3592impl<'de> serde::Deserialize<'de> for window_frame::BoundType {
3593 #[allow(deprecated)]
3594 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3595 where
3596 D: serde::Deserializer<'de>,
3597 {
3598 const FIELDS: &[&str] = &[
3599 "BOUND_TYPE_UNSPECIFIED",
3600 "BOUND_TYPE_UNBOUNDED_PRECEDING",
3601 "BOUND_TYPE_PRECEDING",
3602 "BOUND_TYPE_CURRENT_ROW",
3603 "BOUND_TYPE_FOLLOWING",
3604 "BOUND_TYPE_UNBOUNDED_FOLLOWING",
3605 ];
3606
3607 struct GeneratedVisitor;
3608
3609 impl serde::de::Visitor<'_> for GeneratedVisitor {
3610 type Value = window_frame::BoundType;
3611
3612 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3613 write!(formatter, "expected one of: {:?}", &FIELDS)
3614 }
3615
3616 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3617 where
3618 E: serde::de::Error,
3619 {
3620 i32::try_from(v)
3621 .ok()
3622 .and_then(|x| x.try_into().ok())
3623 .ok_or_else(|| {
3624 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3625 })
3626 }
3627
3628 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3629 where
3630 E: serde::de::Error,
3631 {
3632 i32::try_from(v)
3633 .ok()
3634 .and_then(|x| x.try_into().ok())
3635 .ok_or_else(|| {
3636 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3637 })
3638 }
3639
3640 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3641 where
3642 E: serde::de::Error,
3643 {
3644 match value {
3645 "BOUND_TYPE_UNSPECIFIED" => Ok(window_frame::BoundType::Unspecified),
3646 "BOUND_TYPE_UNBOUNDED_PRECEDING" => Ok(window_frame::BoundType::UnboundedPreceding),
3647 "BOUND_TYPE_PRECEDING" => Ok(window_frame::BoundType::Preceding),
3648 "BOUND_TYPE_CURRENT_ROW" => Ok(window_frame::BoundType::CurrentRow),
3649 "BOUND_TYPE_FOLLOWING" => Ok(window_frame::BoundType::Following),
3650 "BOUND_TYPE_UNBOUNDED_FOLLOWING" => Ok(window_frame::BoundType::UnboundedFollowing),
3651 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3652 }
3653 }
3654 }
3655 deserializer.deserialize_any(GeneratedVisitor)
3656 }
3657}
3658impl serde::Serialize for window_frame::Exclusion {
3659 #[allow(deprecated)]
3660 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3661 where
3662 S: serde::Serializer,
3663 {
3664 let variant = match self {
3665 Self::Unspecified => "EXCLUSION_UNSPECIFIED",
3666 Self::CurrentRow => "EXCLUSION_CURRENT_ROW",
3667 Self::NoOthers => "EXCLUSION_NO_OTHERS",
3668 };
3669 serializer.serialize_str(variant)
3670 }
3671}
3672impl<'de> serde::Deserialize<'de> for window_frame::Exclusion {
3673 #[allow(deprecated)]
3674 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3675 where
3676 D: serde::Deserializer<'de>,
3677 {
3678 const FIELDS: &[&str] = &[
3679 "EXCLUSION_UNSPECIFIED",
3680 "EXCLUSION_CURRENT_ROW",
3681 "EXCLUSION_NO_OTHERS",
3682 ];
3683
3684 struct GeneratedVisitor;
3685
3686 impl serde::de::Visitor<'_> for GeneratedVisitor {
3687 type Value = window_frame::Exclusion;
3688
3689 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3690 write!(formatter, "expected one of: {:?}", &FIELDS)
3691 }
3692
3693 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3694 where
3695 E: serde::de::Error,
3696 {
3697 i32::try_from(v)
3698 .ok()
3699 .and_then(|x| x.try_into().ok())
3700 .ok_or_else(|| {
3701 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3702 })
3703 }
3704
3705 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3706 where
3707 E: serde::de::Error,
3708 {
3709 i32::try_from(v)
3710 .ok()
3711 .and_then(|x| x.try_into().ok())
3712 .ok_or_else(|| {
3713 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3714 })
3715 }
3716
3717 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3718 where
3719 E: serde::de::Error,
3720 {
3721 match value {
3722 "EXCLUSION_UNSPECIFIED" => Ok(window_frame::Exclusion::Unspecified),
3723 "EXCLUSION_CURRENT_ROW" => Ok(window_frame::Exclusion::CurrentRow),
3724 "EXCLUSION_NO_OTHERS" => Ok(window_frame::Exclusion::NoOthers),
3725 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3726 }
3727 }
3728 }
3729 deserializer.deserialize_any(GeneratedVisitor)
3730 }
3731}
3732impl serde::Serialize for window_frame::RangeFrameBound {
3733 #[allow(deprecated)]
3734 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3735 where
3736 S: serde::Serializer,
3737 {
3738 use serde::ser::SerializeStruct;
3739 let mut len = 0;
3740 if self.r#type != 0 {
3741 len += 1;
3742 }
3743 if self.offset.is_some() {
3744 len += 1;
3745 }
3746 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RangeFrameBound", len)?;
3747 if self.r#type != 0 {
3748 let v = window_frame::BoundType::try_from(self.r#type)
3749 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3750 struct_ser.serialize_field("type", &v)?;
3751 }
3752 if let Some(v) = self.offset.as_ref() {
3753 struct_ser.serialize_field("offset", v)?;
3754 }
3755 struct_ser.end()
3756 }
3757}
3758impl<'de> serde::Deserialize<'de> for window_frame::RangeFrameBound {
3759 #[allow(deprecated)]
3760 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3761 where
3762 D: serde::Deserializer<'de>,
3763 {
3764 const FIELDS: &[&str] = &[
3765 "type",
3766 "offset",
3767 ];
3768
3769 #[allow(clippy::enum_variant_names)]
3770 enum GeneratedField {
3771 Type,
3772 Offset,
3773 }
3774 impl<'de> serde::Deserialize<'de> for GeneratedField {
3775 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3776 where
3777 D: serde::Deserializer<'de>,
3778 {
3779 struct GeneratedVisitor;
3780
3781 impl serde::de::Visitor<'_> for GeneratedVisitor {
3782 type Value = GeneratedField;
3783
3784 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3785 write!(formatter, "expected one of: {:?}", &FIELDS)
3786 }
3787
3788 #[allow(unused_variables)]
3789 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3790 where
3791 E: serde::de::Error,
3792 {
3793 match value {
3794 "type" => Ok(GeneratedField::Type),
3795 "offset" => Ok(GeneratedField::Offset),
3796 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3797 }
3798 }
3799 }
3800 deserializer.deserialize_identifier(GeneratedVisitor)
3801 }
3802 }
3803 struct GeneratedVisitor;
3804 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3805 type Value = window_frame::RangeFrameBound;
3806
3807 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3808 formatter.write_str("struct expr.WindowFrame.RangeFrameBound")
3809 }
3810
3811 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RangeFrameBound, V::Error>
3812 where
3813 V: serde::de::MapAccess<'de>,
3814 {
3815 let mut r#type__ = None;
3816 let mut offset__ = None;
3817 while let Some(k) = map_.next_key()? {
3818 match k {
3819 GeneratedField::Type => {
3820 if r#type__.is_some() {
3821 return Err(serde::de::Error::duplicate_field("type"));
3822 }
3823 r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3824 }
3825 GeneratedField::Offset => {
3826 if offset__.is_some() {
3827 return Err(serde::de::Error::duplicate_field("offset"));
3828 }
3829 offset__ = map_.next_value()?;
3830 }
3831 }
3832 }
3833 Ok(window_frame::RangeFrameBound {
3834 r#type: r#type__.unwrap_or_default(),
3835 offset: offset__,
3836 })
3837 }
3838 }
3839 deserializer.deserialize_struct("expr.WindowFrame.RangeFrameBound", FIELDS, GeneratedVisitor)
3840 }
3841}
3842impl serde::Serialize for window_frame::RangeFrameBounds {
3843 #[allow(deprecated)]
3844 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3845 where
3846 S: serde::Serializer,
3847 {
3848 use serde::ser::SerializeStruct;
3849 let mut len = 0;
3850 if self.start.is_some() {
3851 len += 1;
3852 }
3853 if self.end.is_some() {
3854 len += 1;
3855 }
3856 if self.order_data_type.is_some() {
3857 len += 1;
3858 }
3859 if self.order_type.is_some() {
3860 len += 1;
3861 }
3862 if self.offset_data_type.is_some() {
3863 len += 1;
3864 }
3865 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RangeFrameBounds", len)?;
3866 if let Some(v) = self.start.as_ref() {
3867 struct_ser.serialize_field("start", v)?;
3868 }
3869 if let Some(v) = self.end.as_ref() {
3870 struct_ser.serialize_field("end", v)?;
3871 }
3872 if let Some(v) = self.order_data_type.as_ref() {
3873 struct_ser.serialize_field("orderDataType", v)?;
3874 }
3875 if let Some(v) = self.order_type.as_ref() {
3876 struct_ser.serialize_field("orderType", v)?;
3877 }
3878 if let Some(v) = self.offset_data_type.as_ref() {
3879 struct_ser.serialize_field("offsetDataType", v)?;
3880 }
3881 struct_ser.end()
3882 }
3883}
3884impl<'de> serde::Deserialize<'de> for window_frame::RangeFrameBounds {
3885 #[allow(deprecated)]
3886 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3887 where
3888 D: serde::Deserializer<'de>,
3889 {
3890 const FIELDS: &[&str] = &[
3891 "start",
3892 "end",
3893 "order_data_type",
3894 "orderDataType",
3895 "order_type",
3896 "orderType",
3897 "offset_data_type",
3898 "offsetDataType",
3899 ];
3900
3901 #[allow(clippy::enum_variant_names)]
3902 enum GeneratedField {
3903 Start,
3904 End,
3905 OrderDataType,
3906 OrderType,
3907 OffsetDataType,
3908 }
3909 impl<'de> serde::Deserialize<'de> for GeneratedField {
3910 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3911 where
3912 D: serde::Deserializer<'de>,
3913 {
3914 struct GeneratedVisitor;
3915
3916 impl serde::de::Visitor<'_> for GeneratedVisitor {
3917 type Value = GeneratedField;
3918
3919 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3920 write!(formatter, "expected one of: {:?}", &FIELDS)
3921 }
3922
3923 #[allow(unused_variables)]
3924 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3925 where
3926 E: serde::de::Error,
3927 {
3928 match value {
3929 "start" => Ok(GeneratedField::Start),
3930 "end" => Ok(GeneratedField::End),
3931 "orderDataType" | "order_data_type" => Ok(GeneratedField::OrderDataType),
3932 "orderType" | "order_type" => Ok(GeneratedField::OrderType),
3933 "offsetDataType" | "offset_data_type" => Ok(GeneratedField::OffsetDataType),
3934 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3935 }
3936 }
3937 }
3938 deserializer.deserialize_identifier(GeneratedVisitor)
3939 }
3940 }
3941 struct GeneratedVisitor;
3942 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3943 type Value = window_frame::RangeFrameBounds;
3944
3945 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3946 formatter.write_str("struct expr.WindowFrame.RangeFrameBounds")
3947 }
3948
3949 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RangeFrameBounds, V::Error>
3950 where
3951 V: serde::de::MapAccess<'de>,
3952 {
3953 let mut start__ = None;
3954 let mut end__ = None;
3955 let mut order_data_type__ = None;
3956 let mut order_type__ = None;
3957 let mut offset_data_type__ = None;
3958 while let Some(k) = map_.next_key()? {
3959 match k {
3960 GeneratedField::Start => {
3961 if start__.is_some() {
3962 return Err(serde::de::Error::duplicate_field("start"));
3963 }
3964 start__ = map_.next_value()?;
3965 }
3966 GeneratedField::End => {
3967 if end__.is_some() {
3968 return Err(serde::de::Error::duplicate_field("end"));
3969 }
3970 end__ = map_.next_value()?;
3971 }
3972 GeneratedField::OrderDataType => {
3973 if order_data_type__.is_some() {
3974 return Err(serde::de::Error::duplicate_field("orderDataType"));
3975 }
3976 order_data_type__ = map_.next_value()?;
3977 }
3978 GeneratedField::OrderType => {
3979 if order_type__.is_some() {
3980 return Err(serde::de::Error::duplicate_field("orderType"));
3981 }
3982 order_type__ = map_.next_value()?;
3983 }
3984 GeneratedField::OffsetDataType => {
3985 if offset_data_type__.is_some() {
3986 return Err(serde::de::Error::duplicate_field("offsetDataType"));
3987 }
3988 offset_data_type__ = map_.next_value()?;
3989 }
3990 }
3991 }
3992 Ok(window_frame::RangeFrameBounds {
3993 start: start__,
3994 end: end__,
3995 order_data_type: order_data_type__,
3996 order_type: order_type__,
3997 offset_data_type: offset_data_type__,
3998 })
3999 }
4000 }
4001 deserializer.deserialize_struct("expr.WindowFrame.RangeFrameBounds", FIELDS, GeneratedVisitor)
4002 }
4003}
4004impl serde::Serialize for window_frame::RowsFrameBound {
4005 #[allow(deprecated)]
4006 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4007 where
4008 S: serde::Serializer,
4009 {
4010 use serde::ser::SerializeStruct;
4011 let mut len = 0;
4012 if self.r#type != 0 {
4013 len += 1;
4014 }
4015 if self.offset.is_some() {
4016 len += 1;
4017 }
4018 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RowsFrameBound", len)?;
4019 if self.r#type != 0 {
4020 let v = window_frame::BoundType::try_from(self.r#type)
4021 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
4022 struct_ser.serialize_field("type", &v)?;
4023 }
4024 if let Some(v) = self.offset.as_ref() {
4025 #[allow(clippy::needless_borrow)]
4026 #[allow(clippy::needless_borrows_for_generic_args)]
4027 struct_ser.serialize_field("offset", ToString::to_string(&v).as_str())?;
4028 }
4029 struct_ser.end()
4030 }
4031}
4032impl<'de> serde::Deserialize<'de> for window_frame::RowsFrameBound {
4033 #[allow(deprecated)]
4034 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4035 where
4036 D: serde::Deserializer<'de>,
4037 {
4038 const FIELDS: &[&str] = &[
4039 "type",
4040 "offset",
4041 ];
4042
4043 #[allow(clippy::enum_variant_names)]
4044 enum GeneratedField {
4045 Type,
4046 Offset,
4047 }
4048 impl<'de> serde::Deserialize<'de> for GeneratedField {
4049 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4050 where
4051 D: serde::Deserializer<'de>,
4052 {
4053 struct GeneratedVisitor;
4054
4055 impl serde::de::Visitor<'_> for GeneratedVisitor {
4056 type Value = GeneratedField;
4057
4058 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4059 write!(formatter, "expected one of: {:?}", &FIELDS)
4060 }
4061
4062 #[allow(unused_variables)]
4063 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4064 where
4065 E: serde::de::Error,
4066 {
4067 match value {
4068 "type" => Ok(GeneratedField::Type),
4069 "offset" => Ok(GeneratedField::Offset),
4070 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4071 }
4072 }
4073 }
4074 deserializer.deserialize_identifier(GeneratedVisitor)
4075 }
4076 }
4077 struct GeneratedVisitor;
4078 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4079 type Value = window_frame::RowsFrameBound;
4080
4081 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4082 formatter.write_str("struct expr.WindowFrame.RowsFrameBound")
4083 }
4084
4085 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RowsFrameBound, V::Error>
4086 where
4087 V: serde::de::MapAccess<'de>,
4088 {
4089 let mut r#type__ = None;
4090 let mut offset__ = None;
4091 while let Some(k) = map_.next_key()? {
4092 match k {
4093 GeneratedField::Type => {
4094 if r#type__.is_some() {
4095 return Err(serde::de::Error::duplicate_field("type"));
4096 }
4097 r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
4098 }
4099 GeneratedField::Offset => {
4100 if offset__.is_some() {
4101 return Err(serde::de::Error::duplicate_field("offset"));
4102 }
4103 offset__ =
4104 map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4105 ;
4106 }
4107 }
4108 }
4109 Ok(window_frame::RowsFrameBound {
4110 r#type: r#type__.unwrap_or_default(),
4111 offset: offset__,
4112 })
4113 }
4114 }
4115 deserializer.deserialize_struct("expr.WindowFrame.RowsFrameBound", FIELDS, GeneratedVisitor)
4116 }
4117}
4118impl serde::Serialize for window_frame::RowsFrameBounds {
4119 #[allow(deprecated)]
4120 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4121 where
4122 S: serde::Serializer,
4123 {
4124 use serde::ser::SerializeStruct;
4125 let mut len = 0;
4126 if self.start.is_some() {
4127 len += 1;
4128 }
4129 if self.end.is_some() {
4130 len += 1;
4131 }
4132 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RowsFrameBounds", len)?;
4133 if let Some(v) = self.start.as_ref() {
4134 struct_ser.serialize_field("start", v)?;
4135 }
4136 if let Some(v) = self.end.as_ref() {
4137 struct_ser.serialize_field("end", v)?;
4138 }
4139 struct_ser.end()
4140 }
4141}
4142impl<'de> serde::Deserialize<'de> for window_frame::RowsFrameBounds {
4143 #[allow(deprecated)]
4144 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4145 where
4146 D: serde::Deserializer<'de>,
4147 {
4148 const FIELDS: &[&str] = &[
4149 "start",
4150 "end",
4151 ];
4152
4153 #[allow(clippy::enum_variant_names)]
4154 enum GeneratedField {
4155 Start,
4156 End,
4157 }
4158 impl<'de> serde::Deserialize<'de> for GeneratedField {
4159 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4160 where
4161 D: serde::Deserializer<'de>,
4162 {
4163 struct GeneratedVisitor;
4164
4165 impl serde::de::Visitor<'_> for GeneratedVisitor {
4166 type Value = GeneratedField;
4167
4168 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4169 write!(formatter, "expected one of: {:?}", &FIELDS)
4170 }
4171
4172 #[allow(unused_variables)]
4173 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4174 where
4175 E: serde::de::Error,
4176 {
4177 match value {
4178 "start" => Ok(GeneratedField::Start),
4179 "end" => Ok(GeneratedField::End),
4180 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4181 }
4182 }
4183 }
4184 deserializer.deserialize_identifier(GeneratedVisitor)
4185 }
4186 }
4187 struct GeneratedVisitor;
4188 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4189 type Value = window_frame::RowsFrameBounds;
4190
4191 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4192 formatter.write_str("struct expr.WindowFrame.RowsFrameBounds")
4193 }
4194
4195 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RowsFrameBounds, V::Error>
4196 where
4197 V: serde::de::MapAccess<'de>,
4198 {
4199 let mut start__ = None;
4200 let mut end__ = None;
4201 while let Some(k) = map_.next_key()? {
4202 match k {
4203 GeneratedField::Start => {
4204 if start__.is_some() {
4205 return Err(serde::de::Error::duplicate_field("start"));
4206 }
4207 start__ = map_.next_value()?;
4208 }
4209 GeneratedField::End => {
4210 if end__.is_some() {
4211 return Err(serde::de::Error::duplicate_field("end"));
4212 }
4213 end__ = map_.next_value()?;
4214 }
4215 }
4216 }
4217 Ok(window_frame::RowsFrameBounds {
4218 start: start__,
4219 end: end__,
4220 })
4221 }
4222 }
4223 deserializer.deserialize_struct("expr.WindowFrame.RowsFrameBounds", FIELDS, GeneratedVisitor)
4224 }
4225}
4226impl serde::Serialize for window_frame::SessionFrameBounds {
4227 #[allow(deprecated)]
4228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4229 where
4230 S: serde::Serializer,
4231 {
4232 use serde::ser::SerializeStruct;
4233 let mut len = 0;
4234 if self.gap.is_some() {
4235 len += 1;
4236 }
4237 if self.order_data_type.is_some() {
4238 len += 1;
4239 }
4240 if self.order_type.is_some() {
4241 len += 1;
4242 }
4243 if self.gap_data_type.is_some() {
4244 len += 1;
4245 }
4246 let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.SessionFrameBounds", len)?;
4247 if let Some(v) = self.gap.as_ref() {
4248 struct_ser.serialize_field("gap", v)?;
4249 }
4250 if let Some(v) = self.order_data_type.as_ref() {
4251 struct_ser.serialize_field("orderDataType", v)?;
4252 }
4253 if let Some(v) = self.order_type.as_ref() {
4254 struct_ser.serialize_field("orderType", v)?;
4255 }
4256 if let Some(v) = self.gap_data_type.as_ref() {
4257 struct_ser.serialize_field("gapDataType", v)?;
4258 }
4259 struct_ser.end()
4260 }
4261}
4262impl<'de> serde::Deserialize<'de> for window_frame::SessionFrameBounds {
4263 #[allow(deprecated)]
4264 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4265 where
4266 D: serde::Deserializer<'de>,
4267 {
4268 const FIELDS: &[&str] = &[
4269 "gap",
4270 "order_data_type",
4271 "orderDataType",
4272 "order_type",
4273 "orderType",
4274 "gap_data_type",
4275 "gapDataType",
4276 ];
4277
4278 #[allow(clippy::enum_variant_names)]
4279 enum GeneratedField {
4280 Gap,
4281 OrderDataType,
4282 OrderType,
4283 GapDataType,
4284 }
4285 impl<'de> serde::Deserialize<'de> for GeneratedField {
4286 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4287 where
4288 D: serde::Deserializer<'de>,
4289 {
4290 struct GeneratedVisitor;
4291
4292 impl serde::de::Visitor<'_> for GeneratedVisitor {
4293 type Value = GeneratedField;
4294
4295 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4296 write!(formatter, "expected one of: {:?}", &FIELDS)
4297 }
4298
4299 #[allow(unused_variables)]
4300 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4301 where
4302 E: serde::de::Error,
4303 {
4304 match value {
4305 "gap" => Ok(GeneratedField::Gap),
4306 "orderDataType" | "order_data_type" => Ok(GeneratedField::OrderDataType),
4307 "orderType" | "order_type" => Ok(GeneratedField::OrderType),
4308 "gapDataType" | "gap_data_type" => Ok(GeneratedField::GapDataType),
4309 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4310 }
4311 }
4312 }
4313 deserializer.deserialize_identifier(GeneratedVisitor)
4314 }
4315 }
4316 struct GeneratedVisitor;
4317 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4318 type Value = window_frame::SessionFrameBounds;
4319
4320 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4321 formatter.write_str("struct expr.WindowFrame.SessionFrameBounds")
4322 }
4323
4324 fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::SessionFrameBounds, V::Error>
4325 where
4326 V: serde::de::MapAccess<'de>,
4327 {
4328 let mut gap__ = None;
4329 let mut order_data_type__ = None;
4330 let mut order_type__ = None;
4331 let mut gap_data_type__ = None;
4332 while let Some(k) = map_.next_key()? {
4333 match k {
4334 GeneratedField::Gap => {
4335 if gap__.is_some() {
4336 return Err(serde::de::Error::duplicate_field("gap"));
4337 }
4338 gap__ = map_.next_value()?;
4339 }
4340 GeneratedField::OrderDataType => {
4341 if order_data_type__.is_some() {
4342 return Err(serde::de::Error::duplicate_field("orderDataType"));
4343 }
4344 order_data_type__ = map_.next_value()?;
4345 }
4346 GeneratedField::OrderType => {
4347 if order_type__.is_some() {
4348 return Err(serde::de::Error::duplicate_field("orderType"));
4349 }
4350 order_type__ = map_.next_value()?;
4351 }
4352 GeneratedField::GapDataType => {
4353 if gap_data_type__.is_some() {
4354 return Err(serde::de::Error::duplicate_field("gapDataType"));
4355 }
4356 gap_data_type__ = map_.next_value()?;
4357 }
4358 }
4359 }
4360 Ok(window_frame::SessionFrameBounds {
4361 gap: gap__,
4362 order_data_type: order_data_type__,
4363 order_type: order_type__,
4364 gap_data_type: gap_data_type__,
4365 })
4366 }
4367 }
4368 deserializer.deserialize_struct("expr.WindowFrame.SessionFrameBounds", FIELDS, GeneratedVisitor)
4369 }
4370}
4371impl serde::Serialize for window_frame::Type {
4372 #[allow(deprecated)]
4373 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4374 where
4375 S: serde::Serializer,
4376 {
4377 let variant = match self {
4378 Self::Unspecified => "TYPE_UNSPECIFIED",
4379 Self::RowsLegacy => "TYPE_ROWS_LEGACY",
4380 Self::Rows => "TYPE_ROWS",
4381 Self::Range => "TYPE_RANGE",
4382 Self::Session => "TYPE_SESSION",
4383 };
4384 serializer.serialize_str(variant)
4385 }
4386}
4387impl<'de> serde::Deserialize<'de> for window_frame::Type {
4388 #[allow(deprecated)]
4389 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4390 where
4391 D: serde::Deserializer<'de>,
4392 {
4393 const FIELDS: &[&str] = &[
4394 "TYPE_UNSPECIFIED",
4395 "TYPE_ROWS_LEGACY",
4396 "TYPE_ROWS",
4397 "TYPE_RANGE",
4398 "TYPE_SESSION",
4399 ];
4400
4401 struct GeneratedVisitor;
4402
4403 impl serde::de::Visitor<'_> for GeneratedVisitor {
4404 type Value = window_frame::Type;
4405
4406 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4407 write!(formatter, "expected one of: {:?}", &FIELDS)
4408 }
4409
4410 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4411 where
4412 E: serde::de::Error,
4413 {
4414 i32::try_from(v)
4415 .ok()
4416 .and_then(|x| x.try_into().ok())
4417 .ok_or_else(|| {
4418 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4419 })
4420 }
4421
4422 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4423 where
4424 E: serde::de::Error,
4425 {
4426 i32::try_from(v)
4427 .ok()
4428 .and_then(|x| x.try_into().ok())
4429 .ok_or_else(|| {
4430 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4431 })
4432 }
4433
4434 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4435 where
4436 E: serde::de::Error,
4437 {
4438 match value {
4439 "TYPE_UNSPECIFIED" => Ok(window_frame::Type::Unspecified),
4440 "TYPE_ROWS_LEGACY" => Ok(window_frame::Type::RowsLegacy),
4441 "TYPE_ROWS" => Ok(window_frame::Type::Rows),
4442 "TYPE_RANGE" => Ok(window_frame::Type::Range),
4443 "TYPE_SESSION" => Ok(window_frame::Type::Session),
4444 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4445 }
4446 }
4447 }
4448 deserializer.deserialize_any(GeneratedVisitor)
4449 }
4450}
4451impl serde::Serialize for WindowFunction {
4452 #[allow(deprecated)]
4453 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4454 where
4455 S: serde::Serializer,
4456 {
4457 use serde::ser::SerializeStruct;
4458 let mut len = 0;
4459 if !self.args.is_empty() {
4460 len += 1;
4461 }
4462 if self.return_type.is_some() {
4463 len += 1;
4464 }
4465 if self.frame.is_some() {
4466 len += 1;
4467 }
4468 if self.ignore_nulls {
4469 len += 1;
4470 }
4471 if self.r#type.is_some() {
4472 len += 1;
4473 }
4474 let mut struct_ser = serializer.serialize_struct("expr.WindowFunction", len)?;
4475 if !self.args.is_empty() {
4476 struct_ser.serialize_field("args", &self.args)?;
4477 }
4478 if let Some(v) = self.return_type.as_ref() {
4479 struct_ser.serialize_field("returnType", v)?;
4480 }
4481 if let Some(v) = self.frame.as_ref() {
4482 struct_ser.serialize_field("frame", v)?;
4483 }
4484 if self.ignore_nulls {
4485 struct_ser.serialize_field("ignoreNulls", &self.ignore_nulls)?;
4486 }
4487 if let Some(v) = self.r#type.as_ref() {
4488 match v {
4489 window_function::Type::General(v) => {
4490 let v = window_function::GeneralType::try_from(*v)
4491 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
4492 struct_ser.serialize_field("general", &v)?;
4493 }
4494 window_function::Type::Aggregate(v) => {
4495 let v = agg_call::Kind::try_from(*v)
4496 .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
4497 struct_ser.serialize_field("aggregate", &v)?;
4498 }
4499 window_function::Type::Aggregate2(v) => {
4500 struct_ser.serialize_field("aggregate2", v)?;
4501 }
4502 }
4503 }
4504 struct_ser.end()
4505 }
4506}
4507impl<'de> serde::Deserialize<'de> for WindowFunction {
4508 #[allow(deprecated)]
4509 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4510 where
4511 D: serde::Deserializer<'de>,
4512 {
4513 const FIELDS: &[&str] = &[
4514 "args",
4515 "return_type",
4516 "returnType",
4517 "frame",
4518 "ignore_nulls",
4519 "ignoreNulls",
4520 "general",
4521 "aggregate",
4522 "aggregate2",
4523 ];
4524
4525 #[allow(clippy::enum_variant_names)]
4526 enum GeneratedField {
4527 Args,
4528 ReturnType,
4529 Frame,
4530 IgnoreNulls,
4531 General,
4532 Aggregate,
4533 Aggregate2,
4534 }
4535 impl<'de> serde::Deserialize<'de> for GeneratedField {
4536 fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4537 where
4538 D: serde::Deserializer<'de>,
4539 {
4540 struct GeneratedVisitor;
4541
4542 impl serde::de::Visitor<'_> for GeneratedVisitor {
4543 type Value = GeneratedField;
4544
4545 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4546 write!(formatter, "expected one of: {:?}", &FIELDS)
4547 }
4548
4549 #[allow(unused_variables)]
4550 fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4551 where
4552 E: serde::de::Error,
4553 {
4554 match value {
4555 "args" => Ok(GeneratedField::Args),
4556 "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
4557 "frame" => Ok(GeneratedField::Frame),
4558 "ignoreNulls" | "ignore_nulls" => Ok(GeneratedField::IgnoreNulls),
4559 "general" => Ok(GeneratedField::General),
4560 "aggregate" => Ok(GeneratedField::Aggregate),
4561 "aggregate2" => Ok(GeneratedField::Aggregate2),
4562 _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4563 }
4564 }
4565 }
4566 deserializer.deserialize_identifier(GeneratedVisitor)
4567 }
4568 }
4569 struct GeneratedVisitor;
4570 impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4571 type Value = WindowFunction;
4572
4573 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4574 formatter.write_str("struct expr.WindowFunction")
4575 }
4576
4577 fn visit_map<V>(self, mut map_: V) -> std::result::Result<WindowFunction, V::Error>
4578 where
4579 V: serde::de::MapAccess<'de>,
4580 {
4581 let mut args__ = None;
4582 let mut return_type__ = None;
4583 let mut frame__ = None;
4584 let mut ignore_nulls__ = None;
4585 let mut r#type__ = None;
4586 while let Some(k) = map_.next_key()? {
4587 match k {
4588 GeneratedField::Args => {
4589 if args__.is_some() {
4590 return Err(serde::de::Error::duplicate_field("args"));
4591 }
4592 args__ = Some(map_.next_value()?);
4593 }
4594 GeneratedField::ReturnType => {
4595 if return_type__.is_some() {
4596 return Err(serde::de::Error::duplicate_field("returnType"));
4597 }
4598 return_type__ = map_.next_value()?;
4599 }
4600 GeneratedField::Frame => {
4601 if frame__.is_some() {
4602 return Err(serde::de::Error::duplicate_field("frame"));
4603 }
4604 frame__ = map_.next_value()?;
4605 }
4606 GeneratedField::IgnoreNulls => {
4607 if ignore_nulls__.is_some() {
4608 return Err(serde::de::Error::duplicate_field("ignoreNulls"));
4609 }
4610 ignore_nulls__ = Some(map_.next_value()?);
4611 }
4612 GeneratedField::General => {
4613 if r#type__.is_some() {
4614 return Err(serde::de::Error::duplicate_field("general"));
4615 }
4616 r#type__ = map_.next_value::<::std::option::Option<window_function::GeneralType>>()?.map(|x| window_function::Type::General(x as i32));
4617 }
4618 GeneratedField::Aggregate => {
4619 if r#type__.is_some() {
4620 return Err(serde::de::Error::duplicate_field("aggregate"));
4621 }
4622 r#type__ = map_.next_value::<::std::option::Option<agg_call::Kind>>()?.map(|x| window_function::Type::Aggregate(x as i32));
4623 }
4624 GeneratedField::Aggregate2 => {
4625 if r#type__.is_some() {
4626 return Err(serde::de::Error::duplicate_field("aggregate2"));
4627 }
4628 r#type__ = map_.next_value::<::std::option::Option<_>>()?.map(window_function::Type::Aggregate2)
4629;
4630 }
4631 }
4632 }
4633 Ok(WindowFunction {
4634 args: args__.unwrap_or_default(),
4635 return_type: return_type__,
4636 frame: frame__,
4637 ignore_nulls: ignore_nulls__.unwrap_or_default(),
4638 r#type: r#type__,
4639 })
4640 }
4641 }
4642 deserializer.deserialize_struct("expr.WindowFunction", FIELDS, GeneratedVisitor)
4643 }
4644}
4645impl serde::Serialize for window_function::GeneralType {
4646 #[allow(deprecated)]
4647 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4648 where
4649 S: serde::Serializer,
4650 {
4651 let variant = match self {
4652 Self::Unspecified => "UNSPECIFIED",
4653 Self::RowNumber => "ROW_NUMBER",
4654 Self::Rank => "RANK",
4655 Self::DenseRank => "DENSE_RANK",
4656 Self::Lag => "LAG",
4657 Self::Lead => "LEAD",
4658 };
4659 serializer.serialize_str(variant)
4660 }
4661}
4662impl<'de> serde::Deserialize<'de> for window_function::GeneralType {
4663 #[allow(deprecated)]
4664 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4665 where
4666 D: serde::Deserializer<'de>,
4667 {
4668 const FIELDS: &[&str] = &[
4669 "UNSPECIFIED",
4670 "ROW_NUMBER",
4671 "RANK",
4672 "DENSE_RANK",
4673 "LAG",
4674 "LEAD",
4675 ];
4676
4677 struct GeneratedVisitor;
4678
4679 impl serde::de::Visitor<'_> for GeneratedVisitor {
4680 type Value = window_function::GeneralType;
4681
4682 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4683 write!(formatter, "expected one of: {:?}", &FIELDS)
4684 }
4685
4686 fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4687 where
4688 E: serde::de::Error,
4689 {
4690 i32::try_from(v)
4691 .ok()
4692 .and_then(|x| x.try_into().ok())
4693 .ok_or_else(|| {
4694 serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4695 })
4696 }
4697
4698 fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4699 where
4700 E: serde::de::Error,
4701 {
4702 i32::try_from(v)
4703 .ok()
4704 .and_then(|x| x.try_into().ok())
4705 .ok_or_else(|| {
4706 serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4707 })
4708 }
4709
4710 fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4711 where
4712 E: serde::de::Error,
4713 {
4714 match value {
4715 "UNSPECIFIED" => Ok(window_function::GeneralType::Unspecified),
4716 "ROW_NUMBER" => Ok(window_function::GeneralType::RowNumber),
4717 "RANK" => Ok(window_function::GeneralType::Rank),
4718 "DENSE_RANK" => Ok(window_function::GeneralType::DenseRank),
4719 "LAG" => Ok(window_function::GeneralType::Lag),
4720 "LEAD" => Ok(window_function::GeneralType::Lead),
4721 _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4722 }
4723 }
4724 }
4725 deserializer.deserialize_any(GeneratedVisitor)
4726 }
4727}