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