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