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 GetChannelDeltaStatsNode {
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.at_time.is_some() {
2371            len += 1;
2372        }
2373        if self.time_offset.is_some() {
2374            len += 1;
2375        }
2376        let mut struct_ser = serializer.serialize_struct("batch_plan.GetChannelDeltaStatsNode", len)?;
2377        if let Some(v) = self.at_time.as_ref() {
2378            #[allow(clippy::needless_borrow)]
2379            #[allow(clippy::needless_borrows_for_generic_args)]
2380            struct_ser.serialize_field("atTime", ToString::to_string(&v).as_str())?;
2381        }
2382        if let Some(v) = self.time_offset.as_ref() {
2383            #[allow(clippy::needless_borrow)]
2384            #[allow(clippy::needless_borrows_for_generic_args)]
2385            struct_ser.serialize_field("timeOffset", ToString::to_string(&v).as_str())?;
2386        }
2387        struct_ser.end()
2388    }
2389}
2390impl<'de> serde::Deserialize<'de> for GetChannelDeltaStatsNode {
2391    #[allow(deprecated)]
2392    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2393    where
2394        D: serde::Deserializer<'de>,
2395    {
2396        const FIELDS: &[&str] = &[
2397            "at_time",
2398            "atTime",
2399            "time_offset",
2400            "timeOffset",
2401        ];
2402
2403        #[allow(clippy::enum_variant_names)]
2404        enum GeneratedField {
2405            AtTime,
2406            TimeOffset,
2407        }
2408        impl<'de> serde::Deserialize<'de> for GeneratedField {
2409            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2410            where
2411                D: serde::Deserializer<'de>,
2412            {
2413                struct GeneratedVisitor;
2414
2415                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2416                    type Value = GeneratedField;
2417
2418                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2419                        write!(formatter, "expected one of: {:?}", &FIELDS)
2420                    }
2421
2422                    #[allow(unused_variables)]
2423                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2424                    where
2425                        E: serde::de::Error,
2426                    {
2427                        match value {
2428                            "atTime" | "at_time" => Ok(GeneratedField::AtTime),
2429                            "timeOffset" | "time_offset" => Ok(GeneratedField::TimeOffset),
2430                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2431                        }
2432                    }
2433                }
2434                deserializer.deserialize_identifier(GeneratedVisitor)
2435            }
2436        }
2437        struct GeneratedVisitor;
2438        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2439            type Value = GetChannelDeltaStatsNode;
2440
2441            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2442                formatter.write_str("struct batch_plan.GetChannelDeltaStatsNode")
2443            }
2444
2445            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetChannelDeltaStatsNode, V::Error>
2446                where
2447                    V: serde::de::MapAccess<'de>,
2448            {
2449                let mut at_time__ = None;
2450                let mut time_offset__ = None;
2451                while let Some(k) = map_.next_key()? {
2452                    match k {
2453                        GeneratedField::AtTime => {
2454                            if at_time__.is_some() {
2455                                return Err(serde::de::Error::duplicate_field("atTime"));
2456                            }
2457                            at_time__ = 
2458                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2459                            ;
2460                        }
2461                        GeneratedField::TimeOffset => {
2462                            if time_offset__.is_some() {
2463                                return Err(serde::de::Error::duplicate_field("timeOffset"));
2464                            }
2465                            time_offset__ = 
2466                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2467                            ;
2468                        }
2469                    }
2470                }
2471                Ok(GetChannelDeltaStatsNode {
2472                    at_time: at_time__,
2473                    time_offset: time_offset__,
2474                })
2475            }
2476        }
2477        deserializer.deserialize_struct("batch_plan.GetChannelDeltaStatsNode", FIELDS, GeneratedVisitor)
2478    }
2479}
2480impl serde::Serialize for GroupTopNNode {
2481    #[allow(deprecated)]
2482    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2483    where
2484        S: serde::Serializer,
2485    {
2486        use serde::ser::SerializeStruct;
2487        let mut len = 0;
2488        if !self.column_orders.is_empty() {
2489            len += 1;
2490        }
2491        if self.limit != 0 {
2492            len += 1;
2493        }
2494        if self.offset != 0 {
2495            len += 1;
2496        }
2497        if !self.group_key.is_empty() {
2498            len += 1;
2499        }
2500        if self.with_ties {
2501            len += 1;
2502        }
2503        let mut struct_ser = serializer.serialize_struct("batch_plan.GroupTopNNode", len)?;
2504        if !self.column_orders.is_empty() {
2505            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
2506        }
2507        if self.limit != 0 {
2508            #[allow(clippy::needless_borrow)]
2509            #[allow(clippy::needless_borrows_for_generic_args)]
2510            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
2511        }
2512        if self.offset != 0 {
2513            #[allow(clippy::needless_borrow)]
2514            #[allow(clippy::needless_borrows_for_generic_args)]
2515            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
2516        }
2517        if !self.group_key.is_empty() {
2518            struct_ser.serialize_field("groupKey", &self.group_key)?;
2519        }
2520        if self.with_ties {
2521            struct_ser.serialize_field("withTies", &self.with_ties)?;
2522        }
2523        struct_ser.end()
2524    }
2525}
2526impl<'de> serde::Deserialize<'de> for GroupTopNNode {
2527    #[allow(deprecated)]
2528    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2529    where
2530        D: serde::Deserializer<'de>,
2531    {
2532        const FIELDS: &[&str] = &[
2533            "column_orders",
2534            "columnOrders",
2535            "limit",
2536            "offset",
2537            "group_key",
2538            "groupKey",
2539            "with_ties",
2540            "withTies",
2541        ];
2542
2543        #[allow(clippy::enum_variant_names)]
2544        enum GeneratedField {
2545            ColumnOrders,
2546            Limit,
2547            Offset,
2548            GroupKey,
2549            WithTies,
2550        }
2551        impl<'de> serde::Deserialize<'de> for GeneratedField {
2552            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2553            where
2554                D: serde::Deserializer<'de>,
2555            {
2556                struct GeneratedVisitor;
2557
2558                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2559                    type Value = GeneratedField;
2560
2561                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2562                        write!(formatter, "expected one of: {:?}", &FIELDS)
2563                    }
2564
2565                    #[allow(unused_variables)]
2566                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2567                    where
2568                        E: serde::de::Error,
2569                    {
2570                        match value {
2571                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
2572                            "limit" => Ok(GeneratedField::Limit),
2573                            "offset" => Ok(GeneratedField::Offset),
2574                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2575                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
2576                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2577                        }
2578                    }
2579                }
2580                deserializer.deserialize_identifier(GeneratedVisitor)
2581            }
2582        }
2583        struct GeneratedVisitor;
2584        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2585            type Value = GroupTopNNode;
2586
2587            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2588                formatter.write_str("struct batch_plan.GroupTopNNode")
2589            }
2590
2591            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
2592                where
2593                    V: serde::de::MapAccess<'de>,
2594            {
2595                let mut column_orders__ = None;
2596                let mut limit__ = None;
2597                let mut offset__ = None;
2598                let mut group_key__ = None;
2599                let mut with_ties__ = None;
2600                while let Some(k) = map_.next_key()? {
2601                    match k {
2602                        GeneratedField::ColumnOrders => {
2603                            if column_orders__.is_some() {
2604                                return Err(serde::de::Error::duplicate_field("columnOrders"));
2605                            }
2606                            column_orders__ = Some(map_.next_value()?);
2607                        }
2608                        GeneratedField::Limit => {
2609                            if limit__.is_some() {
2610                                return Err(serde::de::Error::duplicate_field("limit"));
2611                            }
2612                            limit__ = 
2613                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2614                            ;
2615                        }
2616                        GeneratedField::Offset => {
2617                            if offset__.is_some() {
2618                                return Err(serde::de::Error::duplicate_field("offset"));
2619                            }
2620                            offset__ = 
2621                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2622                            ;
2623                        }
2624                        GeneratedField::GroupKey => {
2625                            if group_key__.is_some() {
2626                                return Err(serde::de::Error::duplicate_field("groupKey"));
2627                            }
2628                            group_key__ = 
2629                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2630                                    .into_iter().map(|x| x.0).collect())
2631                            ;
2632                        }
2633                        GeneratedField::WithTies => {
2634                            if with_ties__.is_some() {
2635                                return Err(serde::de::Error::duplicate_field("withTies"));
2636                            }
2637                            with_ties__ = Some(map_.next_value()?);
2638                        }
2639                    }
2640                }
2641                Ok(GroupTopNNode {
2642                    column_orders: column_orders__.unwrap_or_default(),
2643                    limit: limit__.unwrap_or_default(),
2644                    offset: offset__.unwrap_or_default(),
2645                    group_key: group_key__.unwrap_or_default(),
2646                    with_ties: with_ties__.unwrap_or_default(),
2647                })
2648            }
2649        }
2650        deserializer.deserialize_struct("batch_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
2651    }
2652}
2653impl serde::Serialize for HashAggNode {
2654    #[allow(deprecated)]
2655    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2656    where
2657        S: serde::Serializer,
2658    {
2659        use serde::ser::SerializeStruct;
2660        let mut len = 0;
2661        if !self.group_key.is_empty() {
2662            len += 1;
2663        }
2664        if !self.agg_calls.is_empty() {
2665            len += 1;
2666        }
2667        let mut struct_ser = serializer.serialize_struct("batch_plan.HashAggNode", len)?;
2668        if !self.group_key.is_empty() {
2669            struct_ser.serialize_field("groupKey", &self.group_key)?;
2670        }
2671        if !self.agg_calls.is_empty() {
2672            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
2673        }
2674        struct_ser.end()
2675    }
2676}
2677impl<'de> serde::Deserialize<'de> for HashAggNode {
2678    #[allow(deprecated)]
2679    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2680    where
2681        D: serde::Deserializer<'de>,
2682    {
2683        const FIELDS: &[&str] = &[
2684            "group_key",
2685            "groupKey",
2686            "agg_calls",
2687            "aggCalls",
2688        ];
2689
2690        #[allow(clippy::enum_variant_names)]
2691        enum GeneratedField {
2692            GroupKey,
2693            AggCalls,
2694        }
2695        impl<'de> serde::Deserialize<'de> for GeneratedField {
2696            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2697            where
2698                D: serde::Deserializer<'de>,
2699            {
2700                struct GeneratedVisitor;
2701
2702                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2703                    type Value = GeneratedField;
2704
2705                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2706                        write!(formatter, "expected one of: {:?}", &FIELDS)
2707                    }
2708
2709                    #[allow(unused_variables)]
2710                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2711                    where
2712                        E: serde::de::Error,
2713                    {
2714                        match value {
2715                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
2716                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
2717                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2718                        }
2719                    }
2720                }
2721                deserializer.deserialize_identifier(GeneratedVisitor)
2722            }
2723        }
2724        struct GeneratedVisitor;
2725        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2726            type Value = HashAggNode;
2727
2728            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2729                formatter.write_str("struct batch_plan.HashAggNode")
2730            }
2731
2732            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
2733                where
2734                    V: serde::de::MapAccess<'de>,
2735            {
2736                let mut group_key__ = None;
2737                let mut agg_calls__ = None;
2738                while let Some(k) = map_.next_key()? {
2739                    match k {
2740                        GeneratedField::GroupKey => {
2741                            if group_key__.is_some() {
2742                                return Err(serde::de::Error::duplicate_field("groupKey"));
2743                            }
2744                            group_key__ = 
2745                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2746                                    .into_iter().map(|x| x.0).collect())
2747                            ;
2748                        }
2749                        GeneratedField::AggCalls => {
2750                            if agg_calls__.is_some() {
2751                                return Err(serde::de::Error::duplicate_field("aggCalls"));
2752                            }
2753                            agg_calls__ = Some(map_.next_value()?);
2754                        }
2755                    }
2756                }
2757                Ok(HashAggNode {
2758                    group_key: group_key__.unwrap_or_default(),
2759                    agg_calls: agg_calls__.unwrap_or_default(),
2760                })
2761            }
2762        }
2763        deserializer.deserialize_struct("batch_plan.HashAggNode", FIELDS, GeneratedVisitor)
2764    }
2765}
2766impl serde::Serialize for HashJoinNode {
2767    #[allow(deprecated)]
2768    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2769    where
2770        S: serde::Serializer,
2771    {
2772        use serde::ser::SerializeStruct;
2773        let mut len = 0;
2774        if self.join_type != 0 {
2775            len += 1;
2776        }
2777        if !self.left_key.is_empty() {
2778            len += 1;
2779        }
2780        if !self.right_key.is_empty() {
2781            len += 1;
2782        }
2783        if self.condition.is_some() {
2784            len += 1;
2785        }
2786        if !self.output_indices.is_empty() {
2787            len += 1;
2788        }
2789        if !self.null_safe.is_empty() {
2790            len += 1;
2791        }
2792        if self.asof_desc.is_some() {
2793            len += 1;
2794        }
2795        let mut struct_ser = serializer.serialize_struct("batch_plan.HashJoinNode", len)?;
2796        if self.join_type != 0 {
2797            let v = super::plan_common::JoinType::try_from(self.join_type)
2798                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2799            struct_ser.serialize_field("joinType", &v)?;
2800        }
2801        if !self.left_key.is_empty() {
2802            struct_ser.serialize_field("leftKey", &self.left_key)?;
2803        }
2804        if !self.right_key.is_empty() {
2805            struct_ser.serialize_field("rightKey", &self.right_key)?;
2806        }
2807        if let Some(v) = self.condition.as_ref() {
2808            struct_ser.serialize_field("condition", v)?;
2809        }
2810        if !self.output_indices.is_empty() {
2811            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2812        }
2813        if !self.null_safe.is_empty() {
2814            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
2815        }
2816        if let Some(v) = self.asof_desc.as_ref() {
2817            struct_ser.serialize_field("asofDesc", v)?;
2818        }
2819        struct_ser.end()
2820    }
2821}
2822impl<'de> serde::Deserialize<'de> for HashJoinNode {
2823    #[allow(deprecated)]
2824    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2825    where
2826        D: serde::Deserializer<'de>,
2827    {
2828        const FIELDS: &[&str] = &[
2829            "join_type",
2830            "joinType",
2831            "left_key",
2832            "leftKey",
2833            "right_key",
2834            "rightKey",
2835            "condition",
2836            "output_indices",
2837            "outputIndices",
2838            "null_safe",
2839            "nullSafe",
2840            "asof_desc",
2841            "asofDesc",
2842        ];
2843
2844        #[allow(clippy::enum_variant_names)]
2845        enum GeneratedField {
2846            JoinType,
2847            LeftKey,
2848            RightKey,
2849            Condition,
2850            OutputIndices,
2851            NullSafe,
2852            AsofDesc,
2853        }
2854        impl<'de> serde::Deserialize<'de> for GeneratedField {
2855            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2856            where
2857                D: serde::Deserializer<'de>,
2858            {
2859                struct GeneratedVisitor;
2860
2861                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2862                    type Value = GeneratedField;
2863
2864                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2865                        write!(formatter, "expected one of: {:?}", &FIELDS)
2866                    }
2867
2868                    #[allow(unused_variables)]
2869                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2870                    where
2871                        E: serde::de::Error,
2872                    {
2873                        match value {
2874                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2875                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2876                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2877                            "condition" => Ok(GeneratedField::Condition),
2878                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2879                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
2880                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
2881                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2882                        }
2883                    }
2884                }
2885                deserializer.deserialize_identifier(GeneratedVisitor)
2886            }
2887        }
2888        struct GeneratedVisitor;
2889        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2890            type Value = HashJoinNode;
2891
2892            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2893                formatter.write_str("struct batch_plan.HashJoinNode")
2894            }
2895
2896            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
2897                where
2898                    V: serde::de::MapAccess<'de>,
2899            {
2900                let mut join_type__ = None;
2901                let mut left_key__ = None;
2902                let mut right_key__ = None;
2903                let mut condition__ = None;
2904                let mut output_indices__ = None;
2905                let mut null_safe__ = None;
2906                let mut asof_desc__ = None;
2907                while let Some(k) = map_.next_key()? {
2908                    match k {
2909                        GeneratedField::JoinType => {
2910                            if join_type__.is_some() {
2911                                return Err(serde::de::Error::duplicate_field("joinType"));
2912                            }
2913                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2914                        }
2915                        GeneratedField::LeftKey => {
2916                            if left_key__.is_some() {
2917                                return Err(serde::de::Error::duplicate_field("leftKey"));
2918                            }
2919                            left_key__ = 
2920                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2921                                    .into_iter().map(|x| x.0).collect())
2922                            ;
2923                        }
2924                        GeneratedField::RightKey => {
2925                            if right_key__.is_some() {
2926                                return Err(serde::de::Error::duplicate_field("rightKey"));
2927                            }
2928                            right_key__ = 
2929                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2930                                    .into_iter().map(|x| x.0).collect())
2931                            ;
2932                        }
2933                        GeneratedField::Condition => {
2934                            if condition__.is_some() {
2935                                return Err(serde::de::Error::duplicate_field("condition"));
2936                            }
2937                            condition__ = map_.next_value()?;
2938                        }
2939                        GeneratedField::OutputIndices => {
2940                            if output_indices__.is_some() {
2941                                return Err(serde::de::Error::duplicate_field("outputIndices"));
2942                            }
2943                            output_indices__ = 
2944                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2945                                    .into_iter().map(|x| x.0).collect())
2946                            ;
2947                        }
2948                        GeneratedField::NullSafe => {
2949                            if null_safe__.is_some() {
2950                                return Err(serde::de::Error::duplicate_field("nullSafe"));
2951                            }
2952                            null_safe__ = Some(map_.next_value()?);
2953                        }
2954                        GeneratedField::AsofDesc => {
2955                            if asof_desc__.is_some() {
2956                                return Err(serde::de::Error::duplicate_field("asofDesc"));
2957                            }
2958                            asof_desc__ = map_.next_value()?;
2959                        }
2960                    }
2961                }
2962                Ok(HashJoinNode {
2963                    join_type: join_type__.unwrap_or_default(),
2964                    left_key: left_key__.unwrap_or_default(),
2965                    right_key: right_key__.unwrap_or_default(),
2966                    condition: condition__,
2967                    output_indices: output_indices__.unwrap_or_default(),
2968                    null_safe: null_safe__.unwrap_or_default(),
2969                    asof_desc: asof_desc__,
2970                })
2971            }
2972        }
2973        deserializer.deserialize_struct("batch_plan.HashJoinNode", FIELDS, GeneratedVisitor)
2974    }
2975}
2976impl serde::Serialize for HopWindowNode {
2977    #[allow(deprecated)]
2978    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2979    where
2980        S: serde::Serializer,
2981    {
2982        use serde::ser::SerializeStruct;
2983        let mut len = 0;
2984        if self.time_col != 0 {
2985            len += 1;
2986        }
2987        if self.window_slide.is_some() {
2988            len += 1;
2989        }
2990        if self.window_size.is_some() {
2991            len += 1;
2992        }
2993        if !self.output_indices.is_empty() {
2994            len += 1;
2995        }
2996        if !self.window_start_exprs.is_empty() {
2997            len += 1;
2998        }
2999        if !self.window_end_exprs.is_empty() {
3000            len += 1;
3001        }
3002        let mut struct_ser = serializer.serialize_struct("batch_plan.HopWindowNode", len)?;
3003        if self.time_col != 0 {
3004            struct_ser.serialize_field("timeCol", &self.time_col)?;
3005        }
3006        if let Some(v) = self.window_slide.as_ref() {
3007            struct_ser.serialize_field("windowSlide", v)?;
3008        }
3009        if let Some(v) = self.window_size.as_ref() {
3010            struct_ser.serialize_field("windowSize", v)?;
3011        }
3012        if !self.output_indices.is_empty() {
3013            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3014        }
3015        if !self.window_start_exprs.is_empty() {
3016            struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
3017        }
3018        if !self.window_end_exprs.is_empty() {
3019            struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
3020        }
3021        struct_ser.end()
3022    }
3023}
3024impl<'de> serde::Deserialize<'de> for HopWindowNode {
3025    #[allow(deprecated)]
3026    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3027    where
3028        D: serde::Deserializer<'de>,
3029    {
3030        const FIELDS: &[&str] = &[
3031            "time_col",
3032            "timeCol",
3033            "window_slide",
3034            "windowSlide",
3035            "window_size",
3036            "windowSize",
3037            "output_indices",
3038            "outputIndices",
3039            "window_start_exprs",
3040            "windowStartExprs",
3041            "window_end_exprs",
3042            "windowEndExprs",
3043        ];
3044
3045        #[allow(clippy::enum_variant_names)]
3046        enum GeneratedField {
3047            TimeCol,
3048            WindowSlide,
3049            WindowSize,
3050            OutputIndices,
3051            WindowStartExprs,
3052            WindowEndExprs,
3053        }
3054        impl<'de> serde::Deserialize<'de> for GeneratedField {
3055            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3056            where
3057                D: serde::Deserializer<'de>,
3058            {
3059                struct GeneratedVisitor;
3060
3061                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3062                    type Value = GeneratedField;
3063
3064                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3065                        write!(formatter, "expected one of: {:?}", &FIELDS)
3066                    }
3067
3068                    #[allow(unused_variables)]
3069                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3070                    where
3071                        E: serde::de::Error,
3072                    {
3073                        match value {
3074                            "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
3075                            "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
3076                            "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
3077                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3078                            "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
3079                            "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
3080                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3081                        }
3082                    }
3083                }
3084                deserializer.deserialize_identifier(GeneratedVisitor)
3085            }
3086        }
3087        struct GeneratedVisitor;
3088        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3089            type Value = HopWindowNode;
3090
3091            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3092                formatter.write_str("struct batch_plan.HopWindowNode")
3093            }
3094
3095            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
3096                where
3097                    V: serde::de::MapAccess<'de>,
3098            {
3099                let mut time_col__ = None;
3100                let mut window_slide__ = None;
3101                let mut window_size__ = None;
3102                let mut output_indices__ = None;
3103                let mut window_start_exprs__ = None;
3104                let mut window_end_exprs__ = None;
3105                while let Some(k) = map_.next_key()? {
3106                    match k {
3107                        GeneratedField::TimeCol => {
3108                            if time_col__.is_some() {
3109                                return Err(serde::de::Error::duplicate_field("timeCol"));
3110                            }
3111                            time_col__ = 
3112                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3113                            ;
3114                        }
3115                        GeneratedField::WindowSlide => {
3116                            if window_slide__.is_some() {
3117                                return Err(serde::de::Error::duplicate_field("windowSlide"));
3118                            }
3119                            window_slide__ = map_.next_value()?;
3120                        }
3121                        GeneratedField::WindowSize => {
3122                            if window_size__.is_some() {
3123                                return Err(serde::de::Error::duplicate_field("windowSize"));
3124                            }
3125                            window_size__ = map_.next_value()?;
3126                        }
3127                        GeneratedField::OutputIndices => {
3128                            if output_indices__.is_some() {
3129                                return Err(serde::de::Error::duplicate_field("outputIndices"));
3130                            }
3131                            output_indices__ = 
3132                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3133                                    .into_iter().map(|x| x.0).collect())
3134                            ;
3135                        }
3136                        GeneratedField::WindowStartExprs => {
3137                            if window_start_exprs__.is_some() {
3138                                return Err(serde::de::Error::duplicate_field("windowStartExprs"));
3139                            }
3140                            window_start_exprs__ = Some(map_.next_value()?);
3141                        }
3142                        GeneratedField::WindowEndExprs => {
3143                            if window_end_exprs__.is_some() {
3144                                return Err(serde::de::Error::duplicate_field("windowEndExprs"));
3145                            }
3146                            window_end_exprs__ = Some(map_.next_value()?);
3147                        }
3148                    }
3149                }
3150                Ok(HopWindowNode {
3151                    time_col: time_col__.unwrap_or_default(),
3152                    window_slide: window_slide__,
3153                    window_size: window_size__,
3154                    output_indices: output_indices__.unwrap_or_default(),
3155                    window_start_exprs: window_start_exprs__.unwrap_or_default(),
3156                    window_end_exprs: window_end_exprs__.unwrap_or_default(),
3157                })
3158            }
3159        }
3160        deserializer.deserialize_struct("batch_plan.HopWindowNode", FIELDS, GeneratedVisitor)
3161    }
3162}
3163impl serde::Serialize for IcebergScanNode {
3164    #[allow(deprecated)]
3165    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3166    where
3167        S: serde::Serializer,
3168    {
3169        use serde::ser::SerializeStruct;
3170        let mut len = 0;
3171        if !self.columns.is_empty() {
3172            len += 1;
3173        }
3174        if !self.with_properties.is_empty() {
3175            len += 1;
3176        }
3177        if !self.split.is_empty() {
3178            len += 1;
3179        }
3180        if !self.secret_refs.is_empty() {
3181            len += 1;
3182        }
3183        if self.iceberg_scan_type != 0 {
3184            len += 1;
3185        }
3186        let mut struct_ser = serializer.serialize_struct("batch_plan.IcebergScanNode", len)?;
3187        if !self.columns.is_empty() {
3188            struct_ser.serialize_field("columns", &self.columns)?;
3189        }
3190        if !self.with_properties.is_empty() {
3191            struct_ser.serialize_field("withProperties", &self.with_properties)?;
3192        }
3193        if !self.split.is_empty() {
3194            struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
3195        }
3196        if !self.secret_refs.is_empty() {
3197            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
3198        }
3199        if self.iceberg_scan_type != 0 {
3200            let v = iceberg_scan_node::IcebergScanType::try_from(self.iceberg_scan_type)
3201                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.iceberg_scan_type)))?;
3202            struct_ser.serialize_field("icebergScanType", &v)?;
3203        }
3204        struct_ser.end()
3205    }
3206}
3207impl<'de> serde::Deserialize<'de> for IcebergScanNode {
3208    #[allow(deprecated)]
3209    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3210    where
3211        D: serde::Deserializer<'de>,
3212    {
3213        const FIELDS: &[&str] = &[
3214            "columns",
3215            "with_properties",
3216            "withProperties",
3217            "split",
3218            "secret_refs",
3219            "secretRefs",
3220            "iceberg_scan_type",
3221            "icebergScanType",
3222        ];
3223
3224        #[allow(clippy::enum_variant_names)]
3225        enum GeneratedField {
3226            Columns,
3227            WithProperties,
3228            Split,
3229            SecretRefs,
3230            IcebergScanType,
3231        }
3232        impl<'de> serde::Deserialize<'de> for GeneratedField {
3233            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3234            where
3235                D: serde::Deserializer<'de>,
3236            {
3237                struct GeneratedVisitor;
3238
3239                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3240                    type Value = GeneratedField;
3241
3242                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3243                        write!(formatter, "expected one of: {:?}", &FIELDS)
3244                    }
3245
3246                    #[allow(unused_variables)]
3247                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3248                    where
3249                        E: serde::de::Error,
3250                    {
3251                        match value {
3252                            "columns" => Ok(GeneratedField::Columns),
3253                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
3254                            "split" => Ok(GeneratedField::Split),
3255                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
3256                            "icebergScanType" | "iceberg_scan_type" => Ok(GeneratedField::IcebergScanType),
3257                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3258                        }
3259                    }
3260                }
3261                deserializer.deserialize_identifier(GeneratedVisitor)
3262            }
3263        }
3264        struct GeneratedVisitor;
3265        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3266            type Value = IcebergScanNode;
3267
3268            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3269                formatter.write_str("struct batch_plan.IcebergScanNode")
3270            }
3271
3272            fn visit_map<V>(self, mut map_: V) -> std::result::Result<IcebergScanNode, V::Error>
3273                where
3274                    V: serde::de::MapAccess<'de>,
3275            {
3276                let mut columns__ = None;
3277                let mut with_properties__ = None;
3278                let mut split__ = None;
3279                let mut secret_refs__ = None;
3280                let mut iceberg_scan_type__ = None;
3281                while let Some(k) = map_.next_key()? {
3282                    match k {
3283                        GeneratedField::Columns => {
3284                            if columns__.is_some() {
3285                                return Err(serde::de::Error::duplicate_field("columns"));
3286                            }
3287                            columns__ = Some(map_.next_value()?);
3288                        }
3289                        GeneratedField::WithProperties => {
3290                            if with_properties__.is_some() {
3291                                return Err(serde::de::Error::duplicate_field("withProperties"));
3292                            }
3293                            with_properties__ = Some(
3294                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3295                            );
3296                        }
3297                        GeneratedField::Split => {
3298                            if split__.is_some() {
3299                                return Err(serde::de::Error::duplicate_field("split"));
3300                            }
3301                            split__ = 
3302                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
3303                                    .into_iter().map(|x| x.0).collect())
3304                            ;
3305                        }
3306                        GeneratedField::SecretRefs => {
3307                            if secret_refs__.is_some() {
3308                                return Err(serde::de::Error::duplicate_field("secretRefs"));
3309                            }
3310                            secret_refs__ = Some(
3311                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
3312                            );
3313                        }
3314                        GeneratedField::IcebergScanType => {
3315                            if iceberg_scan_type__.is_some() {
3316                                return Err(serde::de::Error::duplicate_field("icebergScanType"));
3317                            }
3318                            iceberg_scan_type__ = Some(map_.next_value::<iceberg_scan_node::IcebergScanType>()? as i32);
3319                        }
3320                    }
3321                }
3322                Ok(IcebergScanNode {
3323                    columns: columns__.unwrap_or_default(),
3324                    with_properties: with_properties__.unwrap_or_default(),
3325                    split: split__.unwrap_or_default(),
3326                    secret_refs: secret_refs__.unwrap_or_default(),
3327                    iceberg_scan_type: iceberg_scan_type__.unwrap_or_default(),
3328                })
3329            }
3330        }
3331        deserializer.deserialize_struct("batch_plan.IcebergScanNode", FIELDS, GeneratedVisitor)
3332    }
3333}
3334impl serde::Serialize for iceberg_scan_node::IcebergScanType {
3335    #[allow(deprecated)]
3336    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3337    where
3338        S: serde::Serializer,
3339    {
3340        let variant = match self {
3341            Self::Unspecified => "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3342            Self::DataScan => "ICEBERG_SCAN_TYPE_DATA_SCAN",
3343            Self::EqualityDeleteScan => "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3344            Self::PositionDeleteScan => "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3345            Self::CountStar => "ICEBERG_SCAN_TYPE_COUNT_STAR",
3346        };
3347        serializer.serialize_str(variant)
3348    }
3349}
3350impl<'de> serde::Deserialize<'de> for iceberg_scan_node::IcebergScanType {
3351    #[allow(deprecated)]
3352    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3353    where
3354        D: serde::Deserializer<'de>,
3355    {
3356        const FIELDS: &[&str] = &[
3357            "ICEBERG_SCAN_TYPE_UNSPECIFIED",
3358            "ICEBERG_SCAN_TYPE_DATA_SCAN",
3359            "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN",
3360            "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN",
3361            "ICEBERG_SCAN_TYPE_COUNT_STAR",
3362        ];
3363
3364        struct GeneratedVisitor;
3365
3366        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3367            type Value = iceberg_scan_node::IcebergScanType;
3368
3369            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3370                write!(formatter, "expected one of: {:?}", &FIELDS)
3371            }
3372
3373            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3374            where
3375                E: serde::de::Error,
3376            {
3377                i32::try_from(v)
3378                    .ok()
3379                    .and_then(|x| x.try_into().ok())
3380                    .ok_or_else(|| {
3381                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3382                    })
3383            }
3384
3385            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3386            where
3387                E: serde::de::Error,
3388            {
3389                i32::try_from(v)
3390                    .ok()
3391                    .and_then(|x| x.try_into().ok())
3392                    .ok_or_else(|| {
3393                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3394                    })
3395            }
3396
3397            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3398            where
3399                E: serde::de::Error,
3400            {
3401                match value {
3402                    "ICEBERG_SCAN_TYPE_UNSPECIFIED" => Ok(iceberg_scan_node::IcebergScanType::Unspecified),
3403                    "ICEBERG_SCAN_TYPE_DATA_SCAN" => Ok(iceberg_scan_node::IcebergScanType::DataScan),
3404                    "ICEBERG_SCAN_TYPE_EQUALITY_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::EqualityDeleteScan),
3405                    "ICEBERG_SCAN_TYPE_POSITION_DELETE_SCAN" => Ok(iceberg_scan_node::IcebergScanType::PositionDeleteScan),
3406                    "ICEBERG_SCAN_TYPE_COUNT_STAR" => Ok(iceberg_scan_node::IcebergScanType::CountStar),
3407                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3408                }
3409            }
3410        }
3411        deserializer.deserialize_any(GeneratedVisitor)
3412    }
3413}
3414impl serde::Serialize for InsertNode {
3415    #[allow(deprecated)]
3416    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3417    where
3418        S: serde::Serializer,
3419    {
3420        use serde::ser::SerializeStruct;
3421        let mut len = 0;
3422        if self.table_id != 0 {
3423            len += 1;
3424        }
3425        if self.table_version_id != 0 {
3426            len += 1;
3427        }
3428        if !self.column_indices.is_empty() {
3429            len += 1;
3430        }
3431        if self.default_columns.is_some() {
3432            len += 1;
3433        }
3434        if self.row_id_index.is_some() {
3435            len += 1;
3436        }
3437        if self.returning {
3438            len += 1;
3439        }
3440        if self.session_id != 0 {
3441            len += 1;
3442        }
3443        let mut struct_ser = serializer.serialize_struct("batch_plan.InsertNode", len)?;
3444        if self.table_id != 0 {
3445            struct_ser.serialize_field("tableId", &self.table_id)?;
3446        }
3447        if self.table_version_id != 0 {
3448            #[allow(clippy::needless_borrow)]
3449            #[allow(clippy::needless_borrows_for_generic_args)]
3450            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3451        }
3452        if !self.column_indices.is_empty() {
3453            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
3454        }
3455        if let Some(v) = self.default_columns.as_ref() {
3456            struct_ser.serialize_field("defaultColumns", v)?;
3457        }
3458        if let Some(v) = self.row_id_index.as_ref() {
3459            struct_ser.serialize_field("rowIdIndex", v)?;
3460        }
3461        if self.returning {
3462            struct_ser.serialize_field("returning", &self.returning)?;
3463        }
3464        if self.session_id != 0 {
3465            struct_ser.serialize_field("sessionId", &self.session_id)?;
3466        }
3467        struct_ser.end()
3468    }
3469}
3470impl<'de> serde::Deserialize<'de> for InsertNode {
3471    #[allow(deprecated)]
3472    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3473    where
3474        D: serde::Deserializer<'de>,
3475    {
3476        const FIELDS: &[&str] = &[
3477            "table_id",
3478            "tableId",
3479            "table_version_id",
3480            "tableVersionId",
3481            "column_indices",
3482            "columnIndices",
3483            "default_columns",
3484            "defaultColumns",
3485            "row_id_index",
3486            "rowIdIndex",
3487            "returning",
3488            "session_id",
3489            "sessionId",
3490        ];
3491
3492        #[allow(clippy::enum_variant_names)]
3493        enum GeneratedField {
3494            TableId,
3495            TableVersionId,
3496            ColumnIndices,
3497            DefaultColumns,
3498            RowIdIndex,
3499            Returning,
3500            SessionId,
3501        }
3502        impl<'de> serde::Deserialize<'de> for GeneratedField {
3503            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3504            where
3505                D: serde::Deserializer<'de>,
3506            {
3507                struct GeneratedVisitor;
3508
3509                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3510                    type Value = GeneratedField;
3511
3512                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3513                        write!(formatter, "expected one of: {:?}", &FIELDS)
3514                    }
3515
3516                    #[allow(unused_variables)]
3517                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3518                    where
3519                        E: serde::de::Error,
3520                    {
3521                        match value {
3522                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
3523                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3524                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
3525                            "defaultColumns" | "default_columns" => Ok(GeneratedField::DefaultColumns),
3526                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
3527                            "returning" => Ok(GeneratedField::Returning),
3528                            "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
3529                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3530                        }
3531                    }
3532                }
3533                deserializer.deserialize_identifier(GeneratedVisitor)
3534            }
3535        }
3536        struct GeneratedVisitor;
3537        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3538            type Value = InsertNode;
3539
3540            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3541                formatter.write_str("struct batch_plan.InsertNode")
3542            }
3543
3544            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InsertNode, V::Error>
3545                where
3546                    V: serde::de::MapAccess<'de>,
3547            {
3548                let mut table_id__ = None;
3549                let mut table_version_id__ = None;
3550                let mut column_indices__ = None;
3551                let mut default_columns__ = None;
3552                let mut row_id_index__ = None;
3553                let mut returning__ = None;
3554                let mut session_id__ = None;
3555                while let Some(k) = map_.next_key()? {
3556                    match k {
3557                        GeneratedField::TableId => {
3558                            if table_id__.is_some() {
3559                                return Err(serde::de::Error::duplicate_field("tableId"));
3560                            }
3561                            table_id__ = 
3562                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3563                            ;
3564                        }
3565                        GeneratedField::TableVersionId => {
3566                            if table_version_id__.is_some() {
3567                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
3568                            }
3569                            table_version_id__ = 
3570                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3571                            ;
3572                        }
3573                        GeneratedField::ColumnIndices => {
3574                            if column_indices__.is_some() {
3575                                return Err(serde::de::Error::duplicate_field("columnIndices"));
3576                            }
3577                            column_indices__ = 
3578                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3579                                    .into_iter().map(|x| x.0).collect())
3580                            ;
3581                        }
3582                        GeneratedField::DefaultColumns => {
3583                            if default_columns__.is_some() {
3584                                return Err(serde::de::Error::duplicate_field("defaultColumns"));
3585                            }
3586                            default_columns__ = map_.next_value()?;
3587                        }
3588                        GeneratedField::RowIdIndex => {
3589                            if row_id_index__.is_some() {
3590                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
3591                            }
3592                            row_id_index__ = 
3593                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3594                            ;
3595                        }
3596                        GeneratedField::Returning => {
3597                            if returning__.is_some() {
3598                                return Err(serde::de::Error::duplicate_field("returning"));
3599                            }
3600                            returning__ = Some(map_.next_value()?);
3601                        }
3602                        GeneratedField::SessionId => {
3603                            if session_id__.is_some() {
3604                                return Err(serde::de::Error::duplicate_field("sessionId"));
3605                            }
3606                            session_id__ = 
3607                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3608                            ;
3609                        }
3610                    }
3611                }
3612                Ok(InsertNode {
3613                    table_id: table_id__.unwrap_or_default(),
3614                    table_version_id: table_version_id__.unwrap_or_default(),
3615                    column_indices: column_indices__.unwrap_or_default(),
3616                    default_columns: default_columns__,
3617                    row_id_index: row_id_index__,
3618                    returning: returning__.unwrap_or_default(),
3619                    session_id: session_id__.unwrap_or_default(),
3620                })
3621            }
3622        }
3623        deserializer.deserialize_struct("batch_plan.InsertNode", FIELDS, GeneratedVisitor)
3624    }
3625}
3626impl serde::Serialize for LimitNode {
3627    #[allow(deprecated)]
3628    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3629    where
3630        S: serde::Serializer,
3631    {
3632        use serde::ser::SerializeStruct;
3633        let mut len = 0;
3634        if self.limit != 0 {
3635            len += 1;
3636        }
3637        if self.offset != 0 {
3638            len += 1;
3639        }
3640        let mut struct_ser = serializer.serialize_struct("batch_plan.LimitNode", len)?;
3641        if self.limit != 0 {
3642            #[allow(clippy::needless_borrow)]
3643            #[allow(clippy::needless_borrows_for_generic_args)]
3644            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
3645        }
3646        if self.offset != 0 {
3647            #[allow(clippy::needless_borrow)]
3648            #[allow(clippy::needless_borrows_for_generic_args)]
3649            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
3650        }
3651        struct_ser.end()
3652    }
3653}
3654impl<'de> serde::Deserialize<'de> for LimitNode {
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            "limit",
3662            "offset",
3663        ];
3664
3665        #[allow(clippy::enum_variant_names)]
3666        enum GeneratedField {
3667            Limit,
3668            Offset,
3669        }
3670        impl<'de> serde::Deserialize<'de> for GeneratedField {
3671            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3672            where
3673                D: serde::Deserializer<'de>,
3674            {
3675                struct GeneratedVisitor;
3676
3677                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3678                    type Value = GeneratedField;
3679
3680                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3681                        write!(formatter, "expected one of: {:?}", &FIELDS)
3682                    }
3683
3684                    #[allow(unused_variables)]
3685                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3686                    where
3687                        E: serde::de::Error,
3688                    {
3689                        match value {
3690                            "limit" => Ok(GeneratedField::Limit),
3691                            "offset" => Ok(GeneratedField::Offset),
3692                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3693                        }
3694                    }
3695                }
3696                deserializer.deserialize_identifier(GeneratedVisitor)
3697            }
3698        }
3699        struct GeneratedVisitor;
3700        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3701            type Value = LimitNode;
3702
3703            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3704                formatter.write_str("struct batch_plan.LimitNode")
3705            }
3706
3707            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LimitNode, V::Error>
3708                where
3709                    V: serde::de::MapAccess<'de>,
3710            {
3711                let mut limit__ = None;
3712                let mut offset__ = None;
3713                while let Some(k) = map_.next_key()? {
3714                    match k {
3715                        GeneratedField::Limit => {
3716                            if limit__.is_some() {
3717                                return Err(serde::de::Error::duplicate_field("limit"));
3718                            }
3719                            limit__ = 
3720                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3721                            ;
3722                        }
3723                        GeneratedField::Offset => {
3724                            if offset__.is_some() {
3725                                return Err(serde::de::Error::duplicate_field("offset"));
3726                            }
3727                            offset__ = 
3728                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3729                            ;
3730                        }
3731                    }
3732                }
3733                Ok(LimitNode {
3734                    limit: limit__.unwrap_or_default(),
3735                    offset: offset__.unwrap_or_default(),
3736                })
3737            }
3738        }
3739        deserializer.deserialize_struct("batch_plan.LimitNode", FIELDS, GeneratedVisitor)
3740    }
3741}
3742impl serde::Serialize for LocalExecutePlan {
3743    #[allow(deprecated)]
3744    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3745    where
3746        S: serde::Serializer,
3747    {
3748        use serde::ser::SerializeStruct;
3749        let mut len = 0;
3750        if self.plan.is_some() {
3751            len += 1;
3752        }
3753        if self.epoch.is_some() {
3754            len += 1;
3755        }
3756        if !self.tracing_context.is_empty() {
3757            len += 1;
3758        }
3759        let mut struct_ser = serializer.serialize_struct("batch_plan.LocalExecutePlan", len)?;
3760        if let Some(v) = self.plan.as_ref() {
3761            struct_ser.serialize_field("plan", v)?;
3762        }
3763        if let Some(v) = self.epoch.as_ref() {
3764            struct_ser.serialize_field("epoch", v)?;
3765        }
3766        if !self.tracing_context.is_empty() {
3767            struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
3768        }
3769        struct_ser.end()
3770    }
3771}
3772impl<'de> serde::Deserialize<'de> for LocalExecutePlan {
3773    #[allow(deprecated)]
3774    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3775    where
3776        D: serde::Deserializer<'de>,
3777    {
3778        const FIELDS: &[&str] = &[
3779            "plan",
3780            "epoch",
3781            "tracing_context",
3782            "tracingContext",
3783        ];
3784
3785        #[allow(clippy::enum_variant_names)]
3786        enum GeneratedField {
3787            Plan,
3788            Epoch,
3789            TracingContext,
3790        }
3791        impl<'de> serde::Deserialize<'de> for GeneratedField {
3792            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3793            where
3794                D: serde::Deserializer<'de>,
3795            {
3796                struct GeneratedVisitor;
3797
3798                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3799                    type Value = GeneratedField;
3800
3801                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3802                        write!(formatter, "expected one of: {:?}", &FIELDS)
3803                    }
3804
3805                    #[allow(unused_variables)]
3806                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3807                    where
3808                        E: serde::de::Error,
3809                    {
3810                        match value {
3811                            "plan" => Ok(GeneratedField::Plan),
3812                            "epoch" => Ok(GeneratedField::Epoch),
3813                            "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
3814                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3815                        }
3816                    }
3817                }
3818                deserializer.deserialize_identifier(GeneratedVisitor)
3819            }
3820        }
3821        struct GeneratedVisitor;
3822        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3823            type Value = LocalExecutePlan;
3824
3825            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3826                formatter.write_str("struct batch_plan.LocalExecutePlan")
3827            }
3828
3829            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalExecutePlan, V::Error>
3830                where
3831                    V: serde::de::MapAccess<'de>,
3832            {
3833                let mut plan__ = None;
3834                let mut epoch__ = None;
3835                let mut tracing_context__ = None;
3836                while let Some(k) = map_.next_key()? {
3837                    match k {
3838                        GeneratedField::Plan => {
3839                            if plan__.is_some() {
3840                                return Err(serde::de::Error::duplicate_field("plan"));
3841                            }
3842                            plan__ = map_.next_value()?;
3843                        }
3844                        GeneratedField::Epoch => {
3845                            if epoch__.is_some() {
3846                                return Err(serde::de::Error::duplicate_field("epoch"));
3847                            }
3848                            epoch__ = map_.next_value()?;
3849                        }
3850                        GeneratedField::TracingContext => {
3851                            if tracing_context__.is_some() {
3852                                return Err(serde::de::Error::duplicate_field("tracingContext"));
3853                            }
3854                            tracing_context__ = Some(
3855                                map_.next_value::<std::collections::HashMap<_, _>>()?
3856                            );
3857                        }
3858                    }
3859                }
3860                Ok(LocalExecutePlan {
3861                    plan: plan__,
3862                    epoch: epoch__,
3863                    tracing_context: tracing_context__.unwrap_or_default(),
3864                })
3865            }
3866        }
3867        deserializer.deserialize_struct("batch_plan.LocalExecutePlan", FIELDS, GeneratedVisitor)
3868    }
3869}
3870impl serde::Serialize for LocalLookupJoinNode {
3871    #[allow(deprecated)]
3872    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3873    where
3874        S: serde::Serializer,
3875    {
3876        use serde::ser::SerializeStruct;
3877        let mut len = 0;
3878        if self.join_type != 0 {
3879            len += 1;
3880        }
3881        if self.condition.is_some() {
3882            len += 1;
3883        }
3884        if !self.outer_side_key.is_empty() {
3885            len += 1;
3886        }
3887        if !self.inner_side_key.is_empty() {
3888            len += 1;
3889        }
3890        if self.lookup_prefix_len != 0 {
3891            len += 1;
3892        }
3893        if self.inner_side_table_desc.is_some() {
3894            len += 1;
3895        }
3896        if !self.inner_side_vnode_mapping.is_empty() {
3897            len += 1;
3898        }
3899        if !self.inner_side_column_ids.is_empty() {
3900            len += 1;
3901        }
3902        if !self.output_indices.is_empty() {
3903            len += 1;
3904        }
3905        if !self.worker_nodes.is_empty() {
3906            len += 1;
3907        }
3908        if !self.null_safe.is_empty() {
3909            len += 1;
3910        }
3911        if self.as_of.is_some() {
3912            len += 1;
3913        }
3914        if self.asof_desc.is_some() {
3915            len += 1;
3916        }
3917        let mut struct_ser = serializer.serialize_struct("batch_plan.LocalLookupJoinNode", len)?;
3918        if self.join_type != 0 {
3919            let v = super::plan_common::JoinType::try_from(self.join_type)
3920                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
3921            struct_ser.serialize_field("joinType", &v)?;
3922        }
3923        if let Some(v) = self.condition.as_ref() {
3924            struct_ser.serialize_field("condition", v)?;
3925        }
3926        if !self.outer_side_key.is_empty() {
3927            struct_ser.serialize_field("outerSideKey", &self.outer_side_key)?;
3928        }
3929        if !self.inner_side_key.is_empty() {
3930            struct_ser.serialize_field("innerSideKey", &self.inner_side_key)?;
3931        }
3932        if self.lookup_prefix_len != 0 {
3933            struct_ser.serialize_field("lookupPrefixLen", &self.lookup_prefix_len)?;
3934        }
3935        if let Some(v) = self.inner_side_table_desc.as_ref() {
3936            struct_ser.serialize_field("innerSideTableDesc", v)?;
3937        }
3938        if !self.inner_side_vnode_mapping.is_empty() {
3939            struct_ser.serialize_field("innerSideVnodeMapping", &self.inner_side_vnode_mapping.iter().map(ToString::to_string).collect::<Vec<_>>())?;
3940        }
3941        if !self.inner_side_column_ids.is_empty() {
3942            struct_ser.serialize_field("innerSideColumnIds", &self.inner_side_column_ids)?;
3943        }
3944        if !self.output_indices.is_empty() {
3945            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
3946        }
3947        if !self.worker_nodes.is_empty() {
3948            struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
3949        }
3950        if !self.null_safe.is_empty() {
3951            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
3952        }
3953        if let Some(v) = self.as_of.as_ref() {
3954            struct_ser.serialize_field("asOf", v)?;
3955        }
3956        if let Some(v) = self.asof_desc.as_ref() {
3957            struct_ser.serialize_field("asofDesc", v)?;
3958        }
3959        struct_ser.end()
3960    }
3961}
3962impl<'de> serde::Deserialize<'de> for LocalLookupJoinNode {
3963    #[allow(deprecated)]
3964    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3965    where
3966        D: serde::Deserializer<'de>,
3967    {
3968        const FIELDS: &[&str] = &[
3969            "join_type",
3970            "joinType",
3971            "condition",
3972            "outer_side_key",
3973            "outerSideKey",
3974            "inner_side_key",
3975            "innerSideKey",
3976            "lookup_prefix_len",
3977            "lookupPrefixLen",
3978            "inner_side_table_desc",
3979            "innerSideTableDesc",
3980            "inner_side_vnode_mapping",
3981            "innerSideVnodeMapping",
3982            "inner_side_column_ids",
3983            "innerSideColumnIds",
3984            "output_indices",
3985            "outputIndices",
3986            "worker_nodes",
3987            "workerNodes",
3988            "null_safe",
3989            "nullSafe",
3990            "as_of",
3991            "asOf",
3992            "asof_desc",
3993            "asofDesc",
3994        ];
3995
3996        #[allow(clippy::enum_variant_names)]
3997        enum GeneratedField {
3998            JoinType,
3999            Condition,
4000            OuterSideKey,
4001            InnerSideKey,
4002            LookupPrefixLen,
4003            InnerSideTableDesc,
4004            InnerSideVnodeMapping,
4005            InnerSideColumnIds,
4006            OutputIndices,
4007            WorkerNodes,
4008            NullSafe,
4009            AsOf,
4010            AsofDesc,
4011        }
4012        impl<'de> serde::Deserialize<'de> for GeneratedField {
4013            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4014            where
4015                D: serde::Deserializer<'de>,
4016            {
4017                struct GeneratedVisitor;
4018
4019                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4020                    type Value = GeneratedField;
4021
4022                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4023                        write!(formatter, "expected one of: {:?}", &FIELDS)
4024                    }
4025
4026                    #[allow(unused_variables)]
4027                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4028                    where
4029                        E: serde::de::Error,
4030                    {
4031                        match value {
4032                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4033                            "condition" => Ok(GeneratedField::Condition),
4034                            "outerSideKey" | "outer_side_key" => Ok(GeneratedField::OuterSideKey),
4035                            "innerSideKey" | "inner_side_key" => Ok(GeneratedField::InnerSideKey),
4036                            "lookupPrefixLen" | "lookup_prefix_len" => Ok(GeneratedField::LookupPrefixLen),
4037                            "innerSideTableDesc" | "inner_side_table_desc" => Ok(GeneratedField::InnerSideTableDesc),
4038                            "innerSideVnodeMapping" | "inner_side_vnode_mapping" => Ok(GeneratedField::InnerSideVnodeMapping),
4039                            "innerSideColumnIds" | "inner_side_column_ids" => Ok(GeneratedField::InnerSideColumnIds),
4040                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4041                            "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
4042                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
4043                            "asOf" | "as_of" => Ok(GeneratedField::AsOf),
4044                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
4045                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4046                        }
4047                    }
4048                }
4049                deserializer.deserialize_identifier(GeneratedVisitor)
4050            }
4051        }
4052        struct GeneratedVisitor;
4053        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4054            type Value = LocalLookupJoinNode;
4055
4056            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4057                formatter.write_str("struct batch_plan.LocalLookupJoinNode")
4058            }
4059
4060            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalLookupJoinNode, V::Error>
4061                where
4062                    V: serde::de::MapAccess<'de>,
4063            {
4064                let mut join_type__ = None;
4065                let mut condition__ = None;
4066                let mut outer_side_key__ = None;
4067                let mut inner_side_key__ = None;
4068                let mut lookup_prefix_len__ = None;
4069                let mut inner_side_table_desc__ = None;
4070                let mut inner_side_vnode_mapping__ = None;
4071                let mut inner_side_column_ids__ = None;
4072                let mut output_indices__ = None;
4073                let mut worker_nodes__ = None;
4074                let mut null_safe__ = None;
4075                let mut as_of__ = None;
4076                let mut asof_desc__ = None;
4077                while let Some(k) = map_.next_key()? {
4078                    match k {
4079                        GeneratedField::JoinType => {
4080                            if join_type__.is_some() {
4081                                return Err(serde::de::Error::duplicate_field("joinType"));
4082                            }
4083                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4084                        }
4085                        GeneratedField::Condition => {
4086                            if condition__.is_some() {
4087                                return Err(serde::de::Error::duplicate_field("condition"));
4088                            }
4089                            condition__ = map_.next_value()?;
4090                        }
4091                        GeneratedField::OuterSideKey => {
4092                            if outer_side_key__.is_some() {
4093                                return Err(serde::de::Error::duplicate_field("outerSideKey"));
4094                            }
4095                            outer_side_key__ = 
4096                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4097                                    .into_iter().map(|x| x.0).collect())
4098                            ;
4099                        }
4100                        GeneratedField::InnerSideKey => {
4101                            if inner_side_key__.is_some() {
4102                                return Err(serde::de::Error::duplicate_field("innerSideKey"));
4103                            }
4104                            inner_side_key__ = 
4105                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4106                                    .into_iter().map(|x| x.0).collect())
4107                            ;
4108                        }
4109                        GeneratedField::LookupPrefixLen => {
4110                            if lookup_prefix_len__.is_some() {
4111                                return Err(serde::de::Error::duplicate_field("lookupPrefixLen"));
4112                            }
4113                            lookup_prefix_len__ = 
4114                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4115                            ;
4116                        }
4117                        GeneratedField::InnerSideTableDesc => {
4118                            if inner_side_table_desc__.is_some() {
4119                                return Err(serde::de::Error::duplicate_field("innerSideTableDesc"));
4120                            }
4121                            inner_side_table_desc__ = map_.next_value()?;
4122                        }
4123                        GeneratedField::InnerSideVnodeMapping => {
4124                            if inner_side_vnode_mapping__.is_some() {
4125                                return Err(serde::de::Error::duplicate_field("innerSideVnodeMapping"));
4126                            }
4127                            inner_side_vnode_mapping__ = 
4128                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4129                                    .into_iter().map(|x| x.0).collect())
4130                            ;
4131                        }
4132                        GeneratedField::InnerSideColumnIds => {
4133                            if inner_side_column_ids__.is_some() {
4134                                return Err(serde::de::Error::duplicate_field("innerSideColumnIds"));
4135                            }
4136                            inner_side_column_ids__ = 
4137                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4138                                    .into_iter().map(|x| x.0).collect())
4139                            ;
4140                        }
4141                        GeneratedField::OutputIndices => {
4142                            if output_indices__.is_some() {
4143                                return Err(serde::de::Error::duplicate_field("outputIndices"));
4144                            }
4145                            output_indices__ = 
4146                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4147                                    .into_iter().map(|x| x.0).collect())
4148                            ;
4149                        }
4150                        GeneratedField::WorkerNodes => {
4151                            if worker_nodes__.is_some() {
4152                                return Err(serde::de::Error::duplicate_field("workerNodes"));
4153                            }
4154                            worker_nodes__ = Some(map_.next_value()?);
4155                        }
4156                        GeneratedField::NullSafe => {
4157                            if null_safe__.is_some() {
4158                                return Err(serde::de::Error::duplicate_field("nullSafe"));
4159                            }
4160                            null_safe__ = Some(map_.next_value()?);
4161                        }
4162                        GeneratedField::AsOf => {
4163                            if as_of__.is_some() {
4164                                return Err(serde::de::Error::duplicate_field("asOf"));
4165                            }
4166                            as_of__ = map_.next_value()?;
4167                        }
4168                        GeneratedField::AsofDesc => {
4169                            if asof_desc__.is_some() {
4170                                return Err(serde::de::Error::duplicate_field("asofDesc"));
4171                            }
4172                            asof_desc__ = map_.next_value()?;
4173                        }
4174                    }
4175                }
4176                Ok(LocalLookupJoinNode {
4177                    join_type: join_type__.unwrap_or_default(),
4178                    condition: condition__,
4179                    outer_side_key: outer_side_key__.unwrap_or_default(),
4180                    inner_side_key: inner_side_key__.unwrap_or_default(),
4181                    lookup_prefix_len: lookup_prefix_len__.unwrap_or_default(),
4182                    inner_side_table_desc: inner_side_table_desc__,
4183                    inner_side_vnode_mapping: inner_side_vnode_mapping__.unwrap_or_default(),
4184                    inner_side_column_ids: inner_side_column_ids__.unwrap_or_default(),
4185                    output_indices: output_indices__.unwrap_or_default(),
4186                    worker_nodes: worker_nodes__.unwrap_or_default(),
4187                    null_safe: null_safe__.unwrap_or_default(),
4188                    as_of: as_of__,
4189                    asof_desc: asof_desc__,
4190                })
4191            }
4192        }
4193        deserializer.deserialize_struct("batch_plan.LocalLookupJoinNode", FIELDS, GeneratedVisitor)
4194    }
4195}
4196impl serde::Serialize for LogRowSeqScanNode {
4197    #[allow(deprecated)]
4198    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4199    where
4200        S: serde::Serializer,
4201    {
4202        use serde::ser::SerializeStruct;
4203        let mut len = 0;
4204        if self.table_desc.is_some() {
4205            len += 1;
4206        }
4207        if !self.column_ids.is_empty() {
4208            len += 1;
4209        }
4210        if self.vnode_bitmap.is_some() {
4211            len += 1;
4212        }
4213        if self.old_epoch.is_some() {
4214            len += 1;
4215        }
4216        if self.new_epoch.is_some() {
4217            len += 1;
4218        }
4219        if self.ordered {
4220            len += 1;
4221        }
4222        if self.scan_range.is_some() {
4223            len += 1;
4224        }
4225        let mut struct_ser = serializer.serialize_struct("batch_plan.LogRowSeqScanNode", len)?;
4226        if let Some(v) = self.table_desc.as_ref() {
4227            struct_ser.serialize_field("tableDesc", v)?;
4228        }
4229        if !self.column_ids.is_empty() {
4230            struct_ser.serialize_field("columnIds", &self.column_ids)?;
4231        }
4232        if let Some(v) = self.vnode_bitmap.as_ref() {
4233            struct_ser.serialize_field("vnodeBitmap", v)?;
4234        }
4235        if let Some(v) = self.old_epoch.as_ref() {
4236            struct_ser.serialize_field("oldEpoch", v)?;
4237        }
4238        if let Some(v) = self.new_epoch.as_ref() {
4239            struct_ser.serialize_field("newEpoch", v)?;
4240        }
4241        if self.ordered {
4242            struct_ser.serialize_field("ordered", &self.ordered)?;
4243        }
4244        if let Some(v) = self.scan_range.as_ref() {
4245            struct_ser.serialize_field("scanRange", v)?;
4246        }
4247        struct_ser.end()
4248    }
4249}
4250impl<'de> serde::Deserialize<'de> for LogRowSeqScanNode {
4251    #[allow(deprecated)]
4252    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4253    where
4254        D: serde::Deserializer<'de>,
4255    {
4256        const FIELDS: &[&str] = &[
4257            "table_desc",
4258            "tableDesc",
4259            "column_ids",
4260            "columnIds",
4261            "vnode_bitmap",
4262            "vnodeBitmap",
4263            "old_epoch",
4264            "oldEpoch",
4265            "new_epoch",
4266            "newEpoch",
4267            "ordered",
4268            "scan_range",
4269            "scanRange",
4270        ];
4271
4272        #[allow(clippy::enum_variant_names)]
4273        enum GeneratedField {
4274            TableDesc,
4275            ColumnIds,
4276            VnodeBitmap,
4277            OldEpoch,
4278            NewEpoch,
4279            Ordered,
4280            ScanRange,
4281        }
4282        impl<'de> serde::Deserialize<'de> for GeneratedField {
4283            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4284            where
4285                D: serde::Deserializer<'de>,
4286            {
4287                struct GeneratedVisitor;
4288
4289                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4290                    type Value = GeneratedField;
4291
4292                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4293                        write!(formatter, "expected one of: {:?}", &FIELDS)
4294                    }
4295
4296                    #[allow(unused_variables)]
4297                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4298                    where
4299                        E: serde::de::Error,
4300                    {
4301                        match value {
4302                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
4303                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
4304                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
4305                            "oldEpoch" | "old_epoch" => Ok(GeneratedField::OldEpoch),
4306                            "newEpoch" | "new_epoch" => Ok(GeneratedField::NewEpoch),
4307                            "ordered" => Ok(GeneratedField::Ordered),
4308                            "scanRange" | "scan_range" => Ok(GeneratedField::ScanRange),
4309                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4310                        }
4311                    }
4312                }
4313                deserializer.deserialize_identifier(GeneratedVisitor)
4314            }
4315        }
4316        struct GeneratedVisitor;
4317        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4318            type Value = LogRowSeqScanNode;
4319
4320            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4321                formatter.write_str("struct batch_plan.LogRowSeqScanNode")
4322            }
4323
4324            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LogRowSeqScanNode, V::Error>
4325                where
4326                    V: serde::de::MapAccess<'de>,
4327            {
4328                let mut table_desc__ = None;
4329                let mut column_ids__ = None;
4330                let mut vnode_bitmap__ = None;
4331                let mut old_epoch__ = None;
4332                let mut new_epoch__ = None;
4333                let mut ordered__ = None;
4334                let mut scan_range__ = None;
4335                while let Some(k) = map_.next_key()? {
4336                    match k {
4337                        GeneratedField::TableDesc => {
4338                            if table_desc__.is_some() {
4339                                return Err(serde::de::Error::duplicate_field("tableDesc"));
4340                            }
4341                            table_desc__ = map_.next_value()?;
4342                        }
4343                        GeneratedField::ColumnIds => {
4344                            if column_ids__.is_some() {
4345                                return Err(serde::de::Error::duplicate_field("columnIds"));
4346                            }
4347                            column_ids__ = 
4348                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4349                                    .into_iter().map(|x| x.0).collect())
4350                            ;
4351                        }
4352                        GeneratedField::VnodeBitmap => {
4353                            if vnode_bitmap__.is_some() {
4354                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
4355                            }
4356                            vnode_bitmap__ = map_.next_value()?;
4357                        }
4358                        GeneratedField::OldEpoch => {
4359                            if old_epoch__.is_some() {
4360                                return Err(serde::de::Error::duplicate_field("oldEpoch"));
4361                            }
4362                            old_epoch__ = map_.next_value()?;
4363                        }
4364                        GeneratedField::NewEpoch => {
4365                            if new_epoch__.is_some() {
4366                                return Err(serde::de::Error::duplicate_field("newEpoch"));
4367                            }
4368                            new_epoch__ = map_.next_value()?;
4369                        }
4370                        GeneratedField::Ordered => {
4371                            if ordered__.is_some() {
4372                                return Err(serde::de::Error::duplicate_field("ordered"));
4373                            }
4374                            ordered__ = Some(map_.next_value()?);
4375                        }
4376                        GeneratedField::ScanRange => {
4377                            if scan_range__.is_some() {
4378                                return Err(serde::de::Error::duplicate_field("scanRange"));
4379                            }
4380                            scan_range__ = map_.next_value()?;
4381                        }
4382                    }
4383                }
4384                Ok(LogRowSeqScanNode {
4385                    table_desc: table_desc__,
4386                    column_ids: column_ids__.unwrap_or_default(),
4387                    vnode_bitmap: vnode_bitmap__,
4388                    old_epoch: old_epoch__,
4389                    new_epoch: new_epoch__,
4390                    ordered: ordered__.unwrap_or_default(),
4391                    scan_range: scan_range__,
4392                })
4393            }
4394        }
4395        deserializer.deserialize_struct("batch_plan.LogRowSeqScanNode", FIELDS, GeneratedVisitor)
4396    }
4397}
4398impl serde::Serialize for MaxOneRowNode {
4399    #[allow(deprecated)]
4400    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4401    where
4402        S: serde::Serializer,
4403    {
4404        use serde::ser::SerializeStruct;
4405        let len = 0;
4406        let struct_ser = serializer.serialize_struct("batch_plan.MaxOneRowNode", len)?;
4407        struct_ser.end()
4408    }
4409}
4410impl<'de> serde::Deserialize<'de> for MaxOneRowNode {
4411    #[allow(deprecated)]
4412    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4413    where
4414        D: serde::Deserializer<'de>,
4415    {
4416        const FIELDS: &[&str] = &[
4417        ];
4418
4419        #[allow(clippy::enum_variant_names)]
4420        enum GeneratedField {
4421        }
4422        impl<'de> serde::Deserialize<'de> for GeneratedField {
4423            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4424            where
4425                D: serde::Deserializer<'de>,
4426            {
4427                struct GeneratedVisitor;
4428
4429                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4430                    type Value = GeneratedField;
4431
4432                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4433                        write!(formatter, "expected one of: {:?}", &FIELDS)
4434                    }
4435
4436                    #[allow(unused_variables)]
4437                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4438                    where
4439                        E: serde::de::Error,
4440                    {
4441                            Err(serde::de::Error::unknown_field(value, FIELDS))
4442                    }
4443                }
4444                deserializer.deserialize_identifier(GeneratedVisitor)
4445            }
4446        }
4447        struct GeneratedVisitor;
4448        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4449            type Value = MaxOneRowNode;
4450
4451            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4452                formatter.write_str("struct batch_plan.MaxOneRowNode")
4453            }
4454
4455            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaxOneRowNode, V::Error>
4456                where
4457                    V: serde::de::MapAccess<'de>,
4458            {
4459                while map_.next_key::<GeneratedField>()?.is_some() {
4460                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
4461                }
4462                Ok(MaxOneRowNode {
4463                })
4464            }
4465        }
4466        deserializer.deserialize_struct("batch_plan.MaxOneRowNode", FIELDS, GeneratedVisitor)
4467    }
4468}
4469impl serde::Serialize for MergeSortExchangeNode {
4470    #[allow(deprecated)]
4471    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4472    where
4473        S: serde::Serializer,
4474    {
4475        use serde::ser::SerializeStruct;
4476        let mut len = 0;
4477        if self.exchange.is_some() {
4478            len += 1;
4479        }
4480        if !self.column_orders.is_empty() {
4481            len += 1;
4482        }
4483        let mut struct_ser = serializer.serialize_struct("batch_plan.MergeSortExchangeNode", len)?;
4484        if let Some(v) = self.exchange.as_ref() {
4485            struct_ser.serialize_field("exchange", v)?;
4486        }
4487        if !self.column_orders.is_empty() {
4488            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
4489        }
4490        struct_ser.end()
4491    }
4492}
4493impl<'de> serde::Deserialize<'de> for MergeSortExchangeNode {
4494    #[allow(deprecated)]
4495    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4496    where
4497        D: serde::Deserializer<'de>,
4498    {
4499        const FIELDS: &[&str] = &[
4500            "exchange",
4501            "column_orders",
4502            "columnOrders",
4503        ];
4504
4505        #[allow(clippy::enum_variant_names)]
4506        enum GeneratedField {
4507            Exchange,
4508            ColumnOrders,
4509        }
4510        impl<'de> serde::Deserialize<'de> for GeneratedField {
4511            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4512            where
4513                D: serde::Deserializer<'de>,
4514            {
4515                struct GeneratedVisitor;
4516
4517                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4518                    type Value = GeneratedField;
4519
4520                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4521                        write!(formatter, "expected one of: {:?}", &FIELDS)
4522                    }
4523
4524                    #[allow(unused_variables)]
4525                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4526                    where
4527                        E: serde::de::Error,
4528                    {
4529                        match value {
4530                            "exchange" => Ok(GeneratedField::Exchange),
4531                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
4532                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4533                        }
4534                    }
4535                }
4536                deserializer.deserialize_identifier(GeneratedVisitor)
4537            }
4538        }
4539        struct GeneratedVisitor;
4540        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4541            type Value = MergeSortExchangeNode;
4542
4543            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4544                formatter.write_str("struct batch_plan.MergeSortExchangeNode")
4545            }
4546
4547            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeSortExchangeNode, V::Error>
4548                where
4549                    V: serde::de::MapAccess<'de>,
4550            {
4551                let mut exchange__ = None;
4552                let mut column_orders__ = None;
4553                while let Some(k) = map_.next_key()? {
4554                    match k {
4555                        GeneratedField::Exchange => {
4556                            if exchange__.is_some() {
4557                                return Err(serde::de::Error::duplicate_field("exchange"));
4558                            }
4559                            exchange__ = map_.next_value()?;
4560                        }
4561                        GeneratedField::ColumnOrders => {
4562                            if column_orders__.is_some() {
4563                                return Err(serde::de::Error::duplicate_field("columnOrders"));
4564                            }
4565                            column_orders__ = Some(map_.next_value()?);
4566                        }
4567                    }
4568                }
4569                Ok(MergeSortExchangeNode {
4570                    exchange: exchange__,
4571                    column_orders: column_orders__.unwrap_or_default(),
4572                })
4573            }
4574        }
4575        deserializer.deserialize_struct("batch_plan.MergeSortExchangeNode", FIELDS, GeneratedVisitor)
4576    }
4577}
4578impl serde::Serialize for MySqlQueryNode {
4579    #[allow(deprecated)]
4580    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4581    where
4582        S: serde::Serializer,
4583    {
4584        use serde::ser::SerializeStruct;
4585        let mut len = 0;
4586        if !self.columns.is_empty() {
4587            len += 1;
4588        }
4589        if !self.hostname.is_empty() {
4590            len += 1;
4591        }
4592        if !self.port.is_empty() {
4593            len += 1;
4594        }
4595        if !self.username.is_empty() {
4596            len += 1;
4597        }
4598        if !self.password.is_empty() {
4599            len += 1;
4600        }
4601        if !self.database.is_empty() {
4602            len += 1;
4603        }
4604        if !self.query.is_empty() {
4605            len += 1;
4606        }
4607        let mut struct_ser = serializer.serialize_struct("batch_plan.MySqlQueryNode", len)?;
4608        if !self.columns.is_empty() {
4609            struct_ser.serialize_field("columns", &self.columns)?;
4610        }
4611        if !self.hostname.is_empty() {
4612            struct_ser.serialize_field("hostname", &self.hostname)?;
4613        }
4614        if !self.port.is_empty() {
4615            struct_ser.serialize_field("port", &self.port)?;
4616        }
4617        if !self.username.is_empty() {
4618            struct_ser.serialize_field("username", &self.username)?;
4619        }
4620        if !self.password.is_empty() {
4621            struct_ser.serialize_field("password", &self.password)?;
4622        }
4623        if !self.database.is_empty() {
4624            struct_ser.serialize_field("database", &self.database)?;
4625        }
4626        if !self.query.is_empty() {
4627            struct_ser.serialize_field("query", &self.query)?;
4628        }
4629        struct_ser.end()
4630    }
4631}
4632impl<'de> serde::Deserialize<'de> for MySqlQueryNode {
4633    #[allow(deprecated)]
4634    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4635    where
4636        D: serde::Deserializer<'de>,
4637    {
4638        const FIELDS: &[&str] = &[
4639            "columns",
4640            "hostname",
4641            "port",
4642            "username",
4643            "password",
4644            "database",
4645            "query",
4646        ];
4647
4648        #[allow(clippy::enum_variant_names)]
4649        enum GeneratedField {
4650            Columns,
4651            Hostname,
4652            Port,
4653            Username,
4654            Password,
4655            Database,
4656            Query,
4657        }
4658        impl<'de> serde::Deserialize<'de> for GeneratedField {
4659            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4660            where
4661                D: serde::Deserializer<'de>,
4662            {
4663                struct GeneratedVisitor;
4664
4665                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4666                    type Value = GeneratedField;
4667
4668                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4669                        write!(formatter, "expected one of: {:?}", &FIELDS)
4670                    }
4671
4672                    #[allow(unused_variables)]
4673                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4674                    where
4675                        E: serde::de::Error,
4676                    {
4677                        match value {
4678                            "columns" => Ok(GeneratedField::Columns),
4679                            "hostname" => Ok(GeneratedField::Hostname),
4680                            "port" => Ok(GeneratedField::Port),
4681                            "username" => Ok(GeneratedField::Username),
4682                            "password" => Ok(GeneratedField::Password),
4683                            "database" => Ok(GeneratedField::Database),
4684                            "query" => Ok(GeneratedField::Query),
4685                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4686                        }
4687                    }
4688                }
4689                deserializer.deserialize_identifier(GeneratedVisitor)
4690            }
4691        }
4692        struct GeneratedVisitor;
4693        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4694            type Value = MySqlQueryNode;
4695
4696            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4697                formatter.write_str("struct batch_plan.MySqlQueryNode")
4698            }
4699
4700            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MySqlQueryNode, V::Error>
4701                where
4702                    V: serde::de::MapAccess<'de>,
4703            {
4704                let mut columns__ = None;
4705                let mut hostname__ = None;
4706                let mut port__ = None;
4707                let mut username__ = None;
4708                let mut password__ = None;
4709                let mut database__ = None;
4710                let mut query__ = None;
4711                while let Some(k) = map_.next_key()? {
4712                    match k {
4713                        GeneratedField::Columns => {
4714                            if columns__.is_some() {
4715                                return Err(serde::de::Error::duplicate_field("columns"));
4716                            }
4717                            columns__ = Some(map_.next_value()?);
4718                        }
4719                        GeneratedField::Hostname => {
4720                            if hostname__.is_some() {
4721                                return Err(serde::de::Error::duplicate_field("hostname"));
4722                            }
4723                            hostname__ = Some(map_.next_value()?);
4724                        }
4725                        GeneratedField::Port => {
4726                            if port__.is_some() {
4727                                return Err(serde::de::Error::duplicate_field("port"));
4728                            }
4729                            port__ = Some(map_.next_value()?);
4730                        }
4731                        GeneratedField::Username => {
4732                            if username__.is_some() {
4733                                return Err(serde::de::Error::duplicate_field("username"));
4734                            }
4735                            username__ = Some(map_.next_value()?);
4736                        }
4737                        GeneratedField::Password => {
4738                            if password__.is_some() {
4739                                return Err(serde::de::Error::duplicate_field("password"));
4740                            }
4741                            password__ = Some(map_.next_value()?);
4742                        }
4743                        GeneratedField::Database => {
4744                            if database__.is_some() {
4745                                return Err(serde::de::Error::duplicate_field("database"));
4746                            }
4747                            database__ = Some(map_.next_value()?);
4748                        }
4749                        GeneratedField::Query => {
4750                            if query__.is_some() {
4751                                return Err(serde::de::Error::duplicate_field("query"));
4752                            }
4753                            query__ = Some(map_.next_value()?);
4754                        }
4755                    }
4756                }
4757                Ok(MySqlQueryNode {
4758                    columns: columns__.unwrap_or_default(),
4759                    hostname: hostname__.unwrap_or_default(),
4760                    port: port__.unwrap_or_default(),
4761                    username: username__.unwrap_or_default(),
4762                    password: password__.unwrap_or_default(),
4763                    database: database__.unwrap_or_default(),
4764                    query: query__.unwrap_or_default(),
4765                })
4766            }
4767        }
4768        deserializer.deserialize_struct("batch_plan.MySqlQueryNode", FIELDS, GeneratedVisitor)
4769    }
4770}
4771impl serde::Serialize for NestedLoopJoinNode {
4772    #[allow(deprecated)]
4773    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4774    where
4775        S: serde::Serializer,
4776    {
4777        use serde::ser::SerializeStruct;
4778        let mut len = 0;
4779        if self.join_type != 0 {
4780            len += 1;
4781        }
4782        if self.join_cond.is_some() {
4783            len += 1;
4784        }
4785        if !self.output_indices.is_empty() {
4786            len += 1;
4787        }
4788        let mut struct_ser = serializer.serialize_struct("batch_plan.NestedLoopJoinNode", len)?;
4789        if self.join_type != 0 {
4790            let v = super::plan_common::JoinType::try_from(self.join_type)
4791                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
4792            struct_ser.serialize_field("joinType", &v)?;
4793        }
4794        if let Some(v) = self.join_cond.as_ref() {
4795            struct_ser.serialize_field("joinCond", v)?;
4796        }
4797        if !self.output_indices.is_empty() {
4798            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
4799        }
4800        struct_ser.end()
4801    }
4802}
4803impl<'de> serde::Deserialize<'de> for NestedLoopJoinNode {
4804    #[allow(deprecated)]
4805    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4806    where
4807        D: serde::Deserializer<'de>,
4808    {
4809        const FIELDS: &[&str] = &[
4810            "join_type",
4811            "joinType",
4812            "join_cond",
4813            "joinCond",
4814            "output_indices",
4815            "outputIndices",
4816        ];
4817
4818        #[allow(clippy::enum_variant_names)]
4819        enum GeneratedField {
4820            JoinType,
4821            JoinCond,
4822            OutputIndices,
4823        }
4824        impl<'de> serde::Deserialize<'de> for GeneratedField {
4825            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4826            where
4827                D: serde::Deserializer<'de>,
4828            {
4829                struct GeneratedVisitor;
4830
4831                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4832                    type Value = GeneratedField;
4833
4834                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4835                        write!(formatter, "expected one of: {:?}", &FIELDS)
4836                    }
4837
4838                    #[allow(unused_variables)]
4839                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4840                    where
4841                        E: serde::de::Error,
4842                    {
4843                        match value {
4844                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
4845                            "joinCond" | "join_cond" => Ok(GeneratedField::JoinCond),
4846                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
4847                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4848                        }
4849                    }
4850                }
4851                deserializer.deserialize_identifier(GeneratedVisitor)
4852            }
4853        }
4854        struct GeneratedVisitor;
4855        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4856            type Value = NestedLoopJoinNode;
4857
4858            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4859                formatter.write_str("struct batch_plan.NestedLoopJoinNode")
4860            }
4861
4862            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NestedLoopJoinNode, V::Error>
4863                where
4864                    V: serde::de::MapAccess<'de>,
4865            {
4866                let mut join_type__ = None;
4867                let mut join_cond__ = None;
4868                let mut output_indices__ = None;
4869                while let Some(k) = map_.next_key()? {
4870                    match k {
4871                        GeneratedField::JoinType => {
4872                            if join_type__.is_some() {
4873                                return Err(serde::de::Error::duplicate_field("joinType"));
4874                            }
4875                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
4876                        }
4877                        GeneratedField::JoinCond => {
4878                            if join_cond__.is_some() {
4879                                return Err(serde::de::Error::duplicate_field("joinCond"));
4880                            }
4881                            join_cond__ = map_.next_value()?;
4882                        }
4883                        GeneratedField::OutputIndices => {
4884                            if output_indices__.is_some() {
4885                                return Err(serde::de::Error::duplicate_field("outputIndices"));
4886                            }
4887                            output_indices__ = 
4888                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4889                                    .into_iter().map(|x| x.0).collect())
4890                            ;
4891                        }
4892                    }
4893                }
4894                Ok(NestedLoopJoinNode {
4895                    join_type: join_type__.unwrap_or_default(),
4896                    join_cond: join_cond__,
4897                    output_indices: output_indices__.unwrap_or_default(),
4898                })
4899            }
4900        }
4901        deserializer.deserialize_struct("batch_plan.NestedLoopJoinNode", FIELDS, GeneratedVisitor)
4902    }
4903}
4904impl serde::Serialize for PlanFragment {
4905    #[allow(deprecated)]
4906    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4907    where
4908        S: serde::Serializer,
4909    {
4910        use serde::ser::SerializeStruct;
4911        let mut len = 0;
4912        if self.root.is_some() {
4913            len += 1;
4914        }
4915        if self.exchange_info.is_some() {
4916            len += 1;
4917        }
4918        let mut struct_ser = serializer.serialize_struct("batch_plan.PlanFragment", len)?;
4919        if let Some(v) = self.root.as_ref() {
4920            struct_ser.serialize_field("root", v)?;
4921        }
4922        if let Some(v) = self.exchange_info.as_ref() {
4923            struct_ser.serialize_field("exchangeInfo", v)?;
4924        }
4925        struct_ser.end()
4926    }
4927}
4928impl<'de> serde::Deserialize<'de> for PlanFragment {
4929    #[allow(deprecated)]
4930    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4931    where
4932        D: serde::Deserializer<'de>,
4933    {
4934        const FIELDS: &[&str] = &[
4935            "root",
4936            "exchange_info",
4937            "exchangeInfo",
4938        ];
4939
4940        #[allow(clippy::enum_variant_names)]
4941        enum GeneratedField {
4942            Root,
4943            ExchangeInfo,
4944        }
4945        impl<'de> serde::Deserialize<'de> for GeneratedField {
4946            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4947            where
4948                D: serde::Deserializer<'de>,
4949            {
4950                struct GeneratedVisitor;
4951
4952                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4953                    type Value = GeneratedField;
4954
4955                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4956                        write!(formatter, "expected one of: {:?}", &FIELDS)
4957                    }
4958
4959                    #[allow(unused_variables)]
4960                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4961                    where
4962                        E: serde::de::Error,
4963                    {
4964                        match value {
4965                            "root" => Ok(GeneratedField::Root),
4966                            "exchangeInfo" | "exchange_info" => Ok(GeneratedField::ExchangeInfo),
4967                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4968                        }
4969                    }
4970                }
4971                deserializer.deserialize_identifier(GeneratedVisitor)
4972            }
4973        }
4974        struct GeneratedVisitor;
4975        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4976            type Value = PlanFragment;
4977
4978            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4979                formatter.write_str("struct batch_plan.PlanFragment")
4980            }
4981
4982            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanFragment, V::Error>
4983                where
4984                    V: serde::de::MapAccess<'de>,
4985            {
4986                let mut root__ = None;
4987                let mut exchange_info__ = None;
4988                while let Some(k) = map_.next_key()? {
4989                    match k {
4990                        GeneratedField::Root => {
4991                            if root__.is_some() {
4992                                return Err(serde::de::Error::duplicate_field("root"));
4993                            }
4994                            root__ = map_.next_value()?;
4995                        }
4996                        GeneratedField::ExchangeInfo => {
4997                            if exchange_info__.is_some() {
4998                                return Err(serde::de::Error::duplicate_field("exchangeInfo"));
4999                            }
5000                            exchange_info__ = map_.next_value()?;
5001                        }
5002                    }
5003                }
5004                Ok(PlanFragment {
5005                    root: root__,
5006                    exchange_info: exchange_info__,
5007                })
5008            }
5009        }
5010        deserializer.deserialize_struct("batch_plan.PlanFragment", FIELDS, GeneratedVisitor)
5011    }
5012}
5013impl serde::Serialize for PlanNode {
5014    #[allow(deprecated)]
5015    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5016    where
5017        S: serde::Serializer,
5018    {
5019        use serde::ser::SerializeStruct;
5020        let mut len = 0;
5021        if !self.children.is_empty() {
5022            len += 1;
5023        }
5024        if !self.identity.is_empty() {
5025            len += 1;
5026        }
5027        if self.node_body.is_some() {
5028            len += 1;
5029        }
5030        let mut struct_ser = serializer.serialize_struct("batch_plan.PlanNode", len)?;
5031        if !self.children.is_empty() {
5032            struct_ser.serialize_field("children", &self.children)?;
5033        }
5034        if !self.identity.is_empty() {
5035            struct_ser.serialize_field("identity", &self.identity)?;
5036        }
5037        if let Some(v) = self.node_body.as_ref() {
5038            match v {
5039                plan_node::NodeBody::Insert(v) => {
5040                    struct_ser.serialize_field("insert", v)?;
5041                }
5042                plan_node::NodeBody::Delete(v) => {
5043                    struct_ser.serialize_field("delete", v)?;
5044                }
5045                plan_node::NodeBody::Update(v) => {
5046                    struct_ser.serialize_field("update", v)?;
5047                }
5048                plan_node::NodeBody::Project(v) => {
5049                    struct_ser.serialize_field("project", v)?;
5050                }
5051                plan_node::NodeBody::HashAgg(v) => {
5052                    struct_ser.serialize_field("hashAgg", v)?;
5053                }
5054                plan_node::NodeBody::Filter(v) => {
5055                    struct_ser.serialize_field("filter", v)?;
5056                }
5057                plan_node::NodeBody::Exchange(v) => {
5058                    struct_ser.serialize_field("exchange", v)?;
5059                }
5060                plan_node::NodeBody::Sort(v) => {
5061                    struct_ser.serialize_field("sort", v)?;
5062                }
5063                plan_node::NodeBody::NestedLoopJoin(v) => {
5064                    struct_ser.serialize_field("nestedLoopJoin", v)?;
5065                }
5066                plan_node::NodeBody::TopN(v) => {
5067                    struct_ser.serialize_field("topN", v)?;
5068                }
5069                plan_node::NodeBody::SortAgg(v) => {
5070                    struct_ser.serialize_field("sortAgg", v)?;
5071                }
5072                plan_node::NodeBody::RowSeqScan(v) => {
5073                    struct_ser.serialize_field("rowSeqScan", v)?;
5074                }
5075                plan_node::NodeBody::Limit(v) => {
5076                    struct_ser.serialize_field("limit", v)?;
5077                }
5078                plan_node::NodeBody::Values(v) => {
5079                    struct_ser.serialize_field("values", v)?;
5080                }
5081                plan_node::NodeBody::HashJoin(v) => {
5082                    struct_ser.serialize_field("hashJoin", v)?;
5083                }
5084                plan_node::NodeBody::MergeSortExchange(v) => {
5085                    struct_ser.serialize_field("mergeSortExchange", v)?;
5086                }
5087                plan_node::NodeBody::HopWindow(v) => {
5088                    struct_ser.serialize_field("hopWindow", v)?;
5089                }
5090                plan_node::NodeBody::TableFunction(v) => {
5091                    struct_ser.serialize_field("tableFunction", v)?;
5092                }
5093                plan_node::NodeBody::SysRowSeqScan(v) => {
5094                    struct_ser.serialize_field("sysRowSeqScan", v)?;
5095                }
5096                plan_node::NodeBody::Expand(v) => {
5097                    struct_ser.serialize_field("expand", v)?;
5098                }
5099                plan_node::NodeBody::LocalLookupJoin(v) => {
5100                    struct_ser.serialize_field("localLookupJoin", v)?;
5101                }
5102                plan_node::NodeBody::ProjectSet(v) => {
5103                    struct_ser.serialize_field("projectSet", v)?;
5104                }
5105                plan_node::NodeBody::Union(v) => {
5106                    struct_ser.serialize_field("union", v)?;
5107                }
5108                plan_node::NodeBody::GroupTopN(v) => {
5109                    struct_ser.serialize_field("groupTopN", v)?;
5110                }
5111                plan_node::NodeBody::DistributedLookupJoin(v) => {
5112                    struct_ser.serialize_field("distributedLookupJoin", v)?;
5113                }
5114                plan_node::NodeBody::Source(v) => {
5115                    struct_ser.serialize_field("source", v)?;
5116                }
5117                plan_node::NodeBody::SortOverWindow(v) => {
5118                    struct_ser.serialize_field("sortOverWindow", v)?;
5119                }
5120                plan_node::NodeBody::MaxOneRow(v) => {
5121                    struct_ser.serialize_field("maxOneRow", v)?;
5122                }
5123                plan_node::NodeBody::LogRowSeqScan(v) => {
5124                    struct_ser.serialize_field("logRowSeqScan", v)?;
5125                }
5126                plan_node::NodeBody::FileScan(v) => {
5127                    struct_ser.serialize_field("fileScan", v)?;
5128                }
5129                plan_node::NodeBody::IcebergScan(v) => {
5130                    struct_ser.serialize_field("icebergScan", v)?;
5131                }
5132                plan_node::NodeBody::PostgresQuery(v) => {
5133                    struct_ser.serialize_field("postgresQuery", v)?;
5134                }
5135                plan_node::NodeBody::MysqlQuery(v) => {
5136                    struct_ser.serialize_field("mysqlQuery", v)?;
5137                }
5138                plan_node::NodeBody::GcsFileScan(v) => {
5139                    struct_ser.serialize_field("gcsFileScan", v)?;
5140                }
5141                plan_node::NodeBody::AzblobFileScan(v) => {
5142                    struct_ser.serialize_field("azblobFileScan", v)?;
5143                }
5144                plan_node::NodeBody::VectorIndexNearest(v) => {
5145                    struct_ser.serialize_field("vectorIndexNearest", v)?;
5146                }
5147                plan_node::NodeBody::GetChannelDeltaStats(v) => {
5148                    struct_ser.serialize_field("getChannelDeltaStats", v)?;
5149                }
5150                plan_node::NodeBody::BlockExecutor(v) => {
5151                    struct_ser.serialize_field("blockExecutor", v)?;
5152                }
5153                plan_node::NodeBody::BusyLoopExecutor(v) => {
5154                    struct_ser.serialize_field("busyLoopExecutor", v)?;
5155                }
5156            }
5157        }
5158        struct_ser.end()
5159    }
5160}
5161impl<'de> serde::Deserialize<'de> for PlanNode {
5162    #[allow(deprecated)]
5163    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5164    where
5165        D: serde::Deserializer<'de>,
5166    {
5167        const FIELDS: &[&str] = &[
5168            "children",
5169            "identity",
5170            "insert",
5171            "delete",
5172            "update",
5173            "project",
5174            "hash_agg",
5175            "hashAgg",
5176            "filter",
5177            "exchange",
5178            "sort",
5179            "nested_loop_join",
5180            "nestedLoopJoin",
5181            "top_n",
5182            "topN",
5183            "sort_agg",
5184            "sortAgg",
5185            "row_seq_scan",
5186            "rowSeqScan",
5187            "limit",
5188            "values",
5189            "hash_join",
5190            "hashJoin",
5191            "merge_sort_exchange",
5192            "mergeSortExchange",
5193            "hop_window",
5194            "hopWindow",
5195            "table_function",
5196            "tableFunction",
5197            "sys_row_seq_scan",
5198            "sysRowSeqScan",
5199            "expand",
5200            "local_lookup_join",
5201            "localLookupJoin",
5202            "project_set",
5203            "projectSet",
5204            "union",
5205            "group_top_n",
5206            "groupTopN",
5207            "distributed_lookup_join",
5208            "distributedLookupJoin",
5209            "source",
5210            "sort_over_window",
5211            "sortOverWindow",
5212            "max_one_row",
5213            "maxOneRow",
5214            "log_row_seq_scan",
5215            "logRowSeqScan",
5216            "file_scan",
5217            "fileScan",
5218            "iceberg_scan",
5219            "icebergScan",
5220            "postgres_query",
5221            "postgresQuery",
5222            "mysql_query",
5223            "mysqlQuery",
5224            "gcs_file_scan",
5225            "gcsFileScan",
5226            "azblob_file_scan",
5227            "azblobFileScan",
5228            "vector_index_nearest",
5229            "vectorIndexNearest",
5230            "get_channel_delta_stats",
5231            "getChannelDeltaStats",
5232            "block_executor",
5233            "blockExecutor",
5234            "busy_loop_executor",
5235            "busyLoopExecutor",
5236        ];
5237
5238        #[allow(clippy::enum_variant_names)]
5239        enum GeneratedField {
5240            Children,
5241            Identity,
5242            Insert,
5243            Delete,
5244            Update,
5245            Project,
5246            HashAgg,
5247            Filter,
5248            Exchange,
5249            Sort,
5250            NestedLoopJoin,
5251            TopN,
5252            SortAgg,
5253            RowSeqScan,
5254            Limit,
5255            Values,
5256            HashJoin,
5257            MergeSortExchange,
5258            HopWindow,
5259            TableFunction,
5260            SysRowSeqScan,
5261            Expand,
5262            LocalLookupJoin,
5263            ProjectSet,
5264            Union,
5265            GroupTopN,
5266            DistributedLookupJoin,
5267            Source,
5268            SortOverWindow,
5269            MaxOneRow,
5270            LogRowSeqScan,
5271            FileScan,
5272            IcebergScan,
5273            PostgresQuery,
5274            MysqlQuery,
5275            GcsFileScan,
5276            AzblobFileScan,
5277            VectorIndexNearest,
5278            GetChannelDeltaStats,
5279            BlockExecutor,
5280            BusyLoopExecutor,
5281        }
5282        impl<'de> serde::Deserialize<'de> for GeneratedField {
5283            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5284            where
5285                D: serde::Deserializer<'de>,
5286            {
5287                struct GeneratedVisitor;
5288
5289                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5290                    type Value = GeneratedField;
5291
5292                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5293                        write!(formatter, "expected one of: {:?}", &FIELDS)
5294                    }
5295
5296                    #[allow(unused_variables)]
5297                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5298                    where
5299                        E: serde::de::Error,
5300                    {
5301                        match value {
5302                            "children" => Ok(GeneratedField::Children),
5303                            "identity" => Ok(GeneratedField::Identity),
5304                            "insert" => Ok(GeneratedField::Insert),
5305                            "delete" => Ok(GeneratedField::Delete),
5306                            "update" => Ok(GeneratedField::Update),
5307                            "project" => Ok(GeneratedField::Project),
5308                            "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
5309                            "filter" => Ok(GeneratedField::Filter),
5310                            "exchange" => Ok(GeneratedField::Exchange),
5311                            "sort" => Ok(GeneratedField::Sort),
5312                            "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin),
5313                            "topN" | "top_n" => Ok(GeneratedField::TopN),
5314                            "sortAgg" | "sort_agg" => Ok(GeneratedField::SortAgg),
5315                            "rowSeqScan" | "row_seq_scan" => Ok(GeneratedField::RowSeqScan),
5316                            "limit" => Ok(GeneratedField::Limit),
5317                            "values" => Ok(GeneratedField::Values),
5318                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
5319                            "mergeSortExchange" | "merge_sort_exchange" => Ok(GeneratedField::MergeSortExchange),
5320                            "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
5321                            "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
5322                            "sysRowSeqScan" | "sys_row_seq_scan" => Ok(GeneratedField::SysRowSeqScan),
5323                            "expand" => Ok(GeneratedField::Expand),
5324                            "localLookupJoin" | "local_lookup_join" => Ok(GeneratedField::LocalLookupJoin),
5325                            "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
5326                            "union" => Ok(GeneratedField::Union),
5327                            "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
5328                            "distributedLookupJoin" | "distributed_lookup_join" => Ok(GeneratedField::DistributedLookupJoin),
5329                            "source" => Ok(GeneratedField::Source),
5330                            "sortOverWindow" | "sort_over_window" => Ok(GeneratedField::SortOverWindow),
5331                            "maxOneRow" | "max_one_row" => Ok(GeneratedField::MaxOneRow),
5332                            "logRowSeqScan" | "log_row_seq_scan" => Ok(GeneratedField::LogRowSeqScan),
5333                            "fileScan" | "file_scan" => Ok(GeneratedField::FileScan),
5334                            "icebergScan" | "iceberg_scan" => Ok(GeneratedField::IcebergScan),
5335                            "postgresQuery" | "postgres_query" => Ok(GeneratedField::PostgresQuery),
5336                            "mysqlQuery" | "mysql_query" => Ok(GeneratedField::MysqlQuery),
5337                            "gcsFileScan" | "gcs_file_scan" => Ok(GeneratedField::GcsFileScan),
5338                            "azblobFileScan" | "azblob_file_scan" => Ok(GeneratedField::AzblobFileScan),
5339                            "vectorIndexNearest" | "vector_index_nearest" => Ok(GeneratedField::VectorIndexNearest),
5340                            "getChannelDeltaStats" | "get_channel_delta_stats" => Ok(GeneratedField::GetChannelDeltaStats),
5341                            "blockExecutor" | "block_executor" => Ok(GeneratedField::BlockExecutor),
5342                            "busyLoopExecutor" | "busy_loop_executor" => Ok(GeneratedField::BusyLoopExecutor),
5343                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5344                        }
5345                    }
5346                }
5347                deserializer.deserialize_identifier(GeneratedVisitor)
5348            }
5349        }
5350        struct GeneratedVisitor;
5351        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5352            type Value = PlanNode;
5353
5354            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5355                formatter.write_str("struct batch_plan.PlanNode")
5356            }
5357
5358            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PlanNode, V::Error>
5359                where
5360                    V: serde::de::MapAccess<'de>,
5361            {
5362                let mut children__ = None;
5363                let mut identity__ = None;
5364                let mut node_body__ = None;
5365                while let Some(k) = map_.next_key()? {
5366                    match k {
5367                        GeneratedField::Children => {
5368                            if children__.is_some() {
5369                                return Err(serde::de::Error::duplicate_field("children"));
5370                            }
5371                            children__ = Some(map_.next_value()?);
5372                        }
5373                        GeneratedField::Identity => {
5374                            if identity__.is_some() {
5375                                return Err(serde::de::Error::duplicate_field("identity"));
5376                            }
5377                            identity__ = Some(map_.next_value()?);
5378                        }
5379                        GeneratedField::Insert => {
5380                            if node_body__.is_some() {
5381                                return Err(serde::de::Error::duplicate_field("insert"));
5382                            }
5383                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Insert)
5384;
5385                        }
5386                        GeneratedField::Delete => {
5387                            if node_body__.is_some() {
5388                                return Err(serde::de::Error::duplicate_field("delete"));
5389                            }
5390                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Delete)
5391;
5392                        }
5393                        GeneratedField::Update => {
5394                            if node_body__.is_some() {
5395                                return Err(serde::de::Error::duplicate_field("update"));
5396                            }
5397                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Update)
5398;
5399                        }
5400                        GeneratedField::Project => {
5401                            if node_body__.is_some() {
5402                                return Err(serde::de::Error::duplicate_field("project"));
5403                            }
5404                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Project)
5405;
5406                        }
5407                        GeneratedField::HashAgg => {
5408                            if node_body__.is_some() {
5409                                return Err(serde::de::Error::duplicate_field("hashAgg"));
5410                            }
5411                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashAgg)
5412;
5413                        }
5414                        GeneratedField::Filter => {
5415                            if node_body__.is_some() {
5416                                return Err(serde::de::Error::duplicate_field("filter"));
5417                            }
5418                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Filter)
5419;
5420                        }
5421                        GeneratedField::Exchange => {
5422                            if node_body__.is_some() {
5423                                return Err(serde::de::Error::duplicate_field("exchange"));
5424                            }
5425                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Exchange)
5426;
5427                        }
5428                        GeneratedField::Sort => {
5429                            if node_body__.is_some() {
5430                                return Err(serde::de::Error::duplicate_field("sort"));
5431                            }
5432                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Sort)
5433;
5434                        }
5435                        GeneratedField::NestedLoopJoin => {
5436                            if node_body__.is_some() {
5437                                return Err(serde::de::Error::duplicate_field("nestedLoopJoin"));
5438                            }
5439                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::NestedLoopJoin)
5440;
5441                        }
5442                        GeneratedField::TopN => {
5443                            if node_body__.is_some() {
5444                                return Err(serde::de::Error::duplicate_field("topN"));
5445                            }
5446                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TopN)
5447;
5448                        }
5449                        GeneratedField::SortAgg => {
5450                            if node_body__.is_some() {
5451                                return Err(serde::de::Error::duplicate_field("sortAgg"));
5452                            }
5453                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortAgg)
5454;
5455                        }
5456                        GeneratedField::RowSeqScan => {
5457                            if node_body__.is_some() {
5458                                return Err(serde::de::Error::duplicate_field("rowSeqScan"));
5459                            }
5460                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::RowSeqScan)
5461;
5462                        }
5463                        GeneratedField::Limit => {
5464                            if node_body__.is_some() {
5465                                return Err(serde::de::Error::duplicate_field("limit"));
5466                            }
5467                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Limit)
5468;
5469                        }
5470                        GeneratedField::Values => {
5471                            if node_body__.is_some() {
5472                                return Err(serde::de::Error::duplicate_field("values"));
5473                            }
5474                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Values)
5475;
5476                        }
5477                        GeneratedField::HashJoin => {
5478                            if node_body__.is_some() {
5479                                return Err(serde::de::Error::duplicate_field("hashJoin"));
5480                            }
5481                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HashJoin)
5482;
5483                        }
5484                        GeneratedField::MergeSortExchange => {
5485                            if node_body__.is_some() {
5486                                return Err(serde::de::Error::duplicate_field("mergeSortExchange"));
5487                            }
5488                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MergeSortExchange)
5489;
5490                        }
5491                        GeneratedField::HopWindow => {
5492                            if node_body__.is_some() {
5493                                return Err(serde::de::Error::duplicate_field("hopWindow"));
5494                            }
5495                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::HopWindow)
5496;
5497                        }
5498                        GeneratedField::TableFunction => {
5499                            if node_body__.is_some() {
5500                                return Err(serde::de::Error::duplicate_field("tableFunction"));
5501                            }
5502                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::TableFunction)
5503;
5504                        }
5505                        GeneratedField::SysRowSeqScan => {
5506                            if node_body__.is_some() {
5507                                return Err(serde::de::Error::duplicate_field("sysRowSeqScan"));
5508                            }
5509                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SysRowSeqScan)
5510;
5511                        }
5512                        GeneratedField::Expand => {
5513                            if node_body__.is_some() {
5514                                return Err(serde::de::Error::duplicate_field("expand"));
5515                            }
5516                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Expand)
5517;
5518                        }
5519                        GeneratedField::LocalLookupJoin => {
5520                            if node_body__.is_some() {
5521                                return Err(serde::de::Error::duplicate_field("localLookupJoin"));
5522                            }
5523                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LocalLookupJoin)
5524;
5525                        }
5526                        GeneratedField::ProjectSet => {
5527                            if node_body__.is_some() {
5528                                return Err(serde::de::Error::duplicate_field("projectSet"));
5529                            }
5530                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::ProjectSet)
5531;
5532                        }
5533                        GeneratedField::Union => {
5534                            if node_body__.is_some() {
5535                                return Err(serde::de::Error::duplicate_field("union"));
5536                            }
5537                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Union)
5538;
5539                        }
5540                        GeneratedField::GroupTopN => {
5541                            if node_body__.is_some() {
5542                                return Err(serde::de::Error::duplicate_field("groupTopN"));
5543                            }
5544                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GroupTopN)
5545;
5546                        }
5547                        GeneratedField::DistributedLookupJoin => {
5548                            if node_body__.is_some() {
5549                                return Err(serde::de::Error::duplicate_field("distributedLookupJoin"));
5550                            }
5551                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::DistributedLookupJoin)
5552;
5553                        }
5554                        GeneratedField::Source => {
5555                            if node_body__.is_some() {
5556                                return Err(serde::de::Error::duplicate_field("source"));
5557                            }
5558                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::Source)
5559;
5560                        }
5561                        GeneratedField::SortOverWindow => {
5562                            if node_body__.is_some() {
5563                                return Err(serde::de::Error::duplicate_field("sortOverWindow"));
5564                            }
5565                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::SortOverWindow)
5566;
5567                        }
5568                        GeneratedField::MaxOneRow => {
5569                            if node_body__.is_some() {
5570                                return Err(serde::de::Error::duplicate_field("maxOneRow"));
5571                            }
5572                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MaxOneRow)
5573;
5574                        }
5575                        GeneratedField::LogRowSeqScan => {
5576                            if node_body__.is_some() {
5577                                return Err(serde::de::Error::duplicate_field("logRowSeqScan"));
5578                            }
5579                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::LogRowSeqScan)
5580;
5581                        }
5582                        GeneratedField::FileScan => {
5583                            if node_body__.is_some() {
5584                                return Err(serde::de::Error::duplicate_field("fileScan"));
5585                            }
5586                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::FileScan)
5587;
5588                        }
5589                        GeneratedField::IcebergScan => {
5590                            if node_body__.is_some() {
5591                                return Err(serde::de::Error::duplicate_field("icebergScan"));
5592                            }
5593                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::IcebergScan)
5594;
5595                        }
5596                        GeneratedField::PostgresQuery => {
5597                            if node_body__.is_some() {
5598                                return Err(serde::de::Error::duplicate_field("postgresQuery"));
5599                            }
5600                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::PostgresQuery)
5601;
5602                        }
5603                        GeneratedField::MysqlQuery => {
5604                            if node_body__.is_some() {
5605                                return Err(serde::de::Error::duplicate_field("mysqlQuery"));
5606                            }
5607                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::MysqlQuery)
5608;
5609                        }
5610                        GeneratedField::GcsFileScan => {
5611                            if node_body__.is_some() {
5612                                return Err(serde::de::Error::duplicate_field("gcsFileScan"));
5613                            }
5614                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GcsFileScan)
5615;
5616                        }
5617                        GeneratedField::AzblobFileScan => {
5618                            if node_body__.is_some() {
5619                                return Err(serde::de::Error::duplicate_field("azblobFileScan"));
5620                            }
5621                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::AzblobFileScan)
5622;
5623                        }
5624                        GeneratedField::VectorIndexNearest => {
5625                            if node_body__.is_some() {
5626                                return Err(serde::de::Error::duplicate_field("vectorIndexNearest"));
5627                            }
5628                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::VectorIndexNearest)
5629;
5630                        }
5631                        GeneratedField::GetChannelDeltaStats => {
5632                            if node_body__.is_some() {
5633                                return Err(serde::de::Error::duplicate_field("getChannelDeltaStats"));
5634                            }
5635                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::GetChannelDeltaStats)
5636;
5637                        }
5638                        GeneratedField::BlockExecutor => {
5639                            if node_body__.is_some() {
5640                                return Err(serde::de::Error::duplicate_field("blockExecutor"));
5641                            }
5642                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BlockExecutor);
5643                        }
5644                        GeneratedField::BusyLoopExecutor => {
5645                            if node_body__.is_some() {
5646                                return Err(serde::de::Error::duplicate_field("busyLoopExecutor"));
5647                            }
5648                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(plan_node::NodeBody::BusyLoopExecutor);
5649                        }
5650                    }
5651                }
5652                Ok(PlanNode {
5653                    children: children__.unwrap_or_default(),
5654                    identity: identity__.unwrap_or_default(),
5655                    node_body: node_body__,
5656                })
5657            }
5658        }
5659        deserializer.deserialize_struct("batch_plan.PlanNode", FIELDS, GeneratedVisitor)
5660    }
5661}
5662impl serde::Serialize for PostgresQueryNode {
5663    #[allow(deprecated)]
5664    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5665    where
5666        S: serde::Serializer,
5667    {
5668        use serde::ser::SerializeStruct;
5669        let mut len = 0;
5670        if !self.columns.is_empty() {
5671            len += 1;
5672        }
5673        if !self.hostname.is_empty() {
5674            len += 1;
5675        }
5676        if !self.port.is_empty() {
5677            len += 1;
5678        }
5679        if !self.username.is_empty() {
5680            len += 1;
5681        }
5682        if !self.password.is_empty() {
5683            len += 1;
5684        }
5685        if !self.database.is_empty() {
5686            len += 1;
5687        }
5688        if !self.query.is_empty() {
5689            len += 1;
5690        }
5691        let mut struct_ser = serializer.serialize_struct("batch_plan.PostgresQueryNode", len)?;
5692        if !self.columns.is_empty() {
5693            struct_ser.serialize_field("columns", &self.columns)?;
5694        }
5695        if !self.hostname.is_empty() {
5696            struct_ser.serialize_field("hostname", &self.hostname)?;
5697        }
5698        if !self.port.is_empty() {
5699            struct_ser.serialize_field("port", &self.port)?;
5700        }
5701        if !self.username.is_empty() {
5702            struct_ser.serialize_field("username", &self.username)?;
5703        }
5704        if !self.password.is_empty() {
5705            struct_ser.serialize_field("password", &self.password)?;
5706        }
5707        if !self.database.is_empty() {
5708            struct_ser.serialize_field("database", &self.database)?;
5709        }
5710        if !self.query.is_empty() {
5711            struct_ser.serialize_field("query", &self.query)?;
5712        }
5713        struct_ser.end()
5714    }
5715}
5716impl<'de> serde::Deserialize<'de> for PostgresQueryNode {
5717    #[allow(deprecated)]
5718    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5719    where
5720        D: serde::Deserializer<'de>,
5721    {
5722        const FIELDS: &[&str] = &[
5723            "columns",
5724            "hostname",
5725            "port",
5726            "username",
5727            "password",
5728            "database",
5729            "query",
5730        ];
5731
5732        #[allow(clippy::enum_variant_names)]
5733        enum GeneratedField {
5734            Columns,
5735            Hostname,
5736            Port,
5737            Username,
5738            Password,
5739            Database,
5740            Query,
5741        }
5742        impl<'de> serde::Deserialize<'de> for GeneratedField {
5743            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5744            where
5745                D: serde::Deserializer<'de>,
5746            {
5747                struct GeneratedVisitor;
5748
5749                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5750                    type Value = GeneratedField;
5751
5752                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5753                        write!(formatter, "expected one of: {:?}", &FIELDS)
5754                    }
5755
5756                    #[allow(unused_variables)]
5757                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5758                    where
5759                        E: serde::de::Error,
5760                    {
5761                        match value {
5762                            "columns" => Ok(GeneratedField::Columns),
5763                            "hostname" => Ok(GeneratedField::Hostname),
5764                            "port" => Ok(GeneratedField::Port),
5765                            "username" => Ok(GeneratedField::Username),
5766                            "password" => Ok(GeneratedField::Password),
5767                            "database" => Ok(GeneratedField::Database),
5768                            "query" => Ok(GeneratedField::Query),
5769                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5770                        }
5771                    }
5772                }
5773                deserializer.deserialize_identifier(GeneratedVisitor)
5774            }
5775        }
5776        struct GeneratedVisitor;
5777        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5778            type Value = PostgresQueryNode;
5779
5780            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5781                formatter.write_str("struct batch_plan.PostgresQueryNode")
5782            }
5783
5784            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PostgresQueryNode, V::Error>
5785                where
5786                    V: serde::de::MapAccess<'de>,
5787            {
5788                let mut columns__ = None;
5789                let mut hostname__ = None;
5790                let mut port__ = None;
5791                let mut username__ = None;
5792                let mut password__ = None;
5793                let mut database__ = None;
5794                let mut query__ = None;
5795                while let Some(k) = map_.next_key()? {
5796                    match k {
5797                        GeneratedField::Columns => {
5798                            if columns__.is_some() {
5799                                return Err(serde::de::Error::duplicate_field("columns"));
5800                            }
5801                            columns__ = Some(map_.next_value()?);
5802                        }
5803                        GeneratedField::Hostname => {
5804                            if hostname__.is_some() {
5805                                return Err(serde::de::Error::duplicate_field("hostname"));
5806                            }
5807                            hostname__ = Some(map_.next_value()?);
5808                        }
5809                        GeneratedField::Port => {
5810                            if port__.is_some() {
5811                                return Err(serde::de::Error::duplicate_field("port"));
5812                            }
5813                            port__ = Some(map_.next_value()?);
5814                        }
5815                        GeneratedField::Username => {
5816                            if username__.is_some() {
5817                                return Err(serde::de::Error::duplicate_field("username"));
5818                            }
5819                            username__ = Some(map_.next_value()?);
5820                        }
5821                        GeneratedField::Password => {
5822                            if password__.is_some() {
5823                                return Err(serde::de::Error::duplicate_field("password"));
5824                            }
5825                            password__ = Some(map_.next_value()?);
5826                        }
5827                        GeneratedField::Database => {
5828                            if database__.is_some() {
5829                                return Err(serde::de::Error::duplicate_field("database"));
5830                            }
5831                            database__ = Some(map_.next_value()?);
5832                        }
5833                        GeneratedField::Query => {
5834                            if query__.is_some() {
5835                                return Err(serde::de::Error::duplicate_field("query"));
5836                            }
5837                            query__ = Some(map_.next_value()?);
5838                        }
5839                    }
5840                }
5841                Ok(PostgresQueryNode {
5842                    columns: columns__.unwrap_or_default(),
5843                    hostname: hostname__.unwrap_or_default(),
5844                    port: port__.unwrap_or_default(),
5845                    username: username__.unwrap_or_default(),
5846                    password: password__.unwrap_or_default(),
5847                    database: database__.unwrap_or_default(),
5848                    query: query__.unwrap_or_default(),
5849                })
5850            }
5851        }
5852        deserializer.deserialize_struct("batch_plan.PostgresQueryNode", FIELDS, GeneratedVisitor)
5853    }
5854}
5855impl serde::Serialize for ProjectNode {
5856    #[allow(deprecated)]
5857    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5858    where
5859        S: serde::Serializer,
5860    {
5861        use serde::ser::SerializeStruct;
5862        let mut len = 0;
5863        if !self.select_list.is_empty() {
5864            len += 1;
5865        }
5866        let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectNode", len)?;
5867        if !self.select_list.is_empty() {
5868            struct_ser.serialize_field("selectList", &self.select_list)?;
5869        }
5870        struct_ser.end()
5871    }
5872}
5873impl<'de> serde::Deserialize<'de> for ProjectNode {
5874    #[allow(deprecated)]
5875    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5876    where
5877        D: serde::Deserializer<'de>,
5878    {
5879        const FIELDS: &[&str] = &[
5880            "select_list",
5881            "selectList",
5882        ];
5883
5884        #[allow(clippy::enum_variant_names)]
5885        enum GeneratedField {
5886            SelectList,
5887        }
5888        impl<'de> serde::Deserialize<'de> for GeneratedField {
5889            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5890            where
5891                D: serde::Deserializer<'de>,
5892            {
5893                struct GeneratedVisitor;
5894
5895                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5896                    type Value = GeneratedField;
5897
5898                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5899                        write!(formatter, "expected one of: {:?}", &FIELDS)
5900                    }
5901
5902                    #[allow(unused_variables)]
5903                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5904                    where
5905                        E: serde::de::Error,
5906                    {
5907                        match value {
5908                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
5909                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5910                        }
5911                    }
5912                }
5913                deserializer.deserialize_identifier(GeneratedVisitor)
5914            }
5915        }
5916        struct GeneratedVisitor;
5917        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5918            type Value = ProjectNode;
5919
5920            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5921                formatter.write_str("struct batch_plan.ProjectNode")
5922            }
5923
5924            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
5925                where
5926                    V: serde::de::MapAccess<'de>,
5927            {
5928                let mut select_list__ = None;
5929                while let Some(k) = map_.next_key()? {
5930                    match k {
5931                        GeneratedField::SelectList => {
5932                            if select_list__.is_some() {
5933                                return Err(serde::de::Error::duplicate_field("selectList"));
5934                            }
5935                            select_list__ = Some(map_.next_value()?);
5936                        }
5937                    }
5938                }
5939                Ok(ProjectNode {
5940                    select_list: select_list__.unwrap_or_default(),
5941                })
5942            }
5943        }
5944        deserializer.deserialize_struct("batch_plan.ProjectNode", FIELDS, GeneratedVisitor)
5945    }
5946}
5947impl serde::Serialize for ProjectSetNode {
5948    #[allow(deprecated)]
5949    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5950    where
5951        S: serde::Serializer,
5952    {
5953        use serde::ser::SerializeStruct;
5954        let mut len = 0;
5955        if !self.select_list.is_empty() {
5956            len += 1;
5957        }
5958        let mut struct_ser = serializer.serialize_struct("batch_plan.ProjectSetNode", len)?;
5959        if !self.select_list.is_empty() {
5960            struct_ser.serialize_field("selectList", &self.select_list)?;
5961        }
5962        struct_ser.end()
5963    }
5964}
5965impl<'de> serde::Deserialize<'de> for ProjectSetNode {
5966    #[allow(deprecated)]
5967    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5968    where
5969        D: serde::Deserializer<'de>,
5970    {
5971        const FIELDS: &[&str] = &[
5972            "select_list",
5973            "selectList",
5974        ];
5975
5976        #[allow(clippy::enum_variant_names)]
5977        enum GeneratedField {
5978            SelectList,
5979        }
5980        impl<'de> serde::Deserialize<'de> for GeneratedField {
5981            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5982            where
5983                D: serde::Deserializer<'de>,
5984            {
5985                struct GeneratedVisitor;
5986
5987                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5988                    type Value = GeneratedField;
5989
5990                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5991                        write!(formatter, "expected one of: {:?}", &FIELDS)
5992                    }
5993
5994                    #[allow(unused_variables)]
5995                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5996                    where
5997                        E: serde::de::Error,
5998                    {
5999                        match value {
6000                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
6001                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6002                        }
6003                    }
6004                }
6005                deserializer.deserialize_identifier(GeneratedVisitor)
6006            }
6007        }
6008        struct GeneratedVisitor;
6009        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6010            type Value = ProjectSetNode;
6011
6012            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6013                formatter.write_str("struct batch_plan.ProjectSetNode")
6014            }
6015
6016            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
6017                where
6018                    V: serde::de::MapAccess<'de>,
6019            {
6020                let mut select_list__ = None;
6021                while let Some(k) = map_.next_key()? {
6022                    match k {
6023                        GeneratedField::SelectList => {
6024                            if select_list__.is_some() {
6025                                return Err(serde::de::Error::duplicate_field("selectList"));
6026                            }
6027                            select_list__ = Some(map_.next_value()?);
6028                        }
6029                    }
6030                }
6031                Ok(ProjectSetNode {
6032                    select_list: select_list__.unwrap_or_default(),
6033                })
6034            }
6035        }
6036        deserializer.deserialize_struct("batch_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
6037    }
6038}
6039impl serde::Serialize for RowSeqScanNode {
6040    #[allow(deprecated)]
6041    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6042    where
6043        S: serde::Serializer,
6044    {
6045        use serde::ser::SerializeStruct;
6046        let mut len = 0;
6047        if self.table_desc.is_some() {
6048            len += 1;
6049        }
6050        if !self.column_ids.is_empty() {
6051            len += 1;
6052        }
6053        if !self.scan_ranges.is_empty() {
6054            len += 1;
6055        }
6056        if self.vnode_bitmap.is_some() {
6057            len += 1;
6058        }
6059        if self.ordered {
6060            len += 1;
6061        }
6062        if self.limit.is_some() {
6063            len += 1;
6064        }
6065        if self.as_of.is_some() {
6066            len += 1;
6067        }
6068        let mut struct_ser = serializer.serialize_struct("batch_plan.RowSeqScanNode", len)?;
6069        if let Some(v) = self.table_desc.as_ref() {
6070            struct_ser.serialize_field("tableDesc", v)?;
6071        }
6072        if !self.column_ids.is_empty() {
6073            struct_ser.serialize_field("columnIds", &self.column_ids)?;
6074        }
6075        if !self.scan_ranges.is_empty() {
6076            struct_ser.serialize_field("scanRanges", &self.scan_ranges)?;
6077        }
6078        if let Some(v) = self.vnode_bitmap.as_ref() {
6079            struct_ser.serialize_field("vnodeBitmap", v)?;
6080        }
6081        if self.ordered {
6082            struct_ser.serialize_field("ordered", &self.ordered)?;
6083        }
6084        if let Some(v) = self.limit.as_ref() {
6085            #[allow(clippy::needless_borrow)]
6086            #[allow(clippy::needless_borrows_for_generic_args)]
6087            struct_ser.serialize_field("limit", ToString::to_string(&v).as_str())?;
6088        }
6089        if let Some(v) = self.as_of.as_ref() {
6090            struct_ser.serialize_field("asOf", v)?;
6091        }
6092        struct_ser.end()
6093    }
6094}
6095impl<'de> serde::Deserialize<'de> for RowSeqScanNode {
6096    #[allow(deprecated)]
6097    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6098    where
6099        D: serde::Deserializer<'de>,
6100    {
6101        const FIELDS: &[&str] = &[
6102            "table_desc",
6103            "tableDesc",
6104            "column_ids",
6105            "columnIds",
6106            "scan_ranges",
6107            "scanRanges",
6108            "vnode_bitmap",
6109            "vnodeBitmap",
6110            "ordered",
6111            "limit",
6112            "as_of",
6113            "asOf",
6114        ];
6115
6116        #[allow(clippy::enum_variant_names)]
6117        enum GeneratedField {
6118            TableDesc,
6119            ColumnIds,
6120            ScanRanges,
6121            VnodeBitmap,
6122            Ordered,
6123            Limit,
6124            AsOf,
6125        }
6126        impl<'de> serde::Deserialize<'de> for GeneratedField {
6127            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6128            where
6129                D: serde::Deserializer<'de>,
6130            {
6131                struct GeneratedVisitor;
6132
6133                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6134                    type Value = GeneratedField;
6135
6136                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6137                        write!(formatter, "expected one of: {:?}", &FIELDS)
6138                    }
6139
6140                    #[allow(unused_variables)]
6141                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6142                    where
6143                        E: serde::de::Error,
6144                    {
6145                        match value {
6146                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
6147                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
6148                            "scanRanges" | "scan_ranges" => Ok(GeneratedField::ScanRanges),
6149                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
6150                            "ordered" => Ok(GeneratedField::Ordered),
6151                            "limit" => Ok(GeneratedField::Limit),
6152                            "asOf" | "as_of" => Ok(GeneratedField::AsOf),
6153                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6154                        }
6155                    }
6156                }
6157                deserializer.deserialize_identifier(GeneratedVisitor)
6158            }
6159        }
6160        struct GeneratedVisitor;
6161        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6162            type Value = RowSeqScanNode;
6163
6164            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6165                formatter.write_str("struct batch_plan.RowSeqScanNode")
6166            }
6167
6168            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowSeqScanNode, V::Error>
6169                where
6170                    V: serde::de::MapAccess<'de>,
6171            {
6172                let mut table_desc__ = None;
6173                let mut column_ids__ = None;
6174                let mut scan_ranges__ = None;
6175                let mut vnode_bitmap__ = None;
6176                let mut ordered__ = None;
6177                let mut limit__ = None;
6178                let mut as_of__ = None;
6179                while let Some(k) = map_.next_key()? {
6180                    match k {
6181                        GeneratedField::TableDesc => {
6182                            if table_desc__.is_some() {
6183                                return Err(serde::de::Error::duplicate_field("tableDesc"));
6184                            }
6185                            table_desc__ = map_.next_value()?;
6186                        }
6187                        GeneratedField::ColumnIds => {
6188                            if column_ids__.is_some() {
6189                                return Err(serde::de::Error::duplicate_field("columnIds"));
6190                            }
6191                            column_ids__ = 
6192                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6193                                    .into_iter().map(|x| x.0).collect())
6194                            ;
6195                        }
6196                        GeneratedField::ScanRanges => {
6197                            if scan_ranges__.is_some() {
6198                                return Err(serde::de::Error::duplicate_field("scanRanges"));
6199                            }
6200                            scan_ranges__ = Some(map_.next_value()?);
6201                        }
6202                        GeneratedField::VnodeBitmap => {
6203                            if vnode_bitmap__.is_some() {
6204                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
6205                            }
6206                            vnode_bitmap__ = map_.next_value()?;
6207                        }
6208                        GeneratedField::Ordered => {
6209                            if ordered__.is_some() {
6210                                return Err(serde::de::Error::duplicate_field("ordered"));
6211                            }
6212                            ordered__ = Some(map_.next_value()?);
6213                        }
6214                        GeneratedField::Limit => {
6215                            if limit__.is_some() {
6216                                return Err(serde::de::Error::duplicate_field("limit"));
6217                            }
6218                            limit__ = 
6219                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6220                            ;
6221                        }
6222                        GeneratedField::AsOf => {
6223                            if as_of__.is_some() {
6224                                return Err(serde::de::Error::duplicate_field("asOf"));
6225                            }
6226                            as_of__ = map_.next_value()?;
6227                        }
6228                    }
6229                }
6230                Ok(RowSeqScanNode {
6231                    table_desc: table_desc__,
6232                    column_ids: column_ids__.unwrap_or_default(),
6233                    scan_ranges: scan_ranges__.unwrap_or_default(),
6234                    vnode_bitmap: vnode_bitmap__,
6235                    ordered: ordered__.unwrap_or_default(),
6236                    limit: limit__,
6237                    as_of: as_of__,
6238                })
6239            }
6240        }
6241        deserializer.deserialize_struct("batch_plan.RowSeqScanNode", FIELDS, GeneratedVisitor)
6242    }
6243}
6244impl serde::Serialize for ScanRange {
6245    #[allow(deprecated)]
6246    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6247    where
6248        S: serde::Serializer,
6249    {
6250        use serde::ser::SerializeStruct;
6251        let mut len = 0;
6252        if !self.eq_conds.is_empty() {
6253            len += 1;
6254        }
6255        if self.lower_bound.is_some() {
6256            len += 1;
6257        }
6258        if self.upper_bound.is_some() {
6259            len += 1;
6260        }
6261        let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange", len)?;
6262        if !self.eq_conds.is_empty() {
6263            struct_ser.serialize_field("eqConds", &self.eq_conds.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6264        }
6265        if let Some(v) = self.lower_bound.as_ref() {
6266            struct_ser.serialize_field("lowerBound", v)?;
6267        }
6268        if let Some(v) = self.upper_bound.as_ref() {
6269            struct_ser.serialize_field("upperBound", v)?;
6270        }
6271        struct_ser.end()
6272    }
6273}
6274impl<'de> serde::Deserialize<'de> for ScanRange {
6275    #[allow(deprecated)]
6276    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6277    where
6278        D: serde::Deserializer<'de>,
6279    {
6280        const FIELDS: &[&str] = &[
6281            "eq_conds",
6282            "eqConds",
6283            "lower_bound",
6284            "lowerBound",
6285            "upper_bound",
6286            "upperBound",
6287        ];
6288
6289        #[allow(clippy::enum_variant_names)]
6290        enum GeneratedField {
6291            EqConds,
6292            LowerBound,
6293            UpperBound,
6294        }
6295        impl<'de> serde::Deserialize<'de> for GeneratedField {
6296            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6297            where
6298                D: serde::Deserializer<'de>,
6299            {
6300                struct GeneratedVisitor;
6301
6302                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6303                    type Value = GeneratedField;
6304
6305                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6306                        write!(formatter, "expected one of: {:?}", &FIELDS)
6307                    }
6308
6309                    #[allow(unused_variables)]
6310                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6311                    where
6312                        E: serde::de::Error,
6313                    {
6314                        match value {
6315                            "eqConds" | "eq_conds" => Ok(GeneratedField::EqConds),
6316                            "lowerBound" | "lower_bound" => Ok(GeneratedField::LowerBound),
6317                            "upperBound" | "upper_bound" => Ok(GeneratedField::UpperBound),
6318                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6319                        }
6320                    }
6321                }
6322                deserializer.deserialize_identifier(GeneratedVisitor)
6323            }
6324        }
6325        struct GeneratedVisitor;
6326        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6327            type Value = ScanRange;
6328
6329            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6330                formatter.write_str("struct batch_plan.ScanRange")
6331            }
6332
6333            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ScanRange, V::Error>
6334                where
6335                    V: serde::de::MapAccess<'de>,
6336            {
6337                let mut eq_conds__ = None;
6338                let mut lower_bound__ = None;
6339                let mut upper_bound__ = None;
6340                while let Some(k) = map_.next_key()? {
6341                    match k {
6342                        GeneratedField::EqConds => {
6343                            if eq_conds__.is_some() {
6344                                return Err(serde::de::Error::duplicate_field("eqConds"));
6345                            }
6346                            eq_conds__ = 
6347                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6348                                    .into_iter().map(|x| x.0).collect())
6349                            ;
6350                        }
6351                        GeneratedField::LowerBound => {
6352                            if lower_bound__.is_some() {
6353                                return Err(serde::de::Error::duplicate_field("lowerBound"));
6354                            }
6355                            lower_bound__ = map_.next_value()?;
6356                        }
6357                        GeneratedField::UpperBound => {
6358                            if upper_bound__.is_some() {
6359                                return Err(serde::de::Error::duplicate_field("upperBound"));
6360                            }
6361                            upper_bound__ = map_.next_value()?;
6362                        }
6363                    }
6364                }
6365                Ok(ScanRange {
6366                    eq_conds: eq_conds__.unwrap_or_default(),
6367                    lower_bound: lower_bound__,
6368                    upper_bound: upper_bound__,
6369                })
6370            }
6371        }
6372        deserializer.deserialize_struct("batch_plan.ScanRange", FIELDS, GeneratedVisitor)
6373    }
6374}
6375impl serde::Serialize for scan_range::Bound {
6376    #[allow(deprecated)]
6377    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6378    where
6379        S: serde::Serializer,
6380    {
6381        use serde::ser::SerializeStruct;
6382        let mut len = 0;
6383        if !self.value.is_empty() {
6384            len += 1;
6385        }
6386        if self.inclusive {
6387            len += 1;
6388        }
6389        let mut struct_ser = serializer.serialize_struct("batch_plan.ScanRange.Bound", len)?;
6390        if !self.value.is_empty() {
6391            struct_ser.serialize_field("value", &self.value.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
6392        }
6393        if self.inclusive {
6394            struct_ser.serialize_field("inclusive", &self.inclusive)?;
6395        }
6396        struct_ser.end()
6397    }
6398}
6399impl<'de> serde::Deserialize<'de> for scan_range::Bound {
6400    #[allow(deprecated)]
6401    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6402    where
6403        D: serde::Deserializer<'de>,
6404    {
6405        const FIELDS: &[&str] = &[
6406            "value",
6407            "inclusive",
6408        ];
6409
6410        #[allow(clippy::enum_variant_names)]
6411        enum GeneratedField {
6412            Value,
6413            Inclusive,
6414        }
6415        impl<'de> serde::Deserialize<'de> for GeneratedField {
6416            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6417            where
6418                D: serde::Deserializer<'de>,
6419            {
6420                struct GeneratedVisitor;
6421
6422                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6423                    type Value = GeneratedField;
6424
6425                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6426                        write!(formatter, "expected one of: {:?}", &FIELDS)
6427                    }
6428
6429                    #[allow(unused_variables)]
6430                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6431                    where
6432                        E: serde::de::Error,
6433                    {
6434                        match value {
6435                            "value" => Ok(GeneratedField::Value),
6436                            "inclusive" => Ok(GeneratedField::Inclusive),
6437                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6438                        }
6439                    }
6440                }
6441                deserializer.deserialize_identifier(GeneratedVisitor)
6442            }
6443        }
6444        struct GeneratedVisitor;
6445        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6446            type Value = scan_range::Bound;
6447
6448            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6449                formatter.write_str("struct batch_plan.ScanRange.Bound")
6450            }
6451
6452            fn visit_map<V>(self, mut map_: V) -> std::result::Result<scan_range::Bound, V::Error>
6453                where
6454                    V: serde::de::MapAccess<'de>,
6455            {
6456                let mut value__ = None;
6457                let mut inclusive__ = None;
6458                while let Some(k) = map_.next_key()? {
6459                    match k {
6460                        GeneratedField::Value => {
6461                            if value__.is_some() {
6462                                return Err(serde::de::Error::duplicate_field("value"));
6463                            }
6464                            value__ = 
6465                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
6466                                    .into_iter().map(|x| x.0).collect())
6467                            ;
6468                        }
6469                        GeneratedField::Inclusive => {
6470                            if inclusive__.is_some() {
6471                                return Err(serde::de::Error::duplicate_field("inclusive"));
6472                            }
6473                            inclusive__ = Some(map_.next_value()?);
6474                        }
6475                    }
6476                }
6477                Ok(scan_range::Bound {
6478                    value: value__.unwrap_or_default(),
6479                    inclusive: inclusive__.unwrap_or_default(),
6480                })
6481            }
6482        }
6483        deserializer.deserialize_struct("batch_plan.ScanRange.Bound", FIELDS, GeneratedVisitor)
6484    }
6485}
6486impl serde::Serialize for SortAggNode {
6487    #[allow(deprecated)]
6488    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6489    where
6490        S: serde::Serializer,
6491    {
6492        use serde::ser::SerializeStruct;
6493        let mut len = 0;
6494        if !self.group_key.is_empty() {
6495            len += 1;
6496        }
6497        if !self.agg_calls.is_empty() {
6498            len += 1;
6499        }
6500        let mut struct_ser = serializer.serialize_struct("batch_plan.SortAggNode", len)?;
6501        if !self.group_key.is_empty() {
6502            struct_ser.serialize_field("groupKey", &self.group_key)?;
6503        }
6504        if !self.agg_calls.is_empty() {
6505            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
6506        }
6507        struct_ser.end()
6508    }
6509}
6510impl<'de> serde::Deserialize<'de> for SortAggNode {
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            "group_key",
6518            "groupKey",
6519            "agg_calls",
6520            "aggCalls",
6521        ];
6522
6523        #[allow(clippy::enum_variant_names)]
6524        enum GeneratedField {
6525            GroupKey,
6526            AggCalls,
6527        }
6528        impl<'de> serde::Deserialize<'de> for GeneratedField {
6529            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6530            where
6531                D: serde::Deserializer<'de>,
6532            {
6533                struct GeneratedVisitor;
6534
6535                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6536                    type Value = GeneratedField;
6537
6538                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6539                        write!(formatter, "expected one of: {:?}", &FIELDS)
6540                    }
6541
6542                    #[allow(unused_variables)]
6543                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6544                    where
6545                        E: serde::de::Error,
6546                    {
6547                        match value {
6548                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
6549                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
6550                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6551                        }
6552                    }
6553                }
6554                deserializer.deserialize_identifier(GeneratedVisitor)
6555            }
6556        }
6557        struct GeneratedVisitor;
6558        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6559            type Value = SortAggNode;
6560
6561            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6562                formatter.write_str("struct batch_plan.SortAggNode")
6563            }
6564
6565            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortAggNode, V::Error>
6566                where
6567                    V: serde::de::MapAccess<'de>,
6568            {
6569                let mut group_key__ = None;
6570                let mut agg_calls__ = None;
6571                while let Some(k) = map_.next_key()? {
6572                    match k {
6573                        GeneratedField::GroupKey => {
6574                            if group_key__.is_some() {
6575                                return Err(serde::de::Error::duplicate_field("groupKey"));
6576                            }
6577                            group_key__ = Some(map_.next_value()?);
6578                        }
6579                        GeneratedField::AggCalls => {
6580                            if agg_calls__.is_some() {
6581                                return Err(serde::de::Error::duplicate_field("aggCalls"));
6582                            }
6583                            agg_calls__ = Some(map_.next_value()?);
6584                        }
6585                    }
6586                }
6587                Ok(SortAggNode {
6588                    group_key: group_key__.unwrap_or_default(),
6589                    agg_calls: agg_calls__.unwrap_or_default(),
6590                })
6591            }
6592        }
6593        deserializer.deserialize_struct("batch_plan.SortAggNode", FIELDS, GeneratedVisitor)
6594    }
6595}
6596impl serde::Serialize for SortMergeJoinNode {
6597    #[allow(deprecated)]
6598    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6599    where
6600        S: serde::Serializer,
6601    {
6602        use serde::ser::SerializeStruct;
6603        let mut len = 0;
6604        if self.join_type != 0 {
6605            len += 1;
6606        }
6607        if !self.left_key.is_empty() {
6608            len += 1;
6609        }
6610        if !self.right_key.is_empty() {
6611            len += 1;
6612        }
6613        if self.direction != 0 {
6614            len += 1;
6615        }
6616        if !self.output_indices.is_empty() {
6617            len += 1;
6618        }
6619        let mut struct_ser = serializer.serialize_struct("batch_plan.SortMergeJoinNode", len)?;
6620        if self.join_type != 0 {
6621            let v = super::plan_common::JoinType::try_from(self.join_type)
6622                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
6623            struct_ser.serialize_field("joinType", &v)?;
6624        }
6625        if !self.left_key.is_empty() {
6626            struct_ser.serialize_field("leftKey", &self.left_key)?;
6627        }
6628        if !self.right_key.is_empty() {
6629            struct_ser.serialize_field("rightKey", &self.right_key)?;
6630        }
6631        if self.direction != 0 {
6632            let v = super::common::Direction::try_from(self.direction)
6633                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?;
6634            struct_ser.serialize_field("direction", &v)?;
6635        }
6636        if !self.output_indices.is_empty() {
6637            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
6638        }
6639        struct_ser.end()
6640    }
6641}
6642impl<'de> serde::Deserialize<'de> for SortMergeJoinNode {
6643    #[allow(deprecated)]
6644    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6645    where
6646        D: serde::Deserializer<'de>,
6647    {
6648        const FIELDS: &[&str] = &[
6649            "join_type",
6650            "joinType",
6651            "left_key",
6652            "leftKey",
6653            "right_key",
6654            "rightKey",
6655            "direction",
6656            "output_indices",
6657            "outputIndices",
6658        ];
6659
6660        #[allow(clippy::enum_variant_names)]
6661        enum GeneratedField {
6662            JoinType,
6663            LeftKey,
6664            RightKey,
6665            Direction,
6666            OutputIndices,
6667        }
6668        impl<'de> serde::Deserialize<'de> for GeneratedField {
6669            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6670            where
6671                D: serde::Deserializer<'de>,
6672            {
6673                struct GeneratedVisitor;
6674
6675                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6676                    type Value = GeneratedField;
6677
6678                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6679                        write!(formatter, "expected one of: {:?}", &FIELDS)
6680                    }
6681
6682                    #[allow(unused_variables)]
6683                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6684                    where
6685                        E: serde::de::Error,
6686                    {
6687                        match value {
6688                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
6689                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
6690                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
6691                            "direction" => Ok(GeneratedField::Direction),
6692                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
6693                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6694                        }
6695                    }
6696                }
6697                deserializer.deserialize_identifier(GeneratedVisitor)
6698            }
6699        }
6700        struct GeneratedVisitor;
6701        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6702            type Value = SortMergeJoinNode;
6703
6704            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6705                formatter.write_str("struct batch_plan.SortMergeJoinNode")
6706            }
6707
6708            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortMergeJoinNode, V::Error>
6709                where
6710                    V: serde::de::MapAccess<'de>,
6711            {
6712                let mut join_type__ = None;
6713                let mut left_key__ = None;
6714                let mut right_key__ = None;
6715                let mut direction__ = None;
6716                let mut output_indices__ = None;
6717                while let Some(k) = map_.next_key()? {
6718                    match k {
6719                        GeneratedField::JoinType => {
6720                            if join_type__.is_some() {
6721                                return Err(serde::de::Error::duplicate_field("joinType"));
6722                            }
6723                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
6724                        }
6725                        GeneratedField::LeftKey => {
6726                            if left_key__.is_some() {
6727                                return Err(serde::de::Error::duplicate_field("leftKey"));
6728                            }
6729                            left_key__ = 
6730                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6731                                    .into_iter().map(|x| x.0).collect())
6732                            ;
6733                        }
6734                        GeneratedField::RightKey => {
6735                            if right_key__.is_some() {
6736                                return Err(serde::de::Error::duplicate_field("rightKey"));
6737                            }
6738                            right_key__ = 
6739                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6740                                    .into_iter().map(|x| x.0).collect())
6741                            ;
6742                        }
6743                        GeneratedField::Direction => {
6744                            if direction__.is_some() {
6745                                return Err(serde::de::Error::duplicate_field("direction"));
6746                            }
6747                            direction__ = Some(map_.next_value::<super::common::Direction>()? as i32);
6748                        }
6749                        GeneratedField::OutputIndices => {
6750                            if output_indices__.is_some() {
6751                                return Err(serde::de::Error::duplicate_field("outputIndices"));
6752                            }
6753                            output_indices__ = 
6754                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6755                                    .into_iter().map(|x| x.0).collect())
6756                            ;
6757                        }
6758                    }
6759                }
6760                Ok(SortMergeJoinNode {
6761                    join_type: join_type__.unwrap_or_default(),
6762                    left_key: left_key__.unwrap_or_default(),
6763                    right_key: right_key__.unwrap_or_default(),
6764                    direction: direction__.unwrap_or_default(),
6765                    output_indices: output_indices__.unwrap_or_default(),
6766                })
6767            }
6768        }
6769        deserializer.deserialize_struct("batch_plan.SortMergeJoinNode", FIELDS, GeneratedVisitor)
6770    }
6771}
6772impl serde::Serialize for SortNode {
6773    #[allow(deprecated)]
6774    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6775    where
6776        S: serde::Serializer,
6777    {
6778        use serde::ser::SerializeStruct;
6779        let mut len = 0;
6780        if !self.column_orders.is_empty() {
6781            len += 1;
6782        }
6783        let mut struct_ser = serializer.serialize_struct("batch_plan.SortNode", len)?;
6784        if !self.column_orders.is_empty() {
6785            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6786        }
6787        struct_ser.end()
6788    }
6789}
6790impl<'de> serde::Deserialize<'de> for SortNode {
6791    #[allow(deprecated)]
6792    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6793    where
6794        D: serde::Deserializer<'de>,
6795    {
6796        const FIELDS: &[&str] = &[
6797            "column_orders",
6798            "columnOrders",
6799        ];
6800
6801        #[allow(clippy::enum_variant_names)]
6802        enum GeneratedField {
6803            ColumnOrders,
6804        }
6805        impl<'de> serde::Deserialize<'de> for GeneratedField {
6806            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6807            where
6808                D: serde::Deserializer<'de>,
6809            {
6810                struct GeneratedVisitor;
6811
6812                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6813                    type Value = GeneratedField;
6814
6815                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6816                        write!(formatter, "expected one of: {:?}", &FIELDS)
6817                    }
6818
6819                    #[allow(unused_variables)]
6820                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6821                    where
6822                        E: serde::de::Error,
6823                    {
6824                        match value {
6825                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6826                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6827                        }
6828                    }
6829                }
6830                deserializer.deserialize_identifier(GeneratedVisitor)
6831            }
6832        }
6833        struct GeneratedVisitor;
6834        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6835            type Value = SortNode;
6836
6837            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6838                formatter.write_str("struct batch_plan.SortNode")
6839            }
6840
6841            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
6842                where
6843                    V: serde::de::MapAccess<'de>,
6844            {
6845                let mut column_orders__ = None;
6846                while let Some(k) = map_.next_key()? {
6847                    match k {
6848                        GeneratedField::ColumnOrders => {
6849                            if column_orders__.is_some() {
6850                                return Err(serde::de::Error::duplicate_field("columnOrders"));
6851                            }
6852                            column_orders__ = Some(map_.next_value()?);
6853                        }
6854                    }
6855                }
6856                Ok(SortNode {
6857                    column_orders: column_orders__.unwrap_or_default(),
6858                })
6859            }
6860        }
6861        deserializer.deserialize_struct("batch_plan.SortNode", FIELDS, GeneratedVisitor)
6862    }
6863}
6864impl serde::Serialize for SortOverWindowNode {
6865    #[allow(deprecated)]
6866    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6867    where
6868        S: serde::Serializer,
6869    {
6870        use serde::ser::SerializeStruct;
6871        let mut len = 0;
6872        if !self.calls.is_empty() {
6873            len += 1;
6874        }
6875        if !self.partition_by.is_empty() {
6876            len += 1;
6877        }
6878        if !self.order_by.is_empty() {
6879            len += 1;
6880        }
6881        let mut struct_ser = serializer.serialize_struct("batch_plan.SortOverWindowNode", len)?;
6882        if !self.calls.is_empty() {
6883            struct_ser.serialize_field("calls", &self.calls)?;
6884        }
6885        if !self.partition_by.is_empty() {
6886            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
6887        }
6888        if !self.order_by.is_empty() {
6889            struct_ser.serialize_field("orderBy", &self.order_by)?;
6890        }
6891        struct_ser.end()
6892    }
6893}
6894impl<'de> serde::Deserialize<'de> for SortOverWindowNode {
6895    #[allow(deprecated)]
6896    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6897    where
6898        D: serde::Deserializer<'de>,
6899    {
6900        const FIELDS: &[&str] = &[
6901            "calls",
6902            "partition_by",
6903            "partitionBy",
6904            "order_by",
6905            "orderBy",
6906        ];
6907
6908        #[allow(clippy::enum_variant_names)]
6909        enum GeneratedField {
6910            Calls,
6911            PartitionBy,
6912            OrderBy,
6913        }
6914        impl<'de> serde::Deserialize<'de> for GeneratedField {
6915            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6916            where
6917                D: serde::Deserializer<'de>,
6918            {
6919                struct GeneratedVisitor;
6920
6921                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6922                    type Value = GeneratedField;
6923
6924                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6925                        write!(formatter, "expected one of: {:?}", &FIELDS)
6926                    }
6927
6928                    #[allow(unused_variables)]
6929                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6930                    where
6931                        E: serde::de::Error,
6932                    {
6933                        match value {
6934                            "calls" => Ok(GeneratedField::Calls),
6935                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
6936                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
6937                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6938                        }
6939                    }
6940                }
6941                deserializer.deserialize_identifier(GeneratedVisitor)
6942            }
6943        }
6944        struct GeneratedVisitor;
6945        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6946            type Value = SortOverWindowNode;
6947
6948            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6949                formatter.write_str("struct batch_plan.SortOverWindowNode")
6950            }
6951
6952            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortOverWindowNode, V::Error>
6953                where
6954                    V: serde::de::MapAccess<'de>,
6955            {
6956                let mut calls__ = None;
6957                let mut partition_by__ = None;
6958                let mut order_by__ = None;
6959                while let Some(k) = map_.next_key()? {
6960                    match k {
6961                        GeneratedField::Calls => {
6962                            if calls__.is_some() {
6963                                return Err(serde::de::Error::duplicate_field("calls"));
6964                            }
6965                            calls__ = Some(map_.next_value()?);
6966                        }
6967                        GeneratedField::PartitionBy => {
6968                            if partition_by__.is_some() {
6969                                return Err(serde::de::Error::duplicate_field("partitionBy"));
6970                            }
6971                            partition_by__ = 
6972                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6973                                    .into_iter().map(|x| x.0).collect())
6974                            ;
6975                        }
6976                        GeneratedField::OrderBy => {
6977                            if order_by__.is_some() {
6978                                return Err(serde::de::Error::duplicate_field("orderBy"));
6979                            }
6980                            order_by__ = Some(map_.next_value()?);
6981                        }
6982                    }
6983                }
6984                Ok(SortOverWindowNode {
6985                    calls: calls__.unwrap_or_default(),
6986                    partition_by: partition_by__.unwrap_or_default(),
6987                    order_by: order_by__.unwrap_or_default(),
6988                })
6989            }
6990        }
6991        deserializer.deserialize_struct("batch_plan.SortOverWindowNode", FIELDS, GeneratedVisitor)
6992    }
6993}
6994impl serde::Serialize for SourceNode {
6995    #[allow(deprecated)]
6996    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6997    where
6998        S: serde::Serializer,
6999    {
7000        use serde::ser::SerializeStruct;
7001        let mut len = 0;
7002        if self.source_id != 0 {
7003            len += 1;
7004        }
7005        if !self.columns.is_empty() {
7006            len += 1;
7007        }
7008        if !self.with_properties.is_empty() {
7009            len += 1;
7010        }
7011        if !self.split.is_empty() {
7012            len += 1;
7013        }
7014        if self.info.is_some() {
7015            len += 1;
7016        }
7017        if !self.secret_refs.is_empty() {
7018            len += 1;
7019        }
7020        let mut struct_ser = serializer.serialize_struct("batch_plan.SourceNode", len)?;
7021        if self.source_id != 0 {
7022            struct_ser.serialize_field("sourceId", &self.source_id)?;
7023        }
7024        if !self.columns.is_empty() {
7025            struct_ser.serialize_field("columns", &self.columns)?;
7026        }
7027        if !self.with_properties.is_empty() {
7028            struct_ser.serialize_field("withProperties", &self.with_properties)?;
7029        }
7030        if !self.split.is_empty() {
7031            struct_ser.serialize_field("split", &self.split.iter().map(pbjson::private::base64::encode).collect::<Vec<_>>())?;
7032        }
7033        if let Some(v) = self.info.as_ref() {
7034            struct_ser.serialize_field("info", v)?;
7035        }
7036        if !self.secret_refs.is_empty() {
7037            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
7038        }
7039        struct_ser.end()
7040    }
7041}
7042impl<'de> serde::Deserialize<'de> for SourceNode {
7043    #[allow(deprecated)]
7044    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7045    where
7046        D: serde::Deserializer<'de>,
7047    {
7048        const FIELDS: &[&str] = &[
7049            "source_id",
7050            "sourceId",
7051            "columns",
7052            "with_properties",
7053            "withProperties",
7054            "split",
7055            "info",
7056            "secret_refs",
7057            "secretRefs",
7058        ];
7059
7060        #[allow(clippy::enum_variant_names)]
7061        enum GeneratedField {
7062            SourceId,
7063            Columns,
7064            WithProperties,
7065            Split,
7066            Info,
7067            SecretRefs,
7068        }
7069        impl<'de> serde::Deserialize<'de> for GeneratedField {
7070            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7071            where
7072                D: serde::Deserializer<'de>,
7073            {
7074                struct GeneratedVisitor;
7075
7076                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7077                    type Value = GeneratedField;
7078
7079                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7080                        write!(formatter, "expected one of: {:?}", &FIELDS)
7081                    }
7082
7083                    #[allow(unused_variables)]
7084                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7085                    where
7086                        E: serde::de::Error,
7087                    {
7088                        match value {
7089                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7090                            "columns" => Ok(GeneratedField::Columns),
7091                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
7092                            "split" => Ok(GeneratedField::Split),
7093                            "info" => Ok(GeneratedField::Info),
7094                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
7095                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7096                        }
7097                    }
7098                }
7099                deserializer.deserialize_identifier(GeneratedVisitor)
7100            }
7101        }
7102        struct GeneratedVisitor;
7103        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7104            type Value = SourceNode;
7105
7106            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7107                formatter.write_str("struct batch_plan.SourceNode")
7108            }
7109
7110            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
7111                where
7112                    V: serde::de::MapAccess<'de>,
7113            {
7114                let mut source_id__ = None;
7115                let mut columns__ = None;
7116                let mut with_properties__ = None;
7117                let mut split__ = None;
7118                let mut info__ = None;
7119                let mut secret_refs__ = None;
7120                while let Some(k) = map_.next_key()? {
7121                    match k {
7122                        GeneratedField::SourceId => {
7123                            if source_id__.is_some() {
7124                                return Err(serde::de::Error::duplicate_field("sourceId"));
7125                            }
7126                            source_id__ = 
7127                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7128                            ;
7129                        }
7130                        GeneratedField::Columns => {
7131                            if columns__.is_some() {
7132                                return Err(serde::de::Error::duplicate_field("columns"));
7133                            }
7134                            columns__ = Some(map_.next_value()?);
7135                        }
7136                        GeneratedField::WithProperties => {
7137                            if with_properties__.is_some() {
7138                                return Err(serde::de::Error::duplicate_field("withProperties"));
7139                            }
7140                            with_properties__ = Some(
7141                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
7142                            );
7143                        }
7144                        GeneratedField::Split => {
7145                            if split__.is_some() {
7146                                return Err(serde::de::Error::duplicate_field("split"));
7147                            }
7148                            split__ = 
7149                                Some(map_.next_value::<Vec<::pbjson::private::BytesDeserialize<_>>>()?
7150                                    .into_iter().map(|x| x.0).collect())
7151                            ;
7152                        }
7153                        GeneratedField::Info => {
7154                            if info__.is_some() {
7155                                return Err(serde::de::Error::duplicate_field("info"));
7156                            }
7157                            info__ = map_.next_value()?;
7158                        }
7159                        GeneratedField::SecretRefs => {
7160                            if secret_refs__.is_some() {
7161                                return Err(serde::de::Error::duplicate_field("secretRefs"));
7162                            }
7163                            secret_refs__ = Some(
7164                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
7165                            );
7166                        }
7167                    }
7168                }
7169                Ok(SourceNode {
7170                    source_id: source_id__.unwrap_or_default(),
7171                    columns: columns__.unwrap_or_default(),
7172                    with_properties: with_properties__.unwrap_or_default(),
7173                    split: split__.unwrap_or_default(),
7174                    info: info__,
7175                    secret_refs: secret_refs__.unwrap_or_default(),
7176                })
7177            }
7178        }
7179        deserializer.deserialize_struct("batch_plan.SourceNode", FIELDS, GeneratedVisitor)
7180    }
7181}
7182impl serde::Serialize for SysRowSeqScanNode {
7183    #[allow(deprecated)]
7184    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7185    where
7186        S: serde::Serializer,
7187    {
7188        use serde::ser::SerializeStruct;
7189        let mut len = 0;
7190        if self.table_id != 0 {
7191            len += 1;
7192        }
7193        if !self.column_descs.is_empty() {
7194            len += 1;
7195        }
7196        let mut struct_ser = serializer.serialize_struct("batch_plan.SysRowSeqScanNode", len)?;
7197        if self.table_id != 0 {
7198            struct_ser.serialize_field("tableId", &self.table_id)?;
7199        }
7200        if !self.column_descs.is_empty() {
7201            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
7202        }
7203        struct_ser.end()
7204    }
7205}
7206impl<'de> serde::Deserialize<'de> for SysRowSeqScanNode {
7207    #[allow(deprecated)]
7208    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7209    where
7210        D: serde::Deserializer<'de>,
7211    {
7212        const FIELDS: &[&str] = &[
7213            "table_id",
7214            "tableId",
7215            "column_descs",
7216            "columnDescs",
7217        ];
7218
7219        #[allow(clippy::enum_variant_names)]
7220        enum GeneratedField {
7221            TableId,
7222            ColumnDescs,
7223        }
7224        impl<'de> serde::Deserialize<'de> for GeneratedField {
7225            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7226            where
7227                D: serde::Deserializer<'de>,
7228            {
7229                struct GeneratedVisitor;
7230
7231                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7232                    type Value = GeneratedField;
7233
7234                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7235                        write!(formatter, "expected one of: {:?}", &FIELDS)
7236                    }
7237
7238                    #[allow(unused_variables)]
7239                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7240                    where
7241                        E: serde::de::Error,
7242                    {
7243                        match value {
7244                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
7245                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
7246                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7247                        }
7248                    }
7249                }
7250                deserializer.deserialize_identifier(GeneratedVisitor)
7251            }
7252        }
7253        struct GeneratedVisitor;
7254        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7255            type Value = SysRowSeqScanNode;
7256
7257            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7258                formatter.write_str("struct batch_plan.SysRowSeqScanNode")
7259            }
7260
7261            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SysRowSeqScanNode, V::Error>
7262                where
7263                    V: serde::de::MapAccess<'de>,
7264            {
7265                let mut table_id__ = None;
7266                let mut column_descs__ = None;
7267                while let Some(k) = map_.next_key()? {
7268                    match k {
7269                        GeneratedField::TableId => {
7270                            if table_id__.is_some() {
7271                                return Err(serde::de::Error::duplicate_field("tableId"));
7272                            }
7273                            table_id__ = 
7274                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7275                            ;
7276                        }
7277                        GeneratedField::ColumnDescs => {
7278                            if column_descs__.is_some() {
7279                                return Err(serde::de::Error::duplicate_field("columnDescs"));
7280                            }
7281                            column_descs__ = Some(map_.next_value()?);
7282                        }
7283                    }
7284                }
7285                Ok(SysRowSeqScanNode {
7286                    table_id: table_id__.unwrap_or_default(),
7287                    column_descs: column_descs__.unwrap_or_default(),
7288                })
7289            }
7290        }
7291        deserializer.deserialize_struct("batch_plan.SysRowSeqScanNode", FIELDS, GeneratedVisitor)
7292    }
7293}
7294impl serde::Serialize for TableFunctionNode {
7295    #[allow(deprecated)]
7296    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7297    where
7298        S: serde::Serializer,
7299    {
7300        use serde::ser::SerializeStruct;
7301        let mut len = 0;
7302        if self.table_function.is_some() {
7303            len += 1;
7304        }
7305        let mut struct_ser = serializer.serialize_struct("batch_plan.TableFunctionNode", len)?;
7306        if let Some(v) = self.table_function.as_ref() {
7307            struct_ser.serialize_field("tableFunction", v)?;
7308        }
7309        struct_ser.end()
7310    }
7311}
7312impl<'de> serde::Deserialize<'de> for TableFunctionNode {
7313    #[allow(deprecated)]
7314    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7315    where
7316        D: serde::Deserializer<'de>,
7317    {
7318        const FIELDS: &[&str] = &[
7319            "table_function",
7320            "tableFunction",
7321        ];
7322
7323        #[allow(clippy::enum_variant_names)]
7324        enum GeneratedField {
7325            TableFunction,
7326        }
7327        impl<'de> serde::Deserialize<'de> for GeneratedField {
7328            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7329            where
7330                D: serde::Deserializer<'de>,
7331            {
7332                struct GeneratedVisitor;
7333
7334                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7335                    type Value = GeneratedField;
7336
7337                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7338                        write!(formatter, "expected one of: {:?}", &FIELDS)
7339                    }
7340
7341                    #[allow(unused_variables)]
7342                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7343                    where
7344                        E: serde::de::Error,
7345                    {
7346                        match value {
7347                            "tableFunction" | "table_function" => Ok(GeneratedField::TableFunction),
7348                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7349                        }
7350                    }
7351                }
7352                deserializer.deserialize_identifier(GeneratedVisitor)
7353            }
7354        }
7355        struct GeneratedVisitor;
7356        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7357            type Value = TableFunctionNode;
7358
7359            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7360                formatter.write_str("struct batch_plan.TableFunctionNode")
7361            }
7362
7363            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFunctionNode, V::Error>
7364                where
7365                    V: serde::de::MapAccess<'de>,
7366            {
7367                let mut table_function__ = None;
7368                while let Some(k) = map_.next_key()? {
7369                    match k {
7370                        GeneratedField::TableFunction => {
7371                            if table_function__.is_some() {
7372                                return Err(serde::de::Error::duplicate_field("tableFunction"));
7373                            }
7374                            table_function__ = map_.next_value()?;
7375                        }
7376                    }
7377                }
7378                Ok(TableFunctionNode {
7379                    table_function: table_function__,
7380                })
7381            }
7382        }
7383        deserializer.deserialize_struct("batch_plan.TableFunctionNode", FIELDS, GeneratedVisitor)
7384    }
7385}
7386impl serde::Serialize for TaskId {
7387    #[allow(deprecated)]
7388    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7389    where
7390        S: serde::Serializer,
7391    {
7392        use serde::ser::SerializeStruct;
7393        let mut len = 0;
7394        if !self.query_id.is_empty() {
7395            len += 1;
7396        }
7397        if self.stage_id != 0 {
7398            len += 1;
7399        }
7400        if self.task_id != 0 {
7401            len += 1;
7402        }
7403        let mut struct_ser = serializer.serialize_struct("batch_plan.TaskId", len)?;
7404        if !self.query_id.is_empty() {
7405            struct_ser.serialize_field("queryId", &self.query_id)?;
7406        }
7407        if self.stage_id != 0 {
7408            struct_ser.serialize_field("stageId", &self.stage_id)?;
7409        }
7410        if self.task_id != 0 {
7411            #[allow(clippy::needless_borrow)]
7412            #[allow(clippy::needless_borrows_for_generic_args)]
7413            struct_ser.serialize_field("taskId", ToString::to_string(&self.task_id).as_str())?;
7414        }
7415        struct_ser.end()
7416    }
7417}
7418impl<'de> serde::Deserialize<'de> for TaskId {
7419    #[allow(deprecated)]
7420    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7421    where
7422        D: serde::Deserializer<'de>,
7423    {
7424        const FIELDS: &[&str] = &[
7425            "query_id",
7426            "queryId",
7427            "stage_id",
7428            "stageId",
7429            "task_id",
7430            "taskId",
7431        ];
7432
7433        #[allow(clippy::enum_variant_names)]
7434        enum GeneratedField {
7435            QueryId,
7436            StageId,
7437            TaskId,
7438        }
7439        impl<'de> serde::Deserialize<'de> for GeneratedField {
7440            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7441            where
7442                D: serde::Deserializer<'de>,
7443            {
7444                struct GeneratedVisitor;
7445
7446                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7447                    type Value = GeneratedField;
7448
7449                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7450                        write!(formatter, "expected one of: {:?}", &FIELDS)
7451                    }
7452
7453                    #[allow(unused_variables)]
7454                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7455                    where
7456                        E: serde::de::Error,
7457                    {
7458                        match value {
7459                            "queryId" | "query_id" => Ok(GeneratedField::QueryId),
7460                            "stageId" | "stage_id" => Ok(GeneratedField::StageId),
7461                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7462                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7463                        }
7464                    }
7465                }
7466                deserializer.deserialize_identifier(GeneratedVisitor)
7467            }
7468        }
7469        struct GeneratedVisitor;
7470        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7471            type Value = TaskId;
7472
7473            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7474                formatter.write_str("struct batch_plan.TaskId")
7475            }
7476
7477            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskId, V::Error>
7478                where
7479                    V: serde::de::MapAccess<'de>,
7480            {
7481                let mut query_id__ = None;
7482                let mut stage_id__ = None;
7483                let mut task_id__ = None;
7484                while let Some(k) = map_.next_key()? {
7485                    match k {
7486                        GeneratedField::QueryId => {
7487                            if query_id__.is_some() {
7488                                return Err(serde::de::Error::duplicate_field("queryId"));
7489                            }
7490                            query_id__ = Some(map_.next_value()?);
7491                        }
7492                        GeneratedField::StageId => {
7493                            if stage_id__.is_some() {
7494                                return Err(serde::de::Error::duplicate_field("stageId"));
7495                            }
7496                            stage_id__ = 
7497                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7498                            ;
7499                        }
7500                        GeneratedField::TaskId => {
7501                            if task_id__.is_some() {
7502                                return Err(serde::de::Error::duplicate_field("taskId"));
7503                            }
7504                            task_id__ = 
7505                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7506                            ;
7507                        }
7508                    }
7509                }
7510                Ok(TaskId {
7511                    query_id: query_id__.unwrap_or_default(),
7512                    stage_id: stage_id__.unwrap_or_default(),
7513                    task_id: task_id__.unwrap_or_default(),
7514                })
7515            }
7516        }
7517        deserializer.deserialize_struct("batch_plan.TaskId", FIELDS, GeneratedVisitor)
7518    }
7519}
7520impl serde::Serialize for TaskOutputId {
7521    #[allow(deprecated)]
7522    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7523    where
7524        S: serde::Serializer,
7525    {
7526        use serde::ser::SerializeStruct;
7527        let mut len = 0;
7528        if self.task_id.is_some() {
7529            len += 1;
7530        }
7531        if self.output_id != 0 {
7532            len += 1;
7533        }
7534        let mut struct_ser = serializer.serialize_struct("batch_plan.TaskOutputId", len)?;
7535        if let Some(v) = self.task_id.as_ref() {
7536            struct_ser.serialize_field("taskId", v)?;
7537        }
7538        if self.output_id != 0 {
7539            #[allow(clippy::needless_borrow)]
7540            #[allow(clippy::needless_borrows_for_generic_args)]
7541            struct_ser.serialize_field("outputId", ToString::to_string(&self.output_id).as_str())?;
7542        }
7543        struct_ser.end()
7544    }
7545}
7546impl<'de> serde::Deserialize<'de> for TaskOutputId {
7547    #[allow(deprecated)]
7548    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7549    where
7550        D: serde::Deserializer<'de>,
7551    {
7552        const FIELDS: &[&str] = &[
7553            "task_id",
7554            "taskId",
7555            "output_id",
7556            "outputId",
7557        ];
7558
7559        #[allow(clippy::enum_variant_names)]
7560        enum GeneratedField {
7561            TaskId,
7562            OutputId,
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                            "taskId" | "task_id" => Ok(GeneratedField::TaskId),
7585                            "outputId" | "output_id" => Ok(GeneratedField::OutputId),
7586                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7587                        }
7588                    }
7589                }
7590                deserializer.deserialize_identifier(GeneratedVisitor)
7591            }
7592        }
7593        struct GeneratedVisitor;
7594        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7595            type Value = TaskOutputId;
7596
7597            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7598                formatter.write_str("struct batch_plan.TaskOutputId")
7599            }
7600
7601            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TaskOutputId, V::Error>
7602                where
7603                    V: serde::de::MapAccess<'de>,
7604            {
7605                let mut task_id__ = None;
7606                let mut output_id__ = None;
7607                while let Some(k) = map_.next_key()? {
7608                    match k {
7609                        GeneratedField::TaskId => {
7610                            if task_id__.is_some() {
7611                                return Err(serde::de::Error::duplicate_field("taskId"));
7612                            }
7613                            task_id__ = map_.next_value()?;
7614                        }
7615                        GeneratedField::OutputId => {
7616                            if output_id__.is_some() {
7617                                return Err(serde::de::Error::duplicate_field("outputId"));
7618                            }
7619                            output_id__ = 
7620                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7621                            ;
7622                        }
7623                    }
7624                }
7625                Ok(TaskOutputId {
7626                    task_id: task_id__,
7627                    output_id: output_id__.unwrap_or_default(),
7628                })
7629            }
7630        }
7631        deserializer.deserialize_struct("batch_plan.TaskOutputId", FIELDS, GeneratedVisitor)
7632    }
7633}
7634impl serde::Serialize for TopNNode {
7635    #[allow(deprecated)]
7636    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7637    where
7638        S: serde::Serializer,
7639    {
7640        use serde::ser::SerializeStruct;
7641        let mut len = 0;
7642        if !self.column_orders.is_empty() {
7643            len += 1;
7644        }
7645        if self.limit != 0 {
7646            len += 1;
7647        }
7648        if self.offset != 0 {
7649            len += 1;
7650        }
7651        if self.with_ties {
7652            len += 1;
7653        }
7654        let mut struct_ser = serializer.serialize_struct("batch_plan.TopNNode", len)?;
7655        if !self.column_orders.is_empty() {
7656            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
7657        }
7658        if self.limit != 0 {
7659            #[allow(clippy::needless_borrow)]
7660            #[allow(clippy::needless_borrows_for_generic_args)]
7661            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
7662        }
7663        if self.offset != 0 {
7664            #[allow(clippy::needless_borrow)]
7665            #[allow(clippy::needless_borrows_for_generic_args)]
7666            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
7667        }
7668        if self.with_ties {
7669            struct_ser.serialize_field("withTies", &self.with_ties)?;
7670        }
7671        struct_ser.end()
7672    }
7673}
7674impl<'de> serde::Deserialize<'de> for TopNNode {
7675    #[allow(deprecated)]
7676    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7677    where
7678        D: serde::Deserializer<'de>,
7679    {
7680        const FIELDS: &[&str] = &[
7681            "column_orders",
7682            "columnOrders",
7683            "limit",
7684            "offset",
7685            "with_ties",
7686            "withTies",
7687        ];
7688
7689        #[allow(clippy::enum_variant_names)]
7690        enum GeneratedField {
7691            ColumnOrders,
7692            Limit,
7693            Offset,
7694            WithTies,
7695        }
7696        impl<'de> serde::Deserialize<'de> for GeneratedField {
7697            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7698            where
7699                D: serde::Deserializer<'de>,
7700            {
7701                struct GeneratedVisitor;
7702
7703                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7704                    type Value = GeneratedField;
7705
7706                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7707                        write!(formatter, "expected one of: {:?}", &FIELDS)
7708                    }
7709
7710                    #[allow(unused_variables)]
7711                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7712                    where
7713                        E: serde::de::Error,
7714                    {
7715                        match value {
7716                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
7717                            "limit" => Ok(GeneratedField::Limit),
7718                            "offset" => Ok(GeneratedField::Offset),
7719                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
7720                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7721                        }
7722                    }
7723                }
7724                deserializer.deserialize_identifier(GeneratedVisitor)
7725            }
7726        }
7727        struct GeneratedVisitor;
7728        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7729            type Value = TopNNode;
7730
7731            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7732                formatter.write_str("struct batch_plan.TopNNode")
7733            }
7734
7735            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
7736                where
7737                    V: serde::de::MapAccess<'de>,
7738            {
7739                let mut column_orders__ = None;
7740                let mut limit__ = None;
7741                let mut offset__ = None;
7742                let mut with_ties__ = None;
7743                while let Some(k) = map_.next_key()? {
7744                    match k {
7745                        GeneratedField::ColumnOrders => {
7746                            if column_orders__.is_some() {
7747                                return Err(serde::de::Error::duplicate_field("columnOrders"));
7748                            }
7749                            column_orders__ = Some(map_.next_value()?);
7750                        }
7751                        GeneratedField::Limit => {
7752                            if limit__.is_some() {
7753                                return Err(serde::de::Error::duplicate_field("limit"));
7754                            }
7755                            limit__ = 
7756                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7757                            ;
7758                        }
7759                        GeneratedField::Offset => {
7760                            if offset__.is_some() {
7761                                return Err(serde::de::Error::duplicate_field("offset"));
7762                            }
7763                            offset__ = 
7764                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7765                            ;
7766                        }
7767                        GeneratedField::WithTies => {
7768                            if with_ties__.is_some() {
7769                                return Err(serde::de::Error::duplicate_field("withTies"));
7770                            }
7771                            with_ties__ = Some(map_.next_value()?);
7772                        }
7773                    }
7774                }
7775                Ok(TopNNode {
7776                    column_orders: column_orders__.unwrap_or_default(),
7777                    limit: limit__.unwrap_or_default(),
7778                    offset: offset__.unwrap_or_default(),
7779                    with_ties: with_ties__.unwrap_or_default(),
7780                })
7781            }
7782        }
7783        deserializer.deserialize_struct("batch_plan.TopNNode", FIELDS, GeneratedVisitor)
7784    }
7785}
7786impl serde::Serialize for UnionNode {
7787    #[allow(deprecated)]
7788    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7789    where
7790        S: serde::Serializer,
7791    {
7792        use serde::ser::SerializeStruct;
7793        let len = 0;
7794        let struct_ser = serializer.serialize_struct("batch_plan.UnionNode", len)?;
7795        struct_ser.end()
7796    }
7797}
7798impl<'de> serde::Deserialize<'de> for UnionNode {
7799    #[allow(deprecated)]
7800    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7801    where
7802        D: serde::Deserializer<'de>,
7803    {
7804        const FIELDS: &[&str] = &[
7805        ];
7806
7807        #[allow(clippy::enum_variant_names)]
7808        enum GeneratedField {
7809        }
7810        impl<'de> serde::Deserialize<'de> for GeneratedField {
7811            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7812            where
7813                D: serde::Deserializer<'de>,
7814            {
7815                struct GeneratedVisitor;
7816
7817                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7818                    type Value = GeneratedField;
7819
7820                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7821                        write!(formatter, "expected one of: {:?}", &FIELDS)
7822                    }
7823
7824                    #[allow(unused_variables)]
7825                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7826                    where
7827                        E: serde::de::Error,
7828                    {
7829                            Err(serde::de::Error::unknown_field(value, FIELDS))
7830                    }
7831                }
7832                deserializer.deserialize_identifier(GeneratedVisitor)
7833            }
7834        }
7835        struct GeneratedVisitor;
7836        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7837            type Value = UnionNode;
7838
7839            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7840                formatter.write_str("struct batch_plan.UnionNode")
7841            }
7842
7843            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
7844                where
7845                    V: serde::de::MapAccess<'de>,
7846            {
7847                while map_.next_key::<GeneratedField>()?.is_some() {
7848                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7849                }
7850                Ok(UnionNode {
7851                })
7852            }
7853        }
7854        deserializer.deserialize_struct("batch_plan.UnionNode", FIELDS, GeneratedVisitor)
7855    }
7856}
7857impl serde::Serialize for UpdateNode {
7858    #[allow(deprecated)]
7859    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7860    where
7861        S: serde::Serializer,
7862    {
7863        use serde::ser::SerializeStruct;
7864        let mut len = 0;
7865        if self.table_id != 0 {
7866            len += 1;
7867        }
7868        if self.table_version_id != 0 {
7869            len += 1;
7870        }
7871        if !self.old_exprs.is_empty() {
7872            len += 1;
7873        }
7874        if !self.new_exprs.is_empty() {
7875            len += 1;
7876        }
7877        if self.returning {
7878            len += 1;
7879        }
7880        if self.session_id != 0 {
7881            len += 1;
7882        }
7883        let mut struct_ser = serializer.serialize_struct("batch_plan.UpdateNode", len)?;
7884        if self.table_id != 0 {
7885            struct_ser.serialize_field("tableId", &self.table_id)?;
7886        }
7887        if self.table_version_id != 0 {
7888            #[allow(clippy::needless_borrow)]
7889            #[allow(clippy::needless_borrows_for_generic_args)]
7890            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
7891        }
7892        if !self.old_exprs.is_empty() {
7893            struct_ser.serialize_field("oldExprs", &self.old_exprs)?;
7894        }
7895        if !self.new_exprs.is_empty() {
7896            struct_ser.serialize_field("newExprs", &self.new_exprs)?;
7897        }
7898        if self.returning {
7899            struct_ser.serialize_field("returning", &self.returning)?;
7900        }
7901        if self.session_id != 0 {
7902            struct_ser.serialize_field("sessionId", &self.session_id)?;
7903        }
7904        struct_ser.end()
7905    }
7906}
7907impl<'de> serde::Deserialize<'de> for UpdateNode {
7908    #[allow(deprecated)]
7909    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7910    where
7911        D: serde::Deserializer<'de>,
7912    {
7913        const FIELDS: &[&str] = &[
7914            "table_id",
7915            "tableId",
7916            "table_version_id",
7917            "tableVersionId",
7918            "old_exprs",
7919            "oldExprs",
7920            "new_exprs",
7921            "newExprs",
7922            "returning",
7923            "session_id",
7924            "sessionId",
7925        ];
7926
7927        #[allow(clippy::enum_variant_names)]
7928        enum GeneratedField {
7929            TableId,
7930            TableVersionId,
7931            OldExprs,
7932            NewExprs,
7933            Returning,
7934            SessionId,
7935        }
7936        impl<'de> serde::Deserialize<'de> for GeneratedField {
7937            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7938            where
7939                D: serde::Deserializer<'de>,
7940            {
7941                struct GeneratedVisitor;
7942
7943                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7944                    type Value = GeneratedField;
7945
7946                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7947                        write!(formatter, "expected one of: {:?}", &FIELDS)
7948                    }
7949
7950                    #[allow(unused_variables)]
7951                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7952                    where
7953                        E: serde::de::Error,
7954                    {
7955                        match value {
7956                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
7957                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
7958                            "oldExprs" | "old_exprs" => Ok(GeneratedField::OldExprs),
7959                            "newExprs" | "new_exprs" => Ok(GeneratedField::NewExprs),
7960                            "returning" => Ok(GeneratedField::Returning),
7961                            "sessionId" | "session_id" => Ok(GeneratedField::SessionId),
7962                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7963                        }
7964                    }
7965                }
7966                deserializer.deserialize_identifier(GeneratedVisitor)
7967            }
7968        }
7969        struct GeneratedVisitor;
7970        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7971            type Value = UpdateNode;
7972
7973            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7974                formatter.write_str("struct batch_plan.UpdateNode")
7975            }
7976
7977            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateNode, V::Error>
7978                where
7979                    V: serde::de::MapAccess<'de>,
7980            {
7981                let mut table_id__ = None;
7982                let mut table_version_id__ = None;
7983                let mut old_exprs__ = None;
7984                let mut new_exprs__ = None;
7985                let mut returning__ = None;
7986                let mut session_id__ = None;
7987                while let Some(k) = map_.next_key()? {
7988                    match k {
7989                        GeneratedField::TableId => {
7990                            if table_id__.is_some() {
7991                                return Err(serde::de::Error::duplicate_field("tableId"));
7992                            }
7993                            table_id__ = 
7994                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7995                            ;
7996                        }
7997                        GeneratedField::TableVersionId => {
7998                            if table_version_id__.is_some() {
7999                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
8000                            }
8001                            table_version_id__ = 
8002                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8003                            ;
8004                        }
8005                        GeneratedField::OldExprs => {
8006                            if old_exprs__.is_some() {
8007                                return Err(serde::de::Error::duplicate_field("oldExprs"));
8008                            }
8009                            old_exprs__ = Some(map_.next_value()?);
8010                        }
8011                        GeneratedField::NewExprs => {
8012                            if new_exprs__.is_some() {
8013                                return Err(serde::de::Error::duplicate_field("newExprs"));
8014                            }
8015                            new_exprs__ = Some(map_.next_value()?);
8016                        }
8017                        GeneratedField::Returning => {
8018                            if returning__.is_some() {
8019                                return Err(serde::de::Error::duplicate_field("returning"));
8020                            }
8021                            returning__ = Some(map_.next_value()?);
8022                        }
8023                        GeneratedField::SessionId => {
8024                            if session_id__.is_some() {
8025                                return Err(serde::de::Error::duplicate_field("sessionId"));
8026                            }
8027                            session_id__ = 
8028                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8029                            ;
8030                        }
8031                    }
8032                }
8033                Ok(UpdateNode {
8034                    table_id: table_id__.unwrap_or_default(),
8035                    table_version_id: table_version_id__.unwrap_or_default(),
8036                    old_exprs: old_exprs__.unwrap_or_default(),
8037                    new_exprs: new_exprs__.unwrap_or_default(),
8038                    returning: returning__.unwrap_or_default(),
8039                    session_id: session_id__.unwrap_or_default(),
8040                })
8041            }
8042        }
8043        deserializer.deserialize_struct("batch_plan.UpdateNode", FIELDS, GeneratedVisitor)
8044    }
8045}
8046impl serde::Serialize for ValuesNode {
8047    #[allow(deprecated)]
8048    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8049    where
8050        S: serde::Serializer,
8051    {
8052        use serde::ser::SerializeStruct;
8053        let mut len = 0;
8054        if !self.tuples.is_empty() {
8055            len += 1;
8056        }
8057        if !self.fields.is_empty() {
8058            len += 1;
8059        }
8060        let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode", len)?;
8061        if !self.tuples.is_empty() {
8062            struct_ser.serialize_field("tuples", &self.tuples)?;
8063        }
8064        if !self.fields.is_empty() {
8065            struct_ser.serialize_field("fields", &self.fields)?;
8066        }
8067        struct_ser.end()
8068    }
8069}
8070impl<'de> serde::Deserialize<'de> for ValuesNode {
8071    #[allow(deprecated)]
8072    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8073    where
8074        D: serde::Deserializer<'de>,
8075    {
8076        const FIELDS: &[&str] = &[
8077            "tuples",
8078            "fields",
8079        ];
8080
8081        #[allow(clippy::enum_variant_names)]
8082        enum GeneratedField {
8083            Tuples,
8084            Fields,
8085        }
8086        impl<'de> serde::Deserialize<'de> for GeneratedField {
8087            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8088            where
8089                D: serde::Deserializer<'de>,
8090            {
8091                struct GeneratedVisitor;
8092
8093                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8094                    type Value = GeneratedField;
8095
8096                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8097                        write!(formatter, "expected one of: {:?}", &FIELDS)
8098                    }
8099
8100                    #[allow(unused_variables)]
8101                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8102                    where
8103                        E: serde::de::Error,
8104                    {
8105                        match value {
8106                            "tuples" => Ok(GeneratedField::Tuples),
8107                            "fields" => Ok(GeneratedField::Fields),
8108                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8109                        }
8110                    }
8111                }
8112                deserializer.deserialize_identifier(GeneratedVisitor)
8113            }
8114        }
8115        struct GeneratedVisitor;
8116        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8117            type Value = ValuesNode;
8118
8119            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8120                formatter.write_str("struct batch_plan.ValuesNode")
8121            }
8122
8123            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
8124                where
8125                    V: serde::de::MapAccess<'de>,
8126            {
8127                let mut tuples__ = None;
8128                let mut fields__ = None;
8129                while let Some(k) = map_.next_key()? {
8130                    match k {
8131                        GeneratedField::Tuples => {
8132                            if tuples__.is_some() {
8133                                return Err(serde::de::Error::duplicate_field("tuples"));
8134                            }
8135                            tuples__ = Some(map_.next_value()?);
8136                        }
8137                        GeneratedField::Fields => {
8138                            if fields__.is_some() {
8139                                return Err(serde::de::Error::duplicate_field("fields"));
8140                            }
8141                            fields__ = Some(map_.next_value()?);
8142                        }
8143                    }
8144                }
8145                Ok(ValuesNode {
8146                    tuples: tuples__.unwrap_or_default(),
8147                    fields: fields__.unwrap_or_default(),
8148                })
8149            }
8150        }
8151        deserializer.deserialize_struct("batch_plan.ValuesNode", FIELDS, GeneratedVisitor)
8152    }
8153}
8154impl serde::Serialize for values_node::ExprTuple {
8155    #[allow(deprecated)]
8156    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8157    where
8158        S: serde::Serializer,
8159    {
8160        use serde::ser::SerializeStruct;
8161        let mut len = 0;
8162        if !self.cells.is_empty() {
8163            len += 1;
8164        }
8165        let mut struct_ser = serializer.serialize_struct("batch_plan.ValuesNode.ExprTuple", len)?;
8166        if !self.cells.is_empty() {
8167            struct_ser.serialize_field("cells", &self.cells)?;
8168        }
8169        struct_ser.end()
8170    }
8171}
8172impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
8173    #[allow(deprecated)]
8174    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8175    where
8176        D: serde::Deserializer<'de>,
8177    {
8178        const FIELDS: &[&str] = &[
8179            "cells",
8180        ];
8181
8182        #[allow(clippy::enum_variant_names)]
8183        enum GeneratedField {
8184            Cells,
8185        }
8186        impl<'de> serde::Deserialize<'de> for GeneratedField {
8187            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8188            where
8189                D: serde::Deserializer<'de>,
8190            {
8191                struct GeneratedVisitor;
8192
8193                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8194                    type Value = GeneratedField;
8195
8196                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8197                        write!(formatter, "expected one of: {:?}", &FIELDS)
8198                    }
8199
8200                    #[allow(unused_variables)]
8201                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8202                    where
8203                        E: serde::de::Error,
8204                    {
8205                        match value {
8206                            "cells" => Ok(GeneratedField::Cells),
8207                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8208                        }
8209                    }
8210                }
8211                deserializer.deserialize_identifier(GeneratedVisitor)
8212            }
8213        }
8214        struct GeneratedVisitor;
8215        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8216            type Value = values_node::ExprTuple;
8217
8218            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8219                formatter.write_str("struct batch_plan.ValuesNode.ExprTuple")
8220            }
8221
8222            fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
8223                where
8224                    V: serde::de::MapAccess<'de>,
8225            {
8226                let mut cells__ = None;
8227                while let Some(k) = map_.next_key()? {
8228                    match k {
8229                        GeneratedField::Cells => {
8230                            if cells__.is_some() {
8231                                return Err(serde::de::Error::duplicate_field("cells"));
8232                            }
8233                            cells__ = Some(map_.next_value()?);
8234                        }
8235                    }
8236                }
8237                Ok(values_node::ExprTuple {
8238                    cells: cells__.unwrap_or_default(),
8239                })
8240            }
8241        }
8242        deserializer.deserialize_struct("batch_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
8243    }
8244}
8245impl serde::Serialize for VectorIndexNearestNode {
8246    #[allow(deprecated)]
8247    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8248    where
8249        S: serde::Serializer,
8250    {
8251        use serde::ser::SerializeStruct;
8252        let mut len = 0;
8253        if self.table_id != 0 {
8254            len += 1;
8255        }
8256        if !self.info_column_desc.is_empty() {
8257            len += 1;
8258        }
8259        if self.vector_column_idx != 0 {
8260            len += 1;
8261        }
8262        if self.top_n != 0 {
8263            len += 1;
8264        }
8265        if self.distance_type != 0 {
8266            len += 1;
8267        }
8268        if self.hnsw_ef_search != 0 {
8269            len += 1;
8270        }
8271        let mut struct_ser = serializer.serialize_struct("batch_plan.VectorIndexNearestNode", len)?;
8272        if self.table_id != 0 {
8273            struct_ser.serialize_field("tableId", &self.table_id)?;
8274        }
8275        if !self.info_column_desc.is_empty() {
8276            struct_ser.serialize_field("infoColumnDesc", &self.info_column_desc)?;
8277        }
8278        if self.vector_column_idx != 0 {
8279            struct_ser.serialize_field("vectorColumnIdx", &self.vector_column_idx)?;
8280        }
8281        if self.top_n != 0 {
8282            struct_ser.serialize_field("topN", &self.top_n)?;
8283        }
8284        if self.distance_type != 0 {
8285            let v = super::common::DistanceType::try_from(self.distance_type)
8286                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distance_type)))?;
8287            struct_ser.serialize_field("distanceType", &v)?;
8288        }
8289        if self.hnsw_ef_search != 0 {
8290            struct_ser.serialize_field("hnswEfSearch", &self.hnsw_ef_search)?;
8291        }
8292        struct_ser.end()
8293    }
8294}
8295impl<'de> serde::Deserialize<'de> for VectorIndexNearestNode {
8296    #[allow(deprecated)]
8297    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8298    where
8299        D: serde::Deserializer<'de>,
8300    {
8301        const FIELDS: &[&str] = &[
8302            "table_id",
8303            "tableId",
8304            "info_column_desc",
8305            "infoColumnDesc",
8306            "vector_column_idx",
8307            "vectorColumnIdx",
8308            "top_n",
8309            "topN",
8310            "distance_type",
8311            "distanceType",
8312            "hnsw_ef_search",
8313            "hnswEfSearch",
8314        ];
8315
8316        #[allow(clippy::enum_variant_names)]
8317        enum GeneratedField {
8318            TableId,
8319            InfoColumnDesc,
8320            VectorColumnIdx,
8321            TopN,
8322            DistanceType,
8323            HnswEfSearch,
8324        }
8325        impl<'de> serde::Deserialize<'de> for GeneratedField {
8326            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8327            where
8328                D: serde::Deserializer<'de>,
8329            {
8330                struct GeneratedVisitor;
8331
8332                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8333                    type Value = GeneratedField;
8334
8335                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8336                        write!(formatter, "expected one of: {:?}", &FIELDS)
8337                    }
8338
8339                    #[allow(unused_variables)]
8340                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8341                    where
8342                        E: serde::de::Error,
8343                    {
8344                        match value {
8345                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
8346                            "infoColumnDesc" | "info_column_desc" => Ok(GeneratedField::InfoColumnDesc),
8347                            "vectorColumnIdx" | "vector_column_idx" => Ok(GeneratedField::VectorColumnIdx),
8348                            "topN" | "top_n" => Ok(GeneratedField::TopN),
8349                            "distanceType" | "distance_type" => Ok(GeneratedField::DistanceType),
8350                            "hnswEfSearch" | "hnsw_ef_search" => Ok(GeneratedField::HnswEfSearch),
8351                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8352                        }
8353                    }
8354                }
8355                deserializer.deserialize_identifier(GeneratedVisitor)
8356            }
8357        }
8358        struct GeneratedVisitor;
8359        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8360            type Value = VectorIndexNearestNode;
8361
8362            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8363                formatter.write_str("struct batch_plan.VectorIndexNearestNode")
8364            }
8365
8366            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexNearestNode, V::Error>
8367                where
8368                    V: serde::de::MapAccess<'de>,
8369            {
8370                let mut table_id__ = None;
8371                let mut info_column_desc__ = None;
8372                let mut vector_column_idx__ = None;
8373                let mut top_n__ = None;
8374                let mut distance_type__ = None;
8375                let mut hnsw_ef_search__ = None;
8376                while let Some(k) = map_.next_key()? {
8377                    match k {
8378                        GeneratedField::TableId => {
8379                            if table_id__.is_some() {
8380                                return Err(serde::de::Error::duplicate_field("tableId"));
8381                            }
8382                            table_id__ = 
8383                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8384                            ;
8385                        }
8386                        GeneratedField::InfoColumnDesc => {
8387                            if info_column_desc__.is_some() {
8388                                return Err(serde::de::Error::duplicate_field("infoColumnDesc"));
8389                            }
8390                            info_column_desc__ = Some(map_.next_value()?);
8391                        }
8392                        GeneratedField::VectorColumnIdx => {
8393                            if vector_column_idx__.is_some() {
8394                                return Err(serde::de::Error::duplicate_field("vectorColumnIdx"));
8395                            }
8396                            vector_column_idx__ = 
8397                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8398                            ;
8399                        }
8400                        GeneratedField::TopN => {
8401                            if top_n__.is_some() {
8402                                return Err(serde::de::Error::duplicate_field("topN"));
8403                            }
8404                            top_n__ = 
8405                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8406                            ;
8407                        }
8408                        GeneratedField::DistanceType => {
8409                            if distance_type__.is_some() {
8410                                return Err(serde::de::Error::duplicate_field("distanceType"));
8411                            }
8412                            distance_type__ = Some(map_.next_value::<super::common::DistanceType>()? as i32);
8413                        }
8414                        GeneratedField::HnswEfSearch => {
8415                            if hnsw_ef_search__.is_some() {
8416                                return Err(serde::de::Error::duplicate_field("hnswEfSearch"));
8417                            }
8418                            hnsw_ef_search__ = 
8419                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8420                            ;
8421                        }
8422                    }
8423                }
8424                Ok(VectorIndexNearestNode {
8425                    table_id: table_id__.unwrap_or_default(),
8426                    info_column_desc: info_column_desc__.unwrap_or_default(),
8427                    vector_column_idx: vector_column_idx__.unwrap_or_default(),
8428                    top_n: top_n__.unwrap_or_default(),
8429                    distance_type: distance_type__.unwrap_or_default(),
8430                    hnsw_ef_search: hnsw_ef_search__.unwrap_or_default(),
8431                })
8432            }
8433        }
8434        deserializer.deserialize_struct("batch_plan.VectorIndexNearestNode", FIELDS, GeneratedVisitor)
8435    }
8436}