risingwave_pb/
expr.serde.rs

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