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