risingwave_pb/
batch_plan.serde.rs

1use crate::batch_plan::*;
2impl serde::Serialize for AzblobFileScanNode {
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.columns.is_empty() {
11            len += 1;
12        }
13        if self.file_format != 0 {
14            len += 1;
15        }
16        if !self.account_name.is_empty() {
17            len += 1;
18        }
19        if !self.account_key.is_empty() {
20            len += 1;
21        }
22        if !self.endpoint.is_empty() {
23            len += 1;
24        }
25        if !self.file_location.is_empty() {
26            len += 1;
27        }
28        let mut struct_ser = serializer.serialize_struct("batch_plan.AzblobFileScanNode", len)?;
29        if !self.columns.is_empty() {
30            struct_ser.serialize_field("columns", &self.columns)?;
31        }
32        if self.file_format != 0 {
33            let v = azblob_file_scan_node::FileFormat::try_from(self.file_format)
34                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.file_format)))?;
35            struct_ser.serialize_field("fileFormat", &v)?;
36        }
37        if !self.account_name.is_empty() {
38            struct_ser.serialize_field("accountName", &self.account_name)?;
39        }
40        if !self.account_key.is_empty() {
41            struct_ser.serialize_field("accountKey", &self.account_key)?;
42        }
43        if !self.endpoint.is_empty() {
44            struct_ser.serialize_field("endpoint", &self.endpoint)?;
45        }
46        if !self.file_location.is_empty() {
47            struct_ser.serialize_field("fileLocation", &self.file_location)?;
48        }
49        struct_ser.end()
50    }
51}
52impl<'de> serde::Deserialize<'de> for AzblobFileScanNode {
53    #[allow(deprecated)]
54    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
55    where
56        D: serde::Deserializer<'de>,
57    {
58        const FIELDS: &[&str] = &[
59            "columns",
60            "file_format",
61            "fileFormat",
62            "account_name",
63            "accountName",
64            "account_key",
65            "accountKey",
66            "endpoint",
67            "file_location",
68            "fileLocation",
69        ];
70
71        #[allow(clippy::enum_variant_names)]
72        enum GeneratedField {
73            Columns,
74            FileFormat,
75            AccountName,
76            AccountKey,
77            Endpoint,
78            FileLocation,
79        }
80        impl<'de> serde::Deserialize<'de> for GeneratedField {
81            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
82            where
83                D: serde::Deserializer<'de>,
84            {
85                struct GeneratedVisitor;
86
87                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
88                    type Value = GeneratedField;
89
90                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
91                        write!(formatter, "expected one of: {:?}", &FIELDS)
92                    }
93
94                    #[allow(unused_variables)]
95                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
96                    where
97                        E: serde::de::Error,
98                    {
99                        match value {
100                            "columns" => Ok(GeneratedField::Columns),
101                            "fileFormat" | "file_format" => Ok(GeneratedField::FileFormat),
102                            "accountName" | "account_name" => Ok(GeneratedField::AccountName),
103                            "accountKey" | "account_key" => Ok(GeneratedField::AccountKey),
104                            "endpoint" => Ok(GeneratedField::Endpoint),
105                            "fileLocation" | "file_location" => Ok(GeneratedField::FileLocation),
106                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
107                        }
108                    }
109                }
110                deserializer.deserialize_identifier(GeneratedVisitor)
111            }
112        }
113        struct GeneratedVisitor;
114        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
115            type Value = AzblobFileScanNode;
116
117            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
118                formatter.write_str("struct batch_plan.AzblobFileScanNode")
119            }
120
121            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AzblobFileScanNode, V::Error>
122                where
123                    V: serde::de::MapAccess<'de>,
124            {
125                let mut columns__ = None;
126                let mut file_format__ = None;
127                let mut account_name__ = None;
128                let mut account_key__ = None;
129                let mut endpoint__ = None;
130                let mut file_location__ = None;
131                while let Some(k) = map_.next_key()? {
132                    match k {
133                        GeneratedField::Columns => {
134                            if columns__.is_some() {
135                                return Err(serde::de::Error::duplicate_field("columns"));
136                            }
137                            columns__ = Some(map_.next_value()?);
138                        }
139                        GeneratedField::FileFormat => {
140                            if file_format__.is_some() {
141                                return Err(serde::de::Error::duplicate_field("fileFormat"));
142                            }
143                            file_format__ = Some(map_.next_value::<azblob_file_scan_node::FileFormat>()? as i32);
144                        }
145                        GeneratedField::AccountName => {
146                            if account_name__.is_some() {
147                                return Err(serde::de::Error::duplicate_field("accountName"));
148                            }
149                            account_name__ = Some(map_.next_value()?);
150                        }
151                        GeneratedField::AccountKey => {
152                            if account_key__.is_some() {
153                                return Err(serde::de::Error::duplicate_field("accountKey"));
154                            }
155                            account_key__ = Some(map_.next_value()?);
156                        }
157                        GeneratedField::Endpoint => {
158                            if endpoint__.is_some() {
159                                return Err(serde::de::Error::duplicate_field("endpoint"));
160                            }
161                            endpoint__ = Some(map_.next_value()?);
162                        }
163                        GeneratedField::FileLocation => {
164                            if file_location__.is_some() {
165                                return Err(serde::de::Error::duplicate_field("fileLocation"));
166                            }
167                            file_location__ = Some(map_.next_value()?);
168                        }
169                    }
170                }
171                Ok(AzblobFileScanNode {
172                    columns: columns__.unwrap_or_default(),
173                    file_format: file_format__.unwrap_or_default(),
174                    account_name: account_name__.unwrap_or_default(),
175                    account_key: account_key__.unwrap_or_default(),
176                    endpoint: endpoint__.unwrap_or_default(),
177                    file_location: file_location__.unwrap_or_default(),
178                })
179            }
180        }
181        deserializer.deserialize_struct("batch_plan.AzblobFileScanNode", FIELDS, GeneratedVisitor)
182    }
183}
184impl serde::Serialize for azblob_file_scan_node::FileFormat {
185    #[allow(deprecated)]
186    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
187    where
188        S: serde::Serializer,
189    {
190        let variant = match self {
191            Self::Unspecified => "FILE_FORMAT_UNSPECIFIED",
192            Self::Parquet => "PARQUET",
193        };
194        serializer.serialize_str(variant)
195    }
196}
197impl<'de> serde::Deserialize<'de> for azblob_file_scan_node::FileFormat {
198    #[allow(deprecated)]
199    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
200    where
201        D: serde::Deserializer<'de>,
202    {
203        const FIELDS: &[&str] = &[
204            "FILE_FORMAT_UNSPECIFIED",
205            "PARQUET",
206        ];
207
208        struct GeneratedVisitor;
209
210        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
211            type Value = azblob_file_scan_node::FileFormat;
212
213            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
214                write!(formatter, "expected one of: {:?}", &FIELDS)
215            }
216
217            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
218            where
219                E: serde::de::Error,
220            {
221                i32::try_from(v)
222                    .ok()
223                    .and_then(|x| x.try_into().ok())
224                    .ok_or_else(|| {
225                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
226                    })
227            }
228
229            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
230            where
231                E: serde::de::Error,
232            {
233                i32::try_from(v)
234                    .ok()
235                    .and_then(|x| x.try_into().ok())
236                    .ok_or_else(|| {
237                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
238                    })
239            }
240
241            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
242            where
243                E: serde::de::Error,
244            {
245                match value {
246                    "FILE_FORMAT_UNSPECIFIED" => Ok(azblob_file_scan_node::FileFormat::Unspecified),
247                    "PARQUET" => Ok(azblob_file_scan_node::FileFormat::Parquet),
248                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
249                }
250            }
251        }
252        deserializer.deserialize_any(GeneratedVisitor)
253    }
254}
255impl serde::Serialize for DeleteNode {
256    #[allow(deprecated)]
257    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
258    where
259        S: serde::Serializer,
260    {
261        use serde::ser::SerializeStruct;
262        let mut len = 0;
263        if self.table_id != 0 {
264            len += 1;
265        }
266        if self.table_version_id != 0 {
267            len += 1;
268        }
269        if self.returning {
270            len += 1;
271        }
272        if self.session_id != 0 {
273            len += 1;
274        }
275        let mut struct_ser = serializer.serialize_struct("batch_plan.DeleteNode", len)?;
276        if self.table_id != 0 {
277            struct_ser.serialize_field("tableId", &self.table_id)?;
278        }
279        if self.table_version_id != 0 {
280            #[allow(clippy::needless_borrow)]
281            #[allow(clippy::needless_borrows_for_generic_args)]
282            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
283        }
284        if self.returning {
285            struct_ser.serialize_field("returning", &self.returning)?;
286        }
287        if self.session_id != 0 {
288            struct_ser.serialize_field("sessionId", &self.session_id)?;
289        }
290        struct_ser.end()
291    }
292}
293impl<'de> serde::Deserialize<'de> for DeleteNode {
294    #[allow(deprecated)]
295    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
296    where
297        D: serde::Deserializer<'de>,
298    {
299        const FIELDS: &[&str] = &[
300            "table_id",
301            "tableId",
302            "table_version_id",
303            "tableVersionId",
304            "returning",
305            "session_id",
306            "sessionId",
307        ];
308
309        #[allow(clippy::enum_variant_names)]
310        enum GeneratedField {
311            TableId,
312            TableVersionId,
313            Returning,
314            SessionId,
315        }
316        impl<'de> serde::Deserialize<'de> for GeneratedField {
317            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
318            where
319                D: serde::Deserializer<'de>,
320            {
321                struct GeneratedVisitor;
322
323                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
324                    type Value = GeneratedField;
325
326                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
327                        write!(formatter, "expected one of: {:?}", &FIELDS)
328                    }
329
330                    #[allow(unused_variables)]
331                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
332                    where
333                        E: serde::de::Error,
334                    {
335                        match value {
336                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
337                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
338                            "returning" => Ok(GeneratedField::Returning),
339                            "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
340                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
341                        }
342                    }
343                }
344                deserializer.deserialize_identifier(GeneratedVisitor)
345            }
346        }
347        struct GeneratedVisitor;
348        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
349            type Value = DeleteNode;
350
351            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
352                formatter.write_str("struct batch_plan.DeleteNode")
353            }
354
355            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteNode, V::Error>
356                where
357                    V: serde::de::MapAccess<'de>,
358            {
359                let mut table_id__ = None;
360                let mut table_version_id__ = None;
361                let mut returning__ = None;
362                let mut session_id__ = None;
363                while let Some(k) = map_.next_key()? {
364                    match k {
365                        GeneratedField::TableId => {
366                            if table_id__.is_some() {
367                                return Err(serde::de::Error::duplicate_field("tableId"));
368                            }
369                            table_id__ = 
370                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
371                            ;
372                        }
373                        GeneratedField::TableVersionId => {
374                            if table_version_id__.is_some() {
375                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
376                            }
377                            table_version_id__ = 
378                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
379                            ;
380                        }
381                        GeneratedField::Returning => {
382                            if returning__.is_some() {
383                                return Err(serde::de::Error::duplicate_field("returning"));
384                            }
385                            returning__ = Some(map_.next_value()?);
386                        }
387                        GeneratedField::SessionId => {
388                            if session_id__.is_some() {
389                                return Err(serde::de::Error::duplicate_field("sessionId"));
390                            }
391                            session_id__ = 
392                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
393                            ;
394                        }
395                    }
396                }
397                Ok(DeleteNode {
398                    table_id: table_id__.unwrap_or_default(),
399                    table_version_id: table_version_id__.unwrap_or_default(),
400                    returning: returning__.unwrap_or_default(),
401                    session_id: session_id__.unwrap_or_default(),
402                })
403            }
404        }
405        deserializer.deserialize_struct("batch_plan.DeleteNode", FIELDS, GeneratedVisitor)
406    }
407}
408impl serde::Serialize for DistributedLookupJoinNode {
409    #[allow(deprecated)]
410    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
411    where
412        S: serde::Serializer,
413    {
414        use serde::ser::SerializeStruct;
415        let mut len = 0;
416        if self.join_type != 0 {
417            len += 1;
418        }
419        if self.condition.is_some() {
420            len += 1;
421        }
422        if !self.outer_side_key.is_empty() {
423            len += 1;
424        }
425        if !self.inner_side_key.is_empty() {
426            len += 1;
427        }
428        if self.lookup_prefix_len != 0 {
429            len += 1;
430        }
431        if self.inner_side_table_desc.is_some() {
432            len += 1;
433        }
434        if !self.inner_side_column_ids.is_empty() {
435            len += 1;
436        }
437        if !self.output_indices.is_empty() {
438            len += 1;
439        }
440        if !self.null_safe.is_empty() {
441            len += 1;
442        }
443        if self.as_of.is_some() {
444            len += 1;
445        }
446        if self.asof_desc.is_some() {
447            len += 1;
448        }
449        let mut struct_ser = serializer.serialize_struct("batch_plan.DistributedLookupJoinNode", len)?;
450        if self.join_type != 0 {
451            let v = super::plan_common::JoinType::try_from(self.join_type)
452                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
453            struct_ser.serialize_field("joinType", &v)?;
454        }
455        if let Some(v) = self.condition.as_ref() {
456            struct_ser.serialize_field("condition", v)?;
457        }
458        if !self.outer_side_key.is_empty() {
459            struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
460        }
461        if !self.inner_side_key.is_empty() {
462            struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
463        }
464        if self.lookup_prefix_len != 0 {
465            struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
466        }
467        if let Some(v) = self.inner_side_table_desc.as_ref() {
468            struct_ser.serialize_field("innerSideTableDesc", v)?;
469        }
470        if !self.inner_side_column_ids.is_empty() {
471            struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
472        }
473        if !self.output_indices.is_empty() {
474            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
475        }
476        if !self.null_safe.is_empty() {
477            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
478        }
479        if let Some(v) = self.as_of.as_ref() {
480            struct_ser.serialize_field("asOf", v)?;
481        }
482        if let Some(v) = self.asof_desc.as_ref() {
483            struct_ser.serialize_field("asofDesc", v)?;
484        }
485        struct_ser.end()
486    }
487}
488impl<'de> serde::Deserialize<'de> for DistributedLookupJoinNode {
489    #[allow(deprecated)]
490    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
491    where
492        D: serde::Deserializer<'de>,
493    {
494        const FIELDS: &[&str] = &[
495            "join_type",
496            "joinType",
497            "condition",
498            "outer_side_key",
499            "outerSideKey",
500            "inner_side_key",
501            "innerSideKey",
502            "lookup_prefix_len",
503            "lookupPrefixLen",
504            "inner_side_table_desc",
505            "innerSideTableDesc",
506            "inner_side_column_ids",
507            "innerSideColumnIds",
508            "output_indices",
509            "outputIndices",
510            "null_safe",
511            "nullSafe",
512            "as_of",
513            "asOf",
514            "asof_desc",
515            "asofDesc",
516        ];
517
518        #[allow(clippy::enum_variant_names)]
519        enum GeneratedField {
520            JoinType,
521            Condition,
522            OuterSideKey,
523            InnerSideKey,
524            LookupPrefixLen,
525            InnerSideTableDesc,
526            InnerSideColumnIds,
527            OutputIndices,
528            NullSafe,
529            AsOf,
530            AsofDesc,
531        }
532        impl<'de> serde::Deserialize<'de> for GeneratedField {
533            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
534            where
535                D: serde::Deserializer<'de>,
536            {
537                struct GeneratedVisitor;
538
539                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
540                    type Value = GeneratedField;
541
542                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
543                        write!(formatter, "expected one of: {:?}", &FIELDS)
544                    }
545
546                    #[allow(unused_variables)]
547                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
548                    where
549                        E: serde::de::Error,
550                    {
551                        match value {
552                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
553                            "condition" => Ok(GeneratedField::Condition),
554                            "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
555                            "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
556                            "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
557                            "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
558                            "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
559                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
560                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
561                            "asOf" | "as_of" => Ok(GeneratedField::AsOf),
562                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
563                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
564                        }
565                    }
566                }
567                deserializer.deserialize_identifier(GeneratedVisitor)
568            }
569        }
570        struct GeneratedVisitor;
571        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
572            type Value = DistributedLookupJoinNode;
573
574            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
575                formatter.write_str("struct batch_plan.DistributedLookupJoinNode")
576            }
577
578            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DistributedLookupJoinNode, V::Error>
579                where
580                    V: serde::de::MapAccess<'de>,
581            {
582                let mut join_type__ = None;
583                let mut condition__ = None;
584                let mut outer_side_key__ = None;
585                let mut inner_side_key__ = None;
586                let mut lookup_prefix_len__ = None;
587                let mut inner_side_table_desc__ = None;
588                let mut inner_side_column_ids__ = None;
589                let mut output_indices__ = None;
590                let mut null_safe__ = None;
591                let mut as_of__ = None;
592                let mut asof_desc__ = None;
593                while let Some(k) = map_.next_key()? {
594                    match k {
595                        GeneratedField::JoinType => {
596                            if join_type__.is_some() {
597                                return Err(serde::de::Error::duplicate_field("joinType"));
598                            }
599                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
600                        }
601                        GeneratedField::Condition => {
602                            if condition__.is_some() {
603                                return Err(serde::de::Error::duplicate_field("condition"));
604                            }
605                            condition__ = map_.next_value()?;
606                        }
607                        GeneratedField::OuterSideKey => {
608                            if outer_side_key__.is_some() {
609                                return Err(serde::de::Error::duplicate_field("outerSideKey"));
610                            }
611                            outer_side_key__ = 
612                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
613                                    .into_iter().map(|x| x.0).collect())
614                            ;
615                        }
616                        GeneratedField::InnerSideKey => {
617                            if inner_side_key__.is_some() {
618                                return Err(serde::de::Error::duplicate_field("innerSideKey"));
619                            }
620                            inner_side_key__ = 
621                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
622                                    .into_iter().map(|x| x.0).collect())
623                            ;
624                        }
625                        GeneratedField::LookupPrefixLen => {
626                            if lookup_prefix_len__.is_some() {
627                                return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
628                            }
629                            lookup_prefix_len__ = 
630                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
631                            ;
632                        }
633                        GeneratedField::InnerSideTableDesc => {
634                            if inner_side_table_desc__.is_some() {
635                                return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
636                            }
637                            inner_side_table_desc__ = map_.next_value()?;
638                        }
639                        GeneratedField::InnerSideColumnIds => {
640                            if inner_side_column_ids__.is_some() {
641                                return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
642                            }
643                            inner_side_column_ids__ = 
644                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
645                                    .into_iter().map(|x| x.0).collect())
646                            ;
647                        }
648                        GeneratedField::OutputIndices => {
649                            if output_indices__.is_some() {
650                                return Err(serde::de::Error::duplicate_field("outputIndices"));
651                            }
652                            output_indices__ = 
653                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
654                                    .into_iter().map(|x| x.0).collect())
655                            ;
656                        }
657                        GeneratedField::NullSafe => {
658                            if null_safe__.is_some() {
659                                return Err(serde::de::Error::duplicate_field("nullSafe"));
660                            }
661                            null_safe__ = Some(map_.next_value()?);
662                        }
663                        GeneratedField::AsOf => {
664                            if as_of__.is_some() {
665                                return Err(serde::de::Error::duplicate_field("asOf"));
666                            }
667                            as_of__ = map_.next_value()?;
668                        }
669                        GeneratedField::AsofDesc => {
670                            if asof_desc__.is_some() {
671                                return Err(serde::de::Error::duplicate_field("asofDesc"));
672                            }
673                            asof_desc__ = map_.next_value()?;
674                        }
675                    }
676                }
677                Ok(DistributedLookupJoinNode {
678                    join_type: join_type__.unwrap_or_default(),
679                    condition: condition__,
680                    outer_side_key: outer_side_key__.unwrap_or_default(),
681                    inner_side_key: inner_side_key__.unwrap_or_default(),
682                    lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
683                    inner_side_table_desc: inner_side_table_desc__,
684                    inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
685                    output_indices: output_indices__.unwrap_or_default(),
686                    null_safe: null_safe__.unwrap_or_default(),
687                    as_of: as_of__,
688                    asof_desc: asof_desc__,
689                })
690            }
691        }
692        deserializer.deserialize_struct("batch_plan.DistributedLookupJoinNode", FIELDS, GeneratedVisitor)
693    }
694}
695impl serde::Serialize for ExchangeInfo {
696    #[allow(deprecated)]
697    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
698    where
699        S: serde::Serializer,
700    {
701        use serde::ser::SerializeStruct;
702        let mut len = 0;
703        if self.mode != 0 {
704            len += 1;
705        }
706        if self.distribution.is_some() {
707            len += 1;
708        }
709        let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo", len)?;
710        if self.mode != 0 {
711            let v = exchange_info::DistributionMode::try_from(self.mode)
712                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
713            struct_ser.serialize_field("mode", &v)?;
714        }
715        if let Some(v) = self.distribution.as_ref() {
716            match v {
717                exchange_info::Distribution::BroadcastInfo(v) => {
718                    struct_ser.serialize_field("broadcastInfo", v)?;
719                }
720                exchange_info::Distribution::HashInfo(v) => {
721                    struct_ser.serialize_field("hashInfo", v)?;
722                }
723                exchange_info::Distribution::ConsistentHashInfo(v) => {
724                    struct_ser.serialize_field("consistentHashInfo", v)?;
725                }
726            }
727        }
728        struct_ser.end()
729    }
730}
731impl<'de> serde::Deserialize<'de> for ExchangeInfo {
732    #[allow(deprecated)]
733    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
734    where
735        D: serde::Deserializer<'de>,
736    {
737        const FIELDS: &[&str] = &[
738            "mode",
739            "broadcast_info",
740            "broadcastInfo",
741            "hash_info",
742            "hashInfo",
743            "consistent_hash_info",
744            "consistentHashInfo",
745        ];
746
747        #[allow(clippy::enum_variant_names)]
748        enum GeneratedField {
749            Mode,
750            BroadcastInfo,
751            HashInfo,
752            ConsistentHashInfo,
753        }
754        impl<'de> serde::Deserialize<'de> for GeneratedField {
755            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
756            where
757                D: serde::Deserializer<'de>,
758            {
759                struct GeneratedVisitor;
760
761                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
762                    type Value = GeneratedField;
763
764                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
765                        write!(formatter, "expected one of: {:?}", &FIELDS)
766                    }
767
768                    #[allow(unused_variables)]
769                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
770                    where
771                        E: serde::de::Error,
772                    {
773                        match value {
774                            "mode" => Ok(GeneratedField::Mode),
775                            "broadcastInfo" | "broadcast_info" => Ok(GeneratedField::BroadcastInfo),
776                            "hashInfo" | "hash_info" => Ok(GeneratedField::HashInfo),
777                            "consistentHashInfo" | "consistent_hash_info" => Ok(GeneratedField::ConsistentHashInfo),
778                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
779                        }
780                    }
781                }
782                deserializer.deserialize_identifier(GeneratedVisitor)
783            }
784        }
785        struct GeneratedVisitor;
786        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
787            type Value = ExchangeInfo;
788
789            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
790                formatter.write_str("struct batch_plan.ExchangeInfo")
791            }
792
793            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeInfo, V::Error>
794                where
795                    V: serde::de::MapAccess<'de>,
796            {
797                let mut mode__ = None;
798                let mut distribution__ = None;
799                while let Some(k) = map_.next_key()? {
800                    match k {
801                        GeneratedField::Mode => {
802                            if mode__.is_some() {
803                                return Err(serde::de::Error::duplicate_field("mode"));
804                            }
805                            mode__ = Some(map_.next_value::<exchange_info::DistributionMode>()? as i32);
806                        }
807                        GeneratedField::BroadcastInfo => {
808                            if distribution__.is_some() {
809                                return Err(serde::de::Error::duplicate_field("broadcastInfo"));
810                            }
811                            distribution__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_info::Distribution::BroadcastInfo)
812;
813                        }
814                        GeneratedField::HashInfo => {
815                            if distribution__.is_some() {
816                                return Err(serde::de::Error::duplicate_field("hashInfo"));
817                            }
818                            distribution__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_info::Distribution::HashInfo)
819;
820                        }
821                        GeneratedField::ConsistentHashInfo => {
822                            if distribution__.is_some() {
823                                return Err(serde::de::Error::duplicate_field("consistentHashInfo"));
824                            }
825                            distribution__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_info::Distribution::ConsistentHashInfo)
826;
827                        }
828                    }
829                }
830                Ok(ExchangeInfo {
831                    mode: mode__.unwrap_or_default(),
832                    distribution: distribution__,
833                })
834            }
835        }
836        deserializer.deserialize_struct("batch_plan.ExchangeInfo", FIELDS, GeneratedVisitor)
837    }
838}
839impl serde::Serialize for exchange_info::BroadcastInfo {
840    #[allow(deprecated)]
841    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
842    where
843        S: serde::Serializer,
844    {
845        use serde::ser::SerializeStruct;
846        let mut len = 0;
847        if self.count != 0 {
848            len += 1;
849        }
850        let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo.BroadcastInfo", len)?;
851        if self.count != 0 {
852            struct_ser.serialize_field("count", &self.count)?;
853        }
854        struct_ser.end()
855    }
856}
857impl<'de> serde::Deserialize<'de> for exchange_info::BroadcastInfo {
858    #[allow(deprecated)]
859    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
860    where
861        D: serde::Deserializer<'de>,
862    {
863        const FIELDS: &[&str] = &[
864            "count",
865        ];
866
867        #[allow(clippy::enum_variant_names)]
868        enum GeneratedField {
869            Count,
870        }
871        impl<'de> serde::Deserialize<'de> for GeneratedField {
872            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
873            where
874                D: serde::Deserializer<'de>,
875            {
876                struct GeneratedVisitor;
877
878                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
879                    type Value = GeneratedField;
880
881                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
882                        write!(formatter, "expected one of: {:?}", &FIELDS)
883                    }
884
885                    #[allow(unused_variables)]
886                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
887                    where
888                        E: serde::de::Error,
889                    {
890                        match value {
891                            "count" => Ok(GeneratedField::Count),
892                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
893                        }
894                    }
895                }
896                deserializer.deserialize_identifier(GeneratedVisitor)
897            }
898        }
899        struct GeneratedVisitor;
900        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
901            type Value = exchange_info::BroadcastInfo;
902
903            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
904                formatter.write_str("struct batch_plan.ExchangeInfo.BroadcastInfo")
905            }
906
907            fn visit_map<V>(self, mut map_: V) -> std::result::Result<exchange_info::BroadcastInfo, V::Error>
908                where
909                    V: serde::de::MapAccess<'de>,
910            {
911                let mut count__ = None;
912                while let Some(k) = map_.next_key()? {
913                    match k {
914                        GeneratedField::Count => {
915                            if count__.is_some() {
916                                return Err(serde::de::Error::duplicate_field("count"));
917                            }
918                            count__ = 
919                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
920                            ;
921                        }
922                    }
923                }
924                Ok(exchange_info::BroadcastInfo {
925                    count: count__.unwrap_or_default(),
926                })
927            }
928        }
929        deserializer.deserialize_struct("batch_plan.ExchangeInfo.BroadcastInfo", FIELDS, GeneratedVisitor)
930    }
931}
932impl serde::Serialize for exchange_info::ConsistentHashInfo {
933    #[allow(deprecated)]
934    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
935    where
936        S: serde::Serializer,
937    {
938        use serde::ser::SerializeStruct;
939        let mut len = 0;
940        if !self.vmap.is_empty() {
941            len += 1;
942        }
943        if !self.key.is_empty() {
944            len += 1;
945        }
946        let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo.ConsistentHashInfo", len)?;
947        if !self.vmap.is_empty() {
948            struct_ser.serialize_field("vmap", &self.vmap)?;
949        }
950        if !self.key.is_empty() {
951            struct_ser.serialize_field("key", &self.key)?;
952        }
953        struct_ser.end()
954    }
955}
956impl<'de> serde::Deserialize<'de> for exchange_info::ConsistentHashInfo {
957    #[allow(deprecated)]
958    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
959    where
960        D: serde::Deserializer<'de>,
961    {
962        const FIELDS: &[&str] = &[
963            "vmap",
964            "key",
965        ];
966
967        #[allow(clippy::enum_variant_names)]
968        enum GeneratedField {
969            Vmap,
970            Key,
971        }
972        impl<'de> serde::Deserialize<'de> for GeneratedField {
973            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
974            where
975                D: serde::Deserializer<'de>,
976            {
977                struct GeneratedVisitor;
978
979                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
980                    type Value = GeneratedField;
981
982                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
983                        write!(formatter, "expected one of: {:?}", &FIELDS)
984                    }
985
986                    #[allow(unused_variables)]
987                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
988                    where
989                        E: serde::de::Error,
990                    {
991                        match value {
992                            "vmap" => Ok(GeneratedField::Vmap),
993                            "key" => Ok(GeneratedField::Key),
994                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
995                        }
996                    }
997                }
998                deserializer.deserialize_identifier(GeneratedVisitor)
999            }
1000        }
1001        struct GeneratedVisitor;
1002        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1003            type Value = exchange_info::ConsistentHashInfo;
1004
1005            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1006                formatter.write_str("struct batch_plan.ExchangeInfo.ConsistentHashInfo")
1007            }
1008
1009            fn visit_map<V>(self, mut map_: V) -> std::result::Result<exchange_info::ConsistentHashInfo, V::Error>
1010                where
1011                    V: serde::de::MapAccess<'de>,
1012            {
1013                let mut vmap__ = None;
1014                let mut key__ = None;
1015                while let Some(k) = map_.next_key()? {
1016                    match k {
1017                        GeneratedField::Vmap => {
1018                            if vmap__.is_some() {
1019                                return Err(serde::de::Error::duplicate_field("vmap"));
1020                            }
1021                            vmap__ = 
1022                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1023                                    .into_iter().map(|x| x.0).collect())
1024                            ;
1025                        }
1026                        GeneratedField::Key => {
1027                            if key__.is_some() {
1028                                return Err(serde::de::Error::duplicate_field("key"));
1029                            }
1030                            key__ = 
1031                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1032                                    .into_iter().map(|x| x.0).collect())
1033                            ;
1034                        }
1035                    }
1036                }
1037                Ok(exchange_info::ConsistentHashInfo {
1038                    vmap: vmap__.unwrap_or_default(),
1039                    key: key__.unwrap_or_default(),
1040                })
1041            }
1042        }
1043        deserializer.deserialize_struct("batch_plan.ExchangeInfo.ConsistentHashInfo", FIELDS, GeneratedVisitor)
1044    }
1045}
1046impl serde::Serialize for exchange_info::DistributionMode {
1047    #[allow(deprecated)]
1048    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1049    where
1050        S: serde::Serializer,
1051    {
1052        let variant = match self {
1053            Self::Unspecified => "UNSPECIFIED",
1054            Self::Single => "SINGLE",
1055            Self::Broadcast => "BROADCAST",
1056            Self::Hash => "HASH",
1057            Self::ConsistentHash => "CONSISTENT_HASH",
1058        };
1059        serializer.serialize_str(variant)
1060    }
1061}
1062impl<'de> serde::Deserialize<'de> for exchange_info::DistributionMode {
1063    #[allow(deprecated)]
1064    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1065    where
1066        D: serde::Deserializer<'de>,
1067    {
1068        const FIELDS: &[&str] = &[
1069            "UNSPECIFIED",
1070            "SINGLE",
1071            "BROADCAST",
1072            "HASH",
1073            "CONSISTENT_HASH",
1074        ];
1075
1076        struct GeneratedVisitor;
1077
1078        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1079            type Value = exchange_info::DistributionMode;
1080
1081            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1082                write!(formatter, "expected one of: {:?}", &FIELDS)
1083            }
1084
1085            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1086            where
1087                E: serde::de::Error,
1088            {
1089                i32::try_from(v)
1090                    .ok()
1091                    .and_then(|x| x.try_into().ok())
1092                    .ok_or_else(|| {
1093                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1094                    })
1095            }
1096
1097            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1098            where
1099                E: serde::de::Error,
1100            {
1101                i32::try_from(v)
1102                    .ok()
1103                    .and_then(|x| x.try_into().ok())
1104                    .ok_or_else(|| {
1105                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1106                    })
1107            }
1108
1109            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1110            where
1111                E: serde::de::Error,
1112            {
1113                match value {
1114                    "UNSPECIFIED" => Ok(exchange_info::DistributionMode::Unspecified),
1115                    "SINGLE" => Ok(exchange_info::DistributionMode::Single),
1116                    "BROADCAST" => Ok(exchange_info::DistributionMode::Broadcast),
1117                    "HASH" => Ok(exchange_info::DistributionMode::Hash),
1118                    "CONSISTENT_HASH" => Ok(exchange_info::DistributionMode::ConsistentHash),
1119                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1120                }
1121            }
1122        }
1123        deserializer.deserialize_any(GeneratedVisitor)
1124    }
1125}
1126impl serde::Serialize for exchange_info::HashInfo {
1127    #[allow(deprecated)]
1128    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1129    where
1130        S: serde::Serializer,
1131    {
1132        use serde::ser::SerializeStruct;
1133        let mut len = 0;
1134        if self.output_count != 0 {
1135            len += 1;
1136        }
1137        if !self.key.is_empty() {
1138            len += 1;
1139        }
1140        let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeInfo.HashInfo", len)?;
1141        if self.output_count != 0 {
1142            struct_ser.serialize_field("outputCount", &self.output_count)?;
1143        }
1144        if !self.key.is_empty() {
1145            struct_ser.serialize_field("key", &self.key)?;
1146        }
1147        struct_ser.end()
1148    }
1149}
1150impl<'de> serde::Deserialize<'de> for exchange_info::HashInfo {
1151    #[allow(deprecated)]
1152    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1153    where
1154        D: serde::Deserializer<'de>,
1155    {
1156        const FIELDS: &[&str] = &[
1157            "output_count",
1158            "outputCount",
1159            "key",
1160        ];
1161
1162        #[allow(clippy::enum_variant_names)]
1163        enum GeneratedField {
1164            OutputCount,
1165            Key,
1166        }
1167        impl<'de> serde::Deserialize<'de> for GeneratedField {
1168            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1169            where
1170                D: serde::Deserializer<'de>,
1171            {
1172                struct GeneratedVisitor;
1173
1174                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1175                    type Value = GeneratedField;
1176
1177                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1178                        write!(formatter, "expected one of: {:?}", &FIELDS)
1179                    }
1180
1181                    #[allow(unused_variables)]
1182                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1183                    where
1184                        E: serde::de::Error,
1185                    {
1186                        match value {
1187                            "outputCount" | "output_count" => Ok(GeneratedField::OutputCount),
1188                            "key" => Ok(GeneratedField::Key),
1189                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1190                        }
1191                    }
1192                }
1193                deserializer.deserialize_identifier(GeneratedVisitor)
1194            }
1195        }
1196        struct GeneratedVisitor;
1197        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1198            type Value = exchange_info::HashInfo;
1199
1200            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1201                formatter.write_str("struct batch_plan.ExchangeInfo.HashInfo")
1202            }
1203
1204            fn visit_map<V>(self, mut map_: V) -> std::result::Result<exchange_info::HashInfo, V::Error>
1205                where
1206                    V: serde::de::MapAccess<'de>,
1207            {
1208                let mut output_count__ = None;
1209                let mut key__ = None;
1210                while let Some(k) = map_.next_key()? {
1211                    match k {
1212                        GeneratedField::OutputCount => {
1213                            if output_count__.is_some() {
1214                                return Err(serde::de::Error::duplicate_field("outputCount"));
1215                            }
1216                            output_count__ = 
1217                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1218                            ;
1219                        }
1220                        GeneratedField::Key => {
1221                            if key__.is_some() {
1222                                return Err(serde::de::Error::duplicate_field("key"));
1223                            }
1224                            key__ = 
1225                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1226                                    .into_iter().map(|x| x.0).collect())
1227                            ;
1228                        }
1229                    }
1230                }
1231                Ok(exchange_info::HashInfo {
1232                    output_count: output_count__.unwrap_or_default(),
1233                    key: key__.unwrap_or_default(),
1234                })
1235            }
1236        }
1237        deserializer.deserialize_struct("batch_plan.ExchangeInfo.HashInfo", FIELDS, GeneratedVisitor)
1238    }
1239}
1240impl serde::Serialize for ExchangeNode {
1241    #[allow(deprecated)]
1242    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1243    where
1244        S: serde::Serializer,
1245    {
1246        use serde::ser::SerializeStruct;
1247        let mut len = 0;
1248        if !self.sources.is_empty() {
1249            len += 1;
1250        }
1251        if self.sequential {
1252            len += 1;
1253        }
1254        if !self.input_schema.is_empty() {
1255            len += 1;
1256        }
1257        let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeNode", len)?;
1258        if !self.sources.is_empty() {
1259            struct_ser.serialize_field("sources", &self.sources)?;
1260        }
1261        if self.sequential {
1262            struct_ser.serialize_field("sequential", &self.sequential)?;
1263        }
1264        if !self.input_schema.is_empty() {
1265            struct_ser.serialize_field("inputSchema", &self.input_schema)?;
1266        }
1267        struct_ser.end()
1268    }
1269}
1270impl<'de> serde::Deserialize<'de> for ExchangeNode {
1271    #[allow(deprecated)]
1272    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1273    where
1274        D: serde::Deserializer<'de>,
1275    {
1276        const FIELDS: &[&str] = &[
1277            "sources",
1278            "sequential",
1279            "input_schema",
1280            "inputSchema",
1281        ];
1282
1283        #[allow(clippy::enum_variant_names)]
1284        enum GeneratedField {
1285            Sources,
1286            Sequential,
1287            InputSchema,
1288        }
1289        impl<'de> serde::Deserialize<'de> for GeneratedField {
1290            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1291            where
1292                D: serde::Deserializer<'de>,
1293            {
1294                struct GeneratedVisitor;
1295
1296                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1297                    type Value = GeneratedField;
1298
1299                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1300                        write!(formatter, "expected one of: {:?}", &FIELDS)
1301                    }
1302
1303                    #[allow(unused_variables)]
1304                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1305                    where
1306                        E: serde::de::Error,
1307                    {
1308                        match value {
1309                            "sources" => Ok(GeneratedField::Sources),
1310                            "sequential" => Ok(GeneratedField::Sequential),
1311                            "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
1312                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1313                        }
1314                    }
1315                }
1316                deserializer.deserialize_identifier(GeneratedVisitor)
1317            }
1318        }
1319        struct GeneratedVisitor;
1320        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1321            type Value = ExchangeNode;
1322
1323            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1324                formatter.write_str("struct batch_plan.ExchangeNode")
1325            }
1326
1327            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
1328                where
1329                    V: serde::de::MapAccess<'de>,
1330            {
1331                let mut sources__ = None;
1332                let mut sequential__ = None;
1333                let mut input_schema__ = None;
1334                while let Some(k) = map_.next_key()? {
1335                    match k {
1336                        GeneratedField::Sources => {
1337                            if sources__.is_some() {
1338                                return Err(serde::de::Error::duplicate_field("sources"));
1339                            }
1340                            sources__ = Some(map_.next_value()?);
1341                        }
1342                        GeneratedField::Sequential => {
1343                            if sequential__.is_some() {
1344                                return Err(serde::de::Error::duplicate_field("sequential"));
1345                            }
1346                            sequential__ = Some(map_.next_value()?);
1347                        }
1348                        GeneratedField::InputSchema => {
1349                            if input_schema__.is_some() {
1350                                return Err(serde::de::Error::duplicate_field("inputSchema"));
1351                            }
1352                            input_schema__ = Some(map_.next_value()?);
1353                        }
1354                    }
1355                }
1356                Ok(ExchangeNode {
1357                    sources: sources__.unwrap_or_default(),
1358                    sequential: sequential__.unwrap_or_default(),
1359                    input_schema: input_schema__.unwrap_or_default(),
1360                })
1361            }
1362        }
1363        deserializer.deserialize_struct("batch_plan.ExchangeNode", FIELDS, GeneratedVisitor)
1364    }
1365}
1366impl serde::Serialize for ExchangeSource {
1367    #[allow(deprecated)]
1368    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1369    where
1370        S: serde::Serializer,
1371    {
1372        use serde::ser::SerializeStruct;
1373        let mut len = 0;
1374        if self.task_output_id.is_some() {
1375            len += 1;
1376        }
1377        if self.host.is_some() {
1378            len += 1;
1379        }
1380        if self.local_execute_plan.is_some() {
1381            len += 1;
1382        }
1383        let mut struct_ser = serializer.serialize_struct("batch_plan.ExchangeSource", len)?;
1384        if let Some(v) = self.task_output_id.as_ref() {
1385            struct_ser.serialize_field("taskOutputId", v)?;
1386        }
1387        if let Some(v) = self.host.as_ref() {
1388            struct_ser.serialize_field("host", v)?;
1389        }
1390        if let Some(v) = self.local_execute_plan.as_ref() {
1391            match v {
1392                exchange_source::LocalExecutePlan::Plan(v) => {
1393                    struct_ser.serialize_field("plan", v)?;
1394                }
1395            }
1396        }
1397        struct_ser.end()
1398    }
1399}
1400impl<'de> serde::Deserialize<'de> for ExchangeSource {
1401    #[allow(deprecated)]
1402    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1403    where
1404        D: serde::Deserializer<'de>,
1405    {
1406        const FIELDS: &[&str] = &[
1407            "task_output_id",
1408            "taskOutputId",
1409            "host",
1410            "plan",
1411        ];
1412
1413        #[allow(clippy::enum_variant_names)]
1414        enum GeneratedField {
1415            TaskOutputId,
1416            Host,
1417            Plan,
1418        }
1419        impl<'de> serde::Deserialize<'de> for GeneratedField {
1420            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1421            where
1422                D: serde::Deserializer<'de>,
1423            {
1424                struct GeneratedVisitor;
1425
1426                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1427                    type Value = GeneratedField;
1428
1429                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1430                        write!(formatter, "expected one of: {:?}", &FIELDS)
1431                    }
1432
1433                    #[allow(unused_variables)]
1434                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1435                    where
1436                        E: serde::de::Error,
1437                    {
1438                        match value {
1439                            "taskOutputId" | "task_output_id" => Ok(GeneratedField::TaskOutputId),
1440                            "host" => Ok(GeneratedField::Host),
1441                            "plan" => Ok(GeneratedField::Plan),
1442                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1443                        }
1444                    }
1445                }
1446                deserializer.deserialize_identifier(GeneratedVisitor)
1447            }
1448        }
1449        struct GeneratedVisitor;
1450        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1451            type Value = ExchangeSource;
1452
1453            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1454                formatter.write_str("struct batch_plan.ExchangeSource")
1455            }
1456
1457            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeSource, V::Error>
1458                where
1459                    V: serde::de::MapAccess<'de>,
1460            {
1461                let mut task_output_id__ = None;
1462                let mut host__ = None;
1463                let mut local_execute_plan__ = None;
1464                while let Some(k) = map_.next_key()? {
1465                    match k {
1466                        GeneratedField::TaskOutputId => {
1467                            if task_output_id__.is_some() {
1468                                return Err(serde::de::Error::duplicate_field("taskOutputId"));
1469                            }
1470                            task_output_id__ = map_.next_value()?;
1471                        }
1472                        GeneratedField::Host => {
1473                            if host__.is_some() {
1474                                return Err(serde::de::Error::duplicate_field("host"));
1475                            }
1476                            host__ = map_.next_value()?;
1477                        }
1478                        GeneratedField::Plan => {
1479                            if local_execute_plan__.is_some() {
1480                                return Err(serde::de::Error::duplicate_field("plan"));
1481                            }
1482                            local_execute_plan__ = map_.next_value::<::std::option::Option<_>>()?.map(exchange_source::LocalExecutePlan::Plan)
1483;
1484                        }
1485                    }
1486                }
1487                Ok(ExchangeSource {
1488                    task_output_id: task_output_id__,
1489                    host: host__,
1490                    local_execute_plan: local_execute_plan__,
1491                })
1492            }
1493        }
1494        deserializer.deserialize_struct("batch_plan.ExchangeSource", FIELDS, GeneratedVisitor)
1495    }
1496}
1497impl serde::Serialize for ExpandNode {
1498    #[allow(deprecated)]
1499    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1500    where
1501        S: serde::Serializer,
1502    {
1503        use serde::ser::SerializeStruct;
1504        let mut len = 0;
1505        if !self.column_subsets.is_empty() {
1506            len += 1;
1507        }
1508        let mut struct_ser = serializer.serialize_struct("batch_plan.ExpandNode", len)?;
1509        if !self.column_subsets.is_empty() {
1510            struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
1511        }
1512        struct_ser.end()
1513    }
1514}
1515impl<'de> serde::Deserialize<'de> for ExpandNode {
1516    #[allow(deprecated)]
1517    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1518    where
1519        D: serde::Deserializer<'de>,
1520    {
1521        const FIELDS: &[&str] = &[
1522            "column_subsets",
1523            "columnSubsets",
1524        ];
1525
1526        #[allow(clippy::enum_variant_names)]
1527        enum GeneratedField {
1528            ColumnSubsets,
1529        }
1530        impl<'de> serde::Deserialize<'de> for GeneratedField {
1531            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1532            where
1533                D: serde::Deserializer<'de>,
1534            {
1535                struct GeneratedVisitor;
1536
1537                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1538                    type Value = GeneratedField;
1539
1540                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1541                        write!(formatter, "expected one of: {:?}", &FIELDS)
1542                    }
1543
1544                    #[allow(unused_variables)]
1545                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1546                    where
1547                        E: serde::de::Error,
1548                    {
1549                        match value {
1550                            "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
1551                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1552                        }
1553                    }
1554                }
1555                deserializer.deserialize_identifier(GeneratedVisitor)
1556            }
1557        }
1558        struct GeneratedVisitor;
1559        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1560            type Value = ExpandNode;
1561
1562            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1563                formatter.write_str("struct batch_plan.ExpandNode")
1564            }
1565
1566            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
1567                where
1568                    V: serde::de::MapAccess<'de>,
1569            {
1570                let mut column_subsets__ = None;
1571                while let Some(k) = map_.next_key()? {
1572                    match k {
1573                        GeneratedField::ColumnSubsets => {
1574                            if column_subsets__.is_some() {
1575                                return Err(serde::de::Error::duplicate_field("columnSubsets"));
1576                            }
1577                            column_subsets__ = Some(map_.next_value()?);
1578                        }
1579                    }
1580                }
1581                Ok(ExpandNode {
1582                    column_subsets: column_subsets__.unwrap_or_default(),
1583                })
1584            }
1585        }
1586        deserializer.deserialize_struct("batch_plan.ExpandNode", FIELDS, GeneratedVisitor)
1587    }
1588}
1589impl serde::Serialize for expand_node::Subset {
1590    #[allow(deprecated)]
1591    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1592    where
1593        S: serde::Serializer,
1594    {
1595        use serde::ser::SerializeStruct;
1596        let mut len = 0;
1597        if !self.column_indices.is_empty() {
1598            len += 1;
1599        }
1600        let mut struct_ser = serializer.serialize_struct("batch_plan.ExpandNode.Subset", len)?;
1601        if !self.column_indices.is_empty() {
1602            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
1603        }
1604        struct_ser.end()
1605    }
1606}
1607impl<'de> serde::Deserialize<'de> for expand_node::Subset {
1608    #[allow(deprecated)]
1609    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1610    where
1611        D: serde::Deserializer<'de>,
1612    {
1613        const FIELDS: &[&str] = &[
1614            "column_indices",
1615            "columnIndices",
1616        ];
1617
1618        #[allow(clippy::enum_variant_names)]
1619        enum GeneratedField {
1620            ColumnIndices,
1621        }
1622        impl<'de> serde::Deserialize<'de> for GeneratedField {
1623            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1624            where
1625                D: serde::Deserializer<'de>,
1626            {
1627                struct GeneratedVisitor;
1628
1629                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1630                    type Value = GeneratedField;
1631
1632                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1633                        write!(formatter, "expected one of: {:?}", &FIELDS)
1634                    }
1635
1636                    #[allow(unused_variables)]
1637                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1638                    where
1639                        E: serde::de::Error,
1640                    {
1641                        match value {
1642                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
1643                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1644                        }
1645                    }
1646                }
1647                deserializer.deserialize_identifier(GeneratedVisitor)
1648            }
1649        }
1650        struct GeneratedVisitor;
1651        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1652            type Value = expand_node::Subset;
1653
1654            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1655                formatter.write_str("struct batch_plan.ExpandNode.Subset")
1656            }
1657
1658            fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
1659                where
1660                    V: serde::de::MapAccess<'de>,
1661            {
1662                let mut column_indices__ = None;
1663                while let Some(k) = map_.next_key()? {
1664                    match k {
1665                        GeneratedField::ColumnIndices => {
1666                            if column_indices__.is_some() {
1667                                return Err(serde::de::Error::duplicate_field("columnIndices"));
1668                            }
1669                            column_indices__ = 
1670                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1671                                    .into_iter().map(|x| x.0).collect())
1672                            ;
1673                        }
1674                    }
1675                }
1676                Ok(expand_node::Subset {
1677                    column_indices: column_indices__.unwrap_or_default(),
1678                })
1679            }
1680        }
1681        deserializer.deserialize_struct("batch_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
1682    }
1683}
1684impl serde::Serialize for FileScanNode {
1685    #[allow(deprecated)]
1686    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1687    where
1688        S: serde::Serializer,
1689    {
1690        use serde::ser::SerializeStruct;
1691        let mut len = 0;
1692        if !self.columns.is_empty() {
1693            len += 1;
1694        }
1695        if self.file_format != 0 {
1696            len += 1;
1697        }
1698        if self.storage_type != 0 {
1699            len += 1;
1700        }
1701        if !self.s3_region.is_empty() {
1702            len += 1;
1703        }
1704        if !self.s3_access_key.is_empty() {
1705            len += 1;
1706        }
1707        if !self.s3_secret_key.is_empty() {
1708            len += 1;
1709        }
1710        if !self.file_location.is_empty() {
1711            len += 1;
1712        }
1713        if !self.s3_endpoint.is_empty() {
1714            len += 1;
1715        }
1716        let mut struct_ser = serializer.serialize_struct("batch_plan.FileScanNode", len)?;
1717        if !self.columns.is_empty() {
1718            struct_ser.serialize_field("columns", &self.columns)?;
1719        }
1720        if self.file_format != 0 {
1721            let v = file_scan_node::FileFormat::try_from(self.file_format)
1722                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.file_format)))?;
1723            struct_ser.serialize_field("fileFormat", &v)?;
1724        }
1725        if self.storage_type != 0 {
1726            let v = file_scan_node::StorageType::try_from(self.storage_type)
1727                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.storage_type)))?;
1728            struct_ser.serialize_field("storageType", &v)?;
1729        }
1730        if !self.s3_region.is_empty() {
1731            struct_ser.serialize_field("s3Region", &self.s3_region)?;
1732        }
1733        if !self.s3_access_key.is_empty() {
1734            struct_ser.serialize_field("s3AccessKey", &self.s3_access_key)?;
1735        }
1736        if !self.s3_secret_key.is_empty() {
1737            struct_ser.serialize_field("s3SecretKey", &self.s3_secret_key)?;
1738        }
1739        if !self.file_location.is_empty() {
1740            struct_ser.serialize_field("fileLocation", &self.file_location)?;
1741        }
1742        if !self.s3_endpoint.is_empty() {
1743            struct_ser.serialize_field("s3Endpoint", &self.s3_endpoint)?;
1744        }
1745        struct_ser.end()
1746    }
1747}
1748impl<'de> serde::Deserialize<'de> for FileScanNode {
1749    #[allow(deprecated)]
1750    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1751    where
1752        D: serde::Deserializer<'de>,
1753    {
1754        const FIELDS: &[&str] = &[
1755            "columns",
1756            "file_format",
1757            "fileFormat",
1758            "storage_type",
1759            "storageType",
1760            "s3_region",
1761            "s3Region",
1762            "s3_access_key",
1763            "s3AccessKey",
1764            "s3_secret_key",
1765            "s3SecretKey",
1766            "file_location",
1767            "fileLocation",
1768            "s3_endpoint",
1769            "s3Endpoint",
1770        ];
1771
1772        #[allow(clippy::enum_variant_names)]
1773        enum GeneratedField {
1774            Columns,
1775            FileFormat,
1776            StorageType,
1777            S3Region,
1778            S3AccessKey,
1779            S3SecretKey,
1780            FileLocation,
1781            S3Endpoint,
1782        }
1783        impl<'de> serde::Deserialize<'de> for GeneratedField {
1784            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1785            where
1786                D: serde::Deserializer<'de>,
1787            {
1788                struct GeneratedVisitor;
1789
1790                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1791                    type Value = GeneratedField;
1792
1793                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1794                        write!(formatter, "expected one of: {:?}", &FIELDS)
1795                    }
1796
1797                    #[allow(unused_variables)]
1798                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1799                    where
1800                        E: serde::de::Error,
1801                    {
1802                        match value {
1803                            "columns" => Ok(GeneratedField::Columns),
1804                            "fileFormat" | "file_format" => Ok(GeneratedField::FileFormat),
1805                            "storageType" | "storage_type" => Ok(GeneratedField::StorageType),
1806                            "s3Region" | "s3_region" => Ok(GeneratedField::S3Region),
1807                            "s3AccessKey" | "s3_access_key" => Ok(GeneratedField::S3AccessKey),
1808                            "s3SecretKey" | "s3_secret_key" => Ok(GeneratedField::S3SecretKey),
1809                            "fileLocation" | "file_location" => Ok(GeneratedField::FileLocation),
1810                            "s3Endpoint" | "s3_endpoint" => Ok(GeneratedField::S3Endpoint),
1811                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1812                        }
1813                    }
1814                }
1815                deserializer.deserialize_identifier(GeneratedVisitor)
1816            }
1817        }
1818        struct GeneratedVisitor;
1819        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1820            type Value = FileScanNode;
1821
1822            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1823                formatter.write_str("struct batch_plan.FileScanNode")
1824            }
1825
1826            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FileScanNode, V::Error>
1827                where
1828                    V: serde::de::MapAccess<'de>,
1829            {
1830                let mut columns__ = None;
1831                let mut file_format__ = None;
1832                let mut storage_type__ = None;
1833                let mut s3_region__ = None;
1834                let mut s3_access_key__ = None;
1835                let mut s3_secret_key__ = None;
1836                let mut file_location__ = None;
1837                let mut s3_endpoint__ = None;
1838                while let Some(k) = map_.next_key()? {
1839                    match k {
1840                        GeneratedField::Columns => {
1841                            if columns__.is_some() {
1842                                return Err(serde::de::Error::duplicate_field("columns"));
1843                            }
1844                            columns__ = Some(map_.next_value()?);
1845                        }
1846                        GeneratedField::FileFormat => {
1847                            if file_format__.is_some() {
1848                                return Err(serde::de::Error::duplicate_field("fileFormat"));
1849                            }
1850                            file_format__ = Some(map_.next_value::<file_scan_node::FileFormat>()? as i32);
1851                        }
1852                        GeneratedField::StorageType => {
1853                            if storage_type__.is_some() {
1854                                return Err(serde::de::Error::duplicate_field("storageType"));
1855                            }
1856                            storage_type__ = Some(map_.next_value::<file_scan_node::StorageType>()? as i32);
1857                        }
1858                        GeneratedField::S3Region => {
1859                            if s3_region__.is_some() {
1860                                return Err(serde::de::Error::duplicate_field("s3Region"));
1861                            }
1862                            s3_region__ = Some(map_.next_value()?);
1863                        }
1864                        GeneratedField::S3AccessKey => {
1865                            if s3_access_key__.is_some() {
1866                                return Err(serde::de::Error::duplicate_field("s3AccessKey"));
1867                            }
1868                            s3_access_key__ = Some(map_.next_value()?);
1869                        }
1870                        GeneratedField::S3SecretKey => {
1871                            if s3_secret_key__.is_some() {
1872                                return Err(serde::de::Error::duplicate_field("s3SecretKey"));
1873                            }
1874                            s3_secret_key__ = Some(map_.next_value()?);
1875                        }
1876                        GeneratedField::FileLocation => {
1877                            if file_location__.is_some() {
1878                                return Err(serde::de::Error::duplicate_field("fileLocation"));
1879                            }
1880                            file_location__ = Some(map_.next_value()?);
1881                        }
1882                        GeneratedField::S3Endpoint => {
1883                            if s3_endpoint__.is_some() {
1884                                return Err(serde::de::Error::duplicate_field("s3Endpoint"));
1885                            }
1886                            s3_endpoint__ = Some(map_.next_value()?);
1887                        }
1888                    }
1889                }
1890                Ok(FileScanNode {
1891                    columns: columns__.unwrap_or_default(),
1892                    file_format: file_format__.unwrap_or_default(),
1893                    storage_type: storage_type__.unwrap_or_default(),
1894                    s3_region: s3_region__.unwrap_or_default(),
1895                    s3_access_key: s3_access_key__.unwrap_or_default(),
1896                    s3_secret_key: s3_secret_key__.unwrap_or_default(),
1897                    file_location: file_location__.unwrap_or_default(),
1898                    s3_endpoint: s3_endpoint__.unwrap_or_default(),
1899                })
1900            }
1901        }
1902        deserializer.deserialize_struct("batch_plan.FileScanNode", FIELDS, GeneratedVisitor)
1903    }
1904}
1905impl serde::Serialize for file_scan_node::FileFormat {
1906    #[allow(deprecated)]
1907    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1908    where
1909        S: serde::Serializer,
1910    {
1911        let variant = match self {
1912            Self::Unspecified => "FILE_FORMAT_UNSPECIFIED",
1913            Self::Parquet => "PARQUET",
1914        };
1915        serializer.serialize_str(variant)
1916    }
1917}
1918impl<'de> serde::Deserialize<'de> for file_scan_node::FileFormat {
1919    #[allow(deprecated)]
1920    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1921    where
1922        D: serde::Deserializer<'de>,
1923    {
1924        const FIELDS: &[&str] = &[
1925            "FILE_FORMAT_UNSPECIFIED",
1926            "PARQUET",
1927        ];
1928
1929        struct GeneratedVisitor;
1930
1931        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1932            type Value = file_scan_node::FileFormat;
1933
1934            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1935                write!(formatter, "expected one of: {:?}", &FIELDS)
1936            }
1937
1938            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1939            where
1940                E: serde::de::Error,
1941            {
1942                i32::try_from(v)
1943                    .ok()
1944                    .and_then(|x| x.try_into().ok())
1945                    .ok_or_else(|| {
1946                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1947                    })
1948            }
1949
1950            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1951            where
1952                E: serde::de::Error,
1953            {
1954                i32::try_from(v)
1955                    .ok()
1956                    .and_then(|x| x.try_into().ok())
1957                    .ok_or_else(|| {
1958                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1959                    })
1960            }
1961
1962            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1963            where
1964                E: serde::de::Error,
1965            {
1966                match value {
1967                    "FILE_FORMAT_UNSPECIFIED" => Ok(file_scan_node::FileFormat::Unspecified),
1968                    "PARQUET" => Ok(file_scan_node::FileFormat::Parquet),
1969                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1970                }
1971            }
1972        }
1973        deserializer.deserialize_any(GeneratedVisitor)
1974    }
1975}
1976impl serde::Serialize for file_scan_node::StorageType {
1977    #[allow(deprecated)]
1978    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1979    where
1980        S: serde::Serializer,
1981    {
1982        let variant = match self {
1983            Self::Unspecified => "STORAGE_TYPE_UNSPECIFIED",
1984            Self::S3 => "S3",
1985            Self::Gcs => "GCS",
1986            Self::Azblob => "AZBLOB",
1987        };
1988        serializer.serialize_str(variant)
1989    }
1990}
1991impl<'de> serde::Deserialize<'de> for file_scan_node::StorageType {
1992    #[allow(deprecated)]
1993    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1994    where
1995        D: serde::Deserializer<'de>,
1996    {
1997        const FIELDS: &[&str] = &[
1998            "STORAGE_TYPE_UNSPECIFIED",
1999            "S3",
2000            "GCS",
2001            "AZBLOB",
2002        ];
2003
2004        struct GeneratedVisitor;
2005
2006        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2007            type Value = file_scan_node::StorageType;
2008
2009            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2010                write!(formatter, "expected one of: {:?}", &FIELDS)
2011            }
2012
2013            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2014            where
2015                E: serde::de::Error,
2016            {
2017                i32::try_from(v)
2018                    .ok()
2019                    .and_then(|x| x.try_into().ok())
2020                    .ok_or_else(|| {
2021                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2022                    })
2023            }
2024
2025            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2026            where
2027                E: serde::de::Error,
2028            {
2029                i32::try_from(v)
2030                    .ok()
2031                    .and_then(|x| x.try_into().ok())
2032                    .ok_or_else(|| {
2033                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2034                    })
2035            }
2036
2037            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2038            where
2039                E: serde::de::Error,
2040            {
2041                match value {
2042                    "STORAGE_TYPE_UNSPECIFIED" => Ok(file_scan_node::StorageType::Unspecified),
2043                    "S3" => Ok(file_scan_node::StorageType::S3),
2044                    "GCS" => Ok(file_scan_node::StorageType::Gcs),
2045                    "AZBLOB" => Ok(file_scan_node::StorageType::Azblob),
2046                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2047                }
2048            }
2049        }
2050        deserializer.deserialize_any(GeneratedVisitor)
2051    }
2052}
2053impl serde::Serialize for FilterNode {
2054    #[allow(deprecated)]
2055    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2056    where
2057        S: serde::Serializer,
2058    {
2059        use serde::ser::SerializeStruct;
2060        let mut len = 0;
2061        if self.search_condition.is_some() {
2062            len += 1;
2063        }
2064        let mut struct_ser = serializer.serialize_struct("batch_plan.FilterNode", len)?;
2065        if let Some(v) = self.search_condition.as_ref() {
2066            struct_ser.serialize_field("searchCondition", v)?;
2067        }
2068        struct_ser.end()
2069    }
2070}
2071impl<'de> serde::Deserialize<'de> for FilterNode {
2072    #[allow(deprecated)]
2073    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2074    where
2075        D: serde::Deserializer<'de>,
2076    {
2077        const FIELDS: &[&str] = &[
2078            "search_condition",
2079            "searchCondition",
2080        ];
2081
2082        #[allow(clippy::enum_variant_names)]
2083        enum GeneratedField {
2084            SearchCondition,
2085        }
2086        impl<'de> serde::Deserialize<'de> for GeneratedField {
2087            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2088            where
2089                D: serde::Deserializer<'de>,
2090            {
2091                struct GeneratedVisitor;
2092
2093                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2094                    type Value = GeneratedField;
2095
2096                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2097                        write!(formatter, "expected one of: {:?}", &FIELDS)
2098                    }
2099
2100                    #[allow(unused_variables)]
2101                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2102                    where
2103                        E: serde::de::Error,
2104                    {
2105                        match value {
2106                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2107                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2108                        }
2109                    }
2110                }
2111                deserializer.deserialize_identifier(GeneratedVisitor)
2112            }
2113        }
2114        struct GeneratedVisitor;
2115        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2116            type Value = FilterNode;
2117
2118            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2119                formatter.write_str("struct batch_plan.FilterNode")
2120            }
2121
2122            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
2123                where
2124                    V: serde::de::MapAccess<'de>,
2125            {
2126                let mut search_condition__ = None;
2127                while let Some(k) = map_.next_key()? {
2128                    match k {
2129                        GeneratedField::SearchCondition => {
2130                            if search_condition__.is_some() {
2131                                return Err(serde::de::Error::duplicate_field("searchCondition"));
2132                            }
2133                            search_condition__ = map_.next_value()?;
2134                        }
2135                    }
2136                }
2137                Ok(FilterNode {
2138                    search_condition: search_condition__,
2139                })
2140            }
2141        }
2142        deserializer.deserialize_struct("batch_plan.FilterNode", FIELDS, GeneratedVisitor)
2143    }
2144}
2145impl serde::Serialize for GcsFileScanNode {
2146    #[allow(deprecated)]
2147    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2148    where
2149        S: serde::Serializer,
2150    {
2151        use serde::ser::SerializeStruct;
2152        let mut len = 0;
2153        if !self.columns.is_empty() {
2154            len += 1;
2155        }
2156        if self.file_format != 0 {
2157            len += 1;
2158        }
2159        if !self.credential.is_empty() {
2160            len += 1;
2161        }
2162        if !self.file_location.is_empty() {
2163            len += 1;
2164        }
2165        let mut struct_ser = serializer.serialize_struct("batch_plan.GcsFileScanNode", len)?;
2166        if !self.columns.is_empty() {
2167            struct_ser.serialize_field("columns", &self.columns)?;
2168        }
2169        if self.file_format != 0 {
2170            let v = gcs_file_scan_node::FileFormat::try_from(self.file_format)
2171                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.file_format)))?;
2172            struct_ser.serialize_field("fileFormat", &v)?;
2173        }
2174        if !self.credential.is_empty() {
2175            struct_ser.serialize_field("credential", &self.credential)?;
2176        }
2177        if !self.file_location.is_empty() {
2178            struct_ser.serialize_field("fileLocation", &self.file_location)?;
2179        }
2180        struct_ser.end()
2181    }
2182}
2183impl<'de> serde::Deserialize<'de> for GcsFileScanNode {
2184    #[allow(deprecated)]
2185    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2186    where
2187        D: serde::Deserializer<'de>,
2188    {
2189        const FIELDS: &[&str] = &[
2190            "columns",
2191            "file_format",
2192            "fileFormat",
2193            "credential",
2194            "file_location",
2195            "fileLocation",
2196        ];
2197
2198        #[allow(clippy::enum_variant_names)]
2199        enum GeneratedField {
2200            Columns,
2201            FileFormat,
2202            Credential,
2203            FileLocation,
2204        }
2205        impl<'de> serde::Deserialize<'de> for GeneratedField {
2206            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2207            where
2208                D: serde::Deserializer<'de>,
2209            {
2210                struct GeneratedVisitor;
2211
2212                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2213                    type Value = GeneratedField;
2214
2215                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2216                        write!(formatter, "expected one of: {:?}", &FIELDS)
2217                    }
2218
2219                    #[allow(unused_variables)]
2220                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2221                    where
2222                        E: serde::de::Error,
2223                    {
2224                        match value {
2225                            "columns" => Ok(GeneratedField::Columns),
2226                            "fileFormat" | "file_format" => Ok(GeneratedField::FileFormat),
2227                            "credential" => Ok(GeneratedField::Credential),
2228                            "fileLocation" | "file_location" => Ok(GeneratedField::FileLocation),
2229                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2230                        }
2231                    }
2232                }
2233                deserializer.deserialize_identifier(GeneratedVisitor)
2234            }
2235        }
2236        struct GeneratedVisitor;
2237        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2238            type Value = GcsFileScanNode;
2239
2240            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2241                formatter.write_str("struct batch_plan.GcsFileScanNode")
2242            }
2243
2244            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GcsFileScanNode, V::Error>
2245                where
2246                    V: serde::de::MapAccess<'de>,
2247            {
2248                let mut columns__ = None;
2249                let mut file_format__ = None;
2250                let mut credential__ = None;
2251                let mut file_location__ = None;
2252                while let Some(k) = map_.next_key()? {
2253                    match k {
2254                        GeneratedField::Columns => {
2255                            if columns__.is_some() {
2256                                return Err(serde::de::Error::duplicate_field("columns"));
2257                            }
2258                            columns__ = Some(map_.next_value()?);
2259                        }
2260                        GeneratedField::FileFormat => {
2261                            if file_format__.is_some() {
2262                                return Err(serde::de::Error::duplicate_field("fileFormat"));
2263                            }
2264                            file_format__ = Some(map_.next_value::<gcs_file_scan_node::FileFormat>()? as i32);
2265                        }
2266                        GeneratedField::Credential => {
2267                            if credential__.is_some() {
2268                                return Err(serde::de::Error::duplicate_field("credential"));
2269                            }
2270                            credential__ = Some(map_.next_value()?);
2271                        }
2272                        GeneratedField::FileLocation => {
2273                            if file_location__.is_some() {
2274                                return Err(serde::de::Error::duplicate_field("fileLocation"));
2275                            }
2276                            file_location__ = Some(map_.next_value()?);
2277                        }
2278                    }
2279                }
2280                Ok(GcsFileScanNode {
2281                    columns: columns__.unwrap_or_default(),
2282                    file_format: file_format__.unwrap_or_default(),
2283                    credential: credential__.unwrap_or_default(),
2284                    file_location: file_location__.unwrap_or_default(),
2285                })
2286            }
2287        }
2288        deserializer.deserialize_struct("batch_plan.GcsFileScanNode", FIELDS, GeneratedVisitor)
2289    }
2290}
2291impl serde::Serialize for gcs_file_scan_node::FileFormat {
2292    #[allow(deprecated)]
2293    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2294    where
2295        S: serde::Serializer,
2296    {
2297        let variant = match self {
2298            Self::Unspecified => "FILE_FORMAT_UNSPECIFIED",
2299            Self::Parquet => "PARQUET",
2300        };
2301        serializer.serialize_str(variant)
2302    }
2303}
2304impl<'de> serde::Deserialize<'de> for gcs_file_scan_node::FileFormat {
2305    #[allow(deprecated)]
2306    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2307    where
2308        D: serde::Deserializer<'de>,
2309    {
2310        const FIELDS: &[&str] = &[
2311            "FILE_FORMAT_UNSPECIFIED",
2312            "PARQUET",
2313        ];
2314
2315        struct GeneratedVisitor;
2316
2317        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2318            type Value = gcs_file_scan_node::FileFormat;
2319
2320            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2321                write!(formatter, "expected one of: {:?}", &FIELDS)
2322            }
2323
2324            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2325            where
2326                E: serde::de::Error,
2327            {
2328                i32::try_from(v)
2329                    .ok()
2330                    .and_then(|x| x.try_into().ok())
2331                    .ok_or_else(|| {
2332                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2333                    })
2334            }
2335
2336            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2337            where
2338                E: serde::de::Error,
2339            {
2340                i32::try_from(v)
2341                    .ok()
2342                    .and_then(|x| x.try_into().ok())
2343                    .ok_or_else(|| {
2344                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2345                    })
2346            }
2347
2348            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2349            where
2350                E: serde::de::Error,
2351            {
2352                match value {
2353                    "FILE_FORMAT_UNSPECIFIED" => Ok(gcs_file_scan_node::FileFormat::Unspecified),
2354                    "PARQUET" => Ok(gcs_file_scan_node::FileFormat::Parquet),
2355                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2356                }
2357            }
2358        }
2359        deserializer.deserialize_any(GeneratedVisitor)
2360    }
2361}
2362impl serde::Serialize for GroupTopNNode {
2363    #[allow(deprecated)]
2364    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2365    where
2366        S: serde::Serializer,
2367    {
2368        use serde::ser::SerializeStruct;
2369        let mut len = 0;
2370        if !self.column_orders.is_empty() {
2371            len += 1;
2372        }
2373        if self.limit != 0 {
2374            len += 1;
2375        }
2376        if self.offset != 0 {
2377            len += 1;
2378        }
2379        if !self.group_key.is_empty() {
2380            len += 1;
2381        }
2382        if self.with_ties {
2383            len += 1;
2384        }
2385        let mut struct_ser = serializer.serialize_struct("batch_plan.GroupTopNNode", len)?;
2386        if !self.column_orders.is_empty() {
2387            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
2388        }
2389        if self.limit != 0 {
2390            #[allow(clippy::needless_borrow)]
2391            #[allow(clippy::needless_borrows_for_generic_args)]
2392            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
2393        }
2394        if self.offset != 0 {
2395            #[allow(clippy::needless_borrow)]
2396            #[allow(clippy::needless_borrows_for_generic_args)]
2397            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
2398        }
2399        if !self.group_key.is_empty() {
2400            struct_ser.serialize_field("groupKey", &self.group_key)?;
2401        }
2402        if self.with_ties {
2403            struct_ser.serialize_field("withTies", &self.with_ties)?;
2404        }
2405        struct_ser.end()
2406    }
2407}
2408impl<'de> serde::Deserialize<'de> for GroupTopNNode {
2409    #[allow(deprecated)]
2410    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2411    where
2412        D: serde::Deserializer<'de>,
2413    {
2414        const FIELDS: &[&str] = &[
2415            "column_orders",
2416            "columnOrders",
2417            "limit",
2418            "offset",
2419            "group_key",
2420            "groupKey",
2421            "with_ties",
2422            "withTies",
2423        ];
2424
2425        #[allow(clippy::enum_variant_names)]
2426        enum GeneratedField {
2427            ColumnOrders,
2428            Limit,
2429            Offset,
2430            GroupKey,
2431            WithTies,
2432        }
2433        impl<'de> serde::Deserialize<'de> for GeneratedField {
2434            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2435            where
2436                D: serde::Deserializer<'de>,
2437            {
2438                struct GeneratedVisitor;
2439
2440                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2441                    type Value = GeneratedField;
2442
2443                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2444                        write!(formatter, "expected one of: {:?}", &FIELDS)
2445                    }
2446
2447                    #[allow(unused_variables)]
2448                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2449                    where
2450                        E: serde::de::Error,
2451                    {
2452                        match value {
2453                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
2454                            "limit" => Ok(GeneratedField::Limit),
2455                            "offset" => Ok(GeneratedField::Offset),
2456                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2457                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
2458                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2459                        }
2460                    }
2461                }
2462                deserializer.deserialize_identifier(GeneratedVisitor)
2463            }
2464        }
2465        struct GeneratedVisitor;
2466        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2467            type Value = GroupTopNNode;
2468
2469            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2470                formatter.write_str("struct batch_plan.GroupTopNNode")
2471            }
2472
2473            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
2474                where
2475                    V: serde::de::MapAccess<'de>,
2476            {
2477                let mut column_orders__ = None;
2478                let mut limit__ = None;
2479                let mut offset__ = None;
2480                let mut group_key__ = None;
2481                let mut with_ties__ = None;
2482                while let Some(k) = map_.next_key()? {
2483                    match k {
2484                        GeneratedField::ColumnOrders => {
2485                            if column_orders__.is_some() {
2486                                return Err(serde::de::Error::duplicate_field("columnOrders"));
2487                            }
2488                            column_orders__ = Some(map_.next_value()?);
2489                        }
2490                        GeneratedField::Limit => {
2491                            if limit__.is_some() {
2492                                return Err(serde::de::Error::duplicate_field("limit"));
2493                            }
2494                            limit__ = 
2495                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2496                            ;
2497                        }
2498                        GeneratedField::Offset => {
2499                            if offset__.is_some() {
2500                                return Err(serde::de::Error::duplicate_field("offset"));
2501                            }
2502                            offset__ = 
2503                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2504                            ;
2505                        }
2506                        GeneratedField::GroupKey => {
2507                            if group_key__.is_some() {
2508                                return Err(serde::de::Error::duplicate_field("groupKey"));
2509                            }
2510                            group_key__ = 
2511                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2512                                    .into_iter().map(|x| x.0).collect())
2513                            ;
2514                        }
2515                        GeneratedField::WithTies => {
2516                            if with_ties__.is_some() {
2517                                return Err(serde::de::Error::duplicate_field("withTies"));
2518                            }
2519                            with_ties__ = Some(map_.next_value()?);
2520                        }
2521                    }
2522                }
2523                Ok(GroupTopNNode {
2524                    column_orders: column_orders__.unwrap_or_default(),
2525                    limit: limit__.unwrap_or_default(),
2526                    offset: offset__.unwrap_or_default(),
2527                    group_key: group_key__.unwrap_or_default(),
2528                    with_ties: with_ties__.unwrap_or_default(),
2529                })
2530            }
2531        }
2532        deserializer.deserialize_struct("batch_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
2533    }
2534}
2535impl serde::Serialize for HashAggNode {
2536    #[allow(deprecated)]
2537    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2538    where
2539        S: serde::Serializer,
2540    {
2541        use serde::ser::SerializeStruct;
2542        let mut len = 0;
2543        if !self.group_key.is_empty() {
2544            len += 1;
2545        }
2546        if !self.agg_calls.is_empty() {
2547            len += 1;
2548        }
2549        let mut struct_ser = serializer.serialize_struct("batch_plan.HashAggNode", len)?;
2550        if !self.group_key.is_empty() {
2551            struct_ser.serialize_field("groupKey", &self.group_key)?;
2552        }
2553        if !self.agg_calls.is_empty() {
2554            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
2555        }
2556        struct_ser.end()
2557    }
2558}
2559impl<'de> serde::Deserialize<'de> for HashAggNode {
2560    #[allow(deprecated)]
2561    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2562    where
2563        D: serde::Deserializer<'de>,
2564    {
2565        const FIELDS: &[&str] = &[
2566            "group_key",
2567            "groupKey",
2568            "agg_calls",
2569            "aggCalls",
2570        ];
2571
2572        #[allow(clippy::enum_variant_names)]
2573        enum GeneratedField {
2574            GroupKey,
2575            AggCalls,
2576        }
2577        impl<'de> serde::Deserialize<'de> for GeneratedField {
2578            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2579            where
2580                D: serde::Deserializer<'de>,
2581            {
2582                struct GeneratedVisitor;
2583
2584                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2585                    type Value = GeneratedField;
2586
2587                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2588                        write!(formatter, "expected one of: {:?}", &FIELDS)
2589                    }
2590
2591                    #[allow(unused_variables)]
2592                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2593                    where
2594                        E: serde::de::Error,
2595                    {
2596                        match value {
2597                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2598                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
2599                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2600                        }
2601                    }
2602                }
2603                deserializer.deserialize_identifier(GeneratedVisitor)
2604            }
2605        }
2606        struct GeneratedVisitor;
2607        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2608            type Value = HashAggNode;
2609
2610            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2611                formatter.write_str("struct batch_plan.HashAggNode")
2612            }
2613
2614            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
2615                where
2616                    V: serde::de::MapAccess<'de>,
2617            {
2618                let mut group_key__ = None;
2619                let mut agg_calls__ = None;
2620                while let Some(k) = map_.next_key()? {
2621                    match k {
2622                        GeneratedField::GroupKey => {
2623                            if group_key__.is_some() {
2624                                return Err(serde::de::Error::duplicate_field("groupKey"));
2625                            }
2626                            group_key__ = 
2627                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2628                                    .into_iter().map(|x| x.0).collect())
2629                            ;
2630                        }
2631                        GeneratedField::AggCalls => {
2632                            if agg_calls__.is_some() {
2633                                return Err(serde::de::Error::duplicate_field("aggCalls"));
2634                            }
2635                            agg_calls__ = Some(map_.next_value()?);
2636                        }
2637                    }
2638                }
2639                Ok(HashAggNode {
2640                    group_key: group_key__.unwrap_or_default(),
2641                    agg_calls: agg_calls__.unwrap_or_default(),
2642                })
2643            }
2644        }
2645        deserializer.deserialize_struct("batch_plan.HashAggNode", FIELDS, GeneratedVisitor)
2646    }
2647}
2648impl serde::Serialize for HashJoinNode {
2649    #[allow(deprecated)]
2650    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2651    where
2652        S: serde::Serializer,
2653    {
2654        use serde::ser::SerializeStruct;
2655        let mut len = 0;
2656        if self.join_type != 0 {
2657            len += 1;
2658        }
2659        if !self.left_key.is_empty() {
2660            len += 1;
2661        }
2662        if !self.right_key.is_empty() {
2663            len += 1;
2664        }
2665        if self.condition.is_some() {
2666            len += 1;
2667        }
2668        if !self.output_indices.is_empty() {
2669            len += 1;
2670        }
2671        if !self.null_safe.is_empty() {
2672            len += 1;
2673        }
2674        if self.asof_desc.is_some() {
2675            len += 1;
2676        }
2677        let mut struct_ser = serializer.serialize_struct("batch_plan.HashJoinNode", len)?;
2678        if self.join_type != 0 {
2679            let v = super::plan_common::JoinType::try_from(self.join_type)
2680                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2681            struct_ser.serialize_field("joinType", &v)?;
2682        }
2683        if !self.left_key.is_empty() {
2684            struct_ser.serialize_field("leftKey", &self.left_key)?;
2685        }
2686        if !self.right_key.is_empty() {
2687            struct_ser.serialize_field("rightKey", &self.right_key)?;
2688        }
2689        if let Some(v) = self.condition.as_ref() {
2690            struct_ser.serialize_field("condition", v)?;
2691        }
2692        if !self.output_indices.is_empty() {
2693            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2694        }
2695        if !self.null_safe.is_empty() {
2696            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
2697        }
2698        if let Some(v) = self.asof_desc.as_ref() {
2699            struct_ser.serialize_field("asofDesc", v)?;
2700        }
2701        struct_ser.end()
2702    }
2703}
2704impl<'de> serde::Deserialize<'de> for HashJoinNode {
2705    #[allow(deprecated)]
2706    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2707    where
2708        D: serde::Deserializer<'de>,
2709    {
2710        const FIELDS: &[&str] = &[
2711            "join_type",
2712            "joinType",
2713            "left_key",
2714            "leftKey",
2715            "right_key",
2716            "rightKey",
2717            "condition",
2718            "output_indices",
2719            "outputIndices",
2720            "null_safe",
2721            "nullSafe",
2722            "asof_desc",
2723            "asofDesc",
2724        ];
2725
2726        #[allow(clippy::enum_variant_names)]
2727        enum GeneratedField {
2728            JoinType,
2729            LeftKey,
2730            RightKey,
2731            Condition,
2732            OutputIndices,
2733            NullSafe,
2734            AsofDesc,
2735        }
2736        impl<'de> serde::Deserialize<'de> for GeneratedField {
2737            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2738            where
2739                D: serde::Deserializer<'de>,
2740            {
2741                struct GeneratedVisitor;
2742
2743                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2744                    type Value = GeneratedField;
2745
2746                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2747                        write!(formatter, "expected one of: {:?}", &FIELDS)
2748                    }
2749
2750                    #[allow(unused_variables)]
2751                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2752                    where
2753                        E: serde::de::Error,
2754                    {
2755                        match value {
2756                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2757                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2758                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2759                            "condition" => Ok(GeneratedField::Condition),
2760                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2761                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
2762                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
2763                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2764                        }
2765                    }
2766                }
2767                deserializer.deserialize_identifier(GeneratedVisitor)
2768            }
2769        }
2770        struct GeneratedVisitor;
2771        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2772            type Value = HashJoinNode;
2773
2774            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2775                formatter.write_str("struct batch_plan.HashJoinNode")
2776            }
2777
2778            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
2779                where
2780                    V: serde::de::MapAccess<'de>,
2781            {
2782                let mut join_type__ = None;
2783                let mut left_key__ = None;
2784                let mut right_key__ = None;
2785                let mut condition__ = None;
2786                let mut output_indices__ = None;
2787                let mut null_safe__ = None;
2788                let mut asof_desc__ = None;
2789                while let Some(k) = map_.next_key()? {
2790                    match k {
2791                        GeneratedField::JoinType => {
2792                            if join_type__.is_some() {
2793                                return Err(serde::de::Error::duplicate_field("joinType"));
2794                            }
2795                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2796                        }
2797                        GeneratedField::LeftKey => {
2798                            if left_key__.is_some() {
2799                                return Err(serde::de::Error::duplicate_field("leftKey"));
2800                            }
2801                            left_key__ = 
2802                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2803                                    .into_iter().map(|x| x.0).collect())
2804                            ;
2805                        }
2806                        GeneratedField::RightKey => {
2807                            if right_key__.is_some() {
2808                                return Err(serde::de::Error::duplicate_field("rightKey"));
2809                            }
2810                            right_key__ = 
2811                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2812                                    .into_iter().map(|x| x.0).collect())
2813                            ;
2814                        }
2815                        GeneratedField::Condition => {
2816                            if condition__.is_some() {
2817                                return Err(serde::de::Error::duplicate_field("condition"));
2818                            }
2819                            condition__ = map_.next_value()?;
2820                        }
2821                        GeneratedField::OutputIndices => {
2822                            if output_indices__.is_some() {
2823                                return Err(serde::de::Error::duplicate_field("outputIndices"));
2824                            }
2825                            output_indices__ = 
2826                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2827                                    .into_iter().map(|x| x.0).collect())
2828                            ;
2829                        }
2830                        GeneratedField::NullSafe => {
2831                            if null_safe__.is_some() {
2832                                return Err(serde::de::Error::duplicate_field("nullSafe"));
2833                            }
2834                            null_safe__ = Some(map_.next_value()?);
2835                        }
2836                        GeneratedField::AsofDesc => {
2837                            if asof_desc__.is_some() {
2838                                return Err(serde::de::Error::duplicate_field("asofDesc"));
2839                            }
2840                            asof_desc__ = map_.next_value()?;
2841                        }
2842                    }
2843                }
2844                Ok(HashJoinNode {
2845                    join_type: join_type__.unwrap_or_default(),
2846                    left_key: left_key__.unwrap_or_default(),
2847                    right_key: right_key__.unwrap_or_default(),
2848                    condition: condition__,
2849                    output_indices: output_indices__.unwrap_or_default(),
2850                    null_safe: null_safe__.unwrap_or_default(),
2851                    asof_desc: asof_desc__,
2852                })
2853            }
2854        }
2855        deserializer.deserialize_struct("batch_plan.HashJoinNode", FIELDS, GeneratedVisitor)
2856    }
2857}
2858impl serde::Serialize for HopWindowNode {
2859    #[allow(deprecated)]
2860    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2861    where
2862        S: serde::Serializer,
2863    {
2864        use serde::ser::SerializeStruct;
2865        let mut len = 0;
2866        if self.time_col != 0 {
2867            len += 1;
2868        }
2869        if self.window_slide.is_some() {
2870            len += 1;
2871        }
2872        if self.window_size.is_some() {
2873            len += 1;
2874        }
2875        if !self.output_indices.is_empty() {
2876            len += 1;
2877        }
2878        if !self.window_start_exprs.is_empty() {
2879            len += 1;
2880        }
2881        if !self.window_end_exprs.is_empty() {
2882            len += 1;
2883        }
2884        let mut struct_ser = serializer.serialize_struct("batch_plan.HopWindowNode", len)?;
2885        if self.time_col != 0 {
2886            struct_ser.serialize_field("timeCol", &self.time_col)?;
2887        }
2888        if let Some(v) = self.window_slide.as_ref() {
2889            struct_ser.serialize_field("windowSlide", v)?;
2890        }
2891        if let Some(v) = self.window_size.as_ref() {
2892            struct_ser.serialize_field("windowSize", v)?;
2893        }
2894        if !self.output_indices.is_empty() {
2895            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2896        }
2897        if !self.window_start_exprs.is_empty() {
2898            struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
2899        }
2900        if !self.window_end_exprs.is_empty() {
2901            struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
2902        }
2903        struct_ser.end()
2904    }
2905}
2906impl<'de> serde::Deserialize<'de> for HopWindowNode {
2907    #[allow(deprecated)]
2908    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2909    where
2910        D: serde::Deserializer<'de>,
2911    {
2912        const FIELDS: &[&str] = &[
2913            "time_col",
2914            "timeCol",
2915            "window_slide",
2916            "windowSlide",
2917            "window_size",
2918            "windowSize",
2919            "output_indices",
2920            "outputIndices",
2921            "window_start_exprs",
2922            "windowStartExprs",
2923            "window_end_exprs",
2924            "windowEndExprs",
2925        ];
2926
2927        #[allow(clippy::enum_variant_names)]
2928        enum GeneratedField {
2929            TimeCol,
2930            WindowSlide,
2931            WindowSize,
2932            OutputIndices,
2933            WindowStartExprs,
2934            WindowEndExprs,
2935        }
2936        impl<'de> serde::Deserialize<'de> for GeneratedField {
2937            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2938            where
2939                D: serde::Deserializer<'de>,
2940            {
2941                struct GeneratedVisitor;
2942
2943                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2944                    type Value = GeneratedField;
2945
2946                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2947                        write!(formatter, "expected one of: {:?}", &FIELDS)
2948                    }
2949
2950                    #[allow(unused_variables)]
2951                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2952                    where
2953                        E: serde::de::Error,
2954                    {
2955                        match value {
2956                            "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
2957                            "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
2958                            "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
2959                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2960                            "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
2961                            "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
2962                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2963                        }
2964                    }
2965                }
2966                deserializer.deserialize_identifier(GeneratedVisitor)
2967            }
2968        }
2969        struct GeneratedVisitor;
2970        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2971            type Value = HopWindowNode;
2972
2973            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2974                formatter.write_str("struct batch_plan.HopWindowNode")
2975            }
2976
2977            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
2978                where
2979                    V: serde::de::MapAccess<'de>,
2980            {
2981                let mut time_col__ = None;
2982                let mut window_slide__ = None;
2983                let mut window_size__ = None;
2984                let mut output_indices__ = None;
2985                let mut window_start_exprs__ = None;
2986                let mut window_end_exprs__ = None;
2987                while let Some(k) = map_.next_key()? {
2988                    match k {
2989                        GeneratedField::TimeCol => {
2990                            if time_col__.is_some() {
2991                                return Err(serde::de::Error::duplicate_field("timeCol"));
2992                            }
2993                            time_col__ = 
2994                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2995                            ;
2996                        }
2997                        GeneratedField::WindowSlide => {
2998                            if window_slide__.is_some() {
2999                                return Err(serde::de::Error::duplicate_field("windowSlide"));
3000                            }
3001                            window_slide__ = map_.next_value()?;
3002                        }
3003                        GeneratedField::WindowSize => {
3004                            if window_size__.is_some() {
3005                                return Err(serde::de::Error::duplicate_field("windowSize"));
3006                            }
3007                            window_size__ = map_.next_value()?;
3008                        }
3009                        GeneratedField::OutputIndices => {
3010                            if output_indices__.is_some() {
3011                                return Err(serde::de::Error::duplicate_field("outputIndices"));
3012                            }
3013                            output_indices__ = 
3014                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3015                                    .into_iter().map(|x| x.0).collect())
3016                            ;
3017                        }
3018                        GeneratedField::WindowStartExprs => {
3019                            if window_start_exprs__.is_some() {
3020                                return Err(serde::de::Error::duplicate_field("windowStartExprs"));
3021                            }
3022                            window_start_exprs__ = Some(map_.next_value()?);
3023                        }
3024                        GeneratedField::WindowEndExprs => {
3025                            if window_end_exprs__.is_some() {
3026                                return Err(serde::de::Error::duplicate_field("windowEndExprs"));
3027                            }
3028                            window_end_exprs__ = Some(map_.next_value()?);
3029                        }
3030                    }
3031                }
3032                Ok(HopWindowNode {
3033                    time_col: time_col__.unwrap_or_default(),
3034                    window_slide: window_slide__,
3035                    window_size: window_size__,
3036                    output_indices: output_indices__.unwrap_or_default(),
3037                    window_start_exprs: window_start_exprs__.unwrap_or_default(),
3038                    window_end_exprs: window_end_exprs__.unwrap_or_default(),
3039                })
3040            }
3041        }
3042        deserializer.deserialize_struct("batch_plan.HopWindowNode", FIELDS, GeneratedVisitor)
3043    }
3044}
3045impl serde::Serialize for IcebergScanNode {
3046    #[allow(deprecated)]
3047    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3048    where
3049        S: serde::Serializer,
3050    {
3051        use serde::ser::SerializeStruct;
3052        let mut len = 0;
3053        if !self.columns.is_empty() {
3054            len += 1;
3055        }
3056        if !self.with_properties.is_empty() {
3057            len += 1;
3058        }
3059        if !self.split.is_empty() {
3060            len += 1;
3061        }
3062        if !self.secret_refs.is_empty() {
3063            len += 1;
3064        }
3065        if self.iceberg_scan_type != 0 {
3066            len += 1;
3067        }
3068        let mut struct_ser = serializer.serialize_struct("batch_plan.IcebergScanNode", len)?;
3069        if !self.columns.is_empty() {
3070            struct_ser.serialize_field("columns", &self.columns)?;
3071        }
3072        if !self.with_properties.is_empty() {
3073            struct_ser.serialize_field("withProperties", &self.with_properties)?;
3074        }
3075        if !self.split.is_empty() {
3076            struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
3077        }
3078        if !self.secret_refs.is_empty() {
3079            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3080        }
3081        if self.iceberg_scan_type != 0 {
3082            let v = iceberg_scan_node::IcebergScanType::try_from(self.iceberg_scan_type)
3083                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.iceberg_scan_type)))?;
3084            struct_ser.serialize_field("icebergScanType", &v)?;
3085        }
3086        struct_ser.end()
3087    }
3088}
3089impl<'de> serde::Deserialize<'de> for IcebergScanNode {
3090    #[allow(deprecated)]
3091    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3092    where
3093        D: serde::Deserializer<'de>,
3094    {
3095        const FIELDS: &[&str] = &[
3096            "columns",
3097            "with_properties",
3098            "withProperties",
3099            "split",
3100            "secret_refs",
3101            "secretRefs",
3102            "iceberg_scan_type",
3103            "icebergScanType",
3104        ];
3105
3106        #[allow(clippy::enum_variant_names)]
3107        enum GeneratedField {
3108            Columns,
3109            WithProperties,
3110            Split,
3111            SecretRefs,
3112            IcebergScanType,
3113        }
3114        impl<'de> serde::Deserialize<'de> for GeneratedField {
3115            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3116            where
3117                D: serde::Deserializer<'de>,
3118            {
3119                struct GeneratedVisitor;
3120
3121                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3122                    type Value = GeneratedField;
3123
3124                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3125                        write!(formatter, "expected one of: {:?}", &FIELDS)
3126                    }
3127
3128                    #[allow(unused_variables)]
3129                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3130                    where
3131                        E: serde::de::Error,
3132                    {
3133                        match value {
3134                            "columns" => Ok(GeneratedField::Columns),
3135                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
3136                            "split" => Ok(GeneratedField::Split),
3137                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3138                            "icebergScanType" | "iceberg_scan_type" => Ok(GeneratedField::IcebergScanType),
3139                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3140                        }
3141                    }
3142                }
3143                deserializer.deserialize_identifier(GeneratedVisitor)
3144            }
3145        }
3146        struct GeneratedVisitor;
3147        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3148            type Value = IcebergScanNode;
3149
3150            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3151                formatter.write_str("struct batch_plan.IcebergScanNode")
3152            }
3153
3154            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergScanNode, V::Error>
3155                where
3156                    V: serde::de::MapAccess<'de>,
3157            {
3158                let mut columns__ = None;
3159                let mut with_properties__ = None;
3160                let mut split__ = None;
3161                let mut secret_refs__ = None;
3162                let mut iceberg_scan_type__ = None;
3163                while let Some(k) = map_.next_key()? {
3164                    match k {
3165                        GeneratedField::Columns => {
3166                            if columns__.is_some() {
3167                                return Err(serde::de::Error::duplicate_field("columns"));
3168                            }
3169                            columns__ = Some(map_.next_value()?);
3170                        }
3171                        GeneratedField::WithProperties => {
3172                            if with_properties__.is_some() {
3173                                return Err(serde::de::Error::duplicate_field("withProperties"));
3174                            }
3175                            with_properties__ = Some(
3176                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3177                            );
3178                        }
3179                        GeneratedField::Split => {
3180                            if split__.is_some() {
3181                                return Err(serde::de::Error::duplicate_field("split"));
3182                            }
3183                            split__ = 
3184                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
3185                                    .into_iter().map(|x| x.0).collect())
3186                            ;
3187                        }
3188                        GeneratedField::SecretRefs => {
3189                            if secret_refs__.is_some() {
3190                                return Err(serde::de::Error::duplicate_field("secretRefs"));
3191                            }
3192                            secret_refs__ = Some(
3193                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3194                            );
3195                        }
3196                        GeneratedField::IcebergScanType => {
3197                            if iceberg_scan_type__.is_some() {
3198                                return Err(serde::de::Error::duplicate_field("icebergScanType"));
3199                            }
3200                            iceberg_scan_type__ = Some(map_.next_value::<iceberg_scan_node::IcebergScanType>()? as i32);
3201                        }
3202                    }
3203                }
3204                Ok(IcebergScanNode {
3205                    columns: columns__.unwrap_or_default(),
3206                    with_properties: with_properties__.unwrap_or_default(),
3207                    split: split__.unwrap_or_default(),
3208                    secret_refs: secret_refs__.unwrap_or_default(),
3209                    iceberg_scan_type: iceberg_scan_type__.unwrap_or_default(),
3210                })
3211            }
3212        }
3213        deserializer.deserialize_struct("batch_plan.IcebergScanNode", FIELDS, GeneratedVisitor)
3214    }
3215}
3216impl serde::Serialize for iceberg_scan_node::IcebergScanType {
3217    #[allow(deprecated)]
3218    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3219    where
3220        S: serde::Serializer,
3221    {
3222        let variant = match self {
3223            Self::Unspecified => "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3224            Self::DataScan => "ICEBERG_SCAN_TYPE_DATA_SCAN",
3225            Self::EqualityDeleteScan => "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3226            Self::PositionDeleteScan => "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3227            Self::CountStar => "ICEBERG_SCAN_TYPE_COUNT_STAR",
3228        };
3229        serializer.serialize_str(variant)
3230    }
3231}
3232impl<'de> serde::Deserialize<'de> for iceberg_scan_node::IcebergScanType {
3233    #[allow(deprecated)]
3234    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3235    where
3236        D: serde::Deserializer<'de>,
3237    {
3238        const FIELDS: &[&str] = &[
3239            "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3240            "ICEBERG_SCAN_TYPE_DATA_SCAN",
3241            "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3242            "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3243            "ICEBERG_SCAN_TYPE_COUNT_STAR",
3244        ];
3245
3246        struct GeneratedVisitor;
3247
3248        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3249            type Value = iceberg_scan_node::IcebergScanType;
3250
3251            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3252                write!(formatter, "expected one of: {:?}", &FIELDS)
3253            }
3254
3255            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3256            where
3257                E: serde::de::Error,
3258            {
3259                i32::try_from(v)
3260                    .ok()
3261                    .and_then(|x| x.try_into().ok())
3262                    .ok_or_else(|| {
3263                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3264                    })
3265            }
3266
3267            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3268            where
3269                E: serde::de::Error,
3270            {
3271                i32::try_from(v)
3272                    .ok()
3273                    .and_then(|x| x.try_into().ok())
3274                    .ok_or_else(|| {
3275                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3276                    })
3277            }
3278
3279            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3280            where
3281                E: serde::de::Error,
3282            {
3283                match value {
3284                    "ICEBERG_SCAN_TYPE_UNSPECIFIED" => Ok(iceberg_scan_node::IcebergScanType::Unspecified),
3285                    "ICEBERG_SCAN_TYPE_DATA_SCAN" => Ok(iceberg_scan_node::IcebergScanType::DataScan),
3286                    "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::EqualityDeleteScan),
3287                    "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::PositionDeleteScan),
3288                    "ICEBERG_SCAN_TYPE_COUNT_STAR" => Ok(iceberg_scan_node::IcebergScanType::CountStar),
3289                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3290                }
3291            }
3292        }
3293        deserializer.deserialize_any(GeneratedVisitor)
3294    }
3295}
3296impl serde::Serialize for InsertNode {
3297    #[allow(deprecated)]
3298    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3299    where
3300        S: serde::Serializer,
3301    {
3302        use serde::ser::SerializeStruct;
3303        let mut len = 0;
3304        if self.table_id != 0 {
3305            len += 1;
3306        }
3307        if self.table_version_id != 0 {
3308            len += 1;
3309        }
3310        if !self.column_indices.is_empty() {
3311            len += 1;
3312        }
3313        if self.default_columns.is_some() {
3314            len += 1;
3315        }
3316        if self.row_id_index.is_some() {
3317            len += 1;
3318        }
3319        if self.returning {
3320            len += 1;
3321        }
3322        if self.session_id != 0 {
3323            len += 1;
3324        }
3325        let mut struct_ser = serializer.serialize_struct("batch_plan.InsertNode", len)?;
3326        if self.table_id != 0 {
3327            struct_ser.serialize_field("tableId", &self.table_id)?;
3328        }
3329        if self.table_version_id != 0 {
3330            #[allow(clippy::needless_borrow)]
3331            #[allow(clippy::needless_borrows_for_generic_args)]
3332            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3333        }
3334        if !self.column_indices.is_empty() {
3335            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
3336        }
3337        if let Some(v) = self.default_columns.as_ref() {
3338            struct_ser.serialize_field("defaultColumns", v)?;
3339        }
3340        if let Some(v) = self.row_id_index.as_ref() {
3341            struct_ser.serialize_field("rowIdIndex", v)?;
3342        }
3343        if self.returning {
3344            struct_ser.serialize_field("returning", &self.returning)?;
3345        }
3346        if self.session_id != 0 {
3347            struct_ser.serialize_field("sessionId", &self.session_id)?;
3348        }
3349        struct_ser.end()
3350    }
3351}
3352impl<'de> serde::Deserialize<'de> for InsertNode {
3353    #[allow(deprecated)]
3354    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3355    where
3356        D: serde::Deserializer<'de>,
3357    {
3358        const FIELDS: &[&str] = &[
3359            "table_id",
3360            "tableId",
3361            "table_version_id",
3362            "tableVersionId",
3363            "column_indices",
3364            "columnIndices",
3365            "default_columns",
3366            "defaultColumns",
3367            "row_id_index",
3368            "rowIdIndex",
3369            "returning",
3370            "session_id",
3371            "sessionId",
3372        ];
3373
3374        #[allow(clippy::enum_variant_names)]
3375        enum GeneratedField {
3376            TableId,
3377            TableVersionId,
3378            ColumnIndices,
3379            DefaultColumns,
3380            RowIdIndex,
3381            Returning,
3382            SessionId,
3383        }
3384        impl<'de> serde::Deserialize<'de> for GeneratedField {
3385            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3386            where
3387                D: serde::Deserializer<'de>,
3388            {
3389                struct GeneratedVisitor;
3390
3391                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3392                    type Value = GeneratedField;
3393
3394                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3395                        write!(formatter, "expected one of: {:?}", &FIELDS)
3396                    }
3397
3398                    #[allow(unused_variables)]
3399                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3400                    where
3401                        E: serde::de::Error,
3402                    {
3403                        match value {
3404                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
3405                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3406                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
3407                            "defaultColumns" | "default_columns" => Ok(GeneratedField::DefaultColumns),
3408                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
3409                            "returning" => Ok(GeneratedField::Returning),
3410                            "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
3411                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3412                        }
3413                    }
3414                }
3415                deserializer.deserialize_identifier(GeneratedVisitor)
3416            }
3417        }
3418        struct GeneratedVisitor;
3419        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3420            type Value = InsertNode;
3421
3422            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3423                formatter.write_str("struct batch_plan.InsertNode")
3424            }
3425
3426            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InsertNode, V::Error>
3427                where
3428                    V: serde::de::MapAccess<'de>,
3429            {
3430                let mut table_id__ = None;
3431                let mut table_version_id__ = None;
3432                let mut column_indices__ = None;
3433                let mut default_columns__ = None;
3434                let mut row_id_index__ = None;
3435                let mut returning__ = None;
3436                let mut session_id__ = None;
3437                while let Some(k) = map_.next_key()? {
3438                    match k {
3439                        GeneratedField::TableId => {
3440                            if table_id__.is_some() {
3441                                return Err(serde::de::Error::duplicate_field("tableId"));
3442                            }
3443                            table_id__ = 
3444                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3445                            ;
3446                        }
3447                        GeneratedField::TableVersionId => {
3448                            if table_version_id__.is_some() {
3449                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
3450                            }
3451                            table_version_id__ = 
3452                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3453                            ;
3454                        }
3455                        GeneratedField::ColumnIndices => {
3456                            if column_indices__.is_some() {
3457                                return Err(serde::de::Error::duplicate_field("columnIndices"));
3458                            }
3459                            column_indices__ = 
3460                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3461                                    .into_iter().map(|x| x.0).collect())
3462                            ;
3463                        }
3464                        GeneratedField::DefaultColumns => {
3465                            if default_columns__.is_some() {
3466                                return Err(serde::de::Error::duplicate_field("defaultColumns"));
3467                            }
3468                            default_columns__ = map_.next_value()?;
3469                        }
3470                        GeneratedField::RowIdIndex => {
3471                            if row_id_index__.is_some() {
3472                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
3473                            }
3474                            row_id_index__ = 
3475                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3476                            ;
3477                        }
3478                        GeneratedField::Returning => {
3479                            if returning__.is_some() {
3480                                return Err(serde::de::Error::duplicate_field("returning"));
3481                            }
3482                            returning__ = Some(map_.next_value()?);
3483                        }
3484                        GeneratedField::SessionId => {
3485                            if session_id__.is_some() {
3486                                return Err(serde::de::Error::duplicate_field("sessionId"));
3487                            }
3488                            session_id__ = 
3489                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3490                            ;
3491                        }
3492                    }
3493                }
3494                Ok(InsertNode {
3495                    table_id: table_id__.unwrap_or_default(),
3496                    table_version_id: table_version_id__.unwrap_or_default(),
3497                    column_indices: column_indices__.unwrap_or_default(),
3498                    default_columns: default_columns__,
3499                    row_id_index: row_id_index__,
3500                    returning: returning__.unwrap_or_default(),
3501                    session_id: session_id__.unwrap_or_default(),
3502                })
3503            }
3504        }
3505        deserializer.deserialize_struct("batch_plan.InsertNode", FIELDS, GeneratedVisitor)
3506    }
3507}
3508impl serde::Serialize for LimitNode {
3509    #[allow(deprecated)]
3510    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3511    where
3512        S: serde::Serializer,
3513    {
3514        use serde::ser::SerializeStruct;
3515        let mut len = 0;
3516        if self.limit != 0 {
3517            len += 1;
3518        }
3519        if self.offset != 0 {
3520            len += 1;
3521        }
3522        let mut struct_ser = serializer.serialize_struct("batch_plan.LimitNode", len)?;
3523        if self.limit != 0 {
3524            #[allow(clippy::needless_borrow)]
3525            #[allow(clippy::needless_borrows_for_generic_args)]
3526            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
3527        }
3528        if self.offset != 0 {
3529            #[allow(clippy::needless_borrow)]
3530            #[allow(clippy::needless_borrows_for_generic_args)]
3531            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
3532        }
3533        struct_ser.end()
3534    }
3535}
3536impl<'de> serde::Deserialize<'de> for LimitNode {
3537    #[allow(deprecated)]
3538    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3539    where
3540        D: serde::Deserializer<'de>,
3541    {
3542        const FIELDS: &[&str] = &[
3543            "limit",
3544            "offset",
3545        ];
3546
3547        #[allow(clippy::enum_variant_names)]
3548        enum GeneratedField {
3549            Limit,
3550            Offset,
3551        }
3552        impl<'de> serde::Deserialize<'de> for GeneratedField {
3553            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3554            where
3555                D: serde::Deserializer<'de>,
3556            {
3557                struct GeneratedVisitor;
3558
3559                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3560                    type Value = GeneratedField;
3561
3562                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3563                        write!(formatter, "expected one of: {:?}", &FIELDS)
3564                    }
3565
3566                    #[allow(unused_variables)]
3567                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3568                    where
3569                        E: serde::de::Error,
3570                    {
3571                        match value {
3572                            "limit" => Ok(GeneratedField::Limit),
3573                            "offset" => Ok(GeneratedField::Offset),
3574                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3575                        }
3576                    }
3577                }
3578                deserializer.deserialize_identifier(GeneratedVisitor)
3579            }
3580        }
3581        struct GeneratedVisitor;
3582        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3583            type Value = LimitNode;
3584
3585            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3586                formatter.write_str("struct batch_plan.LimitNode")
3587            }
3588
3589            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LimitNode, V::Error>
3590                where
3591                    V: serde::de::MapAccess<'de>,
3592            {
3593                let mut limit__ = None;
3594                let mut offset__ = None;
3595                while let Some(k) = map_.next_key()? {
3596                    match k {
3597                        GeneratedField::Limit => {
3598                            if limit__.is_some() {
3599                                return Err(serde::de::Error::duplicate_field("limit"));
3600                            }
3601                            limit__ = 
3602                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3603                            ;
3604                        }
3605                        GeneratedField::Offset => {
3606                            if offset__.is_some() {
3607                                return Err(serde::de::Error::duplicate_field("offset"));
3608                            }
3609                            offset__ = 
3610                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3611                            ;
3612                        }
3613                    }
3614                }
3615                Ok(LimitNode {
3616                    limit: limit__.unwrap_or_default(),
3617                    offset: offset__.unwrap_or_default(),
3618                })
3619            }
3620        }
3621        deserializer.deserialize_struct("batch_plan.LimitNode", FIELDS, GeneratedVisitor)
3622    }
3623}
3624impl serde::Serialize for LocalExecutePlan {
3625    #[allow(deprecated)]
3626    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3627    where
3628        S: serde::Serializer,
3629    {
3630        use serde::ser::SerializeStruct;
3631        let mut len = 0;
3632        if self.plan.is_some() {
3633            len += 1;
3634        }
3635        if self.epoch.is_some() {
3636            len += 1;
3637        }
3638        if !self.tracing_context.is_empty() {
3639            len += 1;
3640        }
3641        let mut struct_ser = serializer.serialize_struct("batch_plan.LocalExecutePlan", len)?;
3642        if let Some(v) = self.plan.as_ref() {
3643            struct_ser.serialize_field("plan", v)?;
3644        }
3645        if let Some(v) = self.epoch.as_ref() {
3646            struct_ser.serialize_field("epoch", v)?;
3647        }
3648        if !self.tracing_context.is_empty() {
3649            struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
3650        }
3651        struct_ser.end()
3652    }
3653}
3654impl<'de> serde::Deserialize<'de> for LocalExecutePlan {
3655    #[allow(deprecated)]
3656    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3657    where
3658        D: serde::Deserializer<'de>,
3659    {
3660        const FIELDS: &[&str] = &[
3661            "plan",
3662            "epoch",
3663            "tracing_context",
3664            "tracingContext",
3665        ];
3666
3667        #[allow(clippy::enum_variant_names)]
3668        enum GeneratedField {
3669            Plan,
3670            Epoch,
3671            TracingContext,
3672        }
3673        impl<'de> serde::Deserialize<'de> for GeneratedField {
3674            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3675            where
3676                D: serde::Deserializer<'de>,
3677            {
3678                struct GeneratedVisitor;
3679
3680                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3681                    type Value = GeneratedField;
3682
3683                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3684                        write!(formatter, "expected one of: {:?}", &FIELDS)
3685                    }
3686
3687                    #[allow(unused_variables)]
3688                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3689                    where
3690                        E: serde::de::Error,
3691                    {
3692                        match value {
3693                            "plan" => Ok(GeneratedField::Plan),
3694                            "epoch" => Ok(GeneratedField::Epoch),
3695                            "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
3696                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3697                        }
3698                    }
3699                }
3700                deserializer.deserialize_identifier(GeneratedVisitor)
3701            }
3702        }
3703        struct GeneratedVisitor;
3704        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3705            type Value = LocalExecutePlan;
3706
3707            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3708                formatter.write_str("struct batch_plan.LocalExecutePlan")
3709            }
3710
3711            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalExecutePlan, V::Error>
3712                where
3713                    V: serde::de::MapAccess<'de>,
3714            {
3715                let mut plan__ = None;
3716                let mut epoch__ = None;
3717                let mut tracing_context__ = None;
3718                while let Some(k) = map_.next_key()? {
3719                    match k {
3720                        GeneratedField::Plan => {
3721                            if plan__.is_some() {
3722                                return Err(serde::de::Error::duplicate_field("plan"));
3723                            }
3724                            plan__ = map_.next_value()?;
3725                        }
3726                        GeneratedField::Epoch => {
3727                            if epoch__.is_some() {
3728                                return Err(serde::de::Error::duplicate_field("epoch"));
3729                            }
3730                            epoch__ = map_.next_value()?;
3731                        }
3732                        GeneratedField::TracingContext => {
3733                            if tracing_context__.is_some() {
3734                                return Err(serde::de::Error::duplicate_field("tracingContext"));
3735                            }
3736                            tracing_context__ = Some(
3737                                map_.next_value::<std::collections::HashMap<_, _>>()?
3738                            );
3739                        }
3740                    }
3741                }
3742                Ok(LocalExecutePlan {
3743                    plan: plan__,
3744                    epoch: epoch__,
3745                    tracing_context: tracing_context__.unwrap_or_default(),
3746                })
3747            }
3748        }
3749        deserializer.deserialize_struct("batch_plan.LocalExecutePlan", FIELDS, GeneratedVisitor)
3750    }
3751}
3752impl serde::Serialize for LocalLookupJoinNode {
3753    #[allow(deprecated)]
3754    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3755    where
3756        S: serde::Serializer,
3757    {
3758        use serde::ser::SerializeStruct;
3759        let mut len = 0;
3760        if self.join_type != 0 {
3761            len += 1;
3762        }
3763        if self.condition.is_some() {
3764            len += 1;
3765        }
3766        if !self.outer_side_key.is_empty() {
3767            len += 1;
3768        }
3769        if !self.inner_side_key.is_empty() {
3770            len += 1;
3771        }
3772        if self.lookup_prefix_len != 0 {
3773            len += 1;
3774        }
3775        if self.inner_side_table_desc.is_some() {
3776            len += 1;
3777        }
3778        if !self.inner_side_vnode_mapping.is_empty() {
3779            len += 1;
3780        }
3781        if !self.inner_side_column_ids.is_empty() {
3782            len += 1;
3783        }
3784        if !self.output_indices.is_empty() {
3785            len += 1;
3786        }
3787        if !self.worker_nodes.is_empty() {
3788            len += 1;
3789        }
3790        if !self.null_safe.is_empty() {
3791            len += 1;
3792        }
3793        if self.as_of.is_some() {
3794            len += 1;
3795        }
3796        if self.asof_desc.is_some() {
3797            len += 1;
3798        }
3799        let mut struct_ser = serializer.serialize_struct("batch_plan.LocalLookupJoinNode", len)?;
3800        if self.join_type != 0 {
3801            let v = super::plan_common::JoinType::try_from(self.join_type)
3802                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3803            struct_ser.serialize_field("joinType", &v)?;
3804        }
3805        if let Some(v) = self.condition.as_ref() {
3806            struct_ser.serialize_field("condition", v)?;
3807        }
3808        if !self.outer_side_key.is_empty() {
3809            struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
3810        }
3811        if !self.inner_side_key.is_empty() {
3812            struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
3813        }
3814        if self.lookup_prefix_len != 0 {
3815            struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
3816        }
3817        if let Some(v) = self.inner_side_table_desc.as_ref() {
3818            struct_ser.serialize_field("innerSideTableDesc", v)?;
3819        }
3820        if !self.inner_side_vnode_mapping.is_empty() {
3821            struct_ser.serialize_field("innerSideVnodeMapping", &self.inner_side_vnode_mapping.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3822        }
3823        if !self.inner_side_column_ids.is_empty() {
3824            struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
3825        }
3826        if !self.output_indices.is_empty() {
3827            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3828        }
3829        if !self.worker_nodes.is_empty() {
3830            struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
3831        }
3832        if !self.null_safe.is_empty() {
3833            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
3834        }
3835        if let Some(v) = self.as_of.as_ref() {
3836            struct_ser.serialize_field("asOf", v)?;
3837        }
3838        if let Some(v) = self.asof_desc.as_ref() {
3839            struct_ser.serialize_field("asofDesc", v)?;
3840        }
3841        struct_ser.end()
3842    }
3843}
3844impl<'de> serde::Deserialize<'de> for LocalLookupJoinNode {
3845    #[allow(deprecated)]
3846    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3847    where
3848        D: serde::Deserializer<'de>,
3849    {
3850        const FIELDS: &[&str] = &[
3851            "join_type",
3852            "joinType",
3853            "condition",
3854            "outer_side_key",
3855            "outerSideKey",
3856            "inner_side_key",
3857            "innerSideKey",
3858            "lookup_prefix_len",
3859            "lookupPrefixLen",
3860            "inner_side_table_desc",
3861            "innerSideTableDesc",
3862            "inner_side_vnode_mapping",
3863            "innerSideVnodeMapping",
3864            "inner_side_column_ids",
3865            "innerSideColumnIds",
3866            "output_indices",
3867            "outputIndices",
3868            "worker_nodes",
3869            "workerNodes",
3870            "null_safe",
3871            "nullSafe",
3872            "as_of",
3873            "asOf",
3874            "asof_desc",
3875            "asofDesc",
3876        ];
3877
3878        #[allow(clippy::enum_variant_names)]
3879        enum GeneratedField {
3880            JoinType,
3881            Condition,
3882            OuterSideKey,
3883            InnerSideKey,
3884            LookupPrefixLen,
3885            InnerSideTableDesc,
3886            InnerSideVnodeMapping,
3887            InnerSideColumnIds,
3888            OutputIndices,
3889            WorkerNodes,
3890            NullSafe,
3891            AsOf,
3892            AsofDesc,
3893        }
3894        impl<'de> serde::Deserialize<'de> for GeneratedField {
3895            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3896            where
3897                D: serde::Deserializer<'de>,
3898            {
3899                struct GeneratedVisitor;
3900
3901                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3902                    type Value = GeneratedField;
3903
3904                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3905                        write!(formatter, "expected one of: {:?}", &FIELDS)
3906                    }
3907
3908                    #[allow(unused_variables)]
3909                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3910                    where
3911                        E: serde::de::Error,
3912                    {
3913                        match value {
3914                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3915                            "condition" => Ok(GeneratedField::Condition),
3916                            "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
3917                            "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
3918                            "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
3919                            "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
3920                            "innerSideVnodeMapping" | "inner_side_vnode_mapping" => Ok(GeneratedField::InnerSideVnodeMapping),
3921                            "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
3922                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3923                            "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
3924                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
3925                            "asOf" | "as_of" => Ok(GeneratedField::AsOf),
3926                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
3927                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3928                        }
3929                    }
3930                }
3931                deserializer.deserialize_identifier(GeneratedVisitor)
3932            }
3933        }
3934        struct GeneratedVisitor;
3935        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3936            type Value = LocalLookupJoinNode;
3937
3938            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3939                formatter.write_str("struct batch_plan.LocalLookupJoinNode")
3940            }
3941
3942            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalLookupJoinNode, V::Error>
3943                where
3944                    V: serde::de::MapAccess<'de>,
3945            {
3946                let mut join_type__ = None;
3947                let mut condition__ = None;
3948                let mut outer_side_key__ = None;
3949                let mut inner_side_key__ = None;
3950                let mut lookup_prefix_len__ = None;
3951                let mut inner_side_table_desc__ = None;
3952                let mut inner_side_vnode_mapping__ = None;
3953                let mut inner_side_column_ids__ = None;
3954                let mut output_indices__ = None;
3955                let mut worker_nodes__ = None;
3956                let mut null_safe__ = None;
3957                let mut as_of__ = None;
3958                let mut asof_desc__ = None;
3959                while let Some(k) = map_.next_key()? {
3960                    match k {
3961                        GeneratedField::JoinType => {
3962                            if join_type__.is_some() {
3963                                return Err(serde::de::Error::duplicate_field("joinType"));
3964                            }
3965                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3966                        }
3967                        GeneratedField::Condition => {
3968                            if condition__.is_some() {
3969                                return Err(serde::de::Error::duplicate_field("condition"));
3970                            }
3971                            condition__ = map_.next_value()?;
3972                        }
3973                        GeneratedField::OuterSideKey => {
3974                            if outer_side_key__.is_some() {
3975                                return Err(serde::de::Error::duplicate_field("outerSideKey"));
3976                            }
3977                            outer_side_key__ = 
3978                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3979                                    .into_iter().map(|x| x.0).collect())
3980                            ;
3981                        }
3982                        GeneratedField::InnerSideKey => {
3983                            if inner_side_key__.is_some() {
3984                                return Err(serde::de::Error::duplicate_field("innerSideKey"));
3985                            }
3986                            inner_side_key__ = 
3987                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3988                                    .into_iter().map(|x| x.0).collect())
3989                            ;
3990                        }
3991                        GeneratedField::LookupPrefixLen => {
3992                            if lookup_prefix_len__.is_some() {
3993                                return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
3994                            }
3995                            lookup_prefix_len__ = 
3996                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3997                            ;
3998                        }
3999                        GeneratedField::InnerSideTableDesc => {
4000                            if inner_side_table_desc__.is_some() {
4001                                return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
4002                            }
4003                            inner_side_table_desc__ = map_.next_value()?;
4004                        }
4005                        GeneratedField::InnerSideVnodeMapping => {
4006                            if inner_side_vnode_mapping__.is_some() {
4007                                return Err(serde::de::Error::duplicate_field("innerSideVnodeMapping"));
4008                            }
4009                            inner_side_vnode_mapping__ = 
4010                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4011                                    .into_iter().map(|x| x.0).collect())
4012                            ;
4013                        }
4014                        GeneratedField::InnerSideColumnIds => {
4015                            if inner_side_column_ids__.is_some() {
4016                                return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
4017                            }
4018                            inner_side_column_ids__ = 
4019                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4020                                    .into_iter().map(|x| x.0).collect())
4021                            ;
4022                        }
4023                        GeneratedField::OutputIndices => {
4024                            if output_indices__.is_some() {
4025                                return Err(serde::de::Error::duplicate_field("outputIndices"));
4026                            }
4027                            output_indices__ = 
4028                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4029                                    .into_iter().map(|x| x.0).collect())
4030                            ;
4031                        }
4032                        GeneratedField::WorkerNodes => {
4033                            if worker_nodes__.is_some() {
4034                                return Err(serde::de::Error::duplicate_field("workerNodes"));
4035                            }
4036                            worker_nodes__ = Some(map_.next_value()?);
4037                        }
4038                        GeneratedField::NullSafe => {
4039                            if null_safe__.is_some() {
4040                                return Err(serde::de::Error::duplicate_field("nullSafe"));
4041                            }
4042                            null_safe__ = Some(map_.next_value()?);
4043                        }
4044                        GeneratedField::AsOf => {
4045                            if as_of__.is_some() {
4046                                return Err(serde::de::Error::duplicate_field("asOf"));
4047                            }
4048                            as_of__ = map_.next_value()?;
4049                        }
4050                        GeneratedField::AsofDesc => {
4051                            if asof_desc__.is_some() {
4052                                return Err(serde::de::Error::duplicate_field("asofDesc"));
4053                            }
4054                            asof_desc__ = map_.next_value()?;
4055                        }
4056                    }
4057                }
4058                Ok(LocalLookupJoinNode {
4059                    join_type: join_type__.unwrap_or_default(),
4060                    condition: condition__,
4061                    outer_side_key: outer_side_key__.unwrap_or_default(),
4062                    inner_side_key: inner_side_key__.unwrap_or_default(),
4063                    lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
4064                    inner_side_table_desc: inner_side_table_desc__,
4065                    inner_side_vnode_mapping: inner_side_vnode_mapping__.unwrap_or_default(),
4066                    inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
4067                    output_indices: output_indices__.unwrap_or_default(),
4068                    worker_nodes: worker_nodes__.unwrap_or_default(),
4069                    null_safe: null_safe__.unwrap_or_default(),
4070                    as_of: as_of__,
4071                    asof_desc: asof_desc__,
4072                })
4073            }
4074        }
4075        deserializer.deserialize_struct("batch_plan.LocalLookupJoinNode", FIELDS, GeneratedVisitor)
4076    }
4077}
4078impl serde::Serialize for LogRowSeqScanNode {
4079    #[allow(deprecated)]
4080    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4081    where
4082        S: serde::Serializer,
4083    {
4084        use serde::ser::SerializeStruct;
4085        let mut len = 0;
4086        if self.table_desc.is_some() {
4087            len += 1;
4088        }
4089        if !self.column_ids.is_empty() {
4090            len += 1;
4091        }
4092        if self.vnode_bitmap.is_some() {
4093            len += 1;
4094        }
4095        if self.old_epoch.is_some() {
4096            len += 1;
4097        }
4098        if self.new_epoch.is_some() {
4099            len += 1;
4100        }
4101        if self.ordered {
4102            len += 1;
4103        }
4104        if self.scan_range.is_some() {
4105            len += 1;
4106        }
4107        let mut struct_ser = serializer.serialize_struct("batch_plan.LogRowSeqScanNode", len)?;
4108        if let Some(v) = self.table_desc.as_ref() {
4109            struct_ser.serialize_field("tableDesc", v)?;
4110        }
4111        if !self.column_ids.is_empty() {
4112            struct_ser.serialize_field("columnIds", &self.column_ids)?;
4113        }
4114        if let Some(v) = self.vnode_bitmap.as_ref() {
4115            struct_ser.serialize_field("vnodeBitmap", v)?;
4116        }
4117        if let Some(v) = self.old_epoch.as_ref() {
4118            struct_ser.serialize_field("oldEpoch", v)?;
4119        }
4120        if let Some(v) = self.new_epoch.as_ref() {
4121            struct_ser.serialize_field("newEpoch", v)?;
4122        }
4123        if self.ordered {
4124            struct_ser.serialize_field("ordered", &self.ordered)?;
4125        }
4126        if let Some(v) = self.scan_range.as_ref() {
4127            struct_ser.serialize_field("scanRange", v)?;
4128        }
4129        struct_ser.end()
4130    }
4131}
4132impl<'de> serde::Deserialize<'de> for LogRowSeqScanNode {
4133    #[allow(deprecated)]
4134    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4135    where
4136        D: serde::Deserializer<'de>,
4137    {
4138        const FIELDS: &[&str] = &[
4139            "table_desc",
4140            "tableDesc",
4141            "column_ids",
4142            "columnIds",
4143            "vnode_bitmap",
4144            "vnodeBitmap",
4145            "old_epoch",
4146            "oldEpoch",
4147            "new_epoch",
4148            "newEpoch",
4149            "ordered",
4150            "scan_range",
4151            "scanRange",
4152        ];
4153
4154        #[allow(clippy::enum_variant_names)]
4155        enum GeneratedField {
4156            TableDesc,
4157            ColumnIds,
4158            VnodeBitmap,
4159            OldEpoch,
4160            NewEpoch,
4161            Ordered,
4162            ScanRange,
4163        }
4164        impl<'de> serde::Deserialize<'de> for GeneratedField {
4165            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4166            where
4167                D: serde::Deserializer<'de>,
4168            {
4169                struct GeneratedVisitor;
4170
4171                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4172                    type Value = GeneratedField;
4173
4174                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4175                        write!(formatter, "expected one of: {:?}", &FIELDS)
4176                    }
4177
4178                    #[allow(unused_variables)]
4179                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4180                    where
4181                        E: serde::de::Error,
4182                    {
4183                        match value {
4184                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
4185                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
4186                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
4187                            "oldEpoch" | "old_epoch" => Ok(GeneratedField::OldEpoch),
4188                            "newEpoch" | "new_epoch" => Ok(GeneratedField::NewEpoch),
4189                            "ordered" => Ok(GeneratedField::Ordered),
4190                            "scanRange" | "scan_range" => Ok(GeneratedField::ScanRange),
4191                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4192                        }
4193                    }
4194                }
4195                deserializer.deserialize_identifier(GeneratedVisitor)
4196            }
4197        }
4198        struct GeneratedVisitor;
4199        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4200            type Value = LogRowSeqScanNode;
4201
4202            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4203                formatter.write_str("struct batch_plan.LogRowSeqScanNode")
4204            }
4205
4206            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LogRowSeqScanNode, V::Error>
4207                where
4208                    V: serde::de::MapAccess<'de>,
4209            {
4210                let mut table_desc__ = None;
4211                let mut column_ids__ = None;
4212                let mut vnode_bitmap__ = None;
4213                let mut old_epoch__ = None;
4214                let mut new_epoch__ = None;
4215                let mut ordered__ = None;
4216                let mut scan_range__ = None;
4217                while let Some(k) = map_.next_key()? {
4218                    match k {
4219                        GeneratedField::TableDesc => {
4220                            if table_desc__.is_some() {
4221                                return Err(serde::de::Error::duplicate_field("tableDesc"));
4222                            }
4223                            table_desc__ = map_.next_value()?;
4224                        }
4225                        GeneratedField::ColumnIds => {
4226                            if column_ids__.is_some() {
4227                                return Err(serde::de::Error::duplicate_field("columnIds"));
4228                            }
4229                            column_ids__ = 
4230                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4231                                    .into_iter().map(|x| x.0).collect())
4232                            ;
4233                        }
4234                        GeneratedField::VnodeBitmap => {
4235                            if vnode_bitmap__.is_some() {
4236                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
4237                            }
4238                            vnode_bitmap__ = map_.next_value()?;
4239                        }
4240                        GeneratedField::OldEpoch => {
4241                            if old_epoch__.is_some() {
4242                                return Err(serde::de::Error::duplicate_field("oldEpoch"));
4243                            }
4244                            old_epoch__ = map_.next_value()?;
4245                        }
4246                        GeneratedField::NewEpoch => {
4247                            if new_epoch__.is_some() {
4248                                return Err(serde::de::Error::duplicate_field("newEpoch"));
4249                            }
4250                            new_epoch__ = map_.next_value()?;
4251                        }
4252                        GeneratedField::Ordered => {
4253                            if ordered__.is_some() {
4254                                return Err(serde::de::Error::duplicate_field("ordered"));
4255                            }
4256                            ordered__ = Some(map_.next_value()?);
4257                        }
4258                        GeneratedField::ScanRange => {
4259                            if scan_range__.is_some() {
4260                                return Err(serde::de::Error::duplicate_field("scanRange"));
4261                            }
4262                            scan_range__ = map_.next_value()?;
4263                        }
4264                    }
4265                }
4266                Ok(LogRowSeqScanNode {
4267                    table_desc: table_desc__,
4268                    column_ids: column_ids__.unwrap_or_default(),
4269                    vnode_bitmap: vnode_bitmap__,
4270                    old_epoch: old_epoch__,
4271                    new_epoch: new_epoch__,
4272                    ordered: ordered__.unwrap_or_default(),
4273                    scan_range: scan_range__,
4274                })
4275            }
4276        }
4277        deserializer.deserialize_struct("batch_plan.LogRowSeqScanNode", FIELDS, GeneratedVisitor)
4278    }
4279}
4280impl serde::Serialize for MaxOneRowNode {
4281    #[allow(deprecated)]
4282    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4283    where
4284        S: serde::Serializer,
4285    {
4286        use serde::ser::SerializeStruct;
4287        let len = 0;
4288        let struct_ser = serializer.serialize_struct("batch_plan.MaxOneRowNode", len)?;
4289        struct_ser.end()
4290    }
4291}
4292impl<'de> serde::Deserialize<'de> for MaxOneRowNode {
4293    #[allow(deprecated)]
4294    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4295    where
4296        D: serde::Deserializer<'de>,
4297    {
4298        const FIELDS: &[&str] = &[
4299        ];
4300
4301        #[allow(clippy::enum_variant_names)]
4302        enum GeneratedField {
4303        }
4304        impl<'de> serde::Deserialize<'de> for GeneratedField {
4305            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4306            where
4307                D: serde::Deserializer<'de>,
4308            {
4309                struct GeneratedVisitor;
4310
4311                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4312                    type Value = GeneratedField;
4313
4314                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4315                        write!(formatter, "expected one of: {:?}", &FIELDS)
4316                    }
4317
4318                    #[allow(unused_variables)]
4319                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4320                    where
4321                        E: serde::de::Error,
4322                    {
4323                            Err(serde::de::Error::unknown_field(value, FIELDS))
4324                    }
4325                }
4326                deserializer.deserialize_identifier(GeneratedVisitor)
4327            }
4328        }
4329        struct GeneratedVisitor;
4330        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4331            type Value = MaxOneRowNode;
4332
4333            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4334                formatter.write_str("struct batch_plan.MaxOneRowNode")
4335            }
4336
4337            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaxOneRowNode, V::Error>
4338                where
4339                    V: serde::de::MapAccess<'de>,
4340            {
4341                while map_.next_key::<GeneratedField>()?.is_some() {
4342                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4343                }
4344                Ok(MaxOneRowNode {
4345                })
4346            }
4347        }
4348        deserializer.deserialize_struct("batch_plan.MaxOneRowNode", FIELDS, GeneratedVisitor)
4349    }
4350}
4351impl serde::Serialize for MergeSortExchangeNode {
4352    #[allow(deprecated)]
4353    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4354    where
4355        S: serde::Serializer,
4356    {
4357        use serde::ser::SerializeStruct;
4358        let mut len = 0;
4359        if self.exchange.is_some() {
4360            len += 1;
4361        }
4362        if !self.column_orders.is_empty() {
4363            len += 1;
4364        }
4365        let mut struct_ser = serializer.serialize_struct("batch_plan.MergeSortExchangeNode", len)?;
4366        if let Some(v) = self.exchange.as_ref() {
4367            struct_ser.serialize_field("exchange", v)?;
4368        }
4369        if !self.column_orders.is_empty() {
4370            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
4371        }
4372        struct_ser.end()
4373    }
4374}
4375impl<'de> serde::Deserialize<'de> for MergeSortExchangeNode {
4376    #[allow(deprecated)]
4377    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4378    where
4379        D: serde::Deserializer<'de>,
4380    {
4381        const FIELDS: &[&str] = &[
4382            "exchange",
4383            "column_orders",
4384            "columnOrders",
4385        ];
4386
4387        #[allow(clippy::enum_variant_names)]
4388        enum GeneratedField {
4389            Exchange,
4390            ColumnOrders,
4391        }
4392        impl<'de> serde::Deserialize<'de> for GeneratedField {
4393            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4394            where
4395                D: serde::Deserializer<'de>,
4396            {
4397                struct GeneratedVisitor;
4398
4399                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4400                    type Value = GeneratedField;
4401
4402                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4403                        write!(formatter, "expected one of: {:?}", &FIELDS)
4404                    }
4405
4406                    #[allow(unused_variables)]
4407                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4408                    where
4409                        E: serde::de::Error,
4410                    {
4411                        match value {
4412                            "exchange" => Ok(GeneratedField::Exchange),
4413                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
4414                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4415                        }
4416                    }
4417                }
4418                deserializer.deserialize_identifier(GeneratedVisitor)
4419            }
4420        }
4421        struct GeneratedVisitor;
4422        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4423            type Value = MergeSortExchangeNode;
4424
4425            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4426                formatter.write_str("struct batch_plan.MergeSortExchangeNode")
4427            }
4428
4429            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeSortExchangeNode, V::Error>
4430                where
4431                    V: serde::de::MapAccess<'de>,
4432            {
4433                let mut exchange__ = None;
4434                let mut column_orders__ = None;
4435                while let Some(k) = map_.next_key()? {
4436                    match k {
4437                        GeneratedField::Exchange => {
4438                            if exchange__.is_some() {
4439                                return Err(serde::de::Error::duplicate_field("exchange"));
4440                            }
4441                            exchange__ = map_.next_value()?;
4442                        }
4443                        GeneratedField::ColumnOrders => {
4444                            if column_orders__.is_some() {
4445                                return Err(serde::de::Error::duplicate_field("columnOrders"));
4446                            }
4447                            column_orders__ = Some(map_.next_value()?);
4448                        }
4449                    }
4450                }
4451                Ok(MergeSortExchangeNode {
4452                    exchange: exchange__,
4453                    column_orders: column_orders__.unwrap_or_default(),
4454                })
4455            }
4456        }
4457        deserializer.deserialize_struct("batch_plan.MergeSortExchangeNode", FIELDS, GeneratedVisitor)
4458    }
4459}
4460impl serde::Serialize for MySqlQueryNode {
4461    #[allow(deprecated)]
4462    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4463    where
4464        S: serde::Serializer,
4465    {
4466        use serde::ser::SerializeStruct;
4467        let mut len = 0;
4468        if !self.columns.is_empty() {
4469            len += 1;
4470        }
4471        if !self.hostname.is_empty() {
4472            len += 1;
4473        }
4474        if !self.port.is_empty() {
4475            len += 1;
4476        }
4477        if !self.username.is_empty() {
4478            len += 1;
4479        }
4480        if !self.password.is_empty() {
4481            len += 1;
4482        }
4483        if !self.database.is_empty() {
4484            len += 1;
4485        }
4486        if !self.query.is_empty() {
4487            len += 1;
4488        }
4489        let mut struct_ser = serializer.serialize_struct("batch_plan.MySqlQueryNode", len)?;
4490        if !self.columns.is_empty() {
4491            struct_ser.serialize_field("columns", &self.columns)?;
4492        }
4493        if !self.hostname.is_empty() {
4494            struct_ser.serialize_field("hostname", &self.hostname)?;
4495        }
4496        if !self.port.is_empty() {
4497            struct_ser.serialize_field("port", &self.port)?;
4498        }
4499        if !self.username.is_empty() {
4500            struct_ser.serialize_field("username", &self.username)?;
4501        }
4502        if !self.password.is_empty() {
4503            struct_ser.serialize_field("password", &self.password)?;
4504        }
4505        if !self.database.is_empty() {
4506            struct_ser.serialize_field("database", &self.database)?;
4507        }
4508        if !self.query.is_empty() {
4509            struct_ser.serialize_field("query", &self.query)?;
4510        }
4511        struct_ser.end()
4512    }
4513}
4514impl<'de> serde::Deserialize<'de> for MySqlQueryNode {
4515    #[allow(deprecated)]
4516    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4517    where
4518        D: serde::Deserializer<'de>,
4519    {
4520        const FIELDS: &[&str] = &[
4521            "columns",
4522            "hostname",
4523            "port",
4524            "username",
4525            "password",
4526            "database",
4527            "query",
4528        ];
4529
4530        #[allow(clippy::enum_variant_names)]
4531        enum GeneratedField {
4532            Columns,
4533            Hostname,
4534            Port,
4535            Username,
4536            Password,
4537            Database,
4538            Query,
4539        }
4540        impl<'de> serde::Deserialize<'de> for GeneratedField {
4541            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4542            where
4543                D: serde::Deserializer<'de>,
4544            {
4545                struct GeneratedVisitor;
4546
4547                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4548                    type Value = GeneratedField;
4549
4550                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4551                        write!(formatter, "expected one of: {:?}", &FIELDS)
4552                    }
4553
4554                    #[allow(unused_variables)]
4555                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4556                    where
4557                        E: serde::de::Error,
4558                    {
4559                        match value {
4560                            "columns" => Ok(GeneratedField::Columns),
4561                            "hostname" => Ok(GeneratedField::Hostname),
4562                            "port" => Ok(GeneratedField::Port),
4563                            "username" => Ok(GeneratedField::Username),
4564                            "password" => Ok(GeneratedField::Password),
4565                            "database" => Ok(GeneratedField::Database),
4566                            "query" => Ok(GeneratedField::Query),
4567                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4568                        }
4569                    }
4570                }
4571                deserializer.deserialize_identifier(GeneratedVisitor)
4572            }
4573        }
4574        struct GeneratedVisitor;
4575        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4576            type Value = MySqlQueryNode;
4577
4578            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4579                formatter.write_str("struct batch_plan.MySqlQueryNode")
4580            }
4581
4582            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MySqlQueryNode, V::Error>
4583                where
4584                    V: serde::de::MapAccess<'de>,
4585            {
4586                let mut columns__ = None;
4587                let mut hostname__ = None;
4588                let mut port__ = None;
4589                let mut username__ = None;
4590                let mut password__ = None;
4591                let mut database__ = None;
4592                let mut query__ = None;
4593                while let Some(k) = map_.next_key()? {
4594                    match k {
4595                        GeneratedField::Columns => {
4596                            if columns__.is_some() {
4597                                return Err(serde::de::Error::duplicate_field("columns"));
4598                            }
4599                            columns__ = Some(map_.next_value()?);
4600                        }
4601                        GeneratedField::Hostname => {
4602                            if hostname__.is_some() {
4603                                return Err(serde::de::Error::duplicate_field("hostname"));
4604                            }
4605                            hostname__ = Some(map_.next_value()?);
4606                        }
4607                        GeneratedField::Port => {
4608                            if port__.is_some() {
4609                                return Err(serde::de::Error::duplicate_field("port"));
4610                            }
4611                            port__ = Some(map_.next_value()?);
4612                        }
4613                        GeneratedField::Username => {
4614                            if username__.is_some() {
4615                                return Err(serde::de::Error::duplicate_field("username"));
4616                            }
4617                            username__ = Some(map_.next_value()?);
4618                        }
4619                        GeneratedField::Password => {
4620                            if password__.is_some() {
4621                                return Err(serde::de::Error::duplicate_field("password"));
4622                            }
4623                            password__ = Some(map_.next_value()?);
4624                        }
4625                        GeneratedField::Database => {
4626                            if database__.is_some() {
4627                                return Err(serde::de::Error::duplicate_field("database"));
4628                            }
4629                            database__ = Some(map_.next_value()?);
4630                        }
4631                        GeneratedField::Query => {
4632                            if query__.is_some() {
4633                                return Err(serde::de::Error::duplicate_field("query"));
4634                            }
4635                            query__ = Some(map_.next_value()?);
4636                        }
4637                    }
4638                }
4639                Ok(MySqlQueryNode {
4640                    columns: columns__.unwrap_or_default(),
4641                    hostname: hostname__.unwrap_or_default(),
4642                    port: port__.unwrap_or_default(),
4643                    username: username__.unwrap_or_default(),
4644                    password: password__.unwrap_or_default(),
4645                    database: database__.unwrap_or_default(),
4646                    query: query__.unwrap_or_default(),
4647                })
4648            }
4649        }
4650        deserializer.deserialize_struct("batch_plan.MySqlQueryNode", FIELDS, GeneratedVisitor)
4651    }
4652}
4653impl serde::Serialize for NestedLoopJoinNode {
4654    #[allow(deprecated)]
4655    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4656    where
4657        S: serde::Serializer,
4658    {
4659        use serde::ser::SerializeStruct;
4660        let mut len = 0;
4661        if self.join_type != 0 {
4662            len += 1;
4663        }
4664        if self.join_cond.is_some() {
4665            len += 1;
4666        }
4667        if !self.output_indices.is_empty() {
4668            len += 1;
4669        }
4670        let mut struct_ser = serializer.serialize_struct("batch_plan.NestedLoopJoinNode", len)?;
4671        if self.join_type != 0 {
4672            let v = super::plan_common::JoinType::try_from(self.join_type)
4673                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
4674            struct_ser.serialize_field("joinType", &v)?;
4675        }
4676        if let Some(v) = self.join_cond.as_ref() {
4677            struct_ser.serialize_field("joinCond", v)?;
4678        }
4679        if !self.output_indices.is_empty() {
4680            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
4681        }
4682        struct_ser.end()
4683    }
4684}
4685impl<'de> serde::Deserialize<'de> for NestedLoopJoinNode {
4686    #[allow(deprecated)]
4687    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4688    where
4689        D: serde::Deserializer<'de>,
4690    {
4691        const FIELDS: &[&str] = &[
4692            "join_type",
4693            "joinType",
4694            "join_cond",
4695            "joinCond",
4696            "output_indices",
4697            "outputIndices",
4698        ];
4699
4700        #[allow(clippy::enum_variant_names)]
4701        enum GeneratedField {
4702            JoinType,
4703            JoinCond,
4704            OutputIndices,
4705        }
4706        impl<'de> serde::Deserialize<'de> for GeneratedField {
4707            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4708            where
4709                D: serde::Deserializer<'de>,
4710            {
4711                struct GeneratedVisitor;
4712
4713                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4714                    type Value = GeneratedField;
4715
4716                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4717                        write!(formatter, "expected one of: {:?}", &FIELDS)
4718                    }
4719
4720                    #[allow(unused_variables)]
4721                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4722                    where
4723                        E: serde::de::Error,
4724                    {
4725                        match value {
4726                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4727                            "joinCond" | "join_cond" => Ok(GeneratedField::JoinCond),
4728                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4729                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4730                        }
4731                    }
4732                }
4733                deserializer.deserialize_identifier(GeneratedVisitor)
4734            }
4735        }
4736        struct GeneratedVisitor;
4737        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4738            type Value = NestedLoopJoinNode;
4739
4740            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4741                formatter.write_str("struct batch_plan.NestedLoopJoinNode")
4742            }
4743
4744            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NestedLoopJoinNode, V::Error>
4745                where
4746                    V: serde::de::MapAccess<'de>,
4747            {
4748                let mut join_type__ = None;
4749                let mut join_cond__ = None;
4750                let mut output_indices__ = None;
4751                while let Some(k) = map_.next_key()? {
4752                    match k {
4753                        GeneratedField::JoinType => {
4754                            if join_type__.is_some() {
4755                                return Err(serde::de::Error::duplicate_field("joinType"));
4756                            }
4757                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4758                        }
4759                        GeneratedField::JoinCond => {
4760                            if join_cond__.is_some() {
4761                                return Err(serde::de::Error::duplicate_field("joinCond"));
4762                            }
4763                            join_cond__ = map_.next_value()?;
4764                        }
4765                        GeneratedField::OutputIndices => {
4766                            if output_indices__.is_some() {
4767                                return Err(serde::de::Error::duplicate_field("outputIndices"));
4768                            }
4769                            output_indices__ = 
4770                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4771                                    .into_iter().map(|x| x.0).collect())
4772                            ;
4773                        }
4774                    }
4775                }
4776                Ok(NestedLoopJoinNode {
4777                    join_type: join_type__.unwrap_or_default(),
4778                    join_cond: join_cond__,
4779                    output_indices: output_indices__.unwrap_or_default(),
4780                })
4781            }
4782        }
4783        deserializer.deserialize_struct("batch_plan.NestedLoopJoinNode", FIELDS, GeneratedVisitor)
4784    }
4785}
4786impl serde::Serialize for PlanFragment {
4787    #[allow(deprecated)]
4788    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4789    where
4790        S: serde::Serializer,
4791    {
4792        use serde::ser::SerializeStruct;
4793        let mut len = 0;
4794        if self.root.is_some() {
4795            len += 1;
4796        }
4797        if self.exchange_info.is_some() {
4798            len += 1;
4799        }
4800        let mut struct_ser = serializer.serialize_struct("batch_plan.PlanFragment", len)?;
4801        if let Some(v) = self.root.as_ref() {
4802            struct_ser.serialize_field("root", v)?;
4803        }
4804        if let Some(v) = self.exchange_info.as_ref() {
4805            struct_ser.serialize_field("exchangeInfo", v)?;
4806        }
4807        struct_ser.end()
4808    }
4809}
4810impl<'de> serde::Deserialize<'de> for PlanFragment {
4811    #[allow(deprecated)]
4812    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4813    where
4814        D: serde::Deserializer<'de>,
4815    {
4816        const FIELDS: &[&str] = &[
4817            "root",
4818            "exchange_info",
4819            "exchangeInfo",
4820        ];
4821
4822        #[allow(clippy::enum_variant_names)]
4823        enum GeneratedField {
4824            Root,
4825            ExchangeInfo,
4826        }
4827        impl<'de> serde::Deserialize<'de> for GeneratedField {
4828            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4829            where
4830                D: serde::Deserializer<'de>,
4831            {
4832                struct GeneratedVisitor;
4833
4834                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4835                    type Value = GeneratedField;
4836
4837                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4838                        write!(formatter, "expected one of: {:?}", &FIELDS)
4839                    }
4840
4841                    #[allow(unused_variables)]
4842                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4843                    where
4844                        E: serde::de::Error,
4845                    {
4846                        match value {
4847                            "root" => Ok(GeneratedField::Root),
4848                            "exchangeInfo" | "exchange_info" => Ok(GeneratedField::ExchangeInfo),
4849                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4850                        }
4851                    }
4852                }
4853                deserializer.deserialize_identifier(GeneratedVisitor)
4854            }
4855        }
4856        struct GeneratedVisitor;
4857        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4858            type Value = PlanFragment;
4859
4860            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4861                formatter.write_str("struct batch_plan.PlanFragment")
4862            }
4863
4864            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanFragment, V::Error>
4865                where
4866                    V: serde::de::MapAccess<'de>,
4867            {
4868                let mut root__ = None;
4869                let mut exchange_info__ = None;
4870                while let Some(k) = map_.next_key()? {
4871                    match k {
4872                        GeneratedField::Root => {
4873                            if root__.is_some() {
4874                                return Err(serde::de::Error::duplicate_field("root"));
4875                            }
4876                            root__ = map_.next_value()?;
4877                        }
4878                        GeneratedField::ExchangeInfo => {
4879                            if exchange_info__.is_some() {
4880                                return Err(serde::de::Error::duplicate_field("exchangeInfo"));
4881                            }
4882                            exchange_info__ = map_.next_value()?;
4883                        }
4884                    }
4885                }
4886                Ok(PlanFragment {
4887                    root: root__,
4888                    exchange_info: exchange_info__,
4889                })
4890            }
4891        }
4892        deserializer.deserialize_struct("batch_plan.PlanFragment", FIELDS, GeneratedVisitor)
4893    }
4894}
4895impl serde::Serialize for PlanNode {
4896    #[allow(deprecated)]
4897    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4898    where
4899        S: serde::Serializer,
4900    {
4901        use serde::ser::SerializeStruct;
4902        let mut len = 0;
4903        if !self.children.is_empty() {
4904            len += 1;
4905        }
4906        if !self.identity.is_empty() {
4907            len += 1;
4908        }
4909        if self.node_body.is_some() {
4910            len += 1;
4911        }
4912        let mut struct_ser = serializer.serialize_struct("batch_plan.PlanNode", len)?;
4913        if !self.children.is_empty() {
4914            struct_ser.serialize_field("children", &self.children)?;
4915        }
4916        if !self.identity.is_empty() {
4917            struct_ser.serialize_field("identity", &self.identity)?;
4918        }
4919        if let Some(v) = self.node_body.as_ref() {
4920            match v {
4921                plan_node::NodeBody::Insert(v) => {
4922                    struct_ser.serialize_field("insert", v)?;
4923                }
4924                plan_node::NodeBody::Delete(v) => {
4925                    struct_ser.serialize_field("delete", v)?;
4926                }
4927                plan_node::NodeBody::Update(v) => {
4928                    struct_ser.serialize_field("update", v)?;
4929                }
4930                plan_node::NodeBody::Project(v) => {
4931                    struct_ser.serialize_field("project", v)?;
4932                }
4933                plan_node::NodeBody::HashAgg(v) => {
4934                    struct_ser.serialize_field("hashAgg", v)?;
4935                }
4936                plan_node::NodeBody::Filter(v) => {
4937                    struct_ser.serialize_field("filter", v)?;
4938                }
4939                plan_node::NodeBody::Exchange(v) => {
4940                    struct_ser.serialize_field("exchange", v)?;
4941                }
4942                plan_node::NodeBody::Sort(v) => {
4943                    struct_ser.serialize_field("sort", v)?;
4944                }
4945                plan_node::NodeBody::NestedLoopJoin(v) => {
4946                    struct_ser.serialize_field("nestedLoopJoin", v)?;
4947                }
4948                plan_node::NodeBody::TopN(v) => {
4949                    struct_ser.serialize_field("topN", v)?;
4950                }
4951                plan_node::NodeBody::SortAgg(v) => {
4952                    struct_ser.serialize_field("sortAgg", v)?;
4953                }
4954                plan_node::NodeBody::RowSeqScan(v) => {
4955                    struct_ser.serialize_field("rowSeqScan", v)?;
4956                }
4957                plan_node::NodeBody::Limit(v) => {
4958                    struct_ser.serialize_field("limit", v)?;
4959                }
4960                plan_node::NodeBody::Values(v) => {
4961                    struct_ser.serialize_field("values", v)?;
4962                }
4963                plan_node::NodeBody::HashJoin(v) => {
4964                    struct_ser.serialize_field("hashJoin", v)?;
4965                }
4966                plan_node::NodeBody::MergeSortExchange(v) => {
4967                    struct_ser.serialize_field("mergeSortExchange", v)?;
4968                }
4969                plan_node::NodeBody::HopWindow(v) => {
4970                    struct_ser.serialize_field("hopWindow", v)?;
4971                }
4972                plan_node::NodeBody::TableFunction(v) => {
4973                    struct_ser.serialize_field("tableFunction", v)?;
4974                }
4975                plan_node::NodeBody::SysRowSeqScan(v) => {
4976                    struct_ser.serialize_field("sysRowSeqScan", v)?;
4977                }
4978                plan_node::NodeBody::Expand(v) => {
4979                    struct_ser.serialize_field("expand", v)?;
4980                }
4981                plan_node::NodeBody::LocalLookupJoin(v) => {
4982                    struct_ser.serialize_field("localLookupJoin", v)?;
4983                }
4984                plan_node::NodeBody::ProjectSet(v) => {
4985                    struct_ser.serialize_field("projectSet", v)?;
4986                }
4987                plan_node::NodeBody::Union(v) => {
4988                    struct_ser.serialize_field("union", v)?;
4989                }
4990                plan_node::NodeBody::GroupTopN(v) => {
4991                    struct_ser.serialize_field("groupTopN", v)?;
4992                }
4993                plan_node::NodeBody::DistributedLookupJoin(v) => {
4994                    struct_ser.serialize_field("distributedLookupJoin", v)?;
4995                }
4996                plan_node::NodeBody::Source(v) => {
4997                    struct_ser.serialize_field("source", v)?;
4998                }
4999                plan_node::NodeBody::SortOverWindow(v) => {
5000                    struct_ser.serialize_field("sortOverWindow", v)?;
5001                }
5002                plan_node::NodeBody::MaxOneRow(v) => {
5003                    struct_ser.serialize_field("maxOneRow", v)?;
5004                }
5005                plan_node::NodeBody::LogRowSeqScan(v) => {
5006                    struct_ser.serialize_field("logRowSeqScan", v)?;
5007                }
5008                plan_node::NodeBody::FileScan(v) => {
5009                    struct_ser.serialize_field("fileScan", v)?;
5010                }
5011                plan_node::NodeBody::IcebergScan(v) => {
5012                    struct_ser.serialize_field("icebergScan", v)?;
5013                }
5014                plan_node::NodeBody::PostgresQuery(v) => {
5015                    struct_ser.serialize_field("postgresQuery", v)?;
5016                }
5017                plan_node::NodeBody::MysqlQuery(v) => {
5018                    struct_ser.serialize_field("mysqlQuery", v)?;
5019                }
5020                plan_node::NodeBody::GcsFileScan(v) => {
5021                    struct_ser.serialize_field("gcsFileScan", v)?;
5022                }
5023                plan_node::NodeBody::AzblobFileScan(v) => {
5024                    struct_ser.serialize_field("azblobFileScan", v)?;
5025                }
5026                plan_node::NodeBody::VectorIndexNearest(v) => {
5027                    struct_ser.serialize_field("vectorIndexNearest", v)?;
5028                }
5029                plan_node::NodeBody::BlockExecutor(v) => {
5030                    struct_ser.serialize_field("blockExecutor", v)?;
5031                }
5032                plan_node::NodeBody::BusyLoopExecutor(v) => {
5033                    struct_ser.serialize_field("busyLoopExecutor", v)?;
5034                }
5035            }
5036        }
5037        struct_ser.end()
5038    }
5039}
5040impl<'de> serde::Deserialize<'de> for PlanNode {
5041    #[allow(deprecated)]
5042    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5043    where
5044        D: serde::Deserializer<'de>,
5045    {
5046        const FIELDS: &[&str] = &[
5047            "children",
5048            "identity",
5049            "insert",
5050            "delete",
5051            "update",
5052            "project",
5053            "hash_agg",
5054            "hashAgg",
5055            "filter",
5056            "exchange",
5057            "sort",
5058            "nested_loop_join",
5059            "nestedLoopJoin",
5060            "top_n",
5061            "topN",
5062            "sort_agg",
5063            "sortAgg",
5064            "row_seq_scan",
5065            "rowSeqScan",
5066            "limit",
5067            "values",
5068            "hash_join",
5069            "hashJoin",
5070            "merge_sort_exchange",
5071            "mergeSortExchange",
5072            "hop_window",
5073            "hopWindow",
5074            "table_function",
5075            "tableFunction",
5076            "sys_row_seq_scan",
5077            "sysRowSeqScan",
5078            "expand",
5079            "local_lookup_join",
5080            "localLookupJoin",
5081            "project_set",
5082            "projectSet",
5083            "union",
5084            "group_top_n",
5085            "groupTopN",
5086            "distributed_lookup_join",
5087            "distributedLookupJoin",
5088            "source",
5089            "sort_over_window",
5090            "sortOverWindow",
5091            "max_one_row",
5092            "maxOneRow",
5093            "log_row_seq_scan",
5094            "logRowSeqScan",
5095            "file_scan",
5096            "fileScan",
5097            "iceberg_scan",
5098            "icebergScan",
5099            "postgres_query",
5100            "postgresQuery",
5101            "mysql_query",
5102            "mysqlQuery",
5103            "gcs_file_scan",
5104            "gcsFileScan",
5105            "azblob_file_scan",
5106            "azblobFileScan",
5107            "vector_index_nearest",
5108            "vectorIndexNearest",
5109            "block_executor",
5110            "blockExecutor",
5111            "busy_loop_executor",
5112            "busyLoopExecutor",
5113        ];
5114
5115        #[allow(clippy::enum_variant_names)]
5116        enum GeneratedField {
5117            Children,
5118            Identity,
5119            Insert,
5120            Delete,
5121            Update,
5122            Project,
5123            HashAgg,
5124            Filter,
5125            Exchange,
5126            Sort,
5127            NestedLoopJoin,
5128            TopN,
5129            SortAgg,
5130            RowSeqScan,
5131            Limit,
5132            Values,
5133            HashJoin,
5134            MergeSortExchange,
5135            HopWindow,
5136            TableFunction,
5137            SysRowSeqScan,
5138            Expand,
5139            LocalLookupJoin,
5140            ProjectSet,
5141            Union,
5142            GroupTopN,
5143            DistributedLookupJoin,
5144            Source,
5145            SortOverWindow,
5146            MaxOneRow,
5147            LogRowSeqScan,
5148            FileScan,
5149            IcebergScan,
5150            PostgresQuery,
5151            MysqlQuery,
5152            GcsFileScan,
5153            AzblobFileScan,
5154            VectorIndexNearest,
5155            BlockExecutor,
5156            BusyLoopExecutor,
5157        }
5158        impl<'de> serde::Deserialize<'de> for GeneratedField {
5159            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5160            where
5161                D: serde::Deserializer<'de>,
5162            {
5163                struct GeneratedVisitor;
5164
5165                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5166                    type Value = GeneratedField;
5167
5168                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5169                        write!(formatter, "expected one of: {:?}", &FIELDS)
5170                    }
5171
5172                    #[allow(unused_variables)]
5173                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5174                    where
5175                        E: serde::de::Error,
5176                    {
5177                        match value {
5178                            "children" => Ok(GeneratedField::Children),
5179                            "identity" => Ok(GeneratedField::Identity),
5180                            "insert" => Ok(GeneratedField::Insert),
5181                            "delete" => Ok(GeneratedField::Delete),
5182                            "update" => Ok(GeneratedField::Update),
5183                            "project" => Ok(GeneratedField::Project),
5184                            "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5185                            "filter" => Ok(GeneratedField::Filter),
5186                            "exchange" => Ok(GeneratedField::Exchange),
5187                            "sort" => Ok(GeneratedField::Sort),
5188                            "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5189                            "topN" | "top_n" => Ok(GeneratedField::TopN),
5190                            "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5191                            "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5192                            "limit" => Ok(GeneratedField::Limit),
5193                            "values" => Ok(GeneratedField::Values),
5194                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5195                            "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5196                            "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5197                            "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5198                            "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5199                            "expand" => Ok(GeneratedField::Expand),
5200                            "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5201                            "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5202                            "union" => Ok(GeneratedField::Union),
5203                            "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5204                            "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5205                            "source" => Ok(GeneratedField::Source),
5206                            "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5207                            "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5208                            "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5209                            "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5210                            "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5211                            "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5212                            "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5213                            "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5214                            "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5215                            "vectorIndexNearest" | "vector_index_nearest" => Ok(GeneratedField::VectorIndexNearest),
5216                            "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5217                            "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5218                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5219                        }
5220                    }
5221                }
5222                deserializer.deserialize_identifier(GeneratedVisitor)
5223            }
5224        }
5225        struct GeneratedVisitor;
5226        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5227            type Value = PlanNode;
5228
5229            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5230                formatter.write_str("struct batch_plan.PlanNode")
5231            }
5232
5233            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5234                where
5235                    V: serde::de::MapAccess<'de>,
5236            {
5237                let mut children__ = None;
5238                let mut identity__ = None;
5239                let mut node_body__ = None;
5240                while let Some(k) = map_.next_key()? {
5241                    match k {
5242                        GeneratedField::Children => {
5243                            if children__.is_some() {
5244                                return Err(serde::de::Error::duplicate_field("children"));
5245                            }
5246                            children__ = Some(map_.next_value()?);
5247                        }
5248                        GeneratedField::Identity => {
5249                            if identity__.is_some() {
5250                                return Err(serde::de::Error::duplicate_field("identity"));
5251                            }
5252                            identity__ = Some(map_.next_value()?);
5253                        }
5254                        GeneratedField::Insert => {
5255                            if node_body__.is_some() {
5256                                return Err(serde::de::Error::duplicate_field("insert"));
5257                            }
5258                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5259;
5260                        }
5261                        GeneratedField::Delete => {
5262                            if node_body__.is_some() {
5263                                return Err(serde::de::Error::duplicate_field("delete"));
5264                            }
5265                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5266;
5267                        }
5268                        GeneratedField::Update => {
5269                            if node_body__.is_some() {
5270                                return Err(serde::de::Error::duplicate_field("update"));
5271                            }
5272                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5273;
5274                        }
5275                        GeneratedField::Project => {
5276                            if node_body__.is_some() {
5277                                return Err(serde::de::Error::duplicate_field("project"));
5278                            }
5279                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5280;
5281                        }
5282                        GeneratedField::HashAgg => {
5283                            if node_body__.is_some() {
5284                                return Err(serde::de::Error::duplicate_field("hashAgg"));
5285                            }
5286                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5287;
5288                        }
5289                        GeneratedField::Filter => {
5290                            if node_body__.is_some() {
5291                                return Err(serde::de::Error::duplicate_field("filter"));
5292                            }
5293                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5294;
5295                        }
5296                        GeneratedField::Exchange => {
5297                            if node_body__.is_some() {
5298                                return Err(serde::de::Error::duplicate_field("exchange"));
5299                            }
5300                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5301;
5302                        }
5303                        GeneratedField::Sort => {
5304                            if node_body__.is_some() {
5305                                return Err(serde::de::Error::duplicate_field("sort"));
5306                            }
5307                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5308;
5309                        }
5310                        GeneratedField::NestedLoopJoin => {
5311                            if node_body__.is_some() {
5312                                return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5313                            }
5314                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5315;
5316                        }
5317                        GeneratedField::TopN => {
5318                            if node_body__.is_some() {
5319                                return Err(serde::de::Error::duplicate_field("topN"));
5320                            }
5321                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5322;
5323                        }
5324                        GeneratedField::SortAgg => {
5325                            if node_body__.is_some() {
5326                                return Err(serde::de::Error::duplicate_field("sortAgg"));
5327                            }
5328                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
5329;
5330                        }
5331                        GeneratedField::RowSeqScan => {
5332                            if node_body__.is_some() {
5333                                return Err(serde::de::Error::duplicate_field("rowSeqScan"));
5334                            }
5335                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
5336;
5337                        }
5338                        GeneratedField::Limit => {
5339                            if node_body__.is_some() {
5340                                return Err(serde::de::Error::duplicate_field("limit"));
5341                            }
5342                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
5343;
5344                        }
5345                        GeneratedField::Values => {
5346                            if node_body__.is_some() {
5347                                return Err(serde::de::Error::duplicate_field("values"));
5348                            }
5349                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
5350;
5351                        }
5352                        GeneratedField::HashJoin => {
5353                            if node_body__.is_some() {
5354                                return Err(serde::de::Error::duplicate_field("hashJoin"));
5355                            }
5356                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
5357;
5358                        }
5359                        GeneratedField::MergeSortExchange => {
5360                            if node_body__.is_some() {
5361                                return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
5362                            }
5363                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
5364;
5365                        }
5366                        GeneratedField::HopWindow => {
5367                            if node_body__.is_some() {
5368                                return Err(serde::de::Error::duplicate_field("hopWindow"));
5369                            }
5370                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
5371;
5372                        }
5373                        GeneratedField::TableFunction => {
5374                            if node_body__.is_some() {
5375                                return Err(serde::de::Error::duplicate_field("tableFunction"));
5376                            }
5377                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
5378;
5379                        }
5380                        GeneratedField::SysRowSeqScan => {
5381                            if node_body__.is_some() {
5382                                return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
5383                            }
5384                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
5385;
5386                        }
5387                        GeneratedField::Expand => {
5388                            if node_body__.is_some() {
5389                                return Err(serde::de::Error::duplicate_field("expand"));
5390                            }
5391                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
5392;
5393                        }
5394                        GeneratedField::LocalLookupJoin => {
5395                            if node_body__.is_some() {
5396                                return Err(serde::de::Error::duplicate_field("localLookupJoin"));
5397                            }
5398                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
5399;
5400                        }
5401                        GeneratedField::ProjectSet => {
5402                            if node_body__.is_some() {
5403                                return Err(serde::de::Error::duplicate_field("projectSet"));
5404                            }
5405                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
5406;
5407                        }
5408                        GeneratedField::Union => {
5409                            if node_body__.is_some() {
5410                                return Err(serde::de::Error::duplicate_field("union"));
5411                            }
5412                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
5413;
5414                        }
5415                        GeneratedField::GroupTopN => {
5416                            if node_body__.is_some() {
5417                                return Err(serde::de::Error::duplicate_field("groupTopN"));
5418                            }
5419                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
5420;
5421                        }
5422                        GeneratedField::DistributedLookupJoin => {
5423                            if node_body__.is_some() {
5424                                return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
5425                            }
5426                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
5427;
5428                        }
5429                        GeneratedField::Source => {
5430                            if node_body__.is_some() {
5431                                return Err(serde::de::Error::duplicate_field("source"));
5432                            }
5433                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
5434;
5435                        }
5436                        GeneratedField::SortOverWindow => {
5437                            if node_body__.is_some() {
5438                                return Err(serde::de::Error::duplicate_field("sortOverWindow"));
5439                            }
5440                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
5441;
5442                        }
5443                        GeneratedField::MaxOneRow => {
5444                            if node_body__.is_some() {
5445                                return Err(serde::de::Error::duplicate_field("maxOneRow"));
5446                            }
5447                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
5448;
5449                        }
5450                        GeneratedField::LogRowSeqScan => {
5451                            if node_body__.is_some() {
5452                                return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
5453                            }
5454                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
5455;
5456                        }
5457                        GeneratedField::FileScan => {
5458                            if node_body__.is_some() {
5459                                return Err(serde::de::Error::duplicate_field("fileScan"));
5460                            }
5461                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
5462;
5463                        }
5464                        GeneratedField::IcebergScan => {
5465                            if node_body__.is_some() {
5466                                return Err(serde::de::Error::duplicate_field("icebergScan"));
5467                            }
5468                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
5469;
5470                        }
5471                        GeneratedField::PostgresQuery => {
5472                            if node_body__.is_some() {
5473                                return Err(serde::de::Error::duplicate_field("postgresQuery"));
5474                            }
5475                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
5476;
5477                        }
5478                        GeneratedField::MysqlQuery => {
5479                            if node_body__.is_some() {
5480                                return Err(serde::de::Error::duplicate_field("mysqlQuery"));
5481                            }
5482                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
5483;
5484                        }
5485                        GeneratedField::GcsFileScan => {
5486                            if node_body__.is_some() {
5487                                return Err(serde::de::Error::duplicate_field("gcsFileScan"));
5488                            }
5489                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
5490;
5491                        }
5492                        GeneratedField::AzblobFileScan => {
5493                            if node_body__.is_some() {
5494                                return Err(serde::de::Error::duplicate_field("azblobFileScan"));
5495                            }
5496                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
5497;
5498                        }
5499                        GeneratedField::VectorIndexNearest => {
5500                            if node_body__.is_some() {
5501                                return Err(serde::de::Error::duplicate_field("vectorIndexNearest"));
5502                            }
5503                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::VectorIndexNearest)
5504;
5505                        }
5506                        GeneratedField::BlockExecutor => {
5507                            if node_body__.is_some() {
5508                                return Err(serde::de::Error::duplicate_field("blockExecutor"));
5509                            }
5510                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
5511                        }
5512                        GeneratedField::BusyLoopExecutor => {
5513                            if node_body__.is_some() {
5514                                return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
5515                            }
5516                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
5517                        }
5518                    }
5519                }
5520                Ok(PlanNode {
5521                    children: children__.unwrap_or_default(),
5522                    identity: identity__.unwrap_or_default(),
5523                    node_body: node_body__,
5524                })
5525            }
5526        }
5527        deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
5528    }
5529}
5530impl serde::Serialize for PostgresQueryNode {
5531    #[allow(deprecated)]
5532    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5533    where
5534        S: serde::Serializer,
5535    {
5536        use serde::ser::SerializeStruct;
5537        let mut len = 0;
5538        if !self.columns.is_empty() {
5539            len += 1;
5540        }
5541        if !self.hostname.is_empty() {
5542            len += 1;
5543        }
5544        if !self.port.is_empty() {
5545            len += 1;
5546        }
5547        if !self.username.is_empty() {
5548            len += 1;
5549        }
5550        if !self.password.is_empty() {
5551            len += 1;
5552        }
5553        if !self.database.is_empty() {
5554            len += 1;
5555        }
5556        if !self.query.is_empty() {
5557            len += 1;
5558        }
5559        let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
5560        if !self.columns.is_empty() {
5561            struct_ser.serialize_field("columns", &self.columns)?;
5562        }
5563        if !self.hostname.is_empty() {
5564            struct_ser.serialize_field("hostname", &self.hostname)?;
5565        }
5566        if !self.port.is_empty() {
5567            struct_ser.serialize_field("port", &self.port)?;
5568        }
5569        if !self.username.is_empty() {
5570            struct_ser.serialize_field("username", &self.username)?;
5571        }
5572        if !self.password.is_empty() {
5573            struct_ser.serialize_field("password", &self.password)?;
5574        }
5575        if !self.database.is_empty() {
5576            struct_ser.serialize_field("database", &self.database)?;
5577        }
5578        if !self.query.is_empty() {
5579            struct_ser.serialize_field("query", &self.query)?;
5580        }
5581        struct_ser.end()
5582    }
5583}
5584impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
5585    #[allow(deprecated)]
5586    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5587    where
5588        D: serde::Deserializer<'de>,
5589    {
5590        const FIELDS: &[&str] = &[
5591            "columns",
5592            "hostname",
5593            "port",
5594            "username",
5595            "password",
5596            "database",
5597            "query",
5598        ];
5599
5600        #[allow(clippy::enum_variant_names)]
5601        enum GeneratedField {
5602            Columns,
5603            Hostname,
5604            Port,
5605            Username,
5606            Password,
5607            Database,
5608            Query,
5609        }
5610        impl<'de> serde::Deserialize<'de> for GeneratedField {
5611            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5612            where
5613                D: serde::Deserializer<'de>,
5614            {
5615                struct GeneratedVisitor;
5616
5617                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5618                    type Value = GeneratedField;
5619
5620                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5621                        write!(formatter, "expected one of: {:?}", &FIELDS)
5622                    }
5623
5624                    #[allow(unused_variables)]
5625                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5626                    where
5627                        E: serde::de::Error,
5628                    {
5629                        match value {
5630                            "columns" => Ok(GeneratedField::Columns),
5631                            "hostname" => Ok(GeneratedField::Hostname),
5632                            "port" => Ok(GeneratedField::Port),
5633                            "username" => Ok(GeneratedField::Username),
5634                            "password" => Ok(GeneratedField::Password),
5635                            "database" => Ok(GeneratedField::Database),
5636                            "query" => Ok(GeneratedField::Query),
5637                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5638                        }
5639                    }
5640                }
5641                deserializer.deserialize_identifier(GeneratedVisitor)
5642            }
5643        }
5644        struct GeneratedVisitor;
5645        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5646            type Value = PostgresQueryNode;
5647
5648            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5649                formatter.write_str("struct batch_plan.PostgresQueryNode")
5650            }
5651
5652            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
5653                where
5654                    V: serde::de::MapAccess<'de>,
5655            {
5656                let mut columns__ = None;
5657                let mut hostname__ = None;
5658                let mut port__ = None;
5659                let mut username__ = None;
5660                let mut password__ = None;
5661                let mut database__ = None;
5662                let mut query__ = None;
5663                while let Some(k) = map_.next_key()? {
5664                    match k {
5665                        GeneratedField::Columns => {
5666                            if columns__.is_some() {
5667                                return Err(serde::de::Error::duplicate_field("columns"));
5668                            }
5669                            columns__ = Some(map_.next_value()?);
5670                        }
5671                        GeneratedField::Hostname => {
5672                            if hostname__.is_some() {
5673                                return Err(serde::de::Error::duplicate_field("hostname"));
5674                            }
5675                            hostname__ = Some(map_.next_value()?);
5676                        }
5677                        GeneratedField::Port => {
5678                            if port__.is_some() {
5679                                return Err(serde::de::Error::duplicate_field("port"));
5680                            }
5681                            port__ = Some(map_.next_value()?);
5682                        }
5683                        GeneratedField::Username => {
5684                            if username__.is_some() {
5685                                return Err(serde::de::Error::duplicate_field("username"));
5686                            }
5687                            username__ = Some(map_.next_value()?);
5688                        }
5689                        GeneratedField::Password => {
5690                            if password__.is_some() {
5691                                return Err(serde::de::Error::duplicate_field("password"));
5692                            }
5693                            password__ = Some(map_.next_value()?);
5694                        }
5695                        GeneratedField::Database => {
5696                            if database__.is_some() {
5697                                return Err(serde::de::Error::duplicate_field("database"));
5698                            }
5699                            database__ = Some(map_.next_value()?);
5700                        }
5701                        GeneratedField::Query => {
5702                            if query__.is_some() {
5703                                return Err(serde::de::Error::duplicate_field("query"));
5704                            }
5705                            query__ = Some(map_.next_value()?);
5706                        }
5707                    }
5708                }
5709                Ok(PostgresQueryNode {
5710                    columns: columns__.unwrap_or_default(),
5711                    hostname: hostname__.unwrap_or_default(),
5712                    port: port__.unwrap_or_default(),
5713                    username: username__.unwrap_or_default(),
5714                    password: password__.unwrap_or_default(),
5715                    database: database__.unwrap_or_default(),
5716                    query: query__.unwrap_or_default(),
5717                })
5718            }
5719        }
5720        deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
5721    }
5722}
5723impl serde::Serialize for ProjectNode {
5724    #[allow(deprecated)]
5725    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5726    where
5727        S: serde::Serializer,
5728    {
5729        use serde::ser::SerializeStruct;
5730        let mut len = 0;
5731        if !self.select_list.is_empty() {
5732            len += 1;
5733        }
5734        let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
5735        if !self.select_list.is_empty() {
5736            struct_ser.serialize_field("selectList", &self.select_list)?;
5737        }
5738        struct_ser.end()
5739    }
5740}
5741impl<'de> serde::Deserialize<'de> for ProjectNode {
5742    #[allow(deprecated)]
5743    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5744    where
5745        D: serde::Deserializer<'de>,
5746    {
5747        const FIELDS: &[&str] = &[
5748            "select_list",
5749            "selectList",
5750        ];
5751
5752        #[allow(clippy::enum_variant_names)]
5753        enum GeneratedField {
5754            SelectList,
5755        }
5756        impl<'de> serde::Deserialize<'de> for GeneratedField {
5757            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5758            where
5759                D: serde::Deserializer<'de>,
5760            {
5761                struct GeneratedVisitor;
5762
5763                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5764                    type Value = GeneratedField;
5765
5766                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5767                        write!(formatter, "expected one of: {:?}", &FIELDS)
5768                    }
5769
5770                    #[allow(unused_variables)]
5771                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5772                    where
5773                        E: serde::de::Error,
5774                    {
5775                        match value {
5776                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5777                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5778                        }
5779                    }
5780                }
5781                deserializer.deserialize_identifier(GeneratedVisitor)
5782            }
5783        }
5784        struct GeneratedVisitor;
5785        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5786            type Value = ProjectNode;
5787
5788            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5789                formatter.write_str("struct batch_plan.ProjectNode")
5790            }
5791
5792            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
5793                where
5794                    V: serde::de::MapAccess<'de>,
5795            {
5796                let mut select_list__ = None;
5797                while let Some(k) = map_.next_key()? {
5798                    match k {
5799                        GeneratedField::SelectList => {
5800                            if select_list__.is_some() {
5801                                return Err(serde::de::Error::duplicate_field("selectList"));
5802                            }
5803                            select_list__ = Some(map_.next_value()?);
5804                        }
5805                    }
5806                }
5807                Ok(ProjectNode {
5808                    select_list: select_list__.unwrap_or_default(),
5809                })
5810            }
5811        }
5812        deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
5813    }
5814}
5815impl serde::Serialize for ProjectSetNode {
5816    #[allow(deprecated)]
5817    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5818    where
5819        S: serde::Serializer,
5820    {
5821        use serde::ser::SerializeStruct;
5822        let mut len = 0;
5823        if !self.select_list.is_empty() {
5824            len += 1;
5825        }
5826        let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
5827        if !self.select_list.is_empty() {
5828            struct_ser.serialize_field("selectList", &self.select_list)?;
5829        }
5830        struct_ser.end()
5831    }
5832}
5833impl<'de> serde::Deserialize<'de> for ProjectSetNode {
5834    #[allow(deprecated)]
5835    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5836    where
5837        D: serde::Deserializer<'de>,
5838    {
5839        const FIELDS: &[&str] = &[
5840            "select_list",
5841            "selectList",
5842        ];
5843
5844        #[allow(clippy::enum_variant_names)]
5845        enum GeneratedField {
5846            SelectList,
5847        }
5848        impl<'de> serde::Deserialize<'de> for GeneratedField {
5849            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5850            where
5851                D: serde::Deserializer<'de>,
5852            {
5853                struct GeneratedVisitor;
5854
5855                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5856                    type Value = GeneratedField;
5857
5858                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5859                        write!(formatter, "expected one of: {:?}", &FIELDS)
5860                    }
5861
5862                    #[allow(unused_variables)]
5863                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5864                    where
5865                        E: serde::de::Error,
5866                    {
5867                        match value {
5868                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5869                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5870                        }
5871                    }
5872                }
5873                deserializer.deserialize_identifier(GeneratedVisitor)
5874            }
5875        }
5876        struct GeneratedVisitor;
5877        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5878            type Value = ProjectSetNode;
5879
5880            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5881                formatter.write_str("struct batch_plan.ProjectSetNode")
5882            }
5883
5884            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
5885                where
5886                    V: serde::de::MapAccess<'de>,
5887            {
5888                let mut select_list__ = None;
5889                while let Some(k) = map_.next_key()? {
5890                    match k {
5891                        GeneratedField::SelectList => {
5892                            if select_list__.is_some() {
5893                                return Err(serde::de::Error::duplicate_field("selectList"));
5894                            }
5895                            select_list__ = Some(map_.next_value()?);
5896                        }
5897                    }
5898                }
5899                Ok(ProjectSetNode {
5900                    select_list: select_list__.unwrap_or_default(),
5901                })
5902            }
5903        }
5904        deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
5905    }
5906}
5907impl serde::Serialize for RowSeqScanNode {
5908    #[allow(deprecated)]
5909    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5910    where
5911        S: serde::Serializer,
5912    {
5913        use serde::ser::SerializeStruct;
5914        let mut len = 0;
5915        if self.table_desc.is_some() {
5916            len += 1;
5917        }
5918        if !self.column_ids.is_empty() {
5919            len += 1;
5920        }
5921        if !self.scan_ranges.is_empty() {
5922            len += 1;
5923        }
5924        if self.vnode_bitmap.is_some() {
5925            len += 1;
5926        }
5927        if self.ordered {
5928            len += 1;
5929        }
5930        if self.limit.is_some() {
5931            len += 1;
5932        }
5933        if self.as_of.is_some() {
5934            len += 1;
5935        }
5936        let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
5937        if let Some(v) = self.table_desc.as_ref() {
5938            struct_ser.serialize_field("tableDesc", v)?;
5939        }
5940        if !self.column_ids.is_empty() {
5941            struct_ser.serialize_field("columnIds", &self.column_ids)?;
5942        }
5943        if !self.scan_ranges.is_empty() {
5944            struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
5945        }
5946        if let Some(v) = self.vnode_bitmap.as_ref() {
5947            struct_ser.serialize_field("vnodeBitmap", v)?;
5948        }
5949        if self.ordered {
5950            struct_ser.serialize_field("ordered", &self.ordered)?;
5951        }
5952        if let Some(v) = self.limit.as_ref() {
5953            #[allow(clippy::needless_borrow)]
5954            #[allow(clippy::needless_borrows_for_generic_args)]
5955            struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
5956        }
5957        if let Some(v) = self.as_of.as_ref() {
5958            struct_ser.serialize_field("asOf", v)?;
5959        }
5960        struct_ser.end()
5961    }
5962}
5963impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
5964    #[allow(deprecated)]
5965    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5966    where
5967        D: serde::Deserializer<'de>,
5968    {
5969        const FIELDS: &[&str] = &[
5970            "table_desc",
5971            "tableDesc",
5972            "column_ids",
5973            "columnIds",
5974            "scan_ranges",
5975            "scanRanges",
5976            "vnode_bitmap",
5977            "vnodeBitmap",
5978            "ordered",
5979            "limit",
5980            "as_of",
5981            "asOf",
5982        ];
5983
5984        #[allow(clippy::enum_variant_names)]
5985        enum GeneratedField {
5986            TableDesc,
5987            ColumnIds,
5988            ScanRanges,
5989            VnodeBitmap,
5990            Ordered,
5991            Limit,
5992            AsOf,
5993        }
5994        impl<'de> serde::Deserialize<'de> for GeneratedField {
5995            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5996            where
5997                D: serde::Deserializer<'de>,
5998            {
5999                struct GeneratedVisitor;
6000
6001                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6002                    type Value = GeneratedField;
6003
6004                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6005                        write!(formatter, "expected one of: {:?}", &FIELDS)
6006                    }
6007
6008                    #[allow(unused_variables)]
6009                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6010                    where
6011                        E: serde::de::Error,
6012                    {
6013                        match value {
6014                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6015                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6016                            "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6017                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6018                            "ordered" => Ok(GeneratedField::Ordered),
6019                            "limit" => Ok(GeneratedField::Limit),
6020                            "asOf" | "as_of" => Ok(GeneratedField::AsOf),
6021                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6022                        }
6023                    }
6024                }
6025                deserializer.deserialize_identifier(GeneratedVisitor)
6026            }
6027        }
6028        struct GeneratedVisitor;
6029        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6030            type Value = RowSeqScanNode;
6031
6032            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6033                formatter.write_str("struct batch_plan.RowSeqScanNode")
6034            }
6035
6036            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6037                where
6038                    V: serde::de::MapAccess<'de>,
6039            {
6040                let mut table_desc__ = None;
6041                let mut column_ids__ = None;
6042                let mut scan_ranges__ = None;
6043                let mut vnode_bitmap__ = None;
6044                let mut ordered__ = None;
6045                let mut limit__ = None;
6046                let mut as_of__ = None;
6047                while let Some(k) = map_.next_key()? {
6048                    match k {
6049                        GeneratedField::TableDesc => {
6050                            if table_desc__.is_some() {
6051                                return Err(serde::de::Error::duplicate_field("tableDesc"));
6052                            }
6053                            table_desc__ = map_.next_value()?;
6054                        }
6055                        GeneratedField::ColumnIds => {
6056                            if column_ids__.is_some() {
6057                                return Err(serde::de::Error::duplicate_field("columnIds"));
6058                            }
6059                            column_ids__ = 
6060                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6061                                    .into_iter().map(|x| x.0).collect())
6062                            ;
6063                        }
6064                        GeneratedField::ScanRanges => {
6065                            if scan_ranges__.is_some() {
6066                                return Err(serde::de::Error::duplicate_field("scanRanges"));
6067                            }
6068                            scan_ranges__ = Some(map_.next_value()?);
6069                        }
6070                        GeneratedField::VnodeBitmap => {
6071                            if vnode_bitmap__.is_some() {
6072                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6073                            }
6074                            vnode_bitmap__ = map_.next_value()?;
6075                        }
6076                        GeneratedField::Ordered => {
6077                            if ordered__.is_some() {
6078                                return Err(serde::de::Error::duplicate_field("ordered"));
6079                            }
6080                            ordered__ = Some(map_.next_value()?);
6081                        }
6082                        GeneratedField::Limit => {
6083                            if limit__.is_some() {
6084                                return Err(serde::de::Error::duplicate_field("limit"));
6085                            }
6086                            limit__ = 
6087                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6088                            ;
6089                        }
6090                        GeneratedField::AsOf => {
6091                            if as_of__.is_some() {
6092                                return Err(serde::de::Error::duplicate_field("asOf"));
6093                            }
6094                            as_of__ = map_.next_value()?;
6095                        }
6096                    }
6097                }
6098                Ok(RowSeqScanNode {
6099                    table_desc: table_desc__,
6100                    column_ids: column_ids__.unwrap_or_default(),
6101                    scan_ranges: scan_ranges__.unwrap_or_default(),
6102                    vnode_bitmap: vnode_bitmap__,
6103                    ordered: ordered__.unwrap_or_default(),
6104                    limit: limit__,
6105                    as_of: as_of__,
6106                })
6107            }
6108        }
6109        deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6110    }
6111}
6112impl serde::Serialize for ScanRange {
6113    #[allow(deprecated)]
6114    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6115    where
6116        S: serde::Serializer,
6117    {
6118        use serde::ser::SerializeStruct;
6119        let mut len = 0;
6120        if !self.eq_conds.is_empty() {
6121            len += 1;
6122        }
6123        if self.lower_bound.is_some() {
6124            len += 1;
6125        }
6126        if self.upper_bound.is_some() {
6127            len += 1;
6128        }
6129        let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6130        if !self.eq_conds.is_empty() {
6131            struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6132        }
6133        if let Some(v) = self.lower_bound.as_ref() {
6134            struct_ser.serialize_field("lowerBound", v)?;
6135        }
6136        if let Some(v) = self.upper_bound.as_ref() {
6137            struct_ser.serialize_field("upperBound", v)?;
6138        }
6139        struct_ser.end()
6140    }
6141}
6142impl<'de> serde::Deserialize<'de> for ScanRange {
6143    #[allow(deprecated)]
6144    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6145    where
6146        D: serde::Deserializer<'de>,
6147    {
6148        const FIELDS: &[&str] = &[
6149            "eq_conds",
6150            "eqConds",
6151            "lower_bound",
6152            "lowerBound",
6153            "upper_bound",
6154            "upperBound",
6155        ];
6156
6157        #[allow(clippy::enum_variant_names)]
6158        enum GeneratedField {
6159            EqConds,
6160            LowerBound,
6161            UpperBound,
6162        }
6163        impl<'de> serde::Deserialize<'de> for GeneratedField {
6164            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6165            where
6166                D: serde::Deserializer<'de>,
6167            {
6168                struct GeneratedVisitor;
6169
6170                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6171                    type Value = GeneratedField;
6172
6173                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6174                        write!(formatter, "expected one of: {:?}", &FIELDS)
6175                    }
6176
6177                    #[allow(unused_variables)]
6178                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6179                    where
6180                        E: serde::de::Error,
6181                    {
6182                        match value {
6183                            "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6184                            "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6185                            "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6186                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6187                        }
6188                    }
6189                }
6190                deserializer.deserialize_identifier(GeneratedVisitor)
6191            }
6192        }
6193        struct GeneratedVisitor;
6194        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6195            type Value = ScanRange;
6196
6197            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6198                formatter.write_str("struct batch_plan.ScanRange")
6199            }
6200
6201            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6202                where
6203                    V: serde::de::MapAccess<'de>,
6204            {
6205                let mut eq_conds__ = None;
6206                let mut lower_bound__ = None;
6207                let mut upper_bound__ = None;
6208                while let Some(k) = map_.next_key()? {
6209                    match k {
6210                        GeneratedField::EqConds => {
6211                            if eq_conds__.is_some() {
6212                                return Err(serde::de::Error::duplicate_field("eqConds"));
6213                            }
6214                            eq_conds__ = 
6215                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6216                                    .into_iter().map(|x| x.0).collect())
6217                            ;
6218                        }
6219                        GeneratedField::LowerBound => {
6220                            if lower_bound__.is_some() {
6221                                return Err(serde::de::Error::duplicate_field("lowerBound"));
6222                            }
6223                            lower_bound__ = map_.next_value()?;
6224                        }
6225                        GeneratedField::UpperBound => {
6226                            if upper_bound__.is_some() {
6227                                return Err(serde::de::Error::duplicate_field("upperBound"));
6228                            }
6229                            upper_bound__ = map_.next_value()?;
6230                        }
6231                    }
6232                }
6233                Ok(ScanRange {
6234                    eq_conds: eq_conds__.unwrap_or_default(),
6235                    lower_bound: lower_bound__,
6236                    upper_bound: upper_bound__,
6237                })
6238            }
6239        }
6240        deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6241    }
6242}
6243impl serde::Serialize for scan_range::Bound {
6244    #[allow(deprecated)]
6245    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6246    where
6247        S: serde::Serializer,
6248    {
6249        use serde::ser::SerializeStruct;
6250        let mut len = 0;
6251        if !self.value.is_empty() {
6252            len += 1;
6253        }
6254        if self.inclusive {
6255            len += 1;
6256        }
6257        let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6258        if !self.value.is_empty() {
6259            struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6260        }
6261        if self.inclusive {
6262            struct_ser.serialize_field("inclusive", &self.inclusive)?;
6263        }
6264        struct_ser.end()
6265    }
6266}
6267impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6268    #[allow(deprecated)]
6269    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6270    where
6271        D: serde::Deserializer<'de>,
6272    {
6273        const FIELDS: &[&str] = &[
6274            "value",
6275            "inclusive",
6276        ];
6277
6278        #[allow(clippy::enum_variant_names)]
6279        enum GeneratedField {
6280            Value,
6281            Inclusive,
6282        }
6283        impl<'de> serde::Deserialize<'de> for GeneratedField {
6284            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6285            where
6286                D: serde::Deserializer<'de>,
6287            {
6288                struct GeneratedVisitor;
6289
6290                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6291                    type Value = GeneratedField;
6292
6293                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6294                        write!(formatter, "expected one of: {:?}", &FIELDS)
6295                    }
6296
6297                    #[allow(unused_variables)]
6298                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6299                    where
6300                        E: serde::de::Error,
6301                    {
6302                        match value {
6303                            "value" => Ok(GeneratedField::Value),
6304                            "inclusive" => Ok(GeneratedField::Inclusive),
6305                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6306                        }
6307                    }
6308                }
6309                deserializer.deserialize_identifier(GeneratedVisitor)
6310            }
6311        }
6312        struct GeneratedVisitor;
6313        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6314            type Value = scan_range::Bound;
6315
6316            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6317                formatter.write_str("struct batch_plan.ScanRange.Bound")
6318            }
6319
6320            fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6321                where
6322                    V: serde::de::MapAccess<'de>,
6323            {
6324                let mut value__ = None;
6325                let mut inclusive__ = None;
6326                while let Some(k) = map_.next_key()? {
6327                    match k {
6328                        GeneratedField::Value => {
6329                            if value__.is_some() {
6330                                return Err(serde::de::Error::duplicate_field("value"));
6331                            }
6332                            value__ = 
6333                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6334                                    .into_iter().map(|x| x.0).collect())
6335                            ;
6336                        }
6337                        GeneratedField::Inclusive => {
6338                            if inclusive__.is_some() {
6339                                return Err(serde::de::Error::duplicate_field("inclusive"));
6340                            }
6341                            inclusive__ = Some(map_.next_value()?);
6342                        }
6343                    }
6344                }
6345                Ok(scan_range::Bound {
6346                    value: value__.unwrap_or_default(),
6347                    inclusive: inclusive__.unwrap_or_default(),
6348                })
6349            }
6350        }
6351        deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6352    }
6353}
6354impl serde::Serialize for SortAggNode {
6355    #[allow(deprecated)]
6356    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6357    where
6358        S: serde::Serializer,
6359    {
6360        use serde::ser::SerializeStruct;
6361        let mut len = 0;
6362        if !self.group_key.is_empty() {
6363            len += 1;
6364        }
6365        if !self.agg_calls.is_empty() {
6366            len += 1;
6367        }
6368        let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6369        if !self.group_key.is_empty() {
6370            struct_ser.serialize_field("groupKey", &self.group_key)?;
6371        }
6372        if !self.agg_calls.is_empty() {
6373            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6374        }
6375        struct_ser.end()
6376    }
6377}
6378impl<'de> serde::Deserialize<'de> for SortAggNode {
6379    #[allow(deprecated)]
6380    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6381    where
6382        D: serde::Deserializer<'de>,
6383    {
6384        const FIELDS: &[&str] = &[
6385            "group_key",
6386            "groupKey",
6387            "agg_calls",
6388            "aggCalls",
6389        ];
6390
6391        #[allow(clippy::enum_variant_names)]
6392        enum GeneratedField {
6393            GroupKey,
6394            AggCalls,
6395        }
6396        impl<'de> serde::Deserialize<'de> for GeneratedField {
6397            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6398            where
6399                D: serde::Deserializer<'de>,
6400            {
6401                struct GeneratedVisitor;
6402
6403                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6404                    type Value = GeneratedField;
6405
6406                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6407                        write!(formatter, "expected one of: {:?}", &FIELDS)
6408                    }
6409
6410                    #[allow(unused_variables)]
6411                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6412                    where
6413                        E: serde::de::Error,
6414                    {
6415                        match value {
6416                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6417                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6418                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6419                        }
6420                    }
6421                }
6422                deserializer.deserialize_identifier(GeneratedVisitor)
6423            }
6424        }
6425        struct GeneratedVisitor;
6426        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6427            type Value = SortAggNode;
6428
6429            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6430                formatter.write_str("struct batch_plan.SortAggNode")
6431            }
6432
6433            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6434                where
6435                    V: serde::de::MapAccess<'de>,
6436            {
6437                let mut group_key__ = None;
6438                let mut agg_calls__ = None;
6439                while let Some(k) = map_.next_key()? {
6440                    match k {
6441                        GeneratedField::GroupKey => {
6442                            if group_key__.is_some() {
6443                                return Err(serde::de::Error::duplicate_field("groupKey"));
6444                            }
6445                            group_key__ = Some(map_.next_value()?);
6446                        }
6447                        GeneratedField::AggCalls => {
6448                            if agg_calls__.is_some() {
6449                                return Err(serde::de::Error::duplicate_field("aggCalls"));
6450                            }
6451                            agg_calls__ = Some(map_.next_value()?);
6452                        }
6453                    }
6454                }
6455                Ok(SortAggNode {
6456                    group_key: group_key__.unwrap_or_default(),
6457                    agg_calls: agg_calls__.unwrap_or_default(),
6458                })
6459            }
6460        }
6461        deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6462    }
6463}
6464impl serde::Serialize for SortMergeJoinNode {
6465    #[allow(deprecated)]
6466    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6467    where
6468        S: serde::Serializer,
6469    {
6470        use serde::ser::SerializeStruct;
6471        let mut len = 0;
6472        if self.join_type != 0 {
6473            len += 1;
6474        }
6475        if !self.left_key.is_empty() {
6476            len += 1;
6477        }
6478        if !self.right_key.is_empty() {
6479            len += 1;
6480        }
6481        if self.direction != 0 {
6482            len += 1;
6483        }
6484        if !self.output_indices.is_empty() {
6485            len += 1;
6486        }
6487        let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6488        if self.join_type != 0 {
6489            let v = super::plan_common::JoinType::try_from(self.join_type)
6490                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6491            struct_ser.serialize_field("joinType", &v)?;
6492        }
6493        if !self.left_key.is_empty() {
6494            struct_ser.serialize_field("leftKey", &self.left_key)?;
6495        }
6496        if !self.right_key.is_empty() {
6497            struct_ser.serialize_field("rightKey", &self.right_key)?;
6498        }
6499        if self.direction != 0 {
6500            let v = super::common::Direction::try_from(self.direction)
6501                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6502            struct_ser.serialize_field("direction", &v)?;
6503        }
6504        if !self.output_indices.is_empty() {
6505            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6506        }
6507        struct_ser.end()
6508    }
6509}
6510impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
6511    #[allow(deprecated)]
6512    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6513    where
6514        D: serde::Deserializer<'de>,
6515    {
6516        const FIELDS: &[&str] = &[
6517            "join_type",
6518            "joinType",
6519            "left_key",
6520            "leftKey",
6521            "right_key",
6522            "rightKey",
6523            "direction",
6524            "output_indices",
6525            "outputIndices",
6526        ];
6527
6528        #[allow(clippy::enum_variant_names)]
6529        enum GeneratedField {
6530            JoinType,
6531            LeftKey,
6532            RightKey,
6533            Direction,
6534            OutputIndices,
6535        }
6536        impl<'de> serde::Deserialize<'de> for GeneratedField {
6537            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6538            where
6539                D: serde::Deserializer<'de>,
6540            {
6541                struct GeneratedVisitor;
6542
6543                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6544                    type Value = GeneratedField;
6545
6546                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6547                        write!(formatter, "expected one of: {:?}", &FIELDS)
6548                    }
6549
6550                    #[allow(unused_variables)]
6551                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6552                    where
6553                        E: serde::de::Error,
6554                    {
6555                        match value {
6556                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6557                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6558                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6559                            "direction" => Ok(GeneratedField::Direction),
6560                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6561                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6562                        }
6563                    }
6564                }
6565                deserializer.deserialize_identifier(GeneratedVisitor)
6566            }
6567        }
6568        struct GeneratedVisitor;
6569        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6570            type Value = SortMergeJoinNode;
6571
6572            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6573                formatter.write_str("struct batch_plan.SortMergeJoinNode")
6574            }
6575
6576            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
6577                where
6578                    V: serde::de::MapAccess<'de>,
6579            {
6580                let mut join_type__ = None;
6581                let mut left_key__ = None;
6582                let mut right_key__ = None;
6583                let mut direction__ = None;
6584                let mut output_indices__ = None;
6585                while let Some(k) = map_.next_key()? {
6586                    match k {
6587                        GeneratedField::JoinType => {
6588                            if join_type__.is_some() {
6589                                return Err(serde::de::Error::duplicate_field("joinType"));
6590                            }
6591                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6592                        }
6593                        GeneratedField::LeftKey => {
6594                            if left_key__.is_some() {
6595                                return Err(serde::de::Error::duplicate_field("leftKey"));
6596                            }
6597                            left_key__ = 
6598                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6599                                    .into_iter().map(|x| x.0).collect())
6600                            ;
6601                        }
6602                        GeneratedField::RightKey => {
6603                            if right_key__.is_some() {
6604                                return Err(serde::de::Error::duplicate_field("rightKey"));
6605                            }
6606                            right_key__ = 
6607                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6608                                    .into_iter().map(|x| x.0).collect())
6609                            ;
6610                        }
6611                        GeneratedField::Direction => {
6612                            if direction__.is_some() {
6613                                return Err(serde::de::Error::duplicate_field("direction"));
6614                            }
6615                            direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
6616                        }
6617                        GeneratedField::OutputIndices => {
6618                            if output_indices__.is_some() {
6619                                return Err(serde::de::Error::duplicate_field("outputIndices"));
6620                            }
6621                            output_indices__ = 
6622                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6623                                    .into_iter().map(|x| x.0).collect())
6624                            ;
6625                        }
6626                    }
6627                }
6628                Ok(SortMergeJoinNode {
6629                    join_type: join_type__.unwrap_or_default(),
6630                    left_key: left_key__.unwrap_or_default(),
6631                    right_key: right_key__.unwrap_or_default(),
6632                    direction: direction__.unwrap_or_default(),
6633                    output_indices: output_indices__.unwrap_or_default(),
6634                })
6635            }
6636        }
6637        deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
6638    }
6639}
6640impl serde::Serialize for SortNode {
6641    #[allow(deprecated)]
6642    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6643    where
6644        S: serde::Serializer,
6645    {
6646        use serde::ser::SerializeStruct;
6647        let mut len = 0;
6648        if !self.column_orders.is_empty() {
6649            len += 1;
6650        }
6651        let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
6652        if !self.column_orders.is_empty() {
6653            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6654        }
6655        struct_ser.end()
6656    }
6657}
6658impl<'de> serde::Deserialize<'de> for SortNode {
6659    #[allow(deprecated)]
6660    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6661    where
6662        D: serde::Deserializer<'de>,
6663    {
6664        const FIELDS: &[&str] = &[
6665            "column_orders",
6666            "columnOrders",
6667        ];
6668
6669        #[allow(clippy::enum_variant_names)]
6670        enum GeneratedField {
6671            ColumnOrders,
6672        }
6673        impl<'de> serde::Deserialize<'de> for GeneratedField {
6674            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6675            where
6676                D: serde::Deserializer<'de>,
6677            {
6678                struct GeneratedVisitor;
6679
6680                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6681                    type Value = GeneratedField;
6682
6683                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6684                        write!(formatter, "expected one of: {:?}", &FIELDS)
6685                    }
6686
6687                    #[allow(unused_variables)]
6688                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6689                    where
6690                        E: serde::de::Error,
6691                    {
6692                        match value {
6693                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6694                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6695                        }
6696                    }
6697                }
6698                deserializer.deserialize_identifier(GeneratedVisitor)
6699            }
6700        }
6701        struct GeneratedVisitor;
6702        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6703            type Value = SortNode;
6704
6705            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6706                formatter.write_str("struct batch_plan.SortNode")
6707            }
6708
6709            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
6710                where
6711                    V: serde::de::MapAccess<'de>,
6712            {
6713                let mut column_orders__ = None;
6714                while let Some(k) = map_.next_key()? {
6715                    match k {
6716                        GeneratedField::ColumnOrders => {
6717                            if column_orders__.is_some() {
6718                                return Err(serde::de::Error::duplicate_field("columnOrders"));
6719                            }
6720                            column_orders__ = Some(map_.next_value()?);
6721                        }
6722                    }
6723                }
6724                Ok(SortNode {
6725                    column_orders: column_orders__.unwrap_or_default(),
6726                })
6727            }
6728        }
6729        deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
6730    }
6731}
6732impl serde::Serialize for SortOverWindowNode {
6733    #[allow(deprecated)]
6734    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6735    where
6736        S: serde::Serializer,
6737    {
6738        use serde::ser::SerializeStruct;
6739        let mut len = 0;
6740        if !self.calls.is_empty() {
6741            len += 1;
6742        }
6743        if !self.partition_by.is_empty() {
6744            len += 1;
6745        }
6746        if !self.order_by.is_empty() {
6747            len += 1;
6748        }
6749        let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
6750        if !self.calls.is_empty() {
6751            struct_ser.serialize_field("calls", &self.calls)?;
6752        }
6753        if !self.partition_by.is_empty() {
6754            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
6755        }
6756        if !self.order_by.is_empty() {
6757            struct_ser.serialize_field("orderBy", &self.order_by)?;
6758        }
6759        struct_ser.end()
6760    }
6761}
6762impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
6763    #[allow(deprecated)]
6764    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6765    where
6766        D: serde::Deserializer<'de>,
6767    {
6768        const FIELDS: &[&str] = &[
6769            "calls",
6770            "partition_by",
6771            "partitionBy",
6772            "order_by",
6773            "orderBy",
6774        ];
6775
6776        #[allow(clippy::enum_variant_names)]
6777        enum GeneratedField {
6778            Calls,
6779            PartitionBy,
6780            OrderBy,
6781        }
6782        impl<'de> serde::Deserialize<'de> for GeneratedField {
6783            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6784            where
6785                D: serde::Deserializer<'de>,
6786            {
6787                struct GeneratedVisitor;
6788
6789                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6790                    type Value = GeneratedField;
6791
6792                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6793                        write!(formatter, "expected one of: {:?}", &FIELDS)
6794                    }
6795
6796                    #[allow(unused_variables)]
6797                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6798                    where
6799                        E: serde::de::Error,
6800                    {
6801                        match value {
6802                            "calls" => Ok(GeneratedField::Calls),
6803                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
6804                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6805                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6806                        }
6807                    }
6808                }
6809                deserializer.deserialize_identifier(GeneratedVisitor)
6810            }
6811        }
6812        struct GeneratedVisitor;
6813        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6814            type Value = SortOverWindowNode;
6815
6816            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6817                formatter.write_str("struct batch_plan.SortOverWindowNode")
6818            }
6819
6820            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
6821                where
6822                    V: serde::de::MapAccess<'de>,
6823            {
6824                let mut calls__ = None;
6825                let mut partition_by__ = None;
6826                let mut order_by__ = None;
6827                while let Some(k) = map_.next_key()? {
6828                    match k {
6829                        GeneratedField::Calls => {
6830                            if calls__.is_some() {
6831                                return Err(serde::de::Error::duplicate_field("calls"));
6832                            }
6833                            calls__ = Some(map_.next_value()?);
6834                        }
6835                        GeneratedField::PartitionBy => {
6836                            if partition_by__.is_some() {
6837                                return Err(serde::de::Error::duplicate_field("partitionBy"));
6838                            }
6839                            partition_by__ = 
6840                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6841                                    .into_iter().map(|x| x.0).collect())
6842                            ;
6843                        }
6844                        GeneratedField::OrderBy => {
6845                            if order_by__.is_some() {
6846                                return Err(serde::de::Error::duplicate_field("orderBy"));
6847                            }
6848                            order_by__ = Some(map_.next_value()?);
6849                        }
6850                    }
6851                }
6852                Ok(SortOverWindowNode {
6853                    calls: calls__.unwrap_or_default(),
6854                    partition_by: partition_by__.unwrap_or_default(),
6855                    order_by: order_by__.unwrap_or_default(),
6856                })
6857            }
6858        }
6859        deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
6860    }
6861}
6862impl serde::Serialize for SourceNode {
6863    #[allow(deprecated)]
6864    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6865    where
6866        S: serde::Serializer,
6867    {
6868        use serde::ser::SerializeStruct;
6869        let mut len = 0;
6870        if self.source_id != 0 {
6871            len += 1;
6872        }
6873        if !self.columns.is_empty() {
6874            len += 1;
6875        }
6876        if !self.with_properties.is_empty() {
6877            len += 1;
6878        }
6879        if !self.split.is_empty() {
6880            len += 1;
6881        }
6882        if self.info.is_some() {
6883            len += 1;
6884        }
6885        if !self.secret_refs.is_empty() {
6886            len += 1;
6887        }
6888        let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
6889        if self.source_id != 0 {
6890            struct_ser.serialize_field("sourceId", &self.source_id)?;
6891        }
6892        if !self.columns.is_empty() {
6893            struct_ser.serialize_field("columns", &self.columns)?;
6894        }
6895        if !self.with_properties.is_empty() {
6896            struct_ser.serialize_field("withProperties", &self.with_properties)?;
6897        }
6898        if !self.split.is_empty() {
6899            struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6900        }
6901        if let Some(v) = self.info.as_ref() {
6902            struct_ser.serialize_field("info", v)?;
6903        }
6904        if !self.secret_refs.is_empty() {
6905            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
6906        }
6907        struct_ser.end()
6908    }
6909}
6910impl<'de> serde::Deserialize<'de> for SourceNode {
6911    #[allow(deprecated)]
6912    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6913    where
6914        D: serde::Deserializer<'de>,
6915    {
6916        const FIELDS: &[&str] = &[
6917            "source_id",
6918            "sourceId",
6919            "columns",
6920            "with_properties",
6921            "withProperties",
6922            "split",
6923            "info",
6924            "secret_refs",
6925            "secretRefs",
6926        ];
6927
6928        #[allow(clippy::enum_variant_names)]
6929        enum GeneratedField {
6930            SourceId,
6931            Columns,
6932            WithProperties,
6933            Split,
6934            Info,
6935            SecretRefs,
6936        }
6937        impl<'de> serde::Deserialize<'de> for GeneratedField {
6938            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6939            where
6940                D: serde::Deserializer<'de>,
6941            {
6942                struct GeneratedVisitor;
6943
6944                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6945                    type Value = GeneratedField;
6946
6947                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6948                        write!(formatter, "expected one of: {:?}", &FIELDS)
6949                    }
6950
6951                    #[allow(unused_variables)]
6952                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6953                    where
6954                        E: serde::de::Error,
6955                    {
6956                        match value {
6957                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
6958                            "columns" => Ok(GeneratedField::Columns),
6959                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
6960                            "split" => Ok(GeneratedField::Split),
6961                            "info" => Ok(GeneratedField::Info),
6962                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
6963                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6964                        }
6965                    }
6966                }
6967                deserializer.deserialize_identifier(GeneratedVisitor)
6968            }
6969        }
6970        struct GeneratedVisitor;
6971        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6972            type Value = SourceNode;
6973
6974            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6975                formatter.write_str("struct batch_plan.SourceNode")
6976            }
6977
6978            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
6979                where
6980                    V: serde::de::MapAccess<'de>,
6981            {
6982                let mut source_id__ = None;
6983                let mut columns__ = None;
6984                let mut with_properties__ = None;
6985                let mut split__ = None;
6986                let mut info__ = None;
6987                let mut secret_refs__ = None;
6988                while let Some(k) = map_.next_key()? {
6989                    match k {
6990                        GeneratedField::SourceId => {
6991                            if source_id__.is_some() {
6992                                return Err(serde::de::Error::duplicate_field("sourceId"));
6993                            }
6994                            source_id__ = 
6995                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6996                            ;
6997                        }
6998                        GeneratedField::Columns => {
6999                            if columns__.is_some() {
7000                                return Err(serde::de::Error::duplicate_field("columns"));
7001                            }
7002                            columns__ = Some(map_.next_value()?);
7003                        }
7004                        GeneratedField::WithProperties => {
7005                            if with_properties__.is_some() {
7006                                return Err(serde::de::Error::duplicate_field("withProperties"));
7007                            }
7008                            with_properties__ = Some(
7009                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
7010                            );
7011                        }
7012                        GeneratedField::Split => {
7013                            if split__.is_some() {
7014                                return Err(serde::de::Error::duplicate_field("split"));
7015                            }
7016                            split__ = 
7017                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7018                                    .into_iter().map(|x| x.0).collect())
7019                            ;
7020                        }
7021                        GeneratedField::Info => {
7022                            if info__.is_some() {
7023                                return Err(serde::de::Error::duplicate_field("info"));
7024                            }
7025                            info__ = map_.next_value()?;
7026                        }
7027                        GeneratedField::SecretRefs => {
7028                            if secret_refs__.is_some() {
7029                                return Err(serde::de::Error::duplicate_field("secretRefs"));
7030                            }
7031                            secret_refs__ = Some(
7032                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
7033                            );
7034                        }
7035                    }
7036                }
7037                Ok(SourceNode {
7038                    source_id: source_id__.unwrap_or_default(),
7039                    columns: columns__.unwrap_or_default(),
7040                    with_properties: with_properties__.unwrap_or_default(),
7041                    split: split__.unwrap_or_default(),
7042                    info: info__,
7043                    secret_refs: secret_refs__.unwrap_or_default(),
7044                })
7045            }
7046        }
7047        deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7048    }
7049}
7050impl serde::Serialize for SysRowSeqScanNode {
7051    #[allow(deprecated)]
7052    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7053    where
7054        S: serde::Serializer,
7055    {
7056        use serde::ser::SerializeStruct;
7057        let mut len = 0;
7058        if self.table_id != 0 {
7059            len += 1;
7060        }
7061        if !self.column_descs.is_empty() {
7062            len += 1;
7063        }
7064        let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7065        if self.table_id != 0 {
7066            struct_ser.serialize_field("tableId", &self.table_id)?;
7067        }
7068        if !self.column_descs.is_empty() {
7069            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7070        }
7071        struct_ser.end()
7072    }
7073}
7074impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7075    #[allow(deprecated)]
7076    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7077    where
7078        D: serde::Deserializer<'de>,
7079    {
7080        const FIELDS: &[&str] = &[
7081            "table_id",
7082            "tableId",
7083            "column_descs",
7084            "columnDescs",
7085        ];
7086
7087        #[allow(clippy::enum_variant_names)]
7088        enum GeneratedField {
7089            TableId,
7090            ColumnDescs,
7091        }
7092        impl<'de> serde::Deserialize<'de> for GeneratedField {
7093            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7094            where
7095                D: serde::Deserializer<'de>,
7096            {
7097                struct GeneratedVisitor;
7098
7099                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7100                    type Value = GeneratedField;
7101
7102                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7103                        write!(formatter, "expected one of: {:?}", &FIELDS)
7104                    }
7105
7106                    #[allow(unused_variables)]
7107                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7108                    where
7109                        E: serde::de::Error,
7110                    {
7111                        match value {
7112                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
7113                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7114                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7115                        }
7116                    }
7117                }
7118                deserializer.deserialize_identifier(GeneratedVisitor)
7119            }
7120        }
7121        struct GeneratedVisitor;
7122        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7123            type Value = SysRowSeqScanNode;
7124
7125            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7126                formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7127            }
7128
7129            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7130                where
7131                    V: serde::de::MapAccess<'de>,
7132            {
7133                let mut table_id__ = None;
7134                let mut column_descs__ = None;
7135                while let Some(k) = map_.next_key()? {
7136                    match k {
7137                        GeneratedField::TableId => {
7138                            if table_id__.is_some() {
7139                                return Err(serde::de::Error::duplicate_field("tableId"));
7140                            }
7141                            table_id__ = 
7142                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7143                            ;
7144                        }
7145                        GeneratedField::ColumnDescs => {
7146                            if column_descs__.is_some() {
7147                                return Err(serde::de::Error::duplicate_field("columnDescs"));
7148                            }
7149                            column_descs__ = Some(map_.next_value()?);
7150                        }
7151                    }
7152                }
7153                Ok(SysRowSeqScanNode {
7154                    table_id: table_id__.unwrap_or_default(),
7155                    column_descs: column_descs__.unwrap_or_default(),
7156                })
7157            }
7158        }
7159        deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7160    }
7161}
7162impl serde::Serialize for TableFunctionNode {
7163    #[allow(deprecated)]
7164    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7165    where
7166        S: serde::Serializer,
7167    {
7168        use serde::ser::SerializeStruct;
7169        let mut len = 0;
7170        if self.table_function.is_some() {
7171            len += 1;
7172        }
7173        let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7174        if let Some(v) = self.table_function.as_ref() {
7175            struct_ser.serialize_field("tableFunction", v)?;
7176        }
7177        struct_ser.end()
7178    }
7179}
7180impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7181    #[allow(deprecated)]
7182    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7183    where
7184        D: serde::Deserializer<'de>,
7185    {
7186        const FIELDS: &[&str] = &[
7187            "table_function",
7188            "tableFunction",
7189        ];
7190
7191        #[allow(clippy::enum_variant_names)]
7192        enum GeneratedField {
7193            TableFunction,
7194        }
7195        impl<'de> serde::Deserialize<'de> for GeneratedField {
7196            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7197            where
7198                D: serde::Deserializer<'de>,
7199            {
7200                struct GeneratedVisitor;
7201
7202                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7203                    type Value = GeneratedField;
7204
7205                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7206                        write!(formatter, "expected one of: {:?}", &FIELDS)
7207                    }
7208
7209                    #[allow(unused_variables)]
7210                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7211                    where
7212                        E: serde::de::Error,
7213                    {
7214                        match value {
7215                            "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7216                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7217                        }
7218                    }
7219                }
7220                deserializer.deserialize_identifier(GeneratedVisitor)
7221            }
7222        }
7223        struct GeneratedVisitor;
7224        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7225            type Value = TableFunctionNode;
7226
7227            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7228                formatter.write_str("struct batch_plan.TableFunctionNode")
7229            }
7230
7231            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7232                where
7233                    V: serde::de::MapAccess<'de>,
7234            {
7235                let mut table_function__ = None;
7236                while let Some(k) = map_.next_key()? {
7237                    match k {
7238                        GeneratedField::TableFunction => {
7239                            if table_function__.is_some() {
7240                                return Err(serde::de::Error::duplicate_field("tableFunction"));
7241                            }
7242                            table_function__ = map_.next_value()?;
7243                        }
7244                    }
7245                }
7246                Ok(TableFunctionNode {
7247                    table_function: table_function__,
7248                })
7249            }
7250        }
7251        deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7252    }
7253}
7254impl serde::Serialize for TaskId {
7255    #[allow(deprecated)]
7256    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7257    where
7258        S: serde::Serializer,
7259    {
7260        use serde::ser::SerializeStruct;
7261        let mut len = 0;
7262        if !self.query_id.is_empty() {
7263            len += 1;
7264        }
7265        if self.stage_id != 0 {
7266            len += 1;
7267        }
7268        if self.task_id != 0 {
7269            len += 1;
7270        }
7271        let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7272        if !self.query_id.is_empty() {
7273            struct_ser.serialize_field("queryId", &self.query_id)?;
7274        }
7275        if self.stage_id != 0 {
7276            struct_ser.serialize_field("stageId", &self.stage_id)?;
7277        }
7278        if self.task_id != 0 {
7279            #[allow(clippy::needless_borrow)]
7280            #[allow(clippy::needless_borrows_for_generic_args)]
7281            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7282        }
7283        struct_ser.end()
7284    }
7285}
7286impl<'de> serde::Deserialize<'de> for TaskId {
7287    #[allow(deprecated)]
7288    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7289    where
7290        D: serde::Deserializer<'de>,
7291    {
7292        const FIELDS: &[&str] = &[
7293            "query_id",
7294            "queryId",
7295            "stage_id",
7296            "stageId",
7297            "task_id",
7298            "taskId",
7299        ];
7300
7301        #[allow(clippy::enum_variant_names)]
7302        enum GeneratedField {
7303            QueryId,
7304            StageId,
7305            TaskId,
7306        }
7307        impl<'de> serde::Deserialize<'de> for GeneratedField {
7308            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7309            where
7310                D: serde::Deserializer<'de>,
7311            {
7312                struct GeneratedVisitor;
7313
7314                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7315                    type Value = GeneratedField;
7316
7317                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7318                        write!(formatter, "expected one of: {:?}", &FIELDS)
7319                    }
7320
7321                    #[allow(unused_variables)]
7322                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7323                    where
7324                        E: serde::de::Error,
7325                    {
7326                        match value {
7327                            "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7328                            "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7329                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7330                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7331                        }
7332                    }
7333                }
7334                deserializer.deserialize_identifier(GeneratedVisitor)
7335            }
7336        }
7337        struct GeneratedVisitor;
7338        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7339            type Value = TaskId;
7340
7341            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7342                formatter.write_str("struct batch_plan.TaskId")
7343            }
7344
7345            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7346                where
7347                    V: serde::de::MapAccess<'de>,
7348            {
7349                let mut query_id__ = None;
7350                let mut stage_id__ = None;
7351                let mut task_id__ = None;
7352                while let Some(k) = map_.next_key()? {
7353                    match k {
7354                        GeneratedField::QueryId => {
7355                            if query_id__.is_some() {
7356                                return Err(serde::de::Error::duplicate_field("queryId"));
7357                            }
7358                            query_id__ = Some(map_.next_value()?);
7359                        }
7360                        GeneratedField::StageId => {
7361                            if stage_id__.is_some() {
7362                                return Err(serde::de::Error::duplicate_field("stageId"));
7363                            }
7364                            stage_id__ = 
7365                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7366                            ;
7367                        }
7368                        GeneratedField::TaskId => {
7369                            if task_id__.is_some() {
7370                                return Err(serde::de::Error::duplicate_field("taskId"));
7371                            }
7372                            task_id__ = 
7373                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7374                            ;
7375                        }
7376                    }
7377                }
7378                Ok(TaskId {
7379                    query_id: query_id__.unwrap_or_default(),
7380                    stage_id: stage_id__.unwrap_or_default(),
7381                    task_id: task_id__.unwrap_or_default(),
7382                })
7383            }
7384        }
7385        deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7386    }
7387}
7388impl serde::Serialize for TaskOutputId {
7389    #[allow(deprecated)]
7390    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7391    where
7392        S: serde::Serializer,
7393    {
7394        use serde::ser::SerializeStruct;
7395        let mut len = 0;
7396        if self.task_id.is_some() {
7397            len += 1;
7398        }
7399        if self.output_id != 0 {
7400            len += 1;
7401        }
7402        let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7403        if let Some(v) = self.task_id.as_ref() {
7404            struct_ser.serialize_field("taskId", v)?;
7405        }
7406        if self.output_id != 0 {
7407            #[allow(clippy::needless_borrow)]
7408            #[allow(clippy::needless_borrows_for_generic_args)]
7409            struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7410        }
7411        struct_ser.end()
7412    }
7413}
7414impl<'de> serde::Deserialize<'de> for TaskOutputId {
7415    #[allow(deprecated)]
7416    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7417    where
7418        D: serde::Deserializer<'de>,
7419    {
7420        const FIELDS: &[&str] = &[
7421            "task_id",
7422            "taskId",
7423            "output_id",
7424            "outputId",
7425        ];
7426
7427        #[allow(clippy::enum_variant_names)]
7428        enum GeneratedField {
7429            TaskId,
7430            OutputId,
7431        }
7432        impl<'de> serde::Deserialize<'de> for GeneratedField {
7433            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7434            where
7435                D: serde::Deserializer<'de>,
7436            {
7437                struct GeneratedVisitor;
7438
7439                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7440                    type Value = GeneratedField;
7441
7442                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7443                        write!(formatter, "expected one of: {:?}", &FIELDS)
7444                    }
7445
7446                    #[allow(unused_variables)]
7447                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7448                    where
7449                        E: serde::de::Error,
7450                    {
7451                        match value {
7452                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7453                            "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7454                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7455                        }
7456                    }
7457                }
7458                deserializer.deserialize_identifier(GeneratedVisitor)
7459            }
7460        }
7461        struct GeneratedVisitor;
7462        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7463            type Value = TaskOutputId;
7464
7465            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7466                formatter.write_str("struct batch_plan.TaskOutputId")
7467            }
7468
7469            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7470                where
7471                    V: serde::de::MapAccess<'de>,
7472            {
7473                let mut task_id__ = None;
7474                let mut output_id__ = None;
7475                while let Some(k) = map_.next_key()? {
7476                    match k {
7477                        GeneratedField::TaskId => {
7478                            if task_id__.is_some() {
7479                                return Err(serde::de::Error::duplicate_field("taskId"));
7480                            }
7481                            task_id__ = map_.next_value()?;
7482                        }
7483                        GeneratedField::OutputId => {
7484                            if output_id__.is_some() {
7485                                return Err(serde::de::Error::duplicate_field("outputId"));
7486                            }
7487                            output_id__ = 
7488                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7489                            ;
7490                        }
7491                    }
7492                }
7493                Ok(TaskOutputId {
7494                    task_id: task_id__,
7495                    output_id: output_id__.unwrap_or_default(),
7496                })
7497            }
7498        }
7499        deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7500    }
7501}
7502impl serde::Serialize for TopNNode {
7503    #[allow(deprecated)]
7504    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7505    where
7506        S: serde::Serializer,
7507    {
7508        use serde::ser::SerializeStruct;
7509        let mut len = 0;
7510        if !self.column_orders.is_empty() {
7511            len += 1;
7512        }
7513        if self.limit != 0 {
7514            len += 1;
7515        }
7516        if self.offset != 0 {
7517            len += 1;
7518        }
7519        if self.with_ties {
7520            len += 1;
7521        }
7522        let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
7523        if !self.column_orders.is_empty() {
7524            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7525        }
7526        if self.limit != 0 {
7527            #[allow(clippy::needless_borrow)]
7528            #[allow(clippy::needless_borrows_for_generic_args)]
7529            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
7530        }
7531        if self.offset != 0 {
7532            #[allow(clippy::needless_borrow)]
7533            #[allow(clippy::needless_borrows_for_generic_args)]
7534            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
7535        }
7536        if self.with_ties {
7537            struct_ser.serialize_field("withTies", &self.with_ties)?;
7538        }
7539        struct_ser.end()
7540    }
7541}
7542impl<'de> serde::Deserialize<'de> for TopNNode {
7543    #[allow(deprecated)]
7544    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7545    where
7546        D: serde::Deserializer<'de>,
7547    {
7548        const FIELDS: &[&str] = &[
7549            "column_orders",
7550            "columnOrders",
7551            "limit",
7552            "offset",
7553            "with_ties",
7554            "withTies",
7555        ];
7556
7557        #[allow(clippy::enum_variant_names)]
7558        enum GeneratedField {
7559            ColumnOrders,
7560            Limit,
7561            Offset,
7562            WithTies,
7563        }
7564        impl<'de> serde::Deserialize<'de> for GeneratedField {
7565            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7566            where
7567                D: serde::Deserializer<'de>,
7568            {
7569                struct GeneratedVisitor;
7570
7571                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7572                    type Value = GeneratedField;
7573
7574                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7575                        write!(formatter, "expected one of: {:?}", &FIELDS)
7576                    }
7577
7578                    #[allow(unused_variables)]
7579                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7580                    where
7581                        E: serde::de::Error,
7582                    {
7583                        match value {
7584                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7585                            "limit" => Ok(GeneratedField::Limit),
7586                            "offset" => Ok(GeneratedField::Offset),
7587                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
7588                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7589                        }
7590                    }
7591                }
7592                deserializer.deserialize_identifier(GeneratedVisitor)
7593            }
7594        }
7595        struct GeneratedVisitor;
7596        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7597            type Value = TopNNode;
7598
7599            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7600                formatter.write_str("struct batch_plan.TopNNode")
7601            }
7602
7603            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
7604                where
7605                    V: serde::de::MapAccess<'de>,
7606            {
7607                let mut column_orders__ = None;
7608                let mut limit__ = None;
7609                let mut offset__ = None;
7610                let mut with_ties__ = None;
7611                while let Some(k) = map_.next_key()? {
7612                    match k {
7613                        GeneratedField::ColumnOrders => {
7614                            if column_orders__.is_some() {
7615                                return Err(serde::de::Error::duplicate_field("columnOrders"));
7616                            }
7617                            column_orders__ = Some(map_.next_value()?);
7618                        }
7619                        GeneratedField::Limit => {
7620                            if limit__.is_some() {
7621                                return Err(serde::de::Error::duplicate_field("limit"));
7622                            }
7623                            limit__ = 
7624                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7625                            ;
7626                        }
7627                        GeneratedField::Offset => {
7628                            if offset__.is_some() {
7629                                return Err(serde::de::Error::duplicate_field("offset"));
7630                            }
7631                            offset__ = 
7632                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7633                            ;
7634                        }
7635                        GeneratedField::WithTies => {
7636                            if with_ties__.is_some() {
7637                                return Err(serde::de::Error::duplicate_field("withTies"));
7638                            }
7639                            with_ties__ = Some(map_.next_value()?);
7640                        }
7641                    }
7642                }
7643                Ok(TopNNode {
7644                    column_orders: column_orders__.unwrap_or_default(),
7645                    limit: limit__.unwrap_or_default(),
7646                    offset: offset__.unwrap_or_default(),
7647                    with_ties: with_ties__.unwrap_or_default(),
7648                })
7649            }
7650        }
7651        deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
7652    }
7653}
7654impl serde::Serialize for UnionNode {
7655    #[allow(deprecated)]
7656    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7657    where
7658        S: serde::Serializer,
7659    {
7660        use serde::ser::SerializeStruct;
7661        let len = 0;
7662        let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
7663        struct_ser.end()
7664    }
7665}
7666impl<'de> serde::Deserialize<'de> for UnionNode {
7667    #[allow(deprecated)]
7668    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7669    where
7670        D: serde::Deserializer<'de>,
7671    {
7672        const FIELDS: &[&str] = &[
7673        ];
7674
7675        #[allow(clippy::enum_variant_names)]
7676        enum GeneratedField {
7677        }
7678        impl<'de> serde::Deserialize<'de> for GeneratedField {
7679            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7680            where
7681                D: serde::Deserializer<'de>,
7682            {
7683                struct GeneratedVisitor;
7684
7685                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7686                    type Value = GeneratedField;
7687
7688                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7689                        write!(formatter, "expected one of: {:?}", &FIELDS)
7690                    }
7691
7692                    #[allow(unused_variables)]
7693                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7694                    where
7695                        E: serde::de::Error,
7696                    {
7697                            Err(serde::de::Error::unknown_field(value, FIELDS))
7698                    }
7699                }
7700                deserializer.deserialize_identifier(GeneratedVisitor)
7701            }
7702        }
7703        struct GeneratedVisitor;
7704        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7705            type Value = UnionNode;
7706
7707            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7708                formatter.write_str("struct batch_plan.UnionNode")
7709            }
7710
7711            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
7712                where
7713                    V: serde::de::MapAccess<'de>,
7714            {
7715                while map_.next_key::<GeneratedField>()?.is_some() {
7716                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7717                }
7718                Ok(UnionNode {
7719                })
7720            }
7721        }
7722        deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
7723    }
7724}
7725impl serde::Serialize for UpdateNode {
7726    #[allow(deprecated)]
7727    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7728    where
7729        S: serde::Serializer,
7730    {
7731        use serde::ser::SerializeStruct;
7732        let mut len = 0;
7733        if self.table_id != 0 {
7734            len += 1;
7735        }
7736        if self.table_version_id != 0 {
7737            len += 1;
7738        }
7739        if !self.old_exprs.is_empty() {
7740            len += 1;
7741        }
7742        if !self.new_exprs.is_empty() {
7743            len += 1;
7744        }
7745        if self.returning {
7746            len += 1;
7747        }
7748        if self.session_id != 0 {
7749            len += 1;
7750        }
7751        let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
7752        if self.table_id != 0 {
7753            struct_ser.serialize_field("tableId", &self.table_id)?;
7754        }
7755        if self.table_version_id != 0 {
7756            #[allow(clippy::needless_borrow)]
7757            #[allow(clippy::needless_borrows_for_generic_args)]
7758            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
7759        }
7760        if !self.old_exprs.is_empty() {
7761            struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
7762        }
7763        if !self.new_exprs.is_empty() {
7764            struct_ser.serialize_field("newExprs", &self.new_exprs)?;
7765        }
7766        if self.returning {
7767            struct_ser.serialize_field("returning", &self.returning)?;
7768        }
7769        if self.session_id != 0 {
7770            struct_ser.serialize_field("sessionId", &self.session_id)?;
7771        }
7772        struct_ser.end()
7773    }
7774}
7775impl<'de> serde::Deserialize<'de> for UpdateNode {
7776    #[allow(deprecated)]
7777    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7778    where
7779        D: serde::Deserializer<'de>,
7780    {
7781        const FIELDS: &[&str] = &[
7782            "table_id",
7783            "tableId",
7784            "table_version_id",
7785            "tableVersionId",
7786            "old_exprs",
7787            "oldExprs",
7788            "new_exprs",
7789            "newExprs",
7790            "returning",
7791            "session_id",
7792            "sessionId",
7793        ];
7794
7795        #[allow(clippy::enum_variant_names)]
7796        enum GeneratedField {
7797            TableId,
7798            TableVersionId,
7799            OldExprs,
7800            NewExprs,
7801            Returning,
7802            SessionId,
7803        }
7804        impl<'de> serde::Deserialize<'de> for GeneratedField {
7805            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7806            where
7807                D: serde::Deserializer<'de>,
7808            {
7809                struct GeneratedVisitor;
7810
7811                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7812                    type Value = GeneratedField;
7813
7814                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7815                        write!(formatter, "expected one of: {:?}", &FIELDS)
7816                    }
7817
7818                    #[allow(unused_variables)]
7819                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7820                    where
7821                        E: serde::de::Error,
7822                    {
7823                        match value {
7824                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
7825                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
7826                            "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
7827                            "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
7828                            "returning" => Ok(GeneratedField::Returning),
7829                            "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
7830                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7831                        }
7832                    }
7833                }
7834                deserializer.deserialize_identifier(GeneratedVisitor)
7835            }
7836        }
7837        struct GeneratedVisitor;
7838        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7839            type Value = UpdateNode;
7840
7841            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7842                formatter.write_str("struct batch_plan.UpdateNode")
7843            }
7844
7845            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
7846                where
7847                    V: serde::de::MapAccess<'de>,
7848            {
7849                let mut table_id__ = None;
7850                let mut table_version_id__ = None;
7851                let mut old_exprs__ = None;
7852                let mut new_exprs__ = None;
7853                let mut returning__ = None;
7854                let mut session_id__ = None;
7855                while let Some(k) = map_.next_key()? {
7856                    match k {
7857                        GeneratedField::TableId => {
7858                            if table_id__.is_some() {
7859                                return Err(serde::de::Error::duplicate_field("tableId"));
7860                            }
7861                            table_id__ = 
7862                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7863                            ;
7864                        }
7865                        GeneratedField::TableVersionId => {
7866                            if table_version_id__.is_some() {
7867                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
7868                            }
7869                            table_version_id__ = 
7870                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7871                            ;
7872                        }
7873                        GeneratedField::OldExprs => {
7874                            if old_exprs__.is_some() {
7875                                return Err(serde::de::Error::duplicate_field("oldExprs"));
7876                            }
7877                            old_exprs__ = Some(map_.next_value()?);
7878                        }
7879                        GeneratedField::NewExprs => {
7880                            if new_exprs__.is_some() {
7881                                return Err(serde::de::Error::duplicate_field("newExprs"));
7882                            }
7883                            new_exprs__ = Some(map_.next_value()?);
7884                        }
7885                        GeneratedField::Returning => {
7886                            if returning__.is_some() {
7887                                return Err(serde::de::Error::duplicate_field("returning"));
7888                            }
7889                            returning__ = Some(map_.next_value()?);
7890                        }
7891                        GeneratedField::SessionId => {
7892                            if session_id__.is_some() {
7893                                return Err(serde::de::Error::duplicate_field("sessionId"));
7894                            }
7895                            session_id__ = 
7896                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7897                            ;
7898                        }
7899                    }
7900                }
7901                Ok(UpdateNode {
7902                    table_id: table_id__.unwrap_or_default(),
7903                    table_version_id: table_version_id__.unwrap_or_default(),
7904                    old_exprs: old_exprs__.unwrap_or_default(),
7905                    new_exprs: new_exprs__.unwrap_or_default(),
7906                    returning: returning__.unwrap_or_default(),
7907                    session_id: session_id__.unwrap_or_default(),
7908                })
7909            }
7910        }
7911        deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
7912    }
7913}
7914impl serde::Serialize for ValuesNode {
7915    #[allow(deprecated)]
7916    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7917    where
7918        S: serde::Serializer,
7919    {
7920        use serde::ser::SerializeStruct;
7921        let mut len = 0;
7922        if !self.tuples.is_empty() {
7923            len += 1;
7924        }
7925        if !self.fields.is_empty() {
7926            len += 1;
7927        }
7928        let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
7929        if !self.tuples.is_empty() {
7930            struct_ser.serialize_field("tuples", &self.tuples)?;
7931        }
7932        if !self.fields.is_empty() {
7933            struct_ser.serialize_field("fields", &self.fields)?;
7934        }
7935        struct_ser.end()
7936    }
7937}
7938impl<'de> serde::Deserialize<'de> for ValuesNode {
7939    #[allow(deprecated)]
7940    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7941    where
7942        D: serde::Deserializer<'de>,
7943    {
7944        const FIELDS: &[&str] = &[
7945            "tuples",
7946            "fields",
7947        ];
7948
7949        #[allow(clippy::enum_variant_names)]
7950        enum GeneratedField {
7951            Tuples,
7952            Fields,
7953        }
7954        impl<'de> serde::Deserialize<'de> for GeneratedField {
7955            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7956            where
7957                D: serde::Deserializer<'de>,
7958            {
7959                struct GeneratedVisitor;
7960
7961                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7962                    type Value = GeneratedField;
7963
7964                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7965                        write!(formatter, "expected one of: {:?}", &FIELDS)
7966                    }
7967
7968                    #[allow(unused_variables)]
7969                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7970                    where
7971                        E: serde::de::Error,
7972                    {
7973                        match value {
7974                            "tuples" => Ok(GeneratedField::Tuples),
7975                            "fields" => Ok(GeneratedField::Fields),
7976                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7977                        }
7978                    }
7979                }
7980                deserializer.deserialize_identifier(GeneratedVisitor)
7981            }
7982        }
7983        struct GeneratedVisitor;
7984        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7985            type Value = ValuesNode;
7986
7987            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7988                formatter.write_str("struct batch_plan.ValuesNode")
7989            }
7990
7991            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
7992                where
7993                    V: serde::de::MapAccess<'de>,
7994            {
7995                let mut tuples__ = None;
7996                let mut fields__ = None;
7997                while let Some(k) = map_.next_key()? {
7998                    match k {
7999                        GeneratedField::Tuples => {
8000                            if tuples__.is_some() {
8001                                return Err(serde::de::Error::duplicate_field("tuples"));
8002                            }
8003                            tuples__ = Some(map_.next_value()?);
8004                        }
8005                        GeneratedField::Fields => {
8006                            if fields__.is_some() {
8007                                return Err(serde::de::Error::duplicate_field("fields"));
8008                            }
8009                            fields__ = Some(map_.next_value()?);
8010                        }
8011                    }
8012                }
8013                Ok(ValuesNode {
8014                    tuples: tuples__.unwrap_or_default(),
8015                    fields: fields__.unwrap_or_default(),
8016                })
8017            }
8018        }
8019        deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8020    }
8021}
8022impl serde::Serialize for values_node::ExprTuple {
8023    #[allow(deprecated)]
8024    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8025    where
8026        S: serde::Serializer,
8027    {
8028        use serde::ser::SerializeStruct;
8029        let mut len = 0;
8030        if !self.cells.is_empty() {
8031            len += 1;
8032        }
8033        let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8034        if !self.cells.is_empty() {
8035            struct_ser.serialize_field("cells", &self.cells)?;
8036        }
8037        struct_ser.end()
8038    }
8039}
8040impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8041    #[allow(deprecated)]
8042    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8043    where
8044        D: serde::Deserializer<'de>,
8045    {
8046        const FIELDS: &[&str] = &[
8047            "cells",
8048        ];
8049
8050        #[allow(clippy::enum_variant_names)]
8051        enum GeneratedField {
8052            Cells,
8053        }
8054        impl<'de> serde::Deserialize<'de> for GeneratedField {
8055            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8056            where
8057                D: serde::Deserializer<'de>,
8058            {
8059                struct GeneratedVisitor;
8060
8061                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8062                    type Value = GeneratedField;
8063
8064                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8065                        write!(formatter, "expected one of: {:?}", &FIELDS)
8066                    }
8067
8068                    #[allow(unused_variables)]
8069                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8070                    where
8071                        E: serde::de::Error,
8072                    {
8073                        match value {
8074                            "cells" => Ok(GeneratedField::Cells),
8075                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8076                        }
8077                    }
8078                }
8079                deserializer.deserialize_identifier(GeneratedVisitor)
8080            }
8081        }
8082        struct GeneratedVisitor;
8083        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8084            type Value = values_node::ExprTuple;
8085
8086            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087                formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8088            }
8089
8090            fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8091                where
8092                    V: serde::de::MapAccess<'de>,
8093            {
8094                let mut cells__ = None;
8095                while let Some(k) = map_.next_key()? {
8096                    match k {
8097                        GeneratedField::Cells => {
8098                            if cells__.is_some() {
8099                                return Err(serde::de::Error::duplicate_field("cells"));
8100                            }
8101                            cells__ = Some(map_.next_value()?);
8102                        }
8103                    }
8104                }
8105                Ok(values_node::ExprTuple {
8106                    cells: cells__.unwrap_or_default(),
8107                })
8108            }
8109        }
8110        deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8111    }
8112}
8113impl serde::Serialize for VectorIndexNearestNode {
8114    #[allow(deprecated)]
8115    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8116    where
8117        S: serde::Serializer,
8118    {
8119        use serde::ser::SerializeStruct;
8120        let mut len = 0;
8121        if self.table_id != 0 {
8122            len += 1;
8123        }
8124        if !self.info_column_desc.is_empty() {
8125            len += 1;
8126        }
8127        if self.vector_column_idx != 0 {
8128            len += 1;
8129        }
8130        if self.top_n != 0 {
8131            len += 1;
8132        }
8133        if self.distance_type != 0 {
8134            len += 1;
8135        }
8136        if self.hnsw_ef_search != 0 {
8137            len += 1;
8138        }
8139        let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8140        if self.table_id != 0 {
8141            struct_ser.serialize_field("tableId", &self.table_id)?;
8142        }
8143        if !self.info_column_desc.is_empty() {
8144            struct_ser.serialize_field("infoColumnDesc", &self.info_column_desc)?;
8145        }
8146        if self.vector_column_idx != 0 {
8147            struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8148        }
8149        if self.top_n != 0 {
8150            struct_ser.serialize_field("topN", &self.top_n)?;
8151        }
8152        if self.distance_type != 0 {
8153            let v = super::common::DistanceType::try_from(self.distance_type)
8154                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
8155            struct_ser.serialize_field("distanceType", &v)?;
8156        }
8157        if self.hnsw_ef_search != 0 {
8158            struct_ser.serialize_field("hnswEfSearch", &self.hnsw_ef_search)?;
8159        }
8160        struct_ser.end()
8161    }
8162}
8163impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8164    #[allow(deprecated)]
8165    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8166    where
8167        D: serde::Deserializer<'de>,
8168    {
8169        const FIELDS: &[&str] = &[
8170            "table_id",
8171            "tableId",
8172            "info_column_desc",
8173            "infoColumnDesc",
8174            "vector_column_idx",
8175            "vectorColumnIdx",
8176            "top_n",
8177            "topN",
8178            "distance_type",
8179            "distanceType",
8180            "hnsw_ef_search",
8181            "hnswEfSearch",
8182        ];
8183
8184        #[allow(clippy::enum_variant_names)]
8185        enum GeneratedField {
8186            TableId,
8187            InfoColumnDesc,
8188            VectorColumnIdx,
8189            TopN,
8190            DistanceType,
8191            HnswEfSearch,
8192        }
8193        impl<'de> serde::Deserialize<'de> for GeneratedField {
8194            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8195            where
8196                D: serde::Deserializer<'de>,
8197            {
8198                struct GeneratedVisitor;
8199
8200                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8201                    type Value = GeneratedField;
8202
8203                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8204                        write!(formatter, "expected one of: {:?}", &FIELDS)
8205                    }
8206
8207                    #[allow(unused_variables)]
8208                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8209                    where
8210                        E: serde::de::Error,
8211                    {
8212                        match value {
8213                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
8214                            "infoColumnDesc" | "info_column_desc" => Ok(GeneratedField::InfoColumnDesc),
8215                            "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8216                            "topN" | "top_n" => Ok(GeneratedField::TopN),
8217                            "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
8218                            "hnswEfSearch" | "hnsw_ef_search" => Ok(GeneratedField::HnswEfSearch),
8219                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8220                        }
8221                    }
8222                }
8223                deserializer.deserialize_identifier(GeneratedVisitor)
8224            }
8225        }
8226        struct GeneratedVisitor;
8227        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8228            type Value = VectorIndexNearestNode;
8229
8230            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8231                formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8232            }
8233
8234            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8235                where
8236                    V: serde::de::MapAccess<'de>,
8237            {
8238                let mut table_id__ = None;
8239                let mut info_column_desc__ = None;
8240                let mut vector_column_idx__ = None;
8241                let mut top_n__ = None;
8242                let mut distance_type__ = None;
8243                let mut hnsw_ef_search__ = None;
8244                while let Some(k) = map_.next_key()? {
8245                    match k {
8246                        GeneratedField::TableId => {
8247                            if table_id__.is_some() {
8248                                return Err(serde::de::Error::duplicate_field("tableId"));
8249                            }
8250                            table_id__ = 
8251                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8252                            ;
8253                        }
8254                        GeneratedField::InfoColumnDesc => {
8255                            if info_column_desc__.is_some() {
8256                                return Err(serde::de::Error::duplicate_field("infoColumnDesc"));
8257                            }
8258                            info_column_desc__ = Some(map_.next_value()?);
8259                        }
8260                        GeneratedField::VectorColumnIdx => {
8261                            if vector_column_idx__.is_some() {
8262                                return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8263                            }
8264                            vector_column_idx__ = 
8265                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8266                            ;
8267                        }
8268                        GeneratedField::TopN => {
8269                            if top_n__.is_some() {
8270                                return Err(serde::de::Error::duplicate_field("topN"));
8271                            }
8272                            top_n__ = 
8273                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8274                            ;
8275                        }
8276                        GeneratedField::DistanceType => {
8277                            if distance_type__.is_some() {
8278                                return Err(serde::de::Error::duplicate_field("distanceType"));
8279                            }
8280                            distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
8281                        }
8282                        GeneratedField::HnswEfSearch => {
8283                            if hnsw_ef_search__.is_some() {
8284                                return Err(serde::de::Error::duplicate_field("hnswEfSearch"));
8285                            }
8286                            hnsw_ef_search__ = 
8287                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8288                            ;
8289                        }
8290                    }
8291                }
8292                Ok(VectorIndexNearestNode {
8293                    table_id: table_id__.unwrap_or_default(),
8294                    info_column_desc: info_column_desc__.unwrap_or_default(),
8295                    vector_column_idx: vector_column_idx__.unwrap_or_default(),
8296                    top_n: top_n__.unwrap_or_default(),
8297                    distance_type: distance_type__.unwrap_or_default(),
8298                    hnsw_ef_search: hnsw_ef_search__.unwrap_or_default(),
8299                })
8300            }
8301        }
8302        deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
8303    }
8304}