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