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