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