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::L2Distance => "L2_DISTANCE",
1132            Self::CompositeCast => "COMPOSITE_CAST",
1133            Self::Vnode => "VNODE",
1134            Self::TestPaidTier => "TEST_PAID_TIER",
1135            Self::VnodeUser => "VNODE_USER",
1136            Self::License => "LICENSE",
1137            Self::Proctime => "PROCTIME",
1138            Self::PgSleep => "PG_SLEEP",
1139            Self::PgSleepFor => "PG_SLEEP_FOR",
1140            Self::PgSleepUntil => "PG_SLEEP_UNTIL",
1141            Self::CastRegclass => "CAST_REGCLASS",
1142            Self::PgGetIndexdef => "PG_GET_INDEXDEF",
1143            Self::ColDescription => "COL_DESCRIPTION",
1144            Self::PgGetViewdef => "PG_GET_VIEWDEF",
1145            Self::PgGetUserbyid => "PG_GET_USERBYID",
1146            Self::PgIndexesSize => "PG_INDEXES_SIZE",
1147            Self::PgRelationSize => "PG_RELATION_SIZE",
1148            Self::PgGetSerialSequence => "PG_GET_SERIAL_SEQUENCE",
1149            Self::PgIndexColumnHasProperty => "PG_INDEX_COLUMN_HAS_PROPERTY",
1150            Self::HasTablePrivilege => "HAS_TABLE_PRIVILEGE",
1151            Self::HasAnyColumnPrivilege => "HAS_ANY_COLUMN_PRIVILEGE",
1152            Self::HasSchemaPrivilege => "HAS_SCHEMA_PRIVILEGE",
1153            Self::PgIsInRecovery => "PG_IS_IN_RECOVERY",
1154            Self::RwRecoveryStatus => "RW_RECOVERY_STATUS",
1155            Self::RwEpochToTs => "RW_EPOCH_TO_TS",
1156            Self::PgTableIsVisible => "PG_TABLE_IS_VISIBLE",
1157            Self::HasFunctionPrivilege => "HAS_FUNCTION_PRIVILEGE",
1158            Self::IcebergTransform => "ICEBERG_TRANSFORM",
1159            Self::OpenaiEmbedding => "OPENAI_EMBEDDING",
1160        };
1161        serializer.serialize_str(variant)
1162    }
1163}
1164impl<'de> serde::Deserialize<'de> for expr_node::Type {
1165    #[allow(deprecated)]
1166    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1167    where
1168        D: serde::Deserializer<'de>,
1169    {
1170        const FIELDS: &[&str] = &[
1171            "UNSPECIFIED",
1172            "ADD",
1173            "SUBTRACT",
1174            "MULTIPLY",
1175            "DIVIDE",
1176            "MODULUS",
1177            "EQUAL",
1178            "NOT_EQUAL",
1179            "LESS_THAN",
1180            "LESS_THAN_OR_EQUAL",
1181            "GREATER_THAN",
1182            "GREATER_THAN_OR_EQUAL",
1183            "GREATEST",
1184            "LEAST",
1185            "AND",
1186            "OR",
1187            "NOT",
1188            "IN",
1189            "SOME",
1190            "ALL",
1191            "BITWISE_AND",
1192            "BITWISE_OR",
1193            "BITWISE_XOR",
1194            "BITWISE_NOT",
1195            "BITWISE_SHIFT_LEFT",
1196            "BITWISE_SHIFT_RIGHT",
1197            "EXTRACT",
1198            "DATE_PART",
1199            "TUMBLE_START",
1200            "MAKE_DATE",
1201            "MAKE_TIME",
1202            "MAKE_TIMESTAMP",
1203            "DATE_BIN",
1204            "SEC_TO_TIMESTAMPTZ",
1205            "AT_TIME_ZONE",
1206            "DATE_TRUNC",
1207            "CHAR_TO_TIMESTAMPTZ",
1208            "CHAR_TO_DATE",
1209            "CAST_WITH_TIME_ZONE",
1210            "ADD_WITH_TIME_ZONE",
1211            "SUBTRACT_WITH_TIME_ZONE",
1212            "MAKE_TIMESTAMPTZ",
1213            "CAST",
1214            "SUBSTR",
1215            "LENGTH",
1216            "LIKE",
1217            "I_LIKE",
1218            "SIMILAR_TO_ESCAPE",
1219            "UPPER",
1220            "LOWER",
1221            "TRIM",
1222            "REPLACE",
1223            "POSITION",
1224            "LTRIM",
1225            "RTRIM",
1226            "CASE",
1227            "CONSTANT_LOOKUP",
1228            "ROUND_DIGIT",
1229            "ROUND",
1230            "ASCII",
1231            "TRANSLATE",
1232            "COALESCE",
1233            "CONCAT_WS",
1234            "CONCAT_WS_VARIADIC",
1235            "ABS",
1236            "SPLIT_PART",
1237            "CEIL",
1238            "FLOOR",
1239            "TO_CHAR",
1240            "MD5",
1241            "CHAR_LENGTH",
1242            "REPEAT",
1243            "CONCAT_OP",
1244            "BYTEA_CONCAT_OP",
1245            "CONCAT",
1246            "CONCAT_VARIADIC",
1247            "BOOL_OUT",
1248            "OCTET_LENGTH",
1249            "BIT_LENGTH",
1250            "OVERLAY",
1251            "REGEXP_MATCH",
1252            "REGEXP_REPLACE",
1253            "REGEXP_COUNT",
1254            "REGEXP_SPLIT_TO_ARRAY",
1255            "REGEXP_EQ",
1256            "POW",
1257            "EXP",
1258            "CHR",
1259            "STARTS_WITH",
1260            "INITCAP",
1261            "LPAD",
1262            "RPAD",
1263            "REVERSE",
1264            "STRPOS",
1265            "TO_ASCII",
1266            "TO_HEX",
1267            "QUOTE_IDENT",
1268            "SIN",
1269            "COS",
1270            "TAN",
1271            "COT",
1272            "ASIN",
1273            "ACOS",
1274            "ATAN",
1275            "ATAN2",
1276            "SIND",
1277            "COSD",
1278            "COTD",
1279            "TAND",
1280            "ASIND",
1281            "SQRT",
1282            "DEGREES",
1283            "RADIANS",
1284            "COSH",
1285            "TANH",
1286            "COTH",
1287            "ASINH",
1288            "ACOSH",
1289            "ATANH",
1290            "SINH",
1291            "ACOSD",
1292            "ATAND",
1293            "ATAN2D",
1294            "TRUNC",
1295            "LN",
1296            "LOG10",
1297            "CBRT",
1298            "SIGN",
1299            "SCALE",
1300            "MIN_SCALE",
1301            "TRIM_SCALE",
1302            "IS_TRUE",
1303            "IS_NOT_TRUE",
1304            "IS_FALSE",
1305            "IS_NOT_FALSE",
1306            "IS_NULL",
1307            "IS_NOT_NULL",
1308            "IS_DISTINCT_FROM",
1309            "IS_NOT_DISTINCT_FROM",
1310            "ENCODE",
1311            "DECODE",
1312            "SHA1",
1313            "SHA224",
1314            "SHA256",
1315            "SHA384",
1316            "SHA512",
1317            "LEFT",
1318            "RIGHT",
1319            "FORMAT",
1320            "FORMAT_VARIADIC",
1321            "PGWIRE_SEND",
1322            "PGWIRE_RECV",
1323            "CONVERT_FROM",
1324            "CONVERT_TO",
1325            "DECRYPT",
1326            "ENCRYPT",
1327            "INET_ATON",
1328            "INET_NTOA",
1329            "QUOTE_LITERAL",
1330            "QUOTE_NULLABLE",
1331            "HMAC",
1332            "SECURE_COMPARE",
1333            "CHECK_NOT_NULL",
1334            "NEG",
1335            "FIELD",
1336            "ARRAY",
1337            "ARRAY_ACCESS",
1338            "ROW",
1339            "ARRAY_TO_STRING",
1340            "ARRAY_RANGE_ACCESS",
1341            "ARRAY_CAT",
1342            "ARRAY_APPEND",
1343            "ARRAY_PREPEND",
1344            "FORMAT_TYPE",
1345            "ARRAY_DISTINCT",
1346            "ARRAY_LENGTH",
1347            "CARDINALITY",
1348            "ARRAY_REMOVE",
1349            "ARRAY_POSITIONS",
1350            "TRIM_ARRAY",
1351            "STRING_TO_ARRAY",
1352            "ARRAY_POSITION",
1353            "ARRAY_REPLACE",
1354            "ARRAY_DIMS",
1355            "ARRAY_TRANSFORM",
1356            "ARRAY_MIN",
1357            "ARRAY_MAX",
1358            "ARRAY_SUM",
1359            "ARRAY_SORT",
1360            "ARRAY_CONTAINS",
1361            "ARRAY_CONTAINED",
1362            "ARRAY_FLATTEN",
1363            "HEX_TO_INT256",
1364            "JSONB_ACCESS",
1365            "JSONB_ACCESS_STR",
1366            "JSONB_EXTRACT_PATH",
1367            "JSONB_EXTRACT_PATH_VARIADIC",
1368            "JSONB_EXTRACT_PATH_TEXT",
1369            "JSONB_EXTRACT_PATH_TEXT_VARIADIC",
1370            "JSONB_TYPEOF",
1371            "JSONB_ARRAY_LENGTH",
1372            "IS_JSON",
1373            "JSONB_CONCAT",
1374            "JSONB_OBJECT",
1375            "JSONB_PRETTY",
1376            "JSONB_CONTAINS",
1377            "JSONB_CONTAINED",
1378            "JSONB_EXISTS",
1379            "JSONB_EXISTS_ANY",
1380            "JSONB_EXISTS_ALL",
1381            "JSONB_DELETE_PATH",
1382            "JSONB_STRIP_NULLS",
1383            "TO_JSONB",
1384            "JSONB_BUILD_ARRAY",
1385            "JSONB_BUILD_ARRAY_VARIADIC",
1386            "JSONB_BUILD_OBJECT",
1387            "JSONB_BUILD_OBJECT_VARIADIC",
1388            "JSONB_PATH_EXISTS",
1389            "JSONB_PATH_MATCH",
1390            "JSONB_PATH_QUERY_ARRAY",
1391            "JSONB_PATH_QUERY_FIRST",
1392            "JSONB_POPULATE_RECORD",
1393            "JSONB_TO_RECORD",
1394            "JSONB_SET",
1395            "JSONB_POPULATE_MAP",
1396            "MAP_FROM_ENTRIES",
1397            "MAP_ACCESS",
1398            "MAP_KEYS",
1399            "MAP_VALUES",
1400            "MAP_ENTRIES",
1401            "MAP_FROM_KEY_VALUES",
1402            "MAP_LENGTH",
1403            "MAP_CONTAINS",
1404            "MAP_CAT",
1405            "MAP_INSERT",
1406            "MAP_DELETE",
1407            "MAP_FILTER",
1408            "L2_DISTANCE",
1409            "COMPOSITE_CAST",
1410            "VNODE",
1411            "TEST_PAID_TIER",
1412            "VNODE_USER",
1413            "LICENSE",
1414            "PROCTIME",
1415            "PG_SLEEP",
1416            "PG_SLEEP_FOR",
1417            "PG_SLEEP_UNTIL",
1418            "CAST_REGCLASS",
1419            "PG_GET_INDEXDEF",
1420            "COL_DESCRIPTION",
1421            "PG_GET_VIEWDEF",
1422            "PG_GET_USERBYID",
1423            "PG_INDEXES_SIZE",
1424            "PG_RELATION_SIZE",
1425            "PG_GET_SERIAL_SEQUENCE",
1426            "PG_INDEX_COLUMN_HAS_PROPERTY",
1427            "HAS_TABLE_PRIVILEGE",
1428            "HAS_ANY_COLUMN_PRIVILEGE",
1429            "HAS_SCHEMA_PRIVILEGE",
1430            "PG_IS_IN_RECOVERY",
1431            "RW_RECOVERY_STATUS",
1432            "RW_EPOCH_TO_TS",
1433            "PG_TABLE_IS_VISIBLE",
1434            "HAS_FUNCTION_PRIVILEGE",
1435            "ICEBERG_TRANSFORM",
1436            "OPENAI_EMBEDDING",
1437        ];
1438
1439        struct GeneratedVisitor;
1440
1441        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1442            type Value = expr_node::Type;
1443
1444            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1445                write!(formatter, "expected one of: {:?}", &FIELDS)
1446            }
1447
1448            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1449            where
1450                E: serde::de::Error,
1451            {
1452                i32::try_from(v)
1453                    .ok()
1454                    .and_then(|x| x.try_into().ok())
1455                    .ok_or_else(|| {
1456                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1457                    })
1458            }
1459
1460            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1461            where
1462                E: serde::de::Error,
1463            {
1464                i32::try_from(v)
1465                    .ok()
1466                    .and_then(|x| x.try_into().ok())
1467                    .ok_or_else(|| {
1468                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1469                    })
1470            }
1471
1472            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1473            where
1474                E: serde::de::Error,
1475            {
1476                match value {
1477                    "UNSPECIFIED" => Ok(expr_node::Type::Unspecified),
1478                    "ADD" => Ok(expr_node::Type::Add),
1479                    "SUBTRACT" => Ok(expr_node::Type::Subtract),
1480                    "MULTIPLY" => Ok(expr_node::Type::Multiply),
1481                    "DIVIDE" => Ok(expr_node::Type::Divide),
1482                    "MODULUS" => Ok(expr_node::Type::Modulus),
1483                    "EQUAL" => Ok(expr_node::Type::Equal),
1484                    "NOT_EQUAL" => Ok(expr_node::Type::NotEqual),
1485                    "LESS_THAN" => Ok(expr_node::Type::LessThan),
1486                    "LESS_THAN_OR_EQUAL" => Ok(expr_node::Type::LessThanOrEqual),
1487                    "GREATER_THAN" => Ok(expr_node::Type::GreaterThan),
1488                    "GREATER_THAN_OR_EQUAL" => Ok(expr_node::Type::GreaterThanOrEqual),
1489                    "GREATEST" => Ok(expr_node::Type::Greatest),
1490                    "LEAST" => Ok(expr_node::Type::Least),
1491                    "AND" => Ok(expr_node::Type::And),
1492                    "OR" => Ok(expr_node::Type::Or),
1493                    "NOT" => Ok(expr_node::Type::Not),
1494                    "IN" => Ok(expr_node::Type::In),
1495                    "SOME" => Ok(expr_node::Type::Some),
1496                    "ALL" => Ok(expr_node::Type::All),
1497                    "BITWISE_AND" => Ok(expr_node::Type::BitwiseAnd),
1498                    "BITWISE_OR" => Ok(expr_node::Type::BitwiseOr),
1499                    "BITWISE_XOR" => Ok(expr_node::Type::BitwiseXor),
1500                    "BITWISE_NOT" => Ok(expr_node::Type::BitwiseNot),
1501                    "BITWISE_SHIFT_LEFT" => Ok(expr_node::Type::BitwiseShiftLeft),
1502                    "BITWISE_SHIFT_RIGHT" => Ok(expr_node::Type::BitwiseShiftRight),
1503                    "EXTRACT" => Ok(expr_node::Type::Extract),
1504                    "DATE_PART" => Ok(expr_node::Type::DatePart),
1505                    "TUMBLE_START" => Ok(expr_node::Type::TumbleStart),
1506                    "MAKE_DATE" => Ok(expr_node::Type::MakeDate),
1507                    "MAKE_TIME" => Ok(expr_node::Type::MakeTime),
1508                    "MAKE_TIMESTAMP" => Ok(expr_node::Type::MakeTimestamp),
1509                    "DATE_BIN" => Ok(expr_node::Type::DateBin),
1510                    "SEC_TO_TIMESTAMPTZ" => Ok(expr_node::Type::SecToTimestamptz),
1511                    "AT_TIME_ZONE" => Ok(expr_node::Type::AtTimeZone),
1512                    "DATE_TRUNC" => Ok(expr_node::Type::DateTrunc),
1513                    "CHAR_TO_TIMESTAMPTZ" => Ok(expr_node::Type::CharToTimestamptz),
1514                    "CHAR_TO_DATE" => Ok(expr_node::Type::CharToDate),
1515                    "CAST_WITH_TIME_ZONE" => Ok(expr_node::Type::CastWithTimeZone),
1516                    "ADD_WITH_TIME_ZONE" => Ok(expr_node::Type::AddWithTimeZone),
1517                    "SUBTRACT_WITH_TIME_ZONE" => Ok(expr_node::Type::SubtractWithTimeZone),
1518                    "MAKE_TIMESTAMPTZ" => Ok(expr_node::Type::MakeTimestamptz),
1519                    "CAST" => Ok(expr_node::Type::Cast),
1520                    "SUBSTR" => Ok(expr_node::Type::Substr),
1521                    "LENGTH" => Ok(expr_node::Type::Length),
1522                    "LIKE" => Ok(expr_node::Type::Like),
1523                    "I_LIKE" => Ok(expr_node::Type::ILike),
1524                    "SIMILAR_TO_ESCAPE" => Ok(expr_node::Type::SimilarToEscape),
1525                    "UPPER" => Ok(expr_node::Type::Upper),
1526                    "LOWER" => Ok(expr_node::Type::Lower),
1527                    "TRIM" => Ok(expr_node::Type::Trim),
1528                    "REPLACE" => Ok(expr_node::Type::Replace),
1529                    "POSITION" => Ok(expr_node::Type::Position),
1530                    "LTRIM" => Ok(expr_node::Type::Ltrim),
1531                    "RTRIM" => Ok(expr_node::Type::Rtrim),
1532                    "CASE" => Ok(expr_node::Type::Case),
1533                    "CONSTANT_LOOKUP" => Ok(expr_node::Type::ConstantLookup),
1534                    "ROUND_DIGIT" => Ok(expr_node::Type::RoundDigit),
1535                    "ROUND" => Ok(expr_node::Type::Round),
1536                    "ASCII" => Ok(expr_node::Type::Ascii),
1537                    "TRANSLATE" => Ok(expr_node::Type::Translate),
1538                    "COALESCE" => Ok(expr_node::Type::Coalesce),
1539                    "CONCAT_WS" => Ok(expr_node::Type::ConcatWs),
1540                    "CONCAT_WS_VARIADIC" => Ok(expr_node::Type::ConcatWsVariadic),
1541                    "ABS" => Ok(expr_node::Type::Abs),
1542                    "SPLIT_PART" => Ok(expr_node::Type::SplitPart),
1543                    "CEIL" => Ok(expr_node::Type::Ceil),
1544                    "FLOOR" => Ok(expr_node::Type::Floor),
1545                    "TO_CHAR" => Ok(expr_node::Type::ToChar),
1546                    "MD5" => Ok(expr_node::Type::Md5),
1547                    "CHAR_LENGTH" => Ok(expr_node::Type::CharLength),
1548                    "REPEAT" => Ok(expr_node::Type::Repeat),
1549                    "CONCAT_OP" => Ok(expr_node::Type::ConcatOp),
1550                    "BYTEA_CONCAT_OP" => Ok(expr_node::Type::ByteaConcatOp),
1551                    "CONCAT" => Ok(expr_node::Type::Concat),
1552                    "CONCAT_VARIADIC" => Ok(expr_node::Type::ConcatVariadic),
1553                    "BOOL_OUT" => Ok(expr_node::Type::BoolOut),
1554                    "OCTET_LENGTH" => Ok(expr_node::Type::OctetLength),
1555                    "BIT_LENGTH" => Ok(expr_node::Type::BitLength),
1556                    "OVERLAY" => Ok(expr_node::Type::Overlay),
1557                    "REGEXP_MATCH" => Ok(expr_node::Type::RegexpMatch),
1558                    "REGEXP_REPLACE" => Ok(expr_node::Type::RegexpReplace),
1559                    "REGEXP_COUNT" => Ok(expr_node::Type::RegexpCount),
1560                    "REGEXP_SPLIT_TO_ARRAY" => Ok(expr_node::Type::RegexpSplitToArray),
1561                    "REGEXP_EQ" => Ok(expr_node::Type::RegexpEq),
1562                    "POW" => Ok(expr_node::Type::Pow),
1563                    "EXP" => Ok(expr_node::Type::Exp),
1564                    "CHR" => Ok(expr_node::Type::Chr),
1565                    "STARTS_WITH" => Ok(expr_node::Type::StartsWith),
1566                    "INITCAP" => Ok(expr_node::Type::Initcap),
1567                    "LPAD" => Ok(expr_node::Type::Lpad),
1568                    "RPAD" => Ok(expr_node::Type::Rpad),
1569                    "REVERSE" => Ok(expr_node::Type::Reverse),
1570                    "STRPOS" => Ok(expr_node::Type::Strpos),
1571                    "TO_ASCII" => Ok(expr_node::Type::ToAscii),
1572                    "TO_HEX" => Ok(expr_node::Type::ToHex),
1573                    "QUOTE_IDENT" => Ok(expr_node::Type::QuoteIdent),
1574                    "SIN" => Ok(expr_node::Type::Sin),
1575                    "COS" => Ok(expr_node::Type::Cos),
1576                    "TAN" => Ok(expr_node::Type::Tan),
1577                    "COT" => Ok(expr_node::Type::Cot),
1578                    "ASIN" => Ok(expr_node::Type::Asin),
1579                    "ACOS" => Ok(expr_node::Type::Acos),
1580                    "ATAN" => Ok(expr_node::Type::Atan),
1581                    "ATAN2" => Ok(expr_node::Type::Atan2),
1582                    "SIND" => Ok(expr_node::Type::Sind),
1583                    "COSD" => Ok(expr_node::Type::Cosd),
1584                    "COTD" => Ok(expr_node::Type::Cotd),
1585                    "TAND" => Ok(expr_node::Type::Tand),
1586                    "ASIND" => Ok(expr_node::Type::Asind),
1587                    "SQRT" => Ok(expr_node::Type::Sqrt),
1588                    "DEGREES" => Ok(expr_node::Type::Degrees),
1589                    "RADIANS" => Ok(expr_node::Type::Radians),
1590                    "COSH" => Ok(expr_node::Type::Cosh),
1591                    "TANH" => Ok(expr_node::Type::Tanh),
1592                    "COTH" => Ok(expr_node::Type::Coth),
1593                    "ASINH" => Ok(expr_node::Type::Asinh),
1594                    "ACOSH" => Ok(expr_node::Type::Acosh),
1595                    "ATANH" => Ok(expr_node::Type::Atanh),
1596                    "SINH" => Ok(expr_node::Type::Sinh),
1597                    "ACOSD" => Ok(expr_node::Type::Acosd),
1598                    "ATAND" => Ok(expr_node::Type::Atand),
1599                    "ATAN2D" => Ok(expr_node::Type::Atan2d),
1600                    "TRUNC" => Ok(expr_node::Type::Trunc),
1601                    "LN" => Ok(expr_node::Type::Ln),
1602                    "LOG10" => Ok(expr_node::Type::Log10),
1603                    "CBRT" => Ok(expr_node::Type::Cbrt),
1604                    "SIGN" => Ok(expr_node::Type::Sign),
1605                    "SCALE" => Ok(expr_node::Type::Scale),
1606                    "MIN_SCALE" => Ok(expr_node::Type::MinScale),
1607                    "TRIM_SCALE" => Ok(expr_node::Type::TrimScale),
1608                    "IS_TRUE" => Ok(expr_node::Type::IsTrue),
1609                    "IS_NOT_TRUE" => Ok(expr_node::Type::IsNotTrue),
1610                    "IS_FALSE" => Ok(expr_node::Type::IsFalse),
1611                    "IS_NOT_FALSE" => Ok(expr_node::Type::IsNotFalse),
1612                    "IS_NULL" => Ok(expr_node::Type::IsNull),
1613                    "IS_NOT_NULL" => Ok(expr_node::Type::IsNotNull),
1614                    "IS_DISTINCT_FROM" => Ok(expr_node::Type::IsDistinctFrom),
1615                    "IS_NOT_DISTINCT_FROM" => Ok(expr_node::Type::IsNotDistinctFrom),
1616                    "ENCODE" => Ok(expr_node::Type::Encode),
1617                    "DECODE" => Ok(expr_node::Type::Decode),
1618                    "SHA1" => Ok(expr_node::Type::Sha1),
1619                    "SHA224" => Ok(expr_node::Type::Sha224),
1620                    "SHA256" => Ok(expr_node::Type::Sha256),
1621                    "SHA384" => Ok(expr_node::Type::Sha384),
1622                    "SHA512" => Ok(expr_node::Type::Sha512),
1623                    "LEFT" => Ok(expr_node::Type::Left),
1624                    "RIGHT" => Ok(expr_node::Type::Right),
1625                    "FORMAT" => Ok(expr_node::Type::Format),
1626                    "FORMAT_VARIADIC" => Ok(expr_node::Type::FormatVariadic),
1627                    "PGWIRE_SEND" => Ok(expr_node::Type::PgwireSend),
1628                    "PGWIRE_RECV" => Ok(expr_node::Type::PgwireRecv),
1629                    "CONVERT_FROM" => Ok(expr_node::Type::ConvertFrom),
1630                    "CONVERT_TO" => Ok(expr_node::Type::ConvertTo),
1631                    "DECRYPT" => Ok(expr_node::Type::Decrypt),
1632                    "ENCRYPT" => Ok(expr_node::Type::Encrypt),
1633                    "INET_ATON" => Ok(expr_node::Type::InetAton),
1634                    "INET_NTOA" => Ok(expr_node::Type::InetNtoa),
1635                    "QUOTE_LITERAL" => Ok(expr_node::Type::QuoteLiteral),
1636                    "QUOTE_NULLABLE" => Ok(expr_node::Type::QuoteNullable),
1637                    "HMAC" => Ok(expr_node::Type::Hmac),
1638                    "SECURE_COMPARE" => Ok(expr_node::Type::SecureCompare),
1639                    "CHECK_NOT_NULL" => Ok(expr_node::Type::CheckNotNull),
1640                    "NEG" => Ok(expr_node::Type::Neg),
1641                    "FIELD" => Ok(expr_node::Type::Field),
1642                    "ARRAY" => Ok(expr_node::Type::Array),
1643                    "ARRAY_ACCESS" => Ok(expr_node::Type::ArrayAccess),
1644                    "ROW" => Ok(expr_node::Type::Row),
1645                    "ARRAY_TO_STRING" => Ok(expr_node::Type::ArrayToString),
1646                    "ARRAY_RANGE_ACCESS" => Ok(expr_node::Type::ArrayRangeAccess),
1647                    "ARRAY_CAT" => Ok(expr_node::Type::ArrayCat),
1648                    "ARRAY_APPEND" => Ok(expr_node::Type::ArrayAppend),
1649                    "ARRAY_PREPEND" => Ok(expr_node::Type::ArrayPrepend),
1650                    "FORMAT_TYPE" => Ok(expr_node::Type::FormatType),
1651                    "ARRAY_DISTINCT" => Ok(expr_node::Type::ArrayDistinct),
1652                    "ARRAY_LENGTH" => Ok(expr_node::Type::ArrayLength),
1653                    "CARDINALITY" => Ok(expr_node::Type::Cardinality),
1654                    "ARRAY_REMOVE" => Ok(expr_node::Type::ArrayRemove),
1655                    "ARRAY_POSITIONS" => Ok(expr_node::Type::ArrayPositions),
1656                    "TRIM_ARRAY" => Ok(expr_node::Type::TrimArray),
1657                    "STRING_TO_ARRAY" => Ok(expr_node::Type::StringToArray),
1658                    "ARRAY_POSITION" => Ok(expr_node::Type::ArrayPosition),
1659                    "ARRAY_REPLACE" => Ok(expr_node::Type::ArrayReplace),
1660                    "ARRAY_DIMS" => Ok(expr_node::Type::ArrayDims),
1661                    "ARRAY_TRANSFORM" => Ok(expr_node::Type::ArrayTransform),
1662                    "ARRAY_MIN" => Ok(expr_node::Type::ArrayMin),
1663                    "ARRAY_MAX" => Ok(expr_node::Type::ArrayMax),
1664                    "ARRAY_SUM" => Ok(expr_node::Type::ArraySum),
1665                    "ARRAY_SORT" => Ok(expr_node::Type::ArraySort),
1666                    "ARRAY_CONTAINS" => Ok(expr_node::Type::ArrayContains),
1667                    "ARRAY_CONTAINED" => Ok(expr_node::Type::ArrayContained),
1668                    "ARRAY_FLATTEN" => Ok(expr_node::Type::ArrayFlatten),
1669                    "HEX_TO_INT256" => Ok(expr_node::Type::HexToInt256),
1670                    "JSONB_ACCESS" => Ok(expr_node::Type::JsonbAccess),
1671                    "JSONB_ACCESS_STR" => Ok(expr_node::Type::JsonbAccessStr),
1672                    "JSONB_EXTRACT_PATH" => Ok(expr_node::Type::JsonbExtractPath),
1673                    "JSONB_EXTRACT_PATH_VARIADIC" => Ok(expr_node::Type::JsonbExtractPathVariadic),
1674                    "JSONB_EXTRACT_PATH_TEXT" => Ok(expr_node::Type::JsonbExtractPathText),
1675                    "JSONB_EXTRACT_PATH_TEXT_VARIADIC" => Ok(expr_node::Type::JsonbExtractPathTextVariadic),
1676                    "JSONB_TYPEOF" => Ok(expr_node::Type::JsonbTypeof),
1677                    "JSONB_ARRAY_LENGTH" => Ok(expr_node::Type::JsonbArrayLength),
1678                    "IS_JSON" => Ok(expr_node::Type::IsJson),
1679                    "JSONB_CONCAT" => Ok(expr_node::Type::JsonbConcat),
1680                    "JSONB_OBJECT" => Ok(expr_node::Type::JsonbObject),
1681                    "JSONB_PRETTY" => Ok(expr_node::Type::JsonbPretty),
1682                    "JSONB_CONTAINS" => Ok(expr_node::Type::JsonbContains),
1683                    "JSONB_CONTAINED" => Ok(expr_node::Type::JsonbContained),
1684                    "JSONB_EXISTS" => Ok(expr_node::Type::JsonbExists),
1685                    "JSONB_EXISTS_ANY" => Ok(expr_node::Type::JsonbExistsAny),
1686                    "JSONB_EXISTS_ALL" => Ok(expr_node::Type::JsonbExistsAll),
1687                    "JSONB_DELETE_PATH" => Ok(expr_node::Type::JsonbDeletePath),
1688                    "JSONB_STRIP_NULLS" => Ok(expr_node::Type::JsonbStripNulls),
1689                    "TO_JSONB" => Ok(expr_node::Type::ToJsonb),
1690                    "JSONB_BUILD_ARRAY" => Ok(expr_node::Type::JsonbBuildArray),
1691                    "JSONB_BUILD_ARRAY_VARIADIC" => Ok(expr_node::Type::JsonbBuildArrayVariadic),
1692                    "JSONB_BUILD_OBJECT" => Ok(expr_node::Type::JsonbBuildObject),
1693                    "JSONB_BUILD_OBJECT_VARIADIC" => Ok(expr_node::Type::JsonbBuildObjectVariadic),
1694                    "JSONB_PATH_EXISTS" => Ok(expr_node::Type::JsonbPathExists),
1695                    "JSONB_PATH_MATCH" => Ok(expr_node::Type::JsonbPathMatch),
1696                    "JSONB_PATH_QUERY_ARRAY" => Ok(expr_node::Type::JsonbPathQueryArray),
1697                    "JSONB_PATH_QUERY_FIRST" => Ok(expr_node::Type::JsonbPathQueryFirst),
1698                    "JSONB_POPULATE_RECORD" => Ok(expr_node::Type::JsonbPopulateRecord),
1699                    "JSONB_TO_RECORD" => Ok(expr_node::Type::JsonbToRecord),
1700                    "JSONB_SET" => Ok(expr_node::Type::JsonbSet),
1701                    "JSONB_POPULATE_MAP" => Ok(expr_node::Type::JsonbPopulateMap),
1702                    "MAP_FROM_ENTRIES" => Ok(expr_node::Type::MapFromEntries),
1703                    "MAP_ACCESS" => Ok(expr_node::Type::MapAccess),
1704                    "MAP_KEYS" => Ok(expr_node::Type::MapKeys),
1705                    "MAP_VALUES" => Ok(expr_node::Type::MapValues),
1706                    "MAP_ENTRIES" => Ok(expr_node::Type::MapEntries),
1707                    "MAP_FROM_KEY_VALUES" => Ok(expr_node::Type::MapFromKeyValues),
1708                    "MAP_LENGTH" => Ok(expr_node::Type::MapLength),
1709                    "MAP_CONTAINS" => Ok(expr_node::Type::MapContains),
1710                    "MAP_CAT" => Ok(expr_node::Type::MapCat),
1711                    "MAP_INSERT" => Ok(expr_node::Type::MapInsert),
1712                    "MAP_DELETE" => Ok(expr_node::Type::MapDelete),
1713                    "MAP_FILTER" => Ok(expr_node::Type::MapFilter),
1714                    "L2_DISTANCE" => Ok(expr_node::Type::L2Distance),
1715                    "COMPOSITE_CAST" => Ok(expr_node::Type::CompositeCast),
1716                    "VNODE" => Ok(expr_node::Type::Vnode),
1717                    "TEST_PAID_TIER" => Ok(expr_node::Type::TestPaidTier),
1718                    "VNODE_USER" => Ok(expr_node::Type::VnodeUser),
1719                    "LICENSE" => Ok(expr_node::Type::License),
1720                    "PROCTIME" => Ok(expr_node::Type::Proctime),
1721                    "PG_SLEEP" => Ok(expr_node::Type::PgSleep),
1722                    "PG_SLEEP_FOR" => Ok(expr_node::Type::PgSleepFor),
1723                    "PG_SLEEP_UNTIL" => Ok(expr_node::Type::PgSleepUntil),
1724                    "CAST_REGCLASS" => Ok(expr_node::Type::CastRegclass),
1725                    "PG_GET_INDEXDEF" => Ok(expr_node::Type::PgGetIndexdef),
1726                    "COL_DESCRIPTION" => Ok(expr_node::Type::ColDescription),
1727                    "PG_GET_VIEWDEF" => Ok(expr_node::Type::PgGetViewdef),
1728                    "PG_GET_USERBYID" => Ok(expr_node::Type::PgGetUserbyid),
1729                    "PG_INDEXES_SIZE" => Ok(expr_node::Type::PgIndexesSize),
1730                    "PG_RELATION_SIZE" => Ok(expr_node::Type::PgRelationSize),
1731                    "PG_GET_SERIAL_SEQUENCE" => Ok(expr_node::Type::PgGetSerialSequence),
1732                    "PG_INDEX_COLUMN_HAS_PROPERTY" => Ok(expr_node::Type::PgIndexColumnHasProperty),
1733                    "HAS_TABLE_PRIVILEGE" => Ok(expr_node::Type::HasTablePrivilege),
1734                    "HAS_ANY_COLUMN_PRIVILEGE" => Ok(expr_node::Type::HasAnyColumnPrivilege),
1735                    "HAS_SCHEMA_PRIVILEGE" => Ok(expr_node::Type::HasSchemaPrivilege),
1736                    "PG_IS_IN_RECOVERY" => Ok(expr_node::Type::PgIsInRecovery),
1737                    "RW_RECOVERY_STATUS" => Ok(expr_node::Type::RwRecoveryStatus),
1738                    "RW_EPOCH_TO_TS" => Ok(expr_node::Type::RwEpochToTs),
1739                    "PG_TABLE_IS_VISIBLE" => Ok(expr_node::Type::PgTableIsVisible),
1740                    "HAS_FUNCTION_PRIVILEGE" => Ok(expr_node::Type::HasFunctionPrivilege),
1741                    "ICEBERG_TRANSFORM" => Ok(expr_node::Type::IcebergTransform),
1742                    "OPENAI_EMBEDDING" => Ok(expr_node::Type::OpenaiEmbedding),
1743                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1744                }
1745            }
1746        }
1747        deserializer.deserialize_any(GeneratedVisitor)
1748    }
1749}
1750impl serde::Serialize for FunctionCall {
1751    #[allow(deprecated)]
1752    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1753    where
1754        S: serde::Serializer,
1755    {
1756        use serde::ser::SerializeStruct;
1757        let mut len = 0;
1758        if !self.children.is_empty() {
1759            len += 1;
1760        }
1761        let mut struct_ser = serializer.serialize_struct("expr.FunctionCall", len)?;
1762        if !self.children.is_empty() {
1763            struct_ser.serialize_field("children", &self.children)?;
1764        }
1765        struct_ser.end()
1766    }
1767}
1768impl<'de> serde::Deserialize<'de> for FunctionCall {
1769    #[allow(deprecated)]
1770    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1771    where
1772        D: serde::Deserializer<'de>,
1773    {
1774        const FIELDS: &[&str] = &[
1775            "children",
1776        ];
1777
1778        #[allow(clippy::enum_variant_names)]
1779        enum GeneratedField {
1780            Children,
1781        }
1782        impl<'de> serde::Deserialize<'de> for GeneratedField {
1783            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1784            where
1785                D: serde::Deserializer<'de>,
1786            {
1787                struct GeneratedVisitor;
1788
1789                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1790                    type Value = GeneratedField;
1791
1792                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1793                        write!(formatter, "expected one of: {:?}", &FIELDS)
1794                    }
1795
1796                    #[allow(unused_variables)]
1797                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1798                    where
1799                        E: serde::de::Error,
1800                    {
1801                        match value {
1802                            "children" => Ok(GeneratedField::Children),
1803                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1804                        }
1805                    }
1806                }
1807                deserializer.deserialize_identifier(GeneratedVisitor)
1808            }
1809        }
1810        struct GeneratedVisitor;
1811        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1812            type Value = FunctionCall;
1813
1814            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1815                formatter.write_str("struct expr.FunctionCall")
1816            }
1817
1818            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FunctionCall, V::Error>
1819                where
1820                    V: serde::de::MapAccess<'de>,
1821            {
1822                let mut children__ = None;
1823                while let Some(k) = map_.next_key()? {
1824                    match k {
1825                        GeneratedField::Children => {
1826                            if children__.is_some() {
1827                                return Err(serde::de::Error::duplicate_field("children"));
1828                            }
1829                            children__ = Some(map_.next_value()?);
1830                        }
1831                    }
1832                }
1833                Ok(FunctionCall {
1834                    children: children__.unwrap_or_default(),
1835                })
1836            }
1837        }
1838        deserializer.deserialize_struct("expr.FunctionCall", FIELDS, GeneratedVisitor)
1839    }
1840}
1841impl serde::Serialize for InputRef {
1842    #[allow(deprecated)]
1843    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1844    where
1845        S: serde::Serializer,
1846    {
1847        use serde::ser::SerializeStruct;
1848        let mut len = 0;
1849        if self.index != 0 {
1850            len += 1;
1851        }
1852        if self.r#type.is_some() {
1853            len += 1;
1854        }
1855        let mut struct_ser = serializer.serialize_struct("expr.InputRef", len)?;
1856        if self.index != 0 {
1857            struct_ser.serialize_field("index", &self.index)?;
1858        }
1859        if let Some(v) = self.r#type.as_ref() {
1860            struct_ser.serialize_field("type", v)?;
1861        }
1862        struct_ser.end()
1863    }
1864}
1865impl<'de> serde::Deserialize<'de> for InputRef {
1866    #[allow(deprecated)]
1867    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1868    where
1869        D: serde::Deserializer<'de>,
1870    {
1871        const FIELDS: &[&str] = &[
1872            "index",
1873            "type",
1874        ];
1875
1876        #[allow(clippy::enum_variant_names)]
1877        enum GeneratedField {
1878            Index,
1879            Type,
1880        }
1881        impl<'de> serde::Deserialize<'de> for GeneratedField {
1882            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1883            where
1884                D: serde::Deserializer<'de>,
1885            {
1886                struct GeneratedVisitor;
1887
1888                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1889                    type Value = GeneratedField;
1890
1891                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1892                        write!(formatter, "expected one of: {:?}", &FIELDS)
1893                    }
1894
1895                    #[allow(unused_variables)]
1896                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1897                    where
1898                        E: serde::de::Error,
1899                    {
1900                        match value {
1901                            "index" => Ok(GeneratedField::Index),
1902                            "type" => Ok(GeneratedField::Type),
1903                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1904                        }
1905                    }
1906                }
1907                deserializer.deserialize_identifier(GeneratedVisitor)
1908            }
1909        }
1910        struct GeneratedVisitor;
1911        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1912            type Value = InputRef;
1913
1914            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1915                formatter.write_str("struct expr.InputRef")
1916            }
1917
1918            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InputRef, V::Error>
1919                where
1920                    V: serde::de::MapAccess<'de>,
1921            {
1922                let mut index__ = None;
1923                let mut r#type__ = None;
1924                while let Some(k) = map_.next_key()? {
1925                    match k {
1926                        GeneratedField::Index => {
1927                            if index__.is_some() {
1928                                return Err(serde::de::Error::duplicate_field("index"));
1929                            }
1930                            index__ = 
1931                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1932                            ;
1933                        }
1934                        GeneratedField::Type => {
1935                            if r#type__.is_some() {
1936                                return Err(serde::de::Error::duplicate_field("type"));
1937                            }
1938                            r#type__ = map_.next_value()?;
1939                        }
1940                    }
1941                }
1942                Ok(InputRef {
1943                    index: index__.unwrap_or_default(),
1944                    r#type: r#type__,
1945                })
1946            }
1947        }
1948        deserializer.deserialize_struct("expr.InputRef", FIELDS, GeneratedVisitor)
1949    }
1950}
1951impl serde::Serialize for ProjectSetSelectItem {
1952    #[allow(deprecated)]
1953    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1954    where
1955        S: serde::Serializer,
1956    {
1957        use serde::ser::SerializeStruct;
1958        let mut len = 0;
1959        if self.select_item.is_some() {
1960            len += 1;
1961        }
1962        let mut struct_ser = serializer.serialize_struct("expr.ProjectSetSelectItem", len)?;
1963        if let Some(v) = self.select_item.as_ref() {
1964            match v {
1965                project_set_select_item::SelectItem::Expr(v) => {
1966                    struct_ser.serialize_field("expr", v)?;
1967                }
1968                project_set_select_item::SelectItem::TableFunction(v) => {
1969                    struct_ser.serialize_field("tableFunction", v)?;
1970                }
1971            }
1972        }
1973        struct_ser.end()
1974    }
1975}
1976impl<'de> serde::Deserialize<'de> for ProjectSetSelectItem {
1977    #[allow(deprecated)]
1978    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1979    where
1980        D: serde::Deserializer<'de>,
1981    {
1982        const FIELDS: &[&str] = &[
1983            "expr",
1984            "table_function",
1985            "tableFunction",
1986        ];
1987
1988        #[allow(clippy::enum_variant_names)]
1989        enum GeneratedField {
1990            Expr,
1991            TableFunction,
1992        }
1993        impl<'de> serde::Deserialize<'de> for GeneratedField {
1994            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1995            where
1996                D: serde::Deserializer<'de>,
1997            {
1998                struct GeneratedVisitor;
1999
2000                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2001                    type Value = GeneratedField;
2002
2003                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2004                        write!(formatter, "expected one of: {:?}", &FIELDS)
2005                    }
2006
2007                    #[allow(unused_variables)]
2008                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2009                    where
2010                        E: serde::de::Error,
2011                    {
2012                        match value {
2013                            "expr" => Ok(GeneratedField::Expr),
2014                            "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
2015                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2016                        }
2017                    }
2018                }
2019                deserializer.deserialize_identifier(GeneratedVisitor)
2020            }
2021        }
2022        struct GeneratedVisitor;
2023        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2024            type Value = ProjectSetSelectItem;
2025
2026            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2027                formatter.write_str("struct expr.ProjectSetSelectItem")
2028            }
2029
2030            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetSelectItem, V::Error>
2031                where
2032                    V: serde::de::MapAccess<'de>,
2033            {
2034                let mut select_item__ = None;
2035                while let Some(k) = map_.next_key()? {
2036                    match k {
2037                        GeneratedField::Expr => {
2038                            if select_item__.is_some() {
2039                                return Err(serde::de::Error::duplicate_field("expr"));
2040                            }
2041                            select_item__ = map_.next_value::<::std::option::Option<_>>()?.map(project_set_select_item::SelectItem::Expr)
2042;
2043                        }
2044                        GeneratedField::TableFunction => {
2045                            if select_item__.is_some() {
2046                                return Err(serde::de::Error::duplicate_field("tableFunction"));
2047                            }
2048                            select_item__ = map_.next_value::<::std::option::Option<_>>()?.map(project_set_select_item::SelectItem::TableFunction)
2049;
2050                        }
2051                    }
2052                }
2053                Ok(ProjectSetSelectItem {
2054                    select_item: select_item__,
2055                })
2056            }
2057        }
2058        deserializer.deserialize_struct("expr.ProjectSetSelectItem", FIELDS, GeneratedVisitor)
2059    }
2060}
2061impl serde::Serialize for TableFunction {
2062    #[allow(deprecated)]
2063    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2064    where
2065        S: serde::Serializer,
2066    {
2067        use serde::ser::SerializeStruct;
2068        let mut len = 0;
2069        if self.function_type != 0 {
2070            len += 1;
2071        }
2072        if !self.args.is_empty() {
2073            len += 1;
2074        }
2075        if self.return_type.is_some() {
2076            len += 1;
2077        }
2078        if self.udf.is_some() {
2079            len += 1;
2080        }
2081        let mut struct_ser = serializer.serialize_struct("expr.TableFunction", len)?;
2082        if self.function_type != 0 {
2083            let v = table_function::Type::try_from(self.function_type)
2084                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.function_type)))?;
2085            struct_ser.serialize_field("functionType", &v)?;
2086        }
2087        if !self.args.is_empty() {
2088            struct_ser.serialize_field("args", &self.args)?;
2089        }
2090        if let Some(v) = self.return_type.as_ref() {
2091            struct_ser.serialize_field("returnType", v)?;
2092        }
2093        if let Some(v) = self.udf.as_ref() {
2094            struct_ser.serialize_field("udf", v)?;
2095        }
2096        struct_ser.end()
2097    }
2098}
2099impl<'de> serde::Deserialize<'de> for TableFunction {
2100    #[allow(deprecated)]
2101    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2102    where
2103        D: serde::Deserializer<'de>,
2104    {
2105        const FIELDS: &[&str] = &[
2106            "function_type",
2107            "functionType",
2108            "args",
2109            "return_type",
2110            "returnType",
2111            "udf",
2112        ];
2113
2114        #[allow(clippy::enum_variant_names)]
2115        enum GeneratedField {
2116            FunctionType,
2117            Args,
2118            ReturnType,
2119            Udf,
2120        }
2121        impl<'de> serde::Deserialize<'de> for GeneratedField {
2122            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2123            where
2124                D: serde::Deserializer<'de>,
2125            {
2126                struct GeneratedVisitor;
2127
2128                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2129                    type Value = GeneratedField;
2130
2131                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2132                        write!(formatter, "expected one of: {:?}", &FIELDS)
2133                    }
2134
2135                    #[allow(unused_variables)]
2136                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2137                    where
2138                        E: serde::de::Error,
2139                    {
2140                        match value {
2141                            "functionType" | "function_type" => Ok(GeneratedField::FunctionType),
2142                            "args" => Ok(GeneratedField::Args),
2143                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
2144                            "udf" => Ok(GeneratedField::Udf),
2145                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2146                        }
2147                    }
2148                }
2149                deserializer.deserialize_identifier(GeneratedVisitor)
2150            }
2151        }
2152        struct GeneratedVisitor;
2153        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2154            type Value = TableFunction;
2155
2156            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2157                formatter.write_str("struct expr.TableFunction")
2158            }
2159
2160            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunction, V::Error>
2161                where
2162                    V: serde::de::MapAccess<'de>,
2163            {
2164                let mut function_type__ = None;
2165                let mut args__ = None;
2166                let mut return_type__ = None;
2167                let mut udf__ = None;
2168                while let Some(k) = map_.next_key()? {
2169                    match k {
2170                        GeneratedField::FunctionType => {
2171                            if function_type__.is_some() {
2172                                return Err(serde::de::Error::duplicate_field("functionType"));
2173                            }
2174                            function_type__ = Some(map_.next_value::<table_function::Type>()? as i32);
2175                        }
2176                        GeneratedField::Args => {
2177                            if args__.is_some() {
2178                                return Err(serde::de::Error::duplicate_field("args"));
2179                            }
2180                            args__ = Some(map_.next_value()?);
2181                        }
2182                        GeneratedField::ReturnType => {
2183                            if return_type__.is_some() {
2184                                return Err(serde::de::Error::duplicate_field("returnType"));
2185                            }
2186                            return_type__ = map_.next_value()?;
2187                        }
2188                        GeneratedField::Udf => {
2189                            if udf__.is_some() {
2190                                return Err(serde::de::Error::duplicate_field("udf"));
2191                            }
2192                            udf__ = map_.next_value()?;
2193                        }
2194                    }
2195                }
2196                Ok(TableFunction {
2197                    function_type: function_type__.unwrap_or_default(),
2198                    args: args__.unwrap_or_default(),
2199                    return_type: return_type__,
2200                    udf: udf__,
2201                })
2202            }
2203        }
2204        deserializer.deserialize_struct("expr.TableFunction", FIELDS, GeneratedVisitor)
2205    }
2206}
2207impl serde::Serialize for table_function::Type {
2208    #[allow(deprecated)]
2209    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2210    where
2211        S: serde::Serializer,
2212    {
2213        let variant = match self {
2214            Self::Unspecified => "UNSPECIFIED",
2215            Self::GenerateSeries => "GENERATE_SERIES",
2216            Self::Unnest => "UNNEST",
2217            Self::RegexpMatches => "REGEXP_MATCHES",
2218            Self::Range => "RANGE",
2219            Self::GenerateSubscripts => "GENERATE_SUBSCRIPTS",
2220            Self::PgExpandarray => "_PG_EXPANDARRAY",
2221            Self::PgGetKeywords => "PG_GET_KEYWORDS",
2222            Self::JsonbArrayElements => "JSONB_ARRAY_ELEMENTS",
2223            Self::JsonbArrayElementsText => "JSONB_ARRAY_ELEMENTS_TEXT",
2224            Self::JsonbEach => "JSONB_EACH",
2225            Self::JsonbEachText => "JSONB_EACH_TEXT",
2226            Self::JsonbObjectKeys => "JSONB_OBJECT_KEYS",
2227            Self::JsonbPathQuery => "JSONB_PATH_QUERY",
2228            Self::JsonbPopulateRecordset => "JSONB_POPULATE_RECORDSET",
2229            Self::JsonbToRecordset => "JSONB_TO_RECORDSET",
2230            Self::FileScan => "FILE_SCAN",
2231            Self::PostgresQuery => "POSTGRES_QUERY",
2232            Self::MysqlQuery => "MYSQL_QUERY",
2233            Self::InternalBackfillProgress => "INTERNAL_BACKFILL_PROGRESS",
2234            Self::InternalSourceBackfillProgress => "INTERNAL_SOURCE_BACKFILL_PROGRESS",
2235            Self::UserDefined => "USER_DEFINED",
2236        };
2237        serializer.serialize_str(variant)
2238    }
2239}
2240impl<'de> serde::Deserialize<'de> for table_function::Type {
2241    #[allow(deprecated)]
2242    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2243    where
2244        D: serde::Deserializer<'de>,
2245    {
2246        const FIELDS: &[&str] = &[
2247            "UNSPECIFIED",
2248            "GENERATE_SERIES",
2249            "UNNEST",
2250            "REGEXP_MATCHES",
2251            "RANGE",
2252            "GENERATE_SUBSCRIPTS",
2253            "_PG_EXPANDARRAY",
2254            "PG_GET_KEYWORDS",
2255            "JSONB_ARRAY_ELEMENTS",
2256            "JSONB_ARRAY_ELEMENTS_TEXT",
2257            "JSONB_EACH",
2258            "JSONB_EACH_TEXT",
2259            "JSONB_OBJECT_KEYS",
2260            "JSONB_PATH_QUERY",
2261            "JSONB_POPULATE_RECORDSET",
2262            "JSONB_TO_RECORDSET",
2263            "FILE_SCAN",
2264            "POSTGRES_QUERY",
2265            "MYSQL_QUERY",
2266            "INTERNAL_BACKFILL_PROGRESS",
2267            "INTERNAL_SOURCE_BACKFILL_PROGRESS",
2268            "USER_DEFINED",
2269        ];
2270
2271        struct GeneratedVisitor;
2272
2273        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2274            type Value = table_function::Type;
2275
2276            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2277                write!(formatter, "expected one of: {:?}", &FIELDS)
2278            }
2279
2280            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2281            where
2282                E: serde::de::Error,
2283            {
2284                i32::try_from(v)
2285                    .ok()
2286                    .and_then(|x| x.try_into().ok())
2287                    .ok_or_else(|| {
2288                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2289                    })
2290            }
2291
2292            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2293            where
2294                E: serde::de::Error,
2295            {
2296                i32::try_from(v)
2297                    .ok()
2298                    .and_then(|x| x.try_into().ok())
2299                    .ok_or_else(|| {
2300                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2301                    })
2302            }
2303
2304            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2305            where
2306                E: serde::de::Error,
2307            {
2308                match value {
2309                    "UNSPECIFIED" => Ok(table_function::Type::Unspecified),
2310                    "GENERATE_SERIES" => Ok(table_function::Type::GenerateSeries),
2311                    "UNNEST" => Ok(table_function::Type::Unnest),
2312                    "REGEXP_MATCHES" => Ok(table_function::Type::RegexpMatches),
2313                    "RANGE" => Ok(table_function::Type::Range),
2314                    "GENERATE_SUBSCRIPTS" => Ok(table_function::Type::GenerateSubscripts),
2315                    "_PG_EXPANDARRAY" => Ok(table_function::Type::PgExpandarray),
2316                    "PG_GET_KEYWORDS" => Ok(table_function::Type::PgGetKeywords),
2317                    "JSONB_ARRAY_ELEMENTS" => Ok(table_function::Type::JsonbArrayElements),
2318                    "JSONB_ARRAY_ELEMENTS_TEXT" => Ok(table_function::Type::JsonbArrayElementsText),
2319                    "JSONB_EACH" => Ok(table_function::Type::JsonbEach),
2320                    "JSONB_EACH_TEXT" => Ok(table_function::Type::JsonbEachText),
2321                    "JSONB_OBJECT_KEYS" => Ok(table_function::Type::JsonbObjectKeys),
2322                    "JSONB_PATH_QUERY" => Ok(table_function::Type::JsonbPathQuery),
2323                    "JSONB_POPULATE_RECORDSET" => Ok(table_function::Type::JsonbPopulateRecordset),
2324                    "JSONB_TO_RECORDSET" => Ok(table_function::Type::JsonbToRecordset),
2325                    "FILE_SCAN" => Ok(table_function::Type::FileScan),
2326                    "POSTGRES_QUERY" => Ok(table_function::Type::PostgresQuery),
2327                    "MYSQL_QUERY" => Ok(table_function::Type::MysqlQuery),
2328                    "INTERNAL_BACKFILL_PROGRESS" => Ok(table_function::Type::InternalBackfillProgress),
2329                    "INTERNAL_SOURCE_BACKFILL_PROGRESS" => Ok(table_function::Type::InternalSourceBackfillProgress),
2330                    "USER_DEFINED" => Ok(table_function::Type::UserDefined),
2331                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2332                }
2333            }
2334        }
2335        deserializer.deserialize_any(GeneratedVisitor)
2336    }
2337}
2338impl serde::Serialize for UdfExprVersion {
2339    #[allow(deprecated)]
2340    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2341    where
2342        S: serde::Serializer,
2343    {
2344        let variant = match self {
2345            Self::Unspecified => "UDF_EXPR_VERSION_UNSPECIFIED",
2346            Self::NameInRuntime => "UDF_EXPR_VERSION_NAME_IN_RUNTIME",
2347        };
2348        serializer.serialize_str(variant)
2349    }
2350}
2351impl<'de> serde::Deserialize<'de> for UdfExprVersion {
2352    #[allow(deprecated)]
2353    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2354    where
2355        D: serde::Deserializer<'de>,
2356    {
2357        const FIELDS: &[&str] = &[
2358            "UDF_EXPR_VERSION_UNSPECIFIED",
2359            "UDF_EXPR_VERSION_NAME_IN_RUNTIME",
2360        ];
2361
2362        struct GeneratedVisitor;
2363
2364        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2365            type Value = UdfExprVersion;
2366
2367            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2368                write!(formatter, "expected one of: {:?}", &FIELDS)
2369            }
2370
2371            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2372            where
2373                E: serde::de::Error,
2374            {
2375                i32::try_from(v)
2376                    .ok()
2377                    .and_then(|x| x.try_into().ok())
2378                    .ok_or_else(|| {
2379                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2380                    })
2381            }
2382
2383            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2384            where
2385                E: serde::de::Error,
2386            {
2387                i32::try_from(v)
2388                    .ok()
2389                    .and_then(|x| x.try_into().ok())
2390                    .ok_or_else(|| {
2391                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2392                    })
2393            }
2394
2395            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2396            where
2397                E: serde::de::Error,
2398            {
2399                match value {
2400                    "UDF_EXPR_VERSION_UNSPECIFIED" => Ok(UdfExprVersion::Unspecified),
2401                    "UDF_EXPR_VERSION_NAME_IN_RUNTIME" => Ok(UdfExprVersion::NameInRuntime),
2402                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2403                }
2404            }
2405        }
2406        deserializer.deserialize_any(GeneratedVisitor)
2407    }
2408}
2409impl serde::Serialize for UserDefinedFunction {
2410    #[allow(deprecated)]
2411    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2412    where
2413        S: serde::Serializer,
2414    {
2415        use serde::ser::SerializeStruct;
2416        let mut len = 0;
2417        if !self.children.is_empty() {
2418            len += 1;
2419        }
2420        if !self.name.is_empty() {
2421            len += 1;
2422        }
2423        if !self.arg_names.is_empty() {
2424            len += 1;
2425        }
2426        if !self.arg_types.is_empty() {
2427            len += 1;
2428        }
2429        if !self.language.is_empty() {
2430            len += 1;
2431        }
2432        if self.link.is_some() {
2433            len += 1;
2434        }
2435        if self.identifier.is_some() {
2436            len += 1;
2437        }
2438        if self.body.is_some() {
2439            len += 1;
2440        }
2441        if self.compressed_binary.is_some() {
2442            len += 1;
2443        }
2444        if self.always_retry_on_network_error {
2445            len += 1;
2446        }
2447        if self.runtime.is_some() {
2448            len += 1;
2449        }
2450        if self.is_async.is_some() {
2451            len += 1;
2452        }
2453        if self.is_batched.is_some() {
2454            len += 1;
2455        }
2456        if self.version != 0 {
2457            len += 1;
2458        }
2459        let mut struct_ser = serializer.serialize_struct("expr.UserDefinedFunction", len)?;
2460        if !self.children.is_empty() {
2461            struct_ser.serialize_field("children", &self.children)?;
2462        }
2463        if !self.name.is_empty() {
2464            struct_ser.serialize_field("name", &self.name)?;
2465        }
2466        if !self.arg_names.is_empty() {
2467            struct_ser.serialize_field("argNames", &self.arg_names)?;
2468        }
2469        if !self.arg_types.is_empty() {
2470            struct_ser.serialize_field("argTypes", &self.arg_types)?;
2471        }
2472        if !self.language.is_empty() {
2473            struct_ser.serialize_field("language", &self.language)?;
2474        }
2475        if let Some(v) = self.link.as_ref() {
2476            struct_ser.serialize_field("link", v)?;
2477        }
2478        if let Some(v) = self.identifier.as_ref() {
2479            struct_ser.serialize_field("identifier", v)?;
2480        }
2481        if let Some(v) = self.body.as_ref() {
2482            struct_ser.serialize_field("body", v)?;
2483        }
2484        if let Some(v) = self.compressed_binary.as_ref() {
2485            #[allow(clippy::needless_borrow)]
2486            #[allow(clippy::needless_borrows_for_generic_args)]
2487            struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
2488        }
2489        if self.always_retry_on_network_error {
2490            struct_ser.serialize_field("alwaysRetryOnNetworkError", &self.always_retry_on_network_error)?;
2491        }
2492        if let Some(v) = self.runtime.as_ref() {
2493            struct_ser.serialize_field("runtime", v)?;
2494        }
2495        if let Some(v) = self.is_async.as_ref() {
2496            struct_ser.serialize_field("isAsync", v)?;
2497        }
2498        if let Some(v) = self.is_batched.as_ref() {
2499            struct_ser.serialize_field("isBatched", v)?;
2500        }
2501        if self.version != 0 {
2502            let v = UdfExprVersion::try_from(self.version)
2503                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
2504            struct_ser.serialize_field("version", &v)?;
2505        }
2506        struct_ser.end()
2507    }
2508}
2509impl<'de> serde::Deserialize<'de> for UserDefinedFunction {
2510    #[allow(deprecated)]
2511    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2512    where
2513        D: serde::Deserializer<'de>,
2514    {
2515        const FIELDS: &[&str] = &[
2516            "children",
2517            "name",
2518            "arg_names",
2519            "argNames",
2520            "arg_types",
2521            "argTypes",
2522            "language",
2523            "link",
2524            "identifier",
2525            "body",
2526            "compressed_binary",
2527            "compressedBinary",
2528            "always_retry_on_network_error",
2529            "alwaysRetryOnNetworkError",
2530            "runtime",
2531            "is_async",
2532            "isAsync",
2533            "is_batched",
2534            "isBatched",
2535            "version",
2536        ];
2537
2538        #[allow(clippy::enum_variant_names)]
2539        enum GeneratedField {
2540            Children,
2541            Name,
2542            ArgNames,
2543            ArgTypes,
2544            Language,
2545            Link,
2546            Identifier,
2547            Body,
2548            CompressedBinary,
2549            AlwaysRetryOnNetworkError,
2550            Runtime,
2551            IsAsync,
2552            IsBatched,
2553            Version,
2554        }
2555        impl<'de> serde::Deserialize<'de> for GeneratedField {
2556            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2557            where
2558                D: serde::Deserializer<'de>,
2559            {
2560                struct GeneratedVisitor;
2561
2562                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2563                    type Value = GeneratedField;
2564
2565                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2566                        write!(formatter, "expected one of: {:?}", &FIELDS)
2567                    }
2568
2569                    #[allow(unused_variables)]
2570                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2571                    where
2572                        E: serde::de::Error,
2573                    {
2574                        match value {
2575                            "children" => Ok(GeneratedField::Children),
2576                            "name" => Ok(GeneratedField::Name),
2577                            "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
2578                            "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
2579                            "language" => Ok(GeneratedField::Language),
2580                            "link" => Ok(GeneratedField::Link),
2581                            "identifier" => Ok(GeneratedField::Identifier),
2582                            "body" => Ok(GeneratedField::Body),
2583                            "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
2584                            "alwaysRetryOnNetworkError" | "always_retry_on_network_error" => Ok(GeneratedField::AlwaysRetryOnNetworkError),
2585                            "runtime" => Ok(GeneratedField::Runtime),
2586                            "isAsync" | "is_async" => Ok(GeneratedField::IsAsync),
2587                            "isBatched" | "is_batched" => Ok(GeneratedField::IsBatched),
2588                            "version" => Ok(GeneratedField::Version),
2589                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2590                        }
2591                    }
2592                }
2593                deserializer.deserialize_identifier(GeneratedVisitor)
2594            }
2595        }
2596        struct GeneratedVisitor;
2597        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2598            type Value = UserDefinedFunction;
2599
2600            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2601                formatter.write_str("struct expr.UserDefinedFunction")
2602            }
2603
2604            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserDefinedFunction, V::Error>
2605                where
2606                    V: serde::de::MapAccess<'de>,
2607            {
2608                let mut children__ = None;
2609                let mut name__ = None;
2610                let mut arg_names__ = None;
2611                let mut arg_types__ = None;
2612                let mut language__ = None;
2613                let mut link__ = None;
2614                let mut identifier__ = None;
2615                let mut body__ = None;
2616                let mut compressed_binary__ = None;
2617                let mut always_retry_on_network_error__ = None;
2618                let mut runtime__ = None;
2619                let mut is_async__ = None;
2620                let mut is_batched__ = None;
2621                let mut version__ = None;
2622                while let Some(k) = map_.next_key()? {
2623                    match k {
2624                        GeneratedField::Children => {
2625                            if children__.is_some() {
2626                                return Err(serde::de::Error::duplicate_field("children"));
2627                            }
2628                            children__ = Some(map_.next_value()?);
2629                        }
2630                        GeneratedField::Name => {
2631                            if name__.is_some() {
2632                                return Err(serde::de::Error::duplicate_field("name"));
2633                            }
2634                            name__ = Some(map_.next_value()?);
2635                        }
2636                        GeneratedField::ArgNames => {
2637                            if arg_names__.is_some() {
2638                                return Err(serde::de::Error::duplicate_field("argNames"));
2639                            }
2640                            arg_names__ = Some(map_.next_value()?);
2641                        }
2642                        GeneratedField::ArgTypes => {
2643                            if arg_types__.is_some() {
2644                                return Err(serde::de::Error::duplicate_field("argTypes"));
2645                            }
2646                            arg_types__ = Some(map_.next_value()?);
2647                        }
2648                        GeneratedField::Language => {
2649                            if language__.is_some() {
2650                                return Err(serde::de::Error::duplicate_field("language"));
2651                            }
2652                            language__ = Some(map_.next_value()?);
2653                        }
2654                        GeneratedField::Link => {
2655                            if link__.is_some() {
2656                                return Err(serde::de::Error::duplicate_field("link"));
2657                            }
2658                            link__ = map_.next_value()?;
2659                        }
2660                        GeneratedField::Identifier => {
2661                            if identifier__.is_some() {
2662                                return Err(serde::de::Error::duplicate_field("identifier"));
2663                            }
2664                            identifier__ = map_.next_value()?;
2665                        }
2666                        GeneratedField::Body => {
2667                            if body__.is_some() {
2668                                return Err(serde::de::Error::duplicate_field("body"));
2669                            }
2670                            body__ = map_.next_value()?;
2671                        }
2672                        GeneratedField::CompressedBinary => {
2673                            if compressed_binary__.is_some() {
2674                                return Err(serde::de::Error::duplicate_field("compressedBinary"));
2675                            }
2676                            compressed_binary__ = 
2677                                map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
2678                            ;
2679                        }
2680                        GeneratedField::AlwaysRetryOnNetworkError => {
2681                            if always_retry_on_network_error__.is_some() {
2682                                return Err(serde::de::Error::duplicate_field("alwaysRetryOnNetworkError"));
2683                            }
2684                            always_retry_on_network_error__ = Some(map_.next_value()?);
2685                        }
2686                        GeneratedField::Runtime => {
2687                            if runtime__.is_some() {
2688                                return Err(serde::de::Error::duplicate_field("runtime"));
2689                            }
2690                            runtime__ = map_.next_value()?;
2691                        }
2692                        GeneratedField::IsAsync => {
2693                            if is_async__.is_some() {
2694                                return Err(serde::de::Error::duplicate_field("isAsync"));
2695                            }
2696                            is_async__ = map_.next_value()?;
2697                        }
2698                        GeneratedField::IsBatched => {
2699                            if is_batched__.is_some() {
2700                                return Err(serde::de::Error::duplicate_field("isBatched"));
2701                            }
2702                            is_batched__ = map_.next_value()?;
2703                        }
2704                        GeneratedField::Version => {
2705                            if version__.is_some() {
2706                                return Err(serde::de::Error::duplicate_field("version"));
2707                            }
2708                            version__ = Some(map_.next_value::<UdfExprVersion>()? as i32);
2709                        }
2710                    }
2711                }
2712                Ok(UserDefinedFunction {
2713                    children: children__.unwrap_or_default(),
2714                    name: name__.unwrap_or_default(),
2715                    arg_names: arg_names__.unwrap_or_default(),
2716                    arg_types: arg_types__.unwrap_or_default(),
2717                    language: language__.unwrap_or_default(),
2718                    link: link__,
2719                    identifier: identifier__,
2720                    body: body__,
2721                    compressed_binary: compressed_binary__,
2722                    always_retry_on_network_error: always_retry_on_network_error__.unwrap_or_default(),
2723                    runtime: runtime__,
2724                    is_async: is_async__,
2725                    is_batched: is_batched__,
2726                    version: version__.unwrap_or_default(),
2727                })
2728            }
2729        }
2730        deserializer.deserialize_struct("expr.UserDefinedFunction", FIELDS, GeneratedVisitor)
2731    }
2732}
2733impl serde::Serialize for UserDefinedFunctionMetadata {
2734    #[allow(deprecated)]
2735    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2736    where
2737        S: serde::Serializer,
2738    {
2739        use serde::ser::SerializeStruct;
2740        let mut len = 0;
2741        if !self.arg_names.is_empty() {
2742            len += 1;
2743        }
2744        if !self.arg_types.is_empty() {
2745            len += 1;
2746        }
2747        if self.return_type.is_some() {
2748            len += 1;
2749        }
2750        if !self.language.is_empty() {
2751            len += 1;
2752        }
2753        if self.link.is_some() {
2754            len += 1;
2755        }
2756        if self.identifier.is_some() {
2757            len += 1;
2758        }
2759        if self.body.is_some() {
2760            len += 1;
2761        }
2762        if self.compressed_binary.is_some() {
2763            len += 1;
2764        }
2765        if self.runtime.is_some() {
2766            len += 1;
2767        }
2768        if self.version != 0 {
2769            len += 1;
2770        }
2771        let mut struct_ser = serializer.serialize_struct("expr.UserDefinedFunctionMetadata", len)?;
2772        if !self.arg_names.is_empty() {
2773            struct_ser.serialize_field("argNames", &self.arg_names)?;
2774        }
2775        if !self.arg_types.is_empty() {
2776            struct_ser.serialize_field("argTypes", &self.arg_types)?;
2777        }
2778        if let Some(v) = self.return_type.as_ref() {
2779            struct_ser.serialize_field("returnType", v)?;
2780        }
2781        if !self.language.is_empty() {
2782            struct_ser.serialize_field("language", &self.language)?;
2783        }
2784        if let Some(v) = self.link.as_ref() {
2785            struct_ser.serialize_field("link", v)?;
2786        }
2787        if let Some(v) = self.identifier.as_ref() {
2788            struct_ser.serialize_field("identifier", v)?;
2789        }
2790        if let Some(v) = self.body.as_ref() {
2791            struct_ser.serialize_field("body", v)?;
2792        }
2793        if let Some(v) = self.compressed_binary.as_ref() {
2794            #[allow(clippy::needless_borrow)]
2795            #[allow(clippy::needless_borrows_for_generic_args)]
2796            struct_ser.serialize_field("compressedBinary", pbjson::private::base64::encode(&v).as_str())?;
2797        }
2798        if let Some(v) = self.runtime.as_ref() {
2799            struct_ser.serialize_field("runtime", v)?;
2800        }
2801        if self.version != 0 {
2802            let v = UdfExprVersion::try_from(self.version)
2803                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
2804            struct_ser.serialize_field("version", &v)?;
2805        }
2806        struct_ser.end()
2807    }
2808}
2809impl<'de> serde::Deserialize<'de> for UserDefinedFunctionMetadata {
2810    #[allow(deprecated)]
2811    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2812    where
2813        D: serde::Deserializer<'de>,
2814    {
2815        const FIELDS: &[&str] = &[
2816            "arg_names",
2817            "argNames",
2818            "arg_types",
2819            "argTypes",
2820            "return_type",
2821            "returnType",
2822            "language",
2823            "link",
2824            "identifier",
2825            "body",
2826            "compressed_binary",
2827            "compressedBinary",
2828            "runtime",
2829            "version",
2830        ];
2831
2832        #[allow(clippy::enum_variant_names)]
2833        enum GeneratedField {
2834            ArgNames,
2835            ArgTypes,
2836            ReturnType,
2837            Language,
2838            Link,
2839            Identifier,
2840            Body,
2841            CompressedBinary,
2842            Runtime,
2843            Version,
2844        }
2845        impl<'de> serde::Deserialize<'de> for GeneratedField {
2846            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2847            where
2848                D: serde::Deserializer<'de>,
2849            {
2850                struct GeneratedVisitor;
2851
2852                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2853                    type Value = GeneratedField;
2854
2855                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2856                        write!(formatter, "expected one of: {:?}", &FIELDS)
2857                    }
2858
2859                    #[allow(unused_variables)]
2860                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2861                    where
2862                        E: serde::de::Error,
2863                    {
2864                        match value {
2865                            "argNames" | "arg_names" => Ok(GeneratedField::ArgNames),
2866                            "argTypes" | "arg_types" => Ok(GeneratedField::ArgTypes),
2867                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
2868                            "language" => Ok(GeneratedField::Language),
2869                            "link" => Ok(GeneratedField::Link),
2870                            "identifier" => Ok(GeneratedField::Identifier),
2871                            "body" => Ok(GeneratedField::Body),
2872                            "compressedBinary" | "compressed_binary" => Ok(GeneratedField::CompressedBinary),
2873                            "runtime" => Ok(GeneratedField::Runtime),
2874                            "version" => Ok(GeneratedField::Version),
2875                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2876                        }
2877                    }
2878                }
2879                deserializer.deserialize_identifier(GeneratedVisitor)
2880            }
2881        }
2882        struct GeneratedVisitor;
2883        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2884            type Value = UserDefinedFunctionMetadata;
2885
2886            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2887                formatter.write_str("struct expr.UserDefinedFunctionMetadata")
2888            }
2889
2890            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserDefinedFunctionMetadata, V::Error>
2891                where
2892                    V: serde::de::MapAccess<'de>,
2893            {
2894                let mut arg_names__ = None;
2895                let mut arg_types__ = None;
2896                let mut return_type__ = None;
2897                let mut language__ = None;
2898                let mut link__ = None;
2899                let mut identifier__ = None;
2900                let mut body__ = None;
2901                let mut compressed_binary__ = None;
2902                let mut runtime__ = None;
2903                let mut version__ = None;
2904                while let Some(k) = map_.next_key()? {
2905                    match k {
2906                        GeneratedField::ArgNames => {
2907                            if arg_names__.is_some() {
2908                                return Err(serde::de::Error::duplicate_field("argNames"));
2909                            }
2910                            arg_names__ = Some(map_.next_value()?);
2911                        }
2912                        GeneratedField::ArgTypes => {
2913                            if arg_types__.is_some() {
2914                                return Err(serde::de::Error::duplicate_field("argTypes"));
2915                            }
2916                            arg_types__ = Some(map_.next_value()?);
2917                        }
2918                        GeneratedField::ReturnType => {
2919                            if return_type__.is_some() {
2920                                return Err(serde::de::Error::duplicate_field("returnType"));
2921                            }
2922                            return_type__ = map_.next_value()?;
2923                        }
2924                        GeneratedField::Language => {
2925                            if language__.is_some() {
2926                                return Err(serde::de::Error::duplicate_field("language"));
2927                            }
2928                            language__ = Some(map_.next_value()?);
2929                        }
2930                        GeneratedField::Link => {
2931                            if link__.is_some() {
2932                                return Err(serde::de::Error::duplicate_field("link"));
2933                            }
2934                            link__ = map_.next_value()?;
2935                        }
2936                        GeneratedField::Identifier => {
2937                            if identifier__.is_some() {
2938                                return Err(serde::de::Error::duplicate_field("identifier"));
2939                            }
2940                            identifier__ = map_.next_value()?;
2941                        }
2942                        GeneratedField::Body => {
2943                            if body__.is_some() {
2944                                return Err(serde::de::Error::duplicate_field("body"));
2945                            }
2946                            body__ = map_.next_value()?;
2947                        }
2948                        GeneratedField::CompressedBinary => {
2949                            if compressed_binary__.is_some() {
2950                                return Err(serde::de::Error::duplicate_field("compressedBinary"));
2951                            }
2952                            compressed_binary__ = 
2953                                map_.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
2954                            ;
2955                        }
2956                        GeneratedField::Runtime => {
2957                            if runtime__.is_some() {
2958                                return Err(serde::de::Error::duplicate_field("runtime"));
2959                            }
2960                            runtime__ = map_.next_value()?;
2961                        }
2962                        GeneratedField::Version => {
2963                            if version__.is_some() {
2964                                return Err(serde::de::Error::duplicate_field("version"));
2965                            }
2966                            version__ = Some(map_.next_value::<UdfExprVersion>()? as i32);
2967                        }
2968                    }
2969                }
2970                Ok(UserDefinedFunctionMetadata {
2971                    arg_names: arg_names__.unwrap_or_default(),
2972                    arg_types: arg_types__.unwrap_or_default(),
2973                    return_type: return_type__,
2974                    language: language__.unwrap_or_default(),
2975                    link: link__,
2976                    identifier: identifier__,
2977                    body: body__,
2978                    compressed_binary: compressed_binary__,
2979                    runtime: runtime__,
2980                    version: version__.unwrap_or_default(),
2981                })
2982            }
2983        }
2984        deserializer.deserialize_struct("expr.UserDefinedFunctionMetadata", FIELDS, GeneratedVisitor)
2985    }
2986}
2987impl serde::Serialize for WindowFrame {
2988    #[allow(deprecated)]
2989    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2990    where
2991        S: serde::Serializer,
2992    {
2993        use serde::ser::SerializeStruct;
2994        let mut len = 0;
2995        if self.r#type != 0 {
2996            len += 1;
2997        }
2998        if self.start.is_some() {
2999            len += 1;
3000        }
3001        if self.end.is_some() {
3002            len += 1;
3003        }
3004        if self.exclusion != 0 {
3005            len += 1;
3006        }
3007        if self.bounds.is_some() {
3008            len += 1;
3009        }
3010        let mut struct_ser = serializer.serialize_struct("expr.WindowFrame", len)?;
3011        if self.r#type != 0 {
3012            let v = window_frame::Type::try_from(self.r#type)
3013                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3014            struct_ser.serialize_field("type", &v)?;
3015        }
3016        if let Some(v) = self.start.as_ref() {
3017            struct_ser.serialize_field("start", v)?;
3018        }
3019        if let Some(v) = self.end.as_ref() {
3020            struct_ser.serialize_field("end", v)?;
3021        }
3022        if self.exclusion != 0 {
3023            let v = window_frame::Exclusion::try_from(self.exclusion)
3024                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.exclusion)))?;
3025            struct_ser.serialize_field("exclusion", &v)?;
3026        }
3027        if let Some(v) = self.bounds.as_ref() {
3028            match v {
3029                window_frame::Bounds::Rows(v) => {
3030                    struct_ser.serialize_field("rows", v)?;
3031                }
3032                window_frame::Bounds::Range(v) => {
3033                    struct_ser.serialize_field("range", v)?;
3034                }
3035                window_frame::Bounds::Session(v) => {
3036                    struct_ser.serialize_field("session", v)?;
3037                }
3038            }
3039        }
3040        struct_ser.end()
3041    }
3042}
3043impl<'de> serde::Deserialize<'de> for WindowFrame {
3044    #[allow(deprecated)]
3045    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3046    where
3047        D: serde::Deserializer<'de>,
3048    {
3049        const FIELDS: &[&str] = &[
3050            "type",
3051            "start",
3052            "end",
3053            "exclusion",
3054            "rows",
3055            "range",
3056            "session",
3057        ];
3058
3059        #[allow(clippy::enum_variant_names)]
3060        enum GeneratedField {
3061            Type,
3062            Start,
3063            End,
3064            Exclusion,
3065            Rows,
3066            Range,
3067            Session,
3068        }
3069        impl<'de> serde::Deserialize<'de> for GeneratedField {
3070            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3071            where
3072                D: serde::Deserializer<'de>,
3073            {
3074                struct GeneratedVisitor;
3075
3076                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3077                    type Value = GeneratedField;
3078
3079                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3080                        write!(formatter, "expected one of: {:?}", &FIELDS)
3081                    }
3082
3083                    #[allow(unused_variables)]
3084                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3085                    where
3086                        E: serde::de::Error,
3087                    {
3088                        match value {
3089                            "type" => Ok(GeneratedField::Type),
3090                            "start" => Ok(GeneratedField::Start),
3091                            "end" => Ok(GeneratedField::End),
3092                            "exclusion" => Ok(GeneratedField::Exclusion),
3093                            "rows" => Ok(GeneratedField::Rows),
3094                            "range" => Ok(GeneratedField::Range),
3095                            "session" => Ok(GeneratedField::Session),
3096                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3097                        }
3098                    }
3099                }
3100                deserializer.deserialize_identifier(GeneratedVisitor)
3101            }
3102        }
3103        struct GeneratedVisitor;
3104        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3105            type Value = WindowFrame;
3106
3107            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3108                formatter.write_str("struct expr.WindowFrame")
3109            }
3110
3111            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WindowFrame, V::Error>
3112                where
3113                    V: serde::de::MapAccess<'de>,
3114            {
3115                let mut r#type__ = None;
3116                let mut start__ = None;
3117                let mut end__ = None;
3118                let mut exclusion__ = None;
3119                let mut bounds__ = None;
3120                while let Some(k) = map_.next_key()? {
3121                    match k {
3122                        GeneratedField::Type => {
3123                            if r#type__.is_some() {
3124                                return Err(serde::de::Error::duplicate_field("type"));
3125                            }
3126                            r#type__ = Some(map_.next_value::<window_frame::Type>()? as i32);
3127                        }
3128                        GeneratedField::Start => {
3129                            if start__.is_some() {
3130                                return Err(serde::de::Error::duplicate_field("start"));
3131                            }
3132                            start__ = map_.next_value()?;
3133                        }
3134                        GeneratedField::End => {
3135                            if end__.is_some() {
3136                                return Err(serde::de::Error::duplicate_field("end"));
3137                            }
3138                            end__ = map_.next_value()?;
3139                        }
3140                        GeneratedField::Exclusion => {
3141                            if exclusion__.is_some() {
3142                                return Err(serde::de::Error::duplicate_field("exclusion"));
3143                            }
3144                            exclusion__ = Some(map_.next_value::<window_frame::Exclusion>()? as i32);
3145                        }
3146                        GeneratedField::Rows => {
3147                            if bounds__.is_some() {
3148                                return Err(serde::de::Error::duplicate_field("rows"));
3149                            }
3150                            bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Rows)
3151;
3152                        }
3153                        GeneratedField::Range => {
3154                            if bounds__.is_some() {
3155                                return Err(serde::de::Error::duplicate_field("range"));
3156                            }
3157                            bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Range)
3158;
3159                        }
3160                        GeneratedField::Session => {
3161                            if bounds__.is_some() {
3162                                return Err(serde::de::Error::duplicate_field("session"));
3163                            }
3164                            bounds__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::Bounds::Session)
3165;
3166                        }
3167                    }
3168                }
3169                Ok(WindowFrame {
3170                    r#type: r#type__.unwrap_or_default(),
3171                    start: start__,
3172                    end: end__,
3173                    exclusion: exclusion__.unwrap_or_default(),
3174                    bounds: bounds__,
3175                })
3176            }
3177        }
3178        deserializer.deserialize_struct("expr.WindowFrame", FIELDS, GeneratedVisitor)
3179    }
3180}
3181impl serde::Serialize for window_frame::Bound {
3182    #[allow(deprecated)]
3183    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3184    where
3185        S: serde::Serializer,
3186    {
3187        use serde::ser::SerializeStruct;
3188        let mut len = 0;
3189        if self.r#type != 0 {
3190            len += 1;
3191        }
3192        if self.offset.is_some() {
3193            len += 1;
3194        }
3195        let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.Bound", len)?;
3196        if self.r#type != 0 {
3197            let v = window_frame::BoundType::try_from(self.r#type)
3198                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3199            struct_ser.serialize_field("type", &v)?;
3200        }
3201        if let Some(v) = self.offset.as_ref() {
3202            match v {
3203                window_frame::bound::Offset::Integer(v) => {
3204                    #[allow(clippy::needless_borrow)]
3205                    #[allow(clippy::needless_borrows_for_generic_args)]
3206                    struct_ser.serialize_field("integer", ToString::to_string(&v).as_str())?;
3207                }
3208                window_frame::bound::Offset::Datum(v) => {
3209                    struct_ser.serialize_field("datum", v)?;
3210                }
3211            }
3212        }
3213        struct_ser.end()
3214    }
3215}
3216impl<'de> serde::Deserialize<'de> for window_frame::Bound {
3217    #[allow(deprecated)]
3218    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3219    where
3220        D: serde::Deserializer<'de>,
3221    {
3222        const FIELDS: &[&str] = &[
3223            "type",
3224            "integer",
3225            "datum",
3226        ];
3227
3228        #[allow(clippy::enum_variant_names)]
3229        enum GeneratedField {
3230            Type,
3231            Integer,
3232            Datum,
3233        }
3234        impl<'de> serde::Deserialize<'de> for GeneratedField {
3235            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3236            where
3237                D: serde::Deserializer<'de>,
3238            {
3239                struct GeneratedVisitor;
3240
3241                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3242                    type Value = GeneratedField;
3243
3244                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3245                        write!(formatter, "expected one of: {:?}", &FIELDS)
3246                    }
3247
3248                    #[allow(unused_variables)]
3249                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3250                    where
3251                        E: serde::de::Error,
3252                    {
3253                        match value {
3254                            "type" => Ok(GeneratedField::Type),
3255                            "integer" => Ok(GeneratedField::Integer),
3256                            "datum" => Ok(GeneratedField::Datum),
3257                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3258                        }
3259                    }
3260                }
3261                deserializer.deserialize_identifier(GeneratedVisitor)
3262            }
3263        }
3264        struct GeneratedVisitor;
3265        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3266            type Value = window_frame::Bound;
3267
3268            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3269                formatter.write_str("struct expr.WindowFrame.Bound")
3270            }
3271
3272            fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::Bound, V::Error>
3273                where
3274                    V: serde::de::MapAccess<'de>,
3275            {
3276                let mut r#type__ = None;
3277                let mut offset__ = None;
3278                while let Some(k) = map_.next_key()? {
3279                    match k {
3280                        GeneratedField::Type => {
3281                            if r#type__.is_some() {
3282                                return Err(serde::de::Error::duplicate_field("type"));
3283                            }
3284                            r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3285                        }
3286                        GeneratedField::Integer => {
3287                            if offset__.is_some() {
3288                                return Err(serde::de::Error::duplicate_field("integer"));
3289                            }
3290                            offset__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| window_frame::bound::Offset::Integer(x.0));
3291                        }
3292                        GeneratedField::Datum => {
3293                            if offset__.is_some() {
3294                                return Err(serde::de::Error::duplicate_field("datum"));
3295                            }
3296                            offset__ = map_.next_value::<::std::option::Option<_>>()?.map(window_frame::bound::Offset::Datum)
3297;
3298                        }
3299                    }
3300                }
3301                Ok(window_frame::Bound {
3302                    r#type: r#type__.unwrap_or_default(),
3303                    offset: offset__,
3304                })
3305            }
3306        }
3307        deserializer.deserialize_struct("expr.WindowFrame.Bound", FIELDS, GeneratedVisitor)
3308    }
3309}
3310impl serde::Serialize for window_frame::BoundType {
3311    #[allow(deprecated)]
3312    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3313    where
3314        S: serde::Serializer,
3315    {
3316        let variant = match self {
3317            Self::Unspecified => "BOUND_TYPE_UNSPECIFIED",
3318            Self::UnboundedPreceding => "BOUND_TYPE_UNBOUNDED_PRECEDING",
3319            Self::Preceding => "BOUND_TYPE_PRECEDING",
3320            Self::CurrentRow => "BOUND_TYPE_CURRENT_ROW",
3321            Self::Following => "BOUND_TYPE_FOLLOWING",
3322            Self::UnboundedFollowing => "BOUND_TYPE_UNBOUNDED_FOLLOWING",
3323        };
3324        serializer.serialize_str(variant)
3325    }
3326}
3327impl<'de> serde::Deserialize<'de> for window_frame::BoundType {
3328    #[allow(deprecated)]
3329    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3330    where
3331        D: serde::Deserializer<'de>,
3332    {
3333        const FIELDS: &[&str] = &[
3334            "BOUND_TYPE_UNSPECIFIED",
3335            "BOUND_TYPE_UNBOUNDED_PRECEDING",
3336            "BOUND_TYPE_PRECEDING",
3337            "BOUND_TYPE_CURRENT_ROW",
3338            "BOUND_TYPE_FOLLOWING",
3339            "BOUND_TYPE_UNBOUNDED_FOLLOWING",
3340        ];
3341
3342        struct GeneratedVisitor;
3343
3344        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3345            type Value = window_frame::BoundType;
3346
3347            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3348                write!(formatter, "expected one of: {:?}", &FIELDS)
3349            }
3350
3351            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3352            where
3353                E: serde::de::Error,
3354            {
3355                i32::try_from(v)
3356                    .ok()
3357                    .and_then(|x| x.try_into().ok())
3358                    .ok_or_else(|| {
3359                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3360                    })
3361            }
3362
3363            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3364            where
3365                E: serde::de::Error,
3366            {
3367                i32::try_from(v)
3368                    .ok()
3369                    .and_then(|x| x.try_into().ok())
3370                    .ok_or_else(|| {
3371                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3372                    })
3373            }
3374
3375            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3376            where
3377                E: serde::de::Error,
3378            {
3379                match value {
3380                    "BOUND_TYPE_UNSPECIFIED" => Ok(window_frame::BoundType::Unspecified),
3381                    "BOUND_TYPE_UNBOUNDED_PRECEDING" => Ok(window_frame::BoundType::UnboundedPreceding),
3382                    "BOUND_TYPE_PRECEDING" => Ok(window_frame::BoundType::Preceding),
3383                    "BOUND_TYPE_CURRENT_ROW" => Ok(window_frame::BoundType::CurrentRow),
3384                    "BOUND_TYPE_FOLLOWING" => Ok(window_frame::BoundType::Following),
3385                    "BOUND_TYPE_UNBOUNDED_FOLLOWING" => Ok(window_frame::BoundType::UnboundedFollowing),
3386                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3387                }
3388            }
3389        }
3390        deserializer.deserialize_any(GeneratedVisitor)
3391    }
3392}
3393impl serde::Serialize for window_frame::Exclusion {
3394    #[allow(deprecated)]
3395    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3396    where
3397        S: serde::Serializer,
3398    {
3399        let variant = match self {
3400            Self::Unspecified => "EXCLUSION_UNSPECIFIED",
3401            Self::CurrentRow => "EXCLUSION_CURRENT_ROW",
3402            Self::NoOthers => "EXCLUSION_NO_OTHERS",
3403        };
3404        serializer.serialize_str(variant)
3405    }
3406}
3407impl<'de> serde::Deserialize<'de> for window_frame::Exclusion {
3408    #[allow(deprecated)]
3409    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3410    where
3411        D: serde::Deserializer<'de>,
3412    {
3413        const FIELDS: &[&str] = &[
3414            "EXCLUSION_UNSPECIFIED",
3415            "EXCLUSION_CURRENT_ROW",
3416            "EXCLUSION_NO_OTHERS",
3417        ];
3418
3419        struct GeneratedVisitor;
3420
3421        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3422            type Value = window_frame::Exclusion;
3423
3424            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3425                write!(formatter, "expected one of: {:?}", &FIELDS)
3426            }
3427
3428            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3429            where
3430                E: serde::de::Error,
3431            {
3432                i32::try_from(v)
3433                    .ok()
3434                    .and_then(|x| x.try_into().ok())
3435                    .ok_or_else(|| {
3436                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3437                    })
3438            }
3439
3440            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3441            where
3442                E: serde::de::Error,
3443            {
3444                i32::try_from(v)
3445                    .ok()
3446                    .and_then(|x| x.try_into().ok())
3447                    .ok_or_else(|| {
3448                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3449                    })
3450            }
3451
3452            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3453            where
3454                E: serde::de::Error,
3455            {
3456                match value {
3457                    "EXCLUSION_UNSPECIFIED" => Ok(window_frame::Exclusion::Unspecified),
3458                    "EXCLUSION_CURRENT_ROW" => Ok(window_frame::Exclusion::CurrentRow),
3459                    "EXCLUSION_NO_OTHERS" => Ok(window_frame::Exclusion::NoOthers),
3460                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3461                }
3462            }
3463        }
3464        deserializer.deserialize_any(GeneratedVisitor)
3465    }
3466}
3467impl serde::Serialize for window_frame::RangeFrameBound {
3468    #[allow(deprecated)]
3469    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3470    where
3471        S: serde::Serializer,
3472    {
3473        use serde::ser::SerializeStruct;
3474        let mut len = 0;
3475        if self.r#type != 0 {
3476            len += 1;
3477        }
3478        if self.offset.is_some() {
3479            len += 1;
3480        }
3481        let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RangeFrameBound", len)?;
3482        if self.r#type != 0 {
3483            let v = window_frame::BoundType::try_from(self.r#type)
3484                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3485            struct_ser.serialize_field("type", &v)?;
3486        }
3487        if let Some(v) = self.offset.as_ref() {
3488            struct_ser.serialize_field("offset", v)?;
3489        }
3490        struct_ser.end()
3491    }
3492}
3493impl<'de> serde::Deserialize<'de> for window_frame::RangeFrameBound {
3494    #[allow(deprecated)]
3495    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3496    where
3497        D: serde::Deserializer<'de>,
3498    {
3499        const FIELDS: &[&str] = &[
3500            "type",
3501            "offset",
3502        ];
3503
3504        #[allow(clippy::enum_variant_names)]
3505        enum GeneratedField {
3506            Type,
3507            Offset,
3508        }
3509        impl<'de> serde::Deserialize<'de> for GeneratedField {
3510            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3511            where
3512                D: serde::Deserializer<'de>,
3513            {
3514                struct GeneratedVisitor;
3515
3516                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3517                    type Value = GeneratedField;
3518
3519                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3520                        write!(formatter, "expected one of: {:?}", &FIELDS)
3521                    }
3522
3523                    #[allow(unused_variables)]
3524                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3525                    where
3526                        E: serde::de::Error,
3527                    {
3528                        match value {
3529                            "type" => Ok(GeneratedField::Type),
3530                            "offset" => Ok(GeneratedField::Offset),
3531                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3532                        }
3533                    }
3534                }
3535                deserializer.deserialize_identifier(GeneratedVisitor)
3536            }
3537        }
3538        struct GeneratedVisitor;
3539        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3540            type Value = window_frame::RangeFrameBound;
3541
3542            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3543                formatter.write_str("struct expr.WindowFrame.RangeFrameBound")
3544            }
3545
3546            fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RangeFrameBound, V::Error>
3547                where
3548                    V: serde::de::MapAccess<'de>,
3549            {
3550                let mut r#type__ = None;
3551                let mut offset__ = None;
3552                while let Some(k) = map_.next_key()? {
3553                    match k {
3554                        GeneratedField::Type => {
3555                            if r#type__.is_some() {
3556                                return Err(serde::de::Error::duplicate_field("type"));
3557                            }
3558                            r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3559                        }
3560                        GeneratedField::Offset => {
3561                            if offset__.is_some() {
3562                                return Err(serde::de::Error::duplicate_field("offset"));
3563                            }
3564                            offset__ = map_.next_value()?;
3565                        }
3566                    }
3567                }
3568                Ok(window_frame::RangeFrameBound {
3569                    r#type: r#type__.unwrap_or_default(),
3570                    offset: offset__,
3571                })
3572            }
3573        }
3574        deserializer.deserialize_struct("expr.WindowFrame.RangeFrameBound", FIELDS, GeneratedVisitor)
3575    }
3576}
3577impl serde::Serialize for window_frame::RangeFrameBounds {
3578    #[allow(deprecated)]
3579    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3580    where
3581        S: serde::Serializer,
3582    {
3583        use serde::ser::SerializeStruct;
3584        let mut len = 0;
3585        if self.start.is_some() {
3586            len += 1;
3587        }
3588        if self.end.is_some() {
3589            len += 1;
3590        }
3591        if self.order_data_type.is_some() {
3592            len += 1;
3593        }
3594        if self.order_type.is_some() {
3595            len += 1;
3596        }
3597        if self.offset_data_type.is_some() {
3598            len += 1;
3599        }
3600        let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RangeFrameBounds", len)?;
3601        if let Some(v) = self.start.as_ref() {
3602            struct_ser.serialize_field("start", v)?;
3603        }
3604        if let Some(v) = self.end.as_ref() {
3605            struct_ser.serialize_field("end", v)?;
3606        }
3607        if let Some(v) = self.order_data_type.as_ref() {
3608            struct_ser.serialize_field("orderDataType", v)?;
3609        }
3610        if let Some(v) = self.order_type.as_ref() {
3611            struct_ser.serialize_field("orderType", v)?;
3612        }
3613        if let Some(v) = self.offset_data_type.as_ref() {
3614            struct_ser.serialize_field("offsetDataType", v)?;
3615        }
3616        struct_ser.end()
3617    }
3618}
3619impl<'de> serde::Deserialize<'de> for window_frame::RangeFrameBounds {
3620    #[allow(deprecated)]
3621    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3622    where
3623        D: serde::Deserializer<'de>,
3624    {
3625        const FIELDS: &[&str] = &[
3626            "start",
3627            "end",
3628            "order_data_type",
3629            "orderDataType",
3630            "order_type",
3631            "orderType",
3632            "offset_data_type",
3633            "offsetDataType",
3634        ];
3635
3636        #[allow(clippy::enum_variant_names)]
3637        enum GeneratedField {
3638            Start,
3639            End,
3640            OrderDataType,
3641            OrderType,
3642            OffsetDataType,
3643        }
3644        impl<'de> serde::Deserialize<'de> for GeneratedField {
3645            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3646            where
3647                D: serde::Deserializer<'de>,
3648            {
3649                struct GeneratedVisitor;
3650
3651                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3652                    type Value = GeneratedField;
3653
3654                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3655                        write!(formatter, "expected one of: {:?}", &FIELDS)
3656                    }
3657
3658                    #[allow(unused_variables)]
3659                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3660                    where
3661                        E: serde::de::Error,
3662                    {
3663                        match value {
3664                            "start" => Ok(GeneratedField::Start),
3665                            "end" => Ok(GeneratedField::End),
3666                            "orderDataType" | "order_data_type" => Ok(GeneratedField::OrderDataType),
3667                            "orderType" | "order_type" => Ok(GeneratedField::OrderType),
3668                            "offsetDataType" | "offset_data_type" => Ok(GeneratedField::OffsetDataType),
3669                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3670                        }
3671                    }
3672                }
3673                deserializer.deserialize_identifier(GeneratedVisitor)
3674            }
3675        }
3676        struct GeneratedVisitor;
3677        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3678            type Value = window_frame::RangeFrameBounds;
3679
3680            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3681                formatter.write_str("struct expr.WindowFrame.RangeFrameBounds")
3682            }
3683
3684            fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RangeFrameBounds, V::Error>
3685                where
3686                    V: serde::de::MapAccess<'de>,
3687            {
3688                let mut start__ = None;
3689                let mut end__ = None;
3690                let mut order_data_type__ = None;
3691                let mut order_type__ = None;
3692                let mut offset_data_type__ = None;
3693                while let Some(k) = map_.next_key()? {
3694                    match k {
3695                        GeneratedField::Start => {
3696                            if start__.is_some() {
3697                                return Err(serde::de::Error::duplicate_field("start"));
3698                            }
3699                            start__ = map_.next_value()?;
3700                        }
3701                        GeneratedField::End => {
3702                            if end__.is_some() {
3703                                return Err(serde::de::Error::duplicate_field("end"));
3704                            }
3705                            end__ = map_.next_value()?;
3706                        }
3707                        GeneratedField::OrderDataType => {
3708                            if order_data_type__.is_some() {
3709                                return Err(serde::de::Error::duplicate_field("orderDataType"));
3710                            }
3711                            order_data_type__ = map_.next_value()?;
3712                        }
3713                        GeneratedField::OrderType => {
3714                            if order_type__.is_some() {
3715                                return Err(serde::de::Error::duplicate_field("orderType"));
3716                            }
3717                            order_type__ = map_.next_value()?;
3718                        }
3719                        GeneratedField::OffsetDataType => {
3720                            if offset_data_type__.is_some() {
3721                                return Err(serde::de::Error::duplicate_field("offsetDataType"));
3722                            }
3723                            offset_data_type__ = map_.next_value()?;
3724                        }
3725                    }
3726                }
3727                Ok(window_frame::RangeFrameBounds {
3728                    start: start__,
3729                    end: end__,
3730                    order_data_type: order_data_type__,
3731                    order_type: order_type__,
3732                    offset_data_type: offset_data_type__,
3733                })
3734            }
3735        }
3736        deserializer.deserialize_struct("expr.WindowFrame.RangeFrameBounds", FIELDS, GeneratedVisitor)
3737    }
3738}
3739impl serde::Serialize for window_frame::RowsFrameBound {
3740    #[allow(deprecated)]
3741    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3742    where
3743        S: serde::Serializer,
3744    {
3745        use serde::ser::SerializeStruct;
3746        let mut len = 0;
3747        if self.r#type != 0 {
3748            len += 1;
3749        }
3750        if self.offset.is_some() {
3751            len += 1;
3752        }
3753        let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RowsFrameBound", len)?;
3754        if self.r#type != 0 {
3755            let v = window_frame::BoundType::try_from(self.r#type)
3756                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3757            struct_ser.serialize_field("type", &v)?;
3758        }
3759        if let Some(v) = self.offset.as_ref() {
3760            #[allow(clippy::needless_borrow)]
3761            #[allow(clippy::needless_borrows_for_generic_args)]
3762            struct_ser.serialize_field("offset", ToString::to_string(&v).as_str())?;
3763        }
3764        struct_ser.end()
3765    }
3766}
3767impl<'de> serde::Deserialize<'de> for window_frame::RowsFrameBound {
3768    #[allow(deprecated)]
3769    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3770    where
3771        D: serde::Deserializer<'de>,
3772    {
3773        const FIELDS: &[&str] = &[
3774            "type",
3775            "offset",
3776        ];
3777
3778        #[allow(clippy::enum_variant_names)]
3779        enum GeneratedField {
3780            Type,
3781            Offset,
3782        }
3783        impl<'de> serde::Deserialize<'de> for GeneratedField {
3784            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3785            where
3786                D: serde::Deserializer<'de>,
3787            {
3788                struct GeneratedVisitor;
3789
3790                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3791                    type Value = GeneratedField;
3792
3793                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3794                        write!(formatter, "expected one of: {:?}", &FIELDS)
3795                    }
3796
3797                    #[allow(unused_variables)]
3798                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3799                    where
3800                        E: serde::de::Error,
3801                    {
3802                        match value {
3803                            "type" => Ok(GeneratedField::Type),
3804                            "offset" => Ok(GeneratedField::Offset),
3805                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3806                        }
3807                    }
3808                }
3809                deserializer.deserialize_identifier(GeneratedVisitor)
3810            }
3811        }
3812        struct GeneratedVisitor;
3813        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3814            type Value = window_frame::RowsFrameBound;
3815
3816            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3817                formatter.write_str("struct expr.WindowFrame.RowsFrameBound")
3818            }
3819
3820            fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RowsFrameBound, V::Error>
3821                where
3822                    V: serde::de::MapAccess<'de>,
3823            {
3824                let mut r#type__ = None;
3825                let mut offset__ = None;
3826                while let Some(k) = map_.next_key()? {
3827                    match k {
3828                        GeneratedField::Type => {
3829                            if r#type__.is_some() {
3830                                return Err(serde::de::Error::duplicate_field("type"));
3831                            }
3832                            r#type__ = Some(map_.next_value::<window_frame::BoundType>()? as i32);
3833                        }
3834                        GeneratedField::Offset => {
3835                            if offset__.is_some() {
3836                                return Err(serde::de::Error::duplicate_field("offset"));
3837                            }
3838                            offset__ = 
3839                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3840                            ;
3841                        }
3842                    }
3843                }
3844                Ok(window_frame::RowsFrameBound {
3845                    r#type: r#type__.unwrap_or_default(),
3846                    offset: offset__,
3847                })
3848            }
3849        }
3850        deserializer.deserialize_struct("expr.WindowFrame.RowsFrameBound", FIELDS, GeneratedVisitor)
3851    }
3852}
3853impl serde::Serialize for window_frame::RowsFrameBounds {
3854    #[allow(deprecated)]
3855    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3856    where
3857        S: serde::Serializer,
3858    {
3859        use serde::ser::SerializeStruct;
3860        let mut len = 0;
3861        if self.start.is_some() {
3862            len += 1;
3863        }
3864        if self.end.is_some() {
3865            len += 1;
3866        }
3867        let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.RowsFrameBounds", len)?;
3868        if let Some(v) = self.start.as_ref() {
3869            struct_ser.serialize_field("start", v)?;
3870        }
3871        if let Some(v) = self.end.as_ref() {
3872            struct_ser.serialize_field("end", v)?;
3873        }
3874        struct_ser.end()
3875    }
3876}
3877impl<'de> serde::Deserialize<'de> for window_frame::RowsFrameBounds {
3878    #[allow(deprecated)]
3879    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3880    where
3881        D: serde::Deserializer<'de>,
3882    {
3883        const FIELDS: &[&str] = &[
3884            "start",
3885            "end",
3886        ];
3887
3888        #[allow(clippy::enum_variant_names)]
3889        enum GeneratedField {
3890            Start,
3891            End,
3892        }
3893        impl<'de> serde::Deserialize<'de> for GeneratedField {
3894            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3895            where
3896                D: serde::Deserializer<'de>,
3897            {
3898                struct GeneratedVisitor;
3899
3900                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3901                    type Value = GeneratedField;
3902
3903                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3904                        write!(formatter, "expected one of: {:?}", &FIELDS)
3905                    }
3906
3907                    #[allow(unused_variables)]
3908                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3909                    where
3910                        E: serde::de::Error,
3911                    {
3912                        match value {
3913                            "start" => Ok(GeneratedField::Start),
3914                            "end" => Ok(GeneratedField::End),
3915                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3916                        }
3917                    }
3918                }
3919                deserializer.deserialize_identifier(GeneratedVisitor)
3920            }
3921        }
3922        struct GeneratedVisitor;
3923        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3924            type Value = window_frame::RowsFrameBounds;
3925
3926            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3927                formatter.write_str("struct expr.WindowFrame.RowsFrameBounds")
3928            }
3929
3930            fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::RowsFrameBounds, V::Error>
3931                where
3932                    V: serde::de::MapAccess<'de>,
3933            {
3934                let mut start__ = None;
3935                let mut end__ = None;
3936                while let Some(k) = map_.next_key()? {
3937                    match k {
3938                        GeneratedField::Start => {
3939                            if start__.is_some() {
3940                                return Err(serde::de::Error::duplicate_field("start"));
3941                            }
3942                            start__ = map_.next_value()?;
3943                        }
3944                        GeneratedField::End => {
3945                            if end__.is_some() {
3946                                return Err(serde::de::Error::duplicate_field("end"));
3947                            }
3948                            end__ = map_.next_value()?;
3949                        }
3950                    }
3951                }
3952                Ok(window_frame::RowsFrameBounds {
3953                    start: start__,
3954                    end: end__,
3955                })
3956            }
3957        }
3958        deserializer.deserialize_struct("expr.WindowFrame.RowsFrameBounds", FIELDS, GeneratedVisitor)
3959    }
3960}
3961impl serde::Serialize for window_frame::SessionFrameBounds {
3962    #[allow(deprecated)]
3963    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3964    where
3965        S: serde::Serializer,
3966    {
3967        use serde::ser::SerializeStruct;
3968        let mut len = 0;
3969        if self.gap.is_some() {
3970            len += 1;
3971        }
3972        if self.order_data_type.is_some() {
3973            len += 1;
3974        }
3975        if self.order_type.is_some() {
3976            len += 1;
3977        }
3978        if self.gap_data_type.is_some() {
3979            len += 1;
3980        }
3981        let mut struct_ser = serializer.serialize_struct("expr.WindowFrame.SessionFrameBounds", len)?;
3982        if let Some(v) = self.gap.as_ref() {
3983            struct_ser.serialize_field("gap", v)?;
3984        }
3985        if let Some(v) = self.order_data_type.as_ref() {
3986            struct_ser.serialize_field("orderDataType", v)?;
3987        }
3988        if let Some(v) = self.order_type.as_ref() {
3989            struct_ser.serialize_field("orderType", v)?;
3990        }
3991        if let Some(v) = self.gap_data_type.as_ref() {
3992            struct_ser.serialize_field("gapDataType", v)?;
3993        }
3994        struct_ser.end()
3995    }
3996}
3997impl<'de> serde::Deserialize<'de> for window_frame::SessionFrameBounds {
3998    #[allow(deprecated)]
3999    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4000    where
4001        D: serde::Deserializer<'de>,
4002    {
4003        const FIELDS: &[&str] = &[
4004            "gap",
4005            "order_data_type",
4006            "orderDataType",
4007            "order_type",
4008            "orderType",
4009            "gap_data_type",
4010            "gapDataType",
4011        ];
4012
4013        #[allow(clippy::enum_variant_names)]
4014        enum GeneratedField {
4015            Gap,
4016            OrderDataType,
4017            OrderType,
4018            GapDataType,
4019        }
4020        impl<'de> serde::Deserialize<'de> for GeneratedField {
4021            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4022            where
4023                D: serde::Deserializer<'de>,
4024            {
4025                struct GeneratedVisitor;
4026
4027                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4028                    type Value = GeneratedField;
4029
4030                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4031                        write!(formatter, "expected one of: {:?}", &FIELDS)
4032                    }
4033
4034                    #[allow(unused_variables)]
4035                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4036                    where
4037                        E: serde::de::Error,
4038                    {
4039                        match value {
4040                            "gap" => Ok(GeneratedField::Gap),
4041                            "orderDataType" | "order_data_type" => Ok(GeneratedField::OrderDataType),
4042                            "orderType" | "order_type" => Ok(GeneratedField::OrderType),
4043                            "gapDataType" | "gap_data_type" => Ok(GeneratedField::GapDataType),
4044                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4045                        }
4046                    }
4047                }
4048                deserializer.deserialize_identifier(GeneratedVisitor)
4049            }
4050        }
4051        struct GeneratedVisitor;
4052        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4053            type Value = window_frame::SessionFrameBounds;
4054
4055            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4056                formatter.write_str("struct expr.WindowFrame.SessionFrameBounds")
4057            }
4058
4059            fn visit_map<V>(self, mut map_: V) -> std::result::Result<window_frame::SessionFrameBounds, V::Error>
4060                where
4061                    V: serde::de::MapAccess<'de>,
4062            {
4063                let mut gap__ = None;
4064                let mut order_data_type__ = None;
4065                let mut order_type__ = None;
4066                let mut gap_data_type__ = None;
4067                while let Some(k) = map_.next_key()? {
4068                    match k {
4069                        GeneratedField::Gap => {
4070                            if gap__.is_some() {
4071                                return Err(serde::de::Error::duplicate_field("gap"));
4072                            }
4073                            gap__ = map_.next_value()?;
4074                        }
4075                        GeneratedField::OrderDataType => {
4076                            if order_data_type__.is_some() {
4077                                return Err(serde::de::Error::duplicate_field("orderDataType"));
4078                            }
4079                            order_data_type__ = map_.next_value()?;
4080                        }
4081                        GeneratedField::OrderType => {
4082                            if order_type__.is_some() {
4083                                return Err(serde::de::Error::duplicate_field("orderType"));
4084                            }
4085                            order_type__ = map_.next_value()?;
4086                        }
4087                        GeneratedField::GapDataType => {
4088                            if gap_data_type__.is_some() {
4089                                return Err(serde::de::Error::duplicate_field("gapDataType"));
4090                            }
4091                            gap_data_type__ = map_.next_value()?;
4092                        }
4093                    }
4094                }
4095                Ok(window_frame::SessionFrameBounds {
4096                    gap: gap__,
4097                    order_data_type: order_data_type__,
4098                    order_type: order_type__,
4099                    gap_data_type: gap_data_type__,
4100                })
4101            }
4102        }
4103        deserializer.deserialize_struct("expr.WindowFrame.SessionFrameBounds", FIELDS, GeneratedVisitor)
4104    }
4105}
4106impl serde::Serialize for window_frame::Type {
4107    #[allow(deprecated)]
4108    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4109    where
4110        S: serde::Serializer,
4111    {
4112        let variant = match self {
4113            Self::Unspecified => "TYPE_UNSPECIFIED",
4114            Self::RowsLegacy => "TYPE_ROWS_LEGACY",
4115            Self::Rows => "TYPE_ROWS",
4116            Self::Range => "TYPE_RANGE",
4117            Self::Session => "TYPE_SESSION",
4118        };
4119        serializer.serialize_str(variant)
4120    }
4121}
4122impl<'de> serde::Deserialize<'de> for window_frame::Type {
4123    #[allow(deprecated)]
4124    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4125    where
4126        D: serde::Deserializer<'de>,
4127    {
4128        const FIELDS: &[&str] = &[
4129            "TYPE_UNSPECIFIED",
4130            "TYPE_ROWS_LEGACY",
4131            "TYPE_ROWS",
4132            "TYPE_RANGE",
4133            "TYPE_SESSION",
4134        ];
4135
4136        struct GeneratedVisitor;
4137
4138        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4139            type Value = window_frame::Type;
4140
4141            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4142                write!(formatter, "expected one of: {:?}", &FIELDS)
4143            }
4144
4145            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4146            where
4147                E: serde::de::Error,
4148            {
4149                i32::try_from(v)
4150                    .ok()
4151                    .and_then(|x| x.try_into().ok())
4152                    .ok_or_else(|| {
4153                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4154                    })
4155            }
4156
4157            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4158            where
4159                E: serde::de::Error,
4160            {
4161                i32::try_from(v)
4162                    .ok()
4163                    .and_then(|x| x.try_into().ok())
4164                    .ok_or_else(|| {
4165                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4166                    })
4167            }
4168
4169            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4170            where
4171                E: serde::de::Error,
4172            {
4173                match value {
4174                    "TYPE_UNSPECIFIED" => Ok(window_frame::Type::Unspecified),
4175                    "TYPE_ROWS_LEGACY" => Ok(window_frame::Type::RowsLegacy),
4176                    "TYPE_ROWS" => Ok(window_frame::Type::Rows),
4177                    "TYPE_RANGE" => Ok(window_frame::Type::Range),
4178                    "TYPE_SESSION" => Ok(window_frame::Type::Session),
4179                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4180                }
4181            }
4182        }
4183        deserializer.deserialize_any(GeneratedVisitor)
4184    }
4185}
4186impl serde::Serialize for WindowFunction {
4187    #[allow(deprecated)]
4188    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4189    where
4190        S: serde::Serializer,
4191    {
4192        use serde::ser::SerializeStruct;
4193        let mut len = 0;
4194        if !self.args.is_empty() {
4195            len += 1;
4196        }
4197        if self.return_type.is_some() {
4198            len += 1;
4199        }
4200        if self.frame.is_some() {
4201            len += 1;
4202        }
4203        if self.ignore_nulls {
4204            len += 1;
4205        }
4206        if self.r#type.is_some() {
4207            len += 1;
4208        }
4209        let mut struct_ser = serializer.serialize_struct("expr.WindowFunction", len)?;
4210        if !self.args.is_empty() {
4211            struct_ser.serialize_field("args", &self.args)?;
4212        }
4213        if let Some(v) = self.return_type.as_ref() {
4214            struct_ser.serialize_field("returnType", v)?;
4215        }
4216        if let Some(v) = self.frame.as_ref() {
4217            struct_ser.serialize_field("frame", v)?;
4218        }
4219        if self.ignore_nulls {
4220            struct_ser.serialize_field("ignoreNulls", &self.ignore_nulls)?;
4221        }
4222        if let Some(v) = self.r#type.as_ref() {
4223            match v {
4224                window_function::Type::General(v) => {
4225                    let v = window_function::GeneralType::try_from(*v)
4226                        .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
4227                    struct_ser.serialize_field("general", &v)?;
4228                }
4229                window_function::Type::Aggregate(v) => {
4230                    let v = agg_call::Kind::try_from(*v)
4231                        .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
4232                    struct_ser.serialize_field("aggregate", &v)?;
4233                }
4234                window_function::Type::Aggregate2(v) => {
4235                    struct_ser.serialize_field("aggregate2", v)?;
4236                }
4237            }
4238        }
4239        struct_ser.end()
4240    }
4241}
4242impl<'de> serde::Deserialize<'de> for WindowFunction {
4243    #[allow(deprecated)]
4244    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4245    where
4246        D: serde::Deserializer<'de>,
4247    {
4248        const FIELDS: &[&str] = &[
4249            "args",
4250            "return_type",
4251            "returnType",
4252            "frame",
4253            "ignore_nulls",
4254            "ignoreNulls",
4255            "general",
4256            "aggregate",
4257            "aggregate2",
4258        ];
4259
4260        #[allow(clippy::enum_variant_names)]
4261        enum GeneratedField {
4262            Args,
4263            ReturnType,
4264            Frame,
4265            IgnoreNulls,
4266            General,
4267            Aggregate,
4268            Aggregate2,
4269        }
4270        impl<'de> serde::Deserialize<'de> for GeneratedField {
4271            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4272            where
4273                D: serde::Deserializer<'de>,
4274            {
4275                struct GeneratedVisitor;
4276
4277                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4278                    type Value = GeneratedField;
4279
4280                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4281                        write!(formatter, "expected one of: {:?}", &FIELDS)
4282                    }
4283
4284                    #[allow(unused_variables)]
4285                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4286                    where
4287                        E: serde::de::Error,
4288                    {
4289                        match value {
4290                            "args" => Ok(GeneratedField::Args),
4291                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
4292                            "frame" => Ok(GeneratedField::Frame),
4293                            "ignoreNulls" | "ignore_nulls" => Ok(GeneratedField::IgnoreNulls),
4294                            "general" => Ok(GeneratedField::General),
4295                            "aggregate" => Ok(GeneratedField::Aggregate),
4296                            "aggregate2" => Ok(GeneratedField::Aggregate2),
4297                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4298                        }
4299                    }
4300                }
4301                deserializer.deserialize_identifier(GeneratedVisitor)
4302            }
4303        }
4304        struct GeneratedVisitor;
4305        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4306            type Value = WindowFunction;
4307
4308            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4309                formatter.write_str("struct expr.WindowFunction")
4310            }
4311
4312            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WindowFunction, V::Error>
4313                where
4314                    V: serde::de::MapAccess<'de>,
4315            {
4316                let mut args__ = None;
4317                let mut return_type__ = None;
4318                let mut frame__ = None;
4319                let mut ignore_nulls__ = None;
4320                let mut r#type__ = None;
4321                while let Some(k) = map_.next_key()? {
4322                    match k {
4323                        GeneratedField::Args => {
4324                            if args__.is_some() {
4325                                return Err(serde::de::Error::duplicate_field("args"));
4326                            }
4327                            args__ = Some(map_.next_value()?);
4328                        }
4329                        GeneratedField::ReturnType => {
4330                            if return_type__.is_some() {
4331                                return Err(serde::de::Error::duplicate_field("returnType"));
4332                            }
4333                            return_type__ = map_.next_value()?;
4334                        }
4335                        GeneratedField::Frame => {
4336                            if frame__.is_some() {
4337                                return Err(serde::de::Error::duplicate_field("frame"));
4338                            }
4339                            frame__ = map_.next_value()?;
4340                        }
4341                        GeneratedField::IgnoreNulls => {
4342                            if ignore_nulls__.is_some() {
4343                                return Err(serde::de::Error::duplicate_field("ignoreNulls"));
4344                            }
4345                            ignore_nulls__ = Some(map_.next_value()?);
4346                        }
4347                        GeneratedField::General => {
4348                            if r#type__.is_some() {
4349                                return Err(serde::de::Error::duplicate_field("general"));
4350                            }
4351                            r#type__ = map_.next_value::<::std::option::Option<window_function::GeneralType>>()?.map(|x| window_function::Type::General(x as i32));
4352                        }
4353                        GeneratedField::Aggregate => {
4354                            if r#type__.is_some() {
4355                                return Err(serde::de::Error::duplicate_field("aggregate"));
4356                            }
4357                            r#type__ = map_.next_value::<::std::option::Option<agg_call::Kind>>()?.map(|x| window_function::Type::Aggregate(x as i32));
4358                        }
4359                        GeneratedField::Aggregate2 => {
4360                            if r#type__.is_some() {
4361                                return Err(serde::de::Error::duplicate_field("aggregate2"));
4362                            }
4363                            r#type__ = map_.next_value::<::std::option::Option<_>>()?.map(window_function::Type::Aggregate2)
4364;
4365                        }
4366                    }
4367                }
4368                Ok(WindowFunction {
4369                    args: args__.unwrap_or_default(),
4370                    return_type: return_type__,
4371                    frame: frame__,
4372                    ignore_nulls: ignore_nulls__.unwrap_or_default(),
4373                    r#type: r#type__,
4374                })
4375            }
4376        }
4377        deserializer.deserialize_struct("expr.WindowFunction", FIELDS, GeneratedVisitor)
4378    }
4379}
4380impl serde::Serialize for window_function::GeneralType {
4381    #[allow(deprecated)]
4382    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4383    where
4384        S: serde::Serializer,
4385    {
4386        let variant = match self {
4387            Self::Unspecified => "UNSPECIFIED",
4388            Self::RowNumber => "ROW_NUMBER",
4389            Self::Rank => "RANK",
4390            Self::DenseRank => "DENSE_RANK",
4391            Self::Lag => "LAG",
4392            Self::Lead => "LEAD",
4393        };
4394        serializer.serialize_str(variant)
4395    }
4396}
4397impl<'de> serde::Deserialize<'de> for window_function::GeneralType {
4398    #[allow(deprecated)]
4399    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4400    where
4401        D: serde::Deserializer<'de>,
4402    {
4403        const FIELDS: &[&str] = &[
4404            "UNSPECIFIED",
4405            "ROW_NUMBER",
4406            "RANK",
4407            "DENSE_RANK",
4408            "LAG",
4409            "LEAD",
4410        ];
4411
4412        struct GeneratedVisitor;
4413
4414        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4415            type Value = window_function::GeneralType;
4416
4417            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4418                write!(formatter, "expected one of: {:?}", &FIELDS)
4419            }
4420
4421            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
4422            where
4423                E: serde::de::Error,
4424            {
4425                i32::try_from(v)
4426                    .ok()
4427                    .and_then(|x| x.try_into().ok())
4428                    .ok_or_else(|| {
4429                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
4430                    })
4431            }
4432
4433            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
4434            where
4435                E: serde::de::Error,
4436            {
4437                i32::try_from(v)
4438                    .ok()
4439                    .and_then(|x| x.try_into().ok())
4440                    .ok_or_else(|| {
4441                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
4442                    })
4443            }
4444
4445            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
4446            where
4447                E: serde::de::Error,
4448            {
4449                match value {
4450                    "UNSPECIFIED" => Ok(window_function::GeneralType::Unspecified),
4451                    "ROW_NUMBER" => Ok(window_function::GeneralType::RowNumber),
4452                    "RANK" => Ok(window_function::GeneralType::Rank),
4453                    "DENSE_RANK" => Ok(window_function::GeneralType::DenseRank),
4454                    "LAG" => Ok(window_function::GeneralType::Lag),
4455                    "LEAD" => Ok(window_function::GeneralType::Lead),
4456                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
4457                }
4458            }
4459        }
4460        deserializer.deserialize_any(GeneratedVisitor)
4461    }
4462}