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