risingwave_pb/
expr.serde.rs

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