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