From d519a8939e564cb2740b93f08e3a546da1c4fdcd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 16:28:12 +0200
Subject: [PATCH 01/15] Add fetch to sortpreservingmergeexec

---
 .../global_sort_selection.rs                  |     2 +-
 .../physical_optimizer/sort_enforcement.rs    |    21 +-
 .../core/src/physical_plan/repartition/mod.rs |     1 +
 .../core/src/physical_plan/sorts/merge.rs     |    34 +-
 .../core/src/physical_plan/sorts/sort.rs      |     4 +-
 .../sorts/sort_preserving_merge.rs            |    25 +-
 datafusion/proto/proto/datafusion.proto       |     2 +
 datafusion/proto/proto/proto_descriptor.bin   |   Bin 0 -> 86986 bytes
 datafusion/proto/src/datafusion.rs            |  2864 ++
 datafusion/proto/src/datafusion.serde.rs      | 22857 ++++++++++++++++
 datafusion/proto/src/generated/pbjson.rs      |    19 +
 datafusion/proto/src/generated/prost.rs       |     3 +
 datafusion/proto/src/physical_plan/mod.rs     |     1 +
 13 files changed, 25819 insertions(+), 14 deletions(-)
 create mode 100644 datafusion/proto/proto/proto_descriptor.bin
 create mode 100644 datafusion/proto/src/datafusion.rs
 create mode 100644 datafusion/proto/src/datafusion.serde.rs

diff --git a/datafusion/core/src/physical_optimizer/global_sort_selection.rs b/datafusion/core/src/physical_optimizer/global_sort_selection.rs
index 9466297d24d00..0b9054f89ff4c 100644
--- a/datafusion/core/src/physical_optimizer/global_sort_selection.rs
+++ b/datafusion/core/src/physical_optimizer/global_sort_selection.rs
@@ -70,7 +70,7 @@ impl PhysicalOptimizerRule for GlobalSortSelection {
                                 Arc::new(SortPreservingMergeExec::new(
                                     sort_exec.expr().to_vec(),
                                     Arc::new(sort),
-                                ));
+                                ).with_fetch(sort_exec.fetch()));
                             Some(global_sort)
                         } else {
                             None
diff --git a/datafusion/core/src/physical_optimizer/sort_enforcement.rs b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
index 719c152841b79..f10401877f65b 100644
--- a/datafusion/core/src/physical_optimizer/sort_enforcement.rs
+++ b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
@@ -422,7 +422,8 @@ fn parallelize_sorts(
         update_child_to_remove_coalesce(&mut prev_layer, &mut coalesce_onwards[0])?;
         let sort_exprs = get_sort_exprs(&plan)?;
         add_sort_above(&mut prev_layer, sort_exprs.to_vec())?;
-        let spm = SortPreservingMergeExec::new(sort_exprs.to_vec(), prev_layer);
+        let sort_fetch = get_sort_fetch(&plan)?;
+        let spm = SortPreservingMergeExec::new(sort_exprs.to_vec(), prev_layer).with_fetch(sort_fetch);
         return Ok(Transformed::Yes(PlanWithCorrespondingCoalescePartitions {
             plan: Arc::new(spm),
             coalesce_onwards: vec![None],
@@ -785,7 +786,7 @@ fn remove_corresponding_sort_from_sub_plan(
     Ok(updated_plan)
 }
 
-/// Converts an [ExecutionPlan] trait object to a [PhysicalSortExpr] slice when possible.
+/// Retrieves a fetch from a `SortExec` when possible
 fn get_sort_exprs(sort_any: &Arc<dyn ExecutionPlan>) -> Result<&[PhysicalSortExpr]> {
     if let Some(sort_exec) = sort_any.as_any().downcast_ref::<SortExec>() {
         Ok(sort_exec.expr())
@@ -801,6 +802,22 @@ fn get_sort_exprs(sort_any: &Arc<dyn ExecutionPlan>) -> Result<&[PhysicalSortExp
     }
 }
 
+/// gets 
+fn get_sort_fetch(sort_any: &Arc<dyn ExecutionPlan>) -> Result<Option<usize>> {
+    if let Some(sort_exec) = sort_any.as_any().downcast_ref::<SortExec>() {
+        Ok(sort_exec.fetch())
+    } else if let Some(sort_preserving_merge_exec) =
+        sort_any.as_any().downcast_ref::<SortPreservingMergeExec>()
+    {
+        Ok(sort_preserving_merge_exec.fetch())
+    } else {
+        Err(DataFusionError::Plan(
+            "Given ExecutionPlan is not a SortExec or a SortPreservingMergeExec"
+                .to_string(),
+        ))
+    }
+}
+
 /// Compares physical ordering (output ordering of input executor) with
 /// `partitionby_exprs` and `orderby_keys`
 /// to decide whether existing ordering is sufficient to run current window executor.
diff --git a/datafusion/core/src/physical_plan/repartition/mod.rs b/datafusion/core/src/physical_plan/repartition/mod.rs
index 72ff0c37135b3..85225eb471760 100644
--- a/datafusion/core/src/physical_plan/repartition/mod.rs
+++ b/datafusion/core/src/physical_plan/repartition/mod.rs
@@ -497,6 +497,7 @@ impl ExecutionPlan for RepartitionExec {
                 sort_exprs,
                 BaselineMetrics::new(&self.metrics, partition),
                 context.session_config().batch_size(),
+                None,
             )
         } else {
             Ok(Box::pin(RepartitionStream {
diff --git a/datafusion/core/src/physical_plan/sorts/merge.rs b/datafusion/core/src/physical_plan/sorts/merge.rs
index d8a3cdef4d686..f5472dc57f660 100644
--- a/datafusion/core/src/physical_plan/sorts/merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/merge.rs
@@ -39,13 +39,14 @@ macro_rules! primitive_merge_helper {
 }
 
 macro_rules! merge_helper {
-    ($t:ty, $sort:ident, $streams:ident, $schema:ident, $tracking_metrics:ident, $batch_size:ident) => {{
+    ($t:ty, $sort:ident, $streams:ident, $schema:ident, $tracking_metrics:ident, $batch_size:ident, $fetch:ident) => {{
         let streams = FieldCursorStream::<$t>::new($sort, $streams);
         return Ok(Box::pin(SortPreservingMergeStream::new(
             Box::new(streams),
             $schema,
             $tracking_metrics,
             $batch_size,
+            $fetch,
         )));
     }};
 }
@@ -57,17 +58,18 @@ pub(crate) fn streaming_merge(
     expressions: &[PhysicalSortExpr],
     metrics: BaselineMetrics,
     batch_size: usize,
+    fetch: Option<usize>,
 ) -> Result<SendableRecordBatchStream> {
     // Special case single column comparisons with optimized cursor implementations
     if expressions.len() == 1 {
         let sort = expressions[0].clone();
         let data_type = sort.expr.data_type(schema.as_ref())?;
         downcast_primitive! {
-            data_type => (primitive_merge_helper, sort, streams, schema, metrics, batch_size),
-            DataType::Utf8 => merge_helper!(StringArray, sort, streams, schema, metrics, batch_size)
-            DataType::LargeUtf8 => merge_helper!(LargeStringArray, sort, streams, schema, metrics, batch_size)
-            DataType::Binary => merge_helper!(BinaryArray, sort, streams, schema, metrics, batch_size)
-            DataType::LargeBinary => merge_helper!(LargeBinaryArray, sort, streams, schema, metrics, batch_size)
+            data_type => (primitive_merge_helper, sort, streams, schema, metrics, batch_size, fetch),
+            DataType::Utf8 => merge_helper!(StringArray, sort, streams, schema, metrics, batch_size, fetch)
+            DataType::LargeUtf8 => merge_helper!(LargeStringArray, sort, streams, schema, metrics, batch_size, fetch)
+            DataType::Binary => merge_helper!(BinaryArray, sort, streams, schema, metrics, batch_size, fetch)
+            DataType::LargeBinary => merge_helper!(LargeBinaryArray, sort, streams, schema, metrics, batch_size, fetch)
             _ => {}
         }
     }
@@ -78,6 +80,7 @@ pub(crate) fn streaming_merge(
         schema,
         metrics,
         batch_size,
+        fetch
     )))
 }
 
@@ -140,6 +143,12 @@ struct SortPreservingMergeStream<C> {
 
     /// Vector that holds cursors for each non-exhausted input partition
     cursors: Vec<Option<C>>,
+
+    /// Optional number of rows to fetch
+    fetch: Option<usize>,
+
+    /// number of rows produces
+    produced: usize,
 }
 
 impl<C: Cursor> SortPreservingMergeStream<C> {
@@ -148,6 +157,7 @@ impl<C: Cursor> SortPreservingMergeStream<C> {
         schema: SchemaRef,
         metrics: BaselineMetrics,
         batch_size: usize,
+        fetch: Option<usize>,
     ) -> Self {
         let stream_count = streams.partitions();
 
@@ -160,6 +170,8 @@ impl<C: Cursor> SortPreservingMergeStream<C> {
             loser_tree: vec![],
             loser_tree_adjusted: false,
             batch_size,
+            fetch,
+            produced: 0,
         }
     }
 
@@ -227,11 +239,19 @@ impl<C: Cursor> SortPreservingMergeStream<C> {
             if self.advance(stream_idx) {
                 self.loser_tree_adjusted = false;
                 self.in_progress.push_row(stream_idx);
-                if self.in_progress.len() < self.batch_size {
+
+                // stop sorting if fetch has been reached
+                if self.fetch.map(|fetch| self.produced + self.in_progress.len() >= fetch).unwrap_or(false) {
+                    self.aborted = true;
+                }
+                if self.in_progress.len() < self.batch_size  {
                     continue;
                 }
             }
 
+            self.produced += self.in_progress.len();
+
+
             return Poll::Ready(self.in_progress.build_record_batch().transpose());
         }
     }
diff --git a/datafusion/core/src/physical_plan/sorts/sort.rs b/datafusion/core/src/physical_plan/sorts/sort.rs
index 4983b0ea83e5e..205ec706b5dcd 100644
--- a/datafusion/core/src/physical_plan/sorts/sort.rs
+++ b/datafusion/core/src/physical_plan/sorts/sort.rs
@@ -189,6 +189,7 @@ impl ExternalSorter {
                 &self.expr,
                 self.metrics.baseline.clone(),
                 self.batch_size,
+                self.fetch,
             )
         } else if !self.in_mem_batches.is_empty() {
             let result = self.in_mem_sort_stream(self.metrics.baseline.clone());
@@ -285,14 +286,13 @@ impl ExternalSorter {
             })
             .collect::<Result<_>>()?;
 
-        // TODO: Pushdown fetch to streaming merge (#6000)
-
         streaming_merge(
             streams,
             self.schema.clone(),
             &self.expr,
             metrics,
             self.batch_size,
+            self.fetch,
         )
     }
 
diff --git a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
index 4db1fea2a4f1e..724ec1de3c8eb 100644
--- a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
@@ -71,6 +71,8 @@ pub struct SortPreservingMergeExec {
     expr: Vec<PhysicalSortExpr>,
     /// Execution metrics
     metrics: ExecutionPlanMetricsSet,
+    /// Optional number of rows to fetch
+    fetch: Option<usize>
 }
 
 impl SortPreservingMergeExec {
@@ -80,8 +82,14 @@ impl SortPreservingMergeExec {
             input,
             expr,
             metrics: ExecutionPlanMetricsSet::new(),
+            fetch: None,
         }
     }
+    /// Sets the number of rows to fetch 
+    pub fn with_fetch(mut self, fetch: Option<usize>) -> Self {
+        self.fetch = fetch;
+        self
+    }
 
     /// Input schema
     pub fn input(&self) -> &Arc<dyn ExecutionPlan> {
@@ -92,6 +100,12 @@ impl SortPreservingMergeExec {
     pub fn expr(&self) -> &[PhysicalSortExpr] {
         &self.expr
     }
+
+    /// Fetch
+    pub fn fetch(&self) -> Option<usize> {
+        self.fetch
+    }
+    
 }
 
 impl ExecutionPlan for SortPreservingMergeExec {
@@ -140,7 +154,7 @@ impl ExecutionPlan for SortPreservingMergeExec {
         Ok(Arc::new(SortPreservingMergeExec::new(
             self.expr.clone(),
             children[0].clone(),
-        )))
+        ).with_fetch(self.fetch)))
     }
 
     fn execute(
@@ -192,6 +206,7 @@ impl ExecutionPlan for SortPreservingMergeExec {
                     &self.expr,
                     BaselineMetrics::new(&self.metrics, partition),
                     context.session_config().batch_size(),
+                    self.fetch,
                 )?;
 
                 debug!("Got stream result from SortPreservingMergeStream::new_from_receivers");
@@ -209,7 +224,12 @@ impl ExecutionPlan for SortPreservingMergeExec {
         match t {
             DisplayFormatType::Default | DisplayFormatType::Verbose => {
                 let expr: Vec<String> = self.expr.iter().map(|e| e.to_string()).collect();
-                write!(f, "SortPreservingMergeExec: [{}]", expr.join(","))
+                write!(f, "SortPreservingMergeExec: [{}]", expr.join(","))?;
+                if let Some(fetch) = self.fetch {
+                    write!(f, "fetch={fetch}")?;
+                };
+
+                Ok(())
             }
         }
     }
@@ -814,6 +834,7 @@ mod tests {
             sort.as_slice(),
             BaselineMetrics::new(&metrics, 0),
             task_ctx.session_config().batch_size(),
+            None,
         )
         .unwrap();
 
diff --git a/datafusion/proto/proto/datafusion.proto b/datafusion/proto/proto/datafusion.proto
index 4cc80c207ca45..4f0d324dc1d8a 100644
--- a/datafusion/proto/proto/datafusion.proto
+++ b/datafusion/proto/proto/datafusion.proto
@@ -1365,6 +1365,8 @@ message SortExecNode {
 message SortPreservingMergeExecNode {
   PhysicalPlanNode input = 1;
   repeated PhysicalExprNode expr = 2;
+  // Maximum number of highest/lowest rows to fetch; negative means no limit
+  int64 fetch = 3;
 }
 
 message CoalesceBatchesExecNode {
diff --git a/datafusion/proto/proto/proto_descriptor.bin b/datafusion/proto/proto/proto_descriptor.bin
new file mode 100644
index 0000000000000000000000000000000000000000..448c1eda25bb487fcc6da0a86ef23f86b42f626b
GIT binary patch
literal 86986
zcmdSC33!}Gk^evQ&O0ON)#34L*_P!bo=jrLaU457;@pQM%eE3*HX}I)3uwpE*cOpB
zjz)@Omfa0Y2uC;)AOQk|CE*MZt`Hz>faSiz5$^j~Ah6+v<zD!Is;m2b-;rhcV0Zt|
zFVB-i-?yu(tE;=KyQ_~0KJwaZkRK^emUmCpMyuni_D@tNt6>m-DXt9Kda7en`^HO^
zvGOD|VQ0`dVgK$(7t+g{N)av&205h;!@wUe@2gk}^LMx*!Rf)-ytZ>yoYkuOd=gT}
zf`*N|H;q=tM#9sA>~8tP$ZcLbH_2}(N}3*?8#G-zRUR9KdZOdVnZ?A#`_n<=#@z$M
zdn^0O;h90huql3x95ZM<FPWp&s^n<Gi-X2}mC3RcicE#RSWmBFS8cOIz2lP;2TKu8
z=LJD)T~e42GS^fNS}V$*VSA9ht~@qXF@<U>DLCIdH(mU4OE70^b<gN<d2Gj6dAz?m
zQVDy5ma);=<mmXGq1teH+?uVBRBEfH50-b0RR*9DzAdRzv*nXd;e|m!(|BTKSXw|w
z=Fqy^5v5x81buj3&{V68S!UlbFG^}K;1VrwOpX1sW25^<Cp)r+ZGMt%t0Y(!rIMV=
zd-hCJ_LL_p9l1ku>T-!Lr-(XS5%^E6j*fRU7_RnYMwjv3G8h`6tyL!`I~otA9pJm8
z6`Jsppn0OQzdSKHYHZhJSQaP6m*Qm0ndAsJ1#Ojm`zH?$MZGRCGEPj&=oJdrMXi)p
z!{$DQR|oTlCn^|bsB-;eWn#QMHZ&=9-qCEtostySV+eaKooO0Y=scBCmlUoG8Y<WC
zA1h<N79(t7QdqAhSpkkRJS)f@7#$y}9_VN_JPVRMSDF;dV(BECGHM@uQl+Eq&}_Oi
z$z@|H!}Eh+c%oXX4Vl`VWBBS?Uyr0Fs<_FJ%Lh@>^tD<?{!kUKkX~4GDk@!gY0xCr
z9T#ufG1oBFcQ);xVm?D-*<+?eH4WoM#;VeB#T9jgM%oP3)T4CjTC6}@O?64qnWn}?
zv3W*RU1!=U36@!@q~X~HV>Rh$H+*#sPg{!3$MUx-oBb$qYE!$eovKV69Ks`)YaR0s
zl`~)|x`e>Vact&ecu~-7^|@}ea-d^@5mG;bm}Ywgsa672FD+ia$mla-T;1?w$3nx~
zk!*1rZJOnbXz_hblArp|jzcvU;nSUGqi`6{*^SauwaMx}<zHm@mn1XpG0D><1j=P(
z(C+seA5!V)H2ihlYlkLTy&YwEPS7+mQQbcznsh9lp}ZuD>QQ+u?w(sWiVPmyUnvd+
z?RH?PYq(~RXS6V*N=wNfml0=OkQ*J}KQ&pi17Mx2n>IX^ENSt~U~W8u=schncGQo(
zP0=u0+!8eP)UMl9o!D2N3{MP#z2(}_-b#6dp<ZSrjin~OY%w3g6R<<Yj3IU+&{T>)
z6z2!6JIWKZ%}JGZnctYsd&QO@=(=vAs^5ycgGEvC_fLqyP|=QOVP6o^NoCN*ukN21
z5+k_D!c1ky8yXR%yk&DAYQ=lA*m;K0m}x~|T=kHdQmOB&YeU-)j8{fX6Dn19S0*as
z!<AB#Vd-ZQCUb`U<;lHTCCnKN2$u$JyGO@#I8cWr1A9}cRlY_QO}9&o<sCYF*SUa0
zYOa)EV64np2c|=Km~8v%vr3jCJUeJ0Zw99tgSX6{W;LLr#Z9-Xd7@!<h)G+Gp*%xz
zLX$=<>j+HM)xwj57AT|&hia2$9mpF?&Gy>>pTaYOxs&CIJ(bC!NNTM^M(@^AUK1jb
zwea*HGhDl_LkH$MzZ$hurc^>BWkjH~I6Lsx4Mxa}8zU@^He4C_Wm=>iU+c!oxTV5i
zsKRZ*98<M20~xALNXKY323?x8{$U%nHUXK+Y!}|{e9*RuHlf`?Jc8{eFY<!9hq%9K
ztyO1X$I@EY1X<%j?6iHRHsI#BC8bO>GM$^w*2w<G_Iy$hj8t}yj_Y(z+H_MX@x@x^
z^<FS<2FLz4+ooQ5UDq5}XFRf<5}naMhR(Pmm}>_-?UQCLBxY(U&C!HGnRRYt(qe6O
zXF6z$eTcZ%Flqwg&S!Q5)0@ERz!(2J%c$cVZOIUZ3xcf9MvT{^>nN1QUfnNqbv(Ku
zDAt13x+TirrrzNSRIgs~MwX#&G4Z!$ctl64_F$0MU6~x-YnFEz*3klr_ojn6(-tVl
zqs_^zf~r&FBSRC_U91wM;rf_7Fds|u4XHk(wq`%A%D3=6p@g_OA?*%>eB_*mSa|QP
zjua<@In&4`79iwid}e}hM0+#}wNwY;hB<Kt!xUgrRWG$gpL^tM@q%FPAxp4u8Qc@q
zk*VRzP<6aQ(GS?^Nvr+5eY{et9w^?D4HoJ=T1H)2nVBwPdcryzN6~fF5#6W;S_sjM
zRhhKQTwhF0h{oY?anNLjhDqGGscI7CgSho+b150?>*i7`r;X)xt7I25iAM9o4a+jL
z&pa#_gVxdA%%CQzD&|2lf{O;tqr3a7lfC9s{d`Uq;K})1Snr)>xUTcg;o4xnDgAJD
zA5-d@EYpUJC1mJsD$SF`o;b}IWmC{>hEUUfYR5K^28L7GQcX0U8s8<opfX|>u-G>G
z5MCBEsN1PAFOVjBR&uC5O!HW^-FT{+#*v(W&hvwoWWupTk*rUCRyt@-EG%XW=dEWX
z#ETpIx!Hc*+^1`TCNCyr#totTRg0a6jzC8-x)-0FcKyRHDdVMXxFl%S>7~w%H6R)2
zCo}gwq)kbOnAWD^cCAXy+OCVwNC$JZJ`&4bGo{ppcv6#QdZ8@h|CdyGZaQe$m{`cM
z`ijG@&1;X+UEmVvcDBo@c^XG|+x~WJwt0}TTy5jlmXS(2{Xa^Tq6vVgGi@}m)7I$|
z0M>!k34&zAp@!A7(Z8w_j2rS{nr9H#R_7UPyDtYp9M=iw2f1-wN=Uo%OWAR=dbluX
z)^N{|#7K{3#t|sJEbfYr4Vn|7s<=NK{ZxmA@pYAnUDcWffg4K>ifnw11mcc&8g+Qt
z?@9-)b@9{VQJrYq9>)CrIu>h)d?ptVO@^8bxfzTZ#wA><teK-2#)Voqi~kq|aX|5S
z)TYKYR(aHV2TE_U|9B>7bOFYYdFohY_oSH#9HC(wLQ!{ObkAO$c^rX5DPd`nXs3>B
z;?mmI*10rM#`xt%Av1$qPcX-@3|Gf%lM^(cNwd^%tKXs##-50x)Fv!3Cf405Wiz4H
zA=$Uc9=Vp9g+t_C&gMo}&}PaSOE`)+K#O5<B9;gF@u@L_F|z$r8<M~6G@?!Z?lqtL
z`AZ^I4EId9Y#e{qc4$e9T{v75q8T<}{^Mv&MPkHJv^5bfJN(2n@^mg-#)70SYW;uF
zsET`orfA3IIEpP(h}t!y`^|(jQ!;-`U}}an$Hri8wBG8yzA|ilnOol--c3e6!>nhD
zPi2@sB&vKoil3caC?3V2s_RGw6fd7CzF<xiPIdYb%gGUGVo%jNfx2h~BMd1laV(8Q
z?RA~1Lt*_4D-kVMDjHP7*eH#<JZAUl>Vn0@lgG*vW{4vTM=7ComSAN9^c7h{Yml!l
zwBBu!T@hsIrVR2$BK*-tno7{YzAiEmjU5Rgtr44%vmt01)h?@2G<H;Hp1zv&UCDpc
z{AKtq4f4Xrx<R_Q^6EZboweYtPFnU>*cBKFD}zR1uSn^2S8q;o`VFa=3lc+(jdxWh
z4^%4SCL-9pw$8@gnk21Om@Fj$#q4moRvEHU!a9fCLxQFEg-CW7`M(PhPN$7_7=<QW
zWp^WWiCDL(Apr!@*vXc7plpPU%MR)2brrkyR>#wC(=1O!OV?>&Ofgd)4MEpMA^XN<
zc4L`vRDxLYG#(fo8yPN7jC9D>TO$UEz7RT}Q#0*xX!q2(ZY}FR+et~=Ym?n%DQpI9
z%ILm^>w`vi(ua)A=91C0DjA$O*n_Doa|5ITrP(Kkb=_gBYxX*ANSH7&u7^8<FlxU;
zQzJ5krupdRTHUT+)bw|5+?0@&kGOY^Fx{pjZH_DwiJM{1O)XL{t5pr+1oZ`TC3MX$
zYUTRM$dI0y&~3N6VQzC}vQKHu=?SW54t&W^Y-zTbIhZ*^K-60I-Rh;tl#cX)iZgMu
zW8sr&%u~B6cGs=GG4tKlia*TXvgJBKWPWOYhi<jiwXu>(acxZL<cJ2He{zB&5xToJ
z&0h?XLb-CIHTjDS8X@1!+`#Ro)g9^Rt8J1b>A0i%C;bIqGc+}R&3N^|xZO&d=2v!V
zB3w<QH4E5*Yqnm=D0hNsmeUw<ELJ}lEnv&qxIz4ps(GT}th0o1WlmFZh1E%esI4}e
zsZ;nQ!(G?K4R@?Fxxw$$#`TPiUQ_8<V)*K6Yb)PfZ3&HxO{0dmFhk)I)Ji3L@ih)@
zFaixtRy$5MJayY21DZNmwYfA|^1-T{qc97(z11<<&L|q@x>m?EX}F@vmOaVQ9R!Wi
z$7Hr!+!@T7Mjf^V-l!fcYAW#;ks=ec&^h!>LvIw^Xmr7iVt3tGZ#-Z;Z8>7tQKv1)
z*j(S8WOipf%i(8;QZUI*L)%0n8+&ZWI!b0Sm}O>*A?|0#&b|-*r+JWA|HG~2MgLd@
z*-n$ygIc|AY*p81<}W3oDV`VPXw5R6Kh|7|Z0wtkaD3b*W8+bdIpgz#2J2>yQ)$;#
zk2z;o<m1zumSGI0p5~Y{za(fe?8mMBh9HBVI(D0tf+ll<L|WJ}bITefo`17>u6sgP
z2W|CJV%&XWbwBg&@sXq2{*Q>o^HlfSP&|JXu~TvmcFY<}fHH`uW5>)d3}ZNxqX}#o
zLOH2nW|YLWCE7qh%0jlzLhZ6{re^A3WsqUUXI4Mc0u1%UB_R`a*ob!#<~o-@Z3mm(
zZwQOGvMn7=xtwbWy92Y@i07KJl5AT$^BTpeTWXOxnnRH(k0NkoT(%sRjSd~DX(F76
zKj?aE){@!ygG}CaGh)|KMOPXOareREXVO7?WRt|yF<cZhV&r7Zx&dtB)yHc1M2R$x
ze#|90nvG^xq9K;|X7%vDRGQ)|GC^DY{6E}yJZ*?sVSOvw9?ab}MdXR;dE6Rhuxnd;
za&qO<Eku3es)K8TNSkB0`^Md;s97FGJJM!(anKTNU=AH!OKOf7x)0X1!lQ`LxmGAM
zTf5-eJt3#Vb*Wu9!rRhHa>=gFHVKe(X^z*f1&f5Fn-i<;$PPyvBT70hv48BinAv8=
z*snc`b}V#~^In3qHgYm+yElZzH?h6%Cdf%OMD>Ik$Td?xoeIq^R|xfZ(WLAmAC2xD
zFEX^UjaI1*m-knOhWC~=0L1o)e(K?ioC9d;`+rH{x3OJOx19KY!OCx?RS=mli>zaB
z&F2Sg2liG7`^$f9vyoLt-5Tyn5(oLW)FQO<myD2dMxw&HSJ{rD)i(;Ya2Ee5Xmm0~
ziqXJieiXg1QK()1Nwtr-P-qltlmE5GWG3)%>?UImyDSU2qgduO8A7vsoD7;15vBjD
zTqlB-WIXTKv*j{Lxi)N;RgES2Q@XuGOo@k#PB7uq8A@P2ZIUm=uj6489+^`Lp>x9G
zl!=Ora!f;KQYR$Gt^^aC9h0?EUipkKH(w<B#^Fm2D4H`7cC~jnA>DFrq7)bg^EV;C
ztTJkAot2S6Q;EBqY3Ce6GMvR%r-OV#QI&gTu&}O(hE&^!ma{IjH=W&VtF<S}YJ{3C
zwsQ%xODTrTX7G_#w}GKGE8XJRK~9f65JYx&jWD|O?HO)BIf~-T(m~dQ^$vG@<Jg<N
zOlYNfn2RIYTq4Yv**LtHa4+YN83+%fT|`nmJ(#m;l<4HZ=#whCmf}oaZmcrCXL7G;
zQrVJ4>}xj-j_#{a`}_72hi;k#n6_t|UY&;%N@-!GMj?~GL~Hr`NgTs6cIV8K!^J*s
zmsN&G_m#)wgbt^IhDXiq4Jln~DgGb}L54^!%*Zq=TT-Cs2JB|fxq)wjK4%4iiMYnC
zX2y!*AQo5Ij7NDw&>Gp|_(aITE?Kn=)i9?iWR_E3d=T>%cLl-5Q4?ZklZRt%CcdH$
zx-KFaAK4KK*|SJC*29o0O|geoN~Cjml51FVxVoWHXJZ4mBA%hOwnAwdso0@byei0S
zEAJ;tdyEzoSBA#5A=%<!9jep0Kt74ntc=JhqAZPp8;om%<|+B(NU8;f%IJl+Q8cuV
zAcB$Jwzke3M)Wobqj9JU;qs>}t|lqg&?qqhIkAu}H3;q-smb}yIl6w4`ZoPMTxdes
z(!Z=LCTQI+v8|)N_P9E_v7}4Xx~a8hXR<2Ui%mridf8=^benZ+RgtrTdD1`DtsSaW
zI1%7nmNb|wzI3i84wy9MI6vsH9K?5Nc1bp=3t?NJ6x(6~!`t0pTUqh>b;@j5UnhFQ
z`k{TJayKg}S~SWy(HqupiwTtX++d+(3h#J%yq;CG64v=j&>y8wQ|ftM(5{vnM3Qkq
zDtkj<3N(vW?IQXRoz@2?%foAAY(GsOHjRzd>nlWjl$2qPWR$FqShwkwA<j!!tZq@V
zmMQ5d^=y0ODC25+axh;F61x=TrjwW*r=;Jj>m;#zX)=V;w`3FHy68shw2ixDleKQ<
z@xh|LaTYl6Y^#n>?%h~ED7I1!7(n*PN1c-}fGCmyaHM=tVn{T_lKETwxoH%puW{hn
z0L~9Ls~1y&tXS2R8x>s;>ag9a*$^96xfMdx1`n@&f5sue5)?N(lSZRJJR;hhrKz{L
zew!F6wMcHH{Euezk2m>c^Gf`QopYRwjOKd36;%msqDe@#+)Dx`AXUdFdCT5ylYEN^
zrY3ivo0!Zr34wf5f)zoYjh;P>(=nN}S0QUNDLW%ta^u926K2L&5hmYM80W_UYc|;I
zq-lyr5w0~Gk|emS>r7*kvjdLAxiyu7Gf)yaA|PEsq&Q~-$&_SkNhCngDkSEkW^_u>
zA}CVETnd85Fgk54QKXKXFBU<D$mwH=B8B88t{jUuL{6inLF?|ZYI!meCHwpyR4w+i
zYURixVREZB9g#U{rv|NTS5<~0X|k0sc50T-PO<KwMLbGGq}OKaLZz`wv`ivHnN%U}
zjGOt0+IlY8Ogp@$5~9%$elvkl?jGJH&{^4<wXQOBE4*$W)Xv<XfqhQQp+a0?Bb&$$
zxYW2QtTPEi7u9JT%Fw||dBV61TmP~NZH6vKakV4R9PqO)We5i&<+q%&7j68kOUF-1
zvhrOX7?*8E6U(4iJL?t~v5n(l2kqNLPW&b8$5zqg&Pvl8pLO9xl{U?18?!~ssvONy
z5BFGEvUA-cR@1Law2FI=rhC_s%2u_IYS&jEru4Q+MOC5O(uZkMwrV6#DXXigCj<+f
zHJOLu=Ede_9JRaEb=TYa4mV05w%y6umKZ{~>f6HMM`p0L;JT|_@9a&wDUxWX<XXbV
z1`Bt~ddAGahw98y#4OGA!CkG5Y3^P$Gcw{ek&zvZy(~25<=cx~2#s653}n|CpQl5F
zg0Lk>yTf+r{eol|qD_|4wc>rPY>BxIY&k&GzrDZLtfiXQ)}0hEms+-QQKG!3f^vpV
z=)1RX-)aWaBhU*Sllkn<zW%{;P5!epD52zF7&M?gt42b{j6Nqhtl41SiI|PUQi@i}
zA|u5Sv@(P)mvw9HBN0c;W!+kv3oIJyo{dG+fy0(%!+LwRY&I5CmJRD|F0kkg)Y(`h
z7dX}j4V$)Z?-G;As55){9cjcxd1g3mHm$KJ7bS9ep`SkWFq?kLg@&|&or9aswNE|F
z#$xDLbOu|yN}GF!43~D@*|?evwGfNRyZidPN>`ghYO~wIQp$XMQ{Pp+8;1t^9@{%)
z+2#0}3>R}ulB8$?v91<X&Jyb3n%UHAHuRPq1vhpL_G0$AN31MMDTNXqjIQU}X3NY{
z!qd2MXQ^wjZ+pKv$2RTU_#nQRb*`L+jOf^LXd3L>);loRwQYxeA);>1FHB~zf-9z^
zdUL`?kz`Old`6ba(Ni2bfOZ6WnhzVLwDjK66<u4+!Lzn{$L0nHR~$!6RJCDaZ%^Mg
z*z^Qi-SIH%bt#IY;+CJkwQpe19zM$_gP=0Efz+fEwzBQhQ0r(v6ScNWAqqK^pJ-!-
zPsjDTLsQWhVzX<F8lMruY2$&x($1d24n2WZcRWs)I_PL=ShHkz_Dl8ap|iSxjR|o;
zs}uzLgN=PX(pIGB=y+Z~Ig92MFePZiQwZ{O?XU;H>JHix`+-(cWxuZ+h31DU<5T;J
zZ9z-Y$1n^ov{z|H5|@I^qVg1WYV|=Fo@9`%Mj0EM*od_sWrLf;{2g*nZXXe{Lj>?T
zg51ZGv^oi`(N`m)J6IHn*s=FuZIrbaN6Yk5#Zk(*FB>#QJVe<0=whSgu|$!MVrZU$
zE4(t8H-mlb=vDWU%nW2=M(ScF3E>q%$0iPhkIle#6a(F1dBevB?U6N;#g{d1^V(CB
zeQPE<tMZI8IHaC8Iw$4IglKkme+W;wHJE2BC|Tcj=XW+II}=;@_+Wlik~(>Mg1&A-
zJ0qbj^UPAhEsRo9QFWq^JmEQ%Nv_53r(K)Sj`qf@2w+Z5aO`)KD94C2U<u7fM7GV=
zh2~u=FEt98>8M0z<Zm;XY$}<*iz|Y#yF5`bx1gg3O=OyDo)oZMSwXQkn7>2b_OO?x
zV{$@4dJWXlyGKSMG190w&t+s59~Xq12!2e<Ql6mE3!GMngA#wS(pAhM(oLwtN&iYZ
zm^Z^4EzFGkT@=)ss_xkPp$4Ec8fqpJ@+^oH*-pXhmU%N;1761?neL{jb~av@>7gc&
zOoh68fqP_S!o4t~t>BeGkWaQQbHHn(IbR|#nIxZ`tGoM&nv%{kh;3ZG<3nC@%EWzU
zfNA8#6qTSJpzZ(!PpeGhZh%}q(GIf}c@fQ)v2M6DBS<1krR3mr;?)}4o9k>7KT(lj
zPVjIzsAbPsbr;V@=#zEY&FTuh*`%9mR0$!?%4R-u1+H1{>N_ENjipYJt&%)lMqrp!
z#6`(h@O0f#x6Y2vfhBZ^-^~jzu+JsP<vzOxsoPwY=N06(U4q-Zm>}O|)-F3RGc81P
z^E#?(L&qJ8{BV^`wHl8k>?-r(1dk`_f~0PI>ajH4N|MNWj$^k;G;e!W&Mr~v?sIH1
z7yc6L?p)o)L3Uq-Xr*1DEK3eGE_2hf<WYrMLV&U{RZBkFXBRDXb)R^^BEg>I;s~jG
z5^sipo9;AIcL{FyG9K{&^J<+wa;KMQ>Z&}tE|_3WJak8u%j-hg)pUtbSLO1=(6qkR
zC=8~vbtT`t)3rvuL$cGN=t(JY5%l%Mqj&UIvuS28&(!r-GwV#KZC|H5Cw_BK<AQa*
zfs-L}3p&9Ty*tQ=D=l<L-hUwI$N0t5AyV^tJ?6Az%}bNz83aqWO~?`==ZTzY$=$q3
zl5~eM#udwqQ8O9A?8{>e<Nw_QYP8?F2h{2+!ikZARLmH?p!TYS8<t}+#tkE??xJB`
zS8$>Zxp0`cL8xB0J^&VPF36x_?;7&ZXx$A$omka9e(LhmprF$c8OfW3{fFEn)DTeJ
zJjh8(__64U+q4^n9CVcHFbrUNvPoxEGunZ(>5z#&y6Gw!GJiVsW}*7^y6)vPGUwZ^
zm}xf*xuG`hZWyXluQRKYzyWtLE2Jj>b?(xjy73v?f;%t<pFb>@2iMxmgR(Kvy!LQB
z?y8pX$fdxf->!>7JJr;GN0wIq&5O6@thZbyRKGnVZ}LDpdPY1%ZK6ws8d0hn>Ri_G
zX?B?D9<tI69}``c<G`|BAJp(to%41ga8<;s-H}=Af~H?1ypa8Rca3m{XZD<|#NjWg
zEO(udKA;DGw5_QRpRo_9FHiOXWi)lpO{JPqR_+wqmq%xGs9Geh{5glJY<vhS!9ugm
z!vdDm2X1$xLX)-;q?JiG=gPH_Eg%WkxZp@a!FCZhJ&j9QY}s66PYtT;pRxMo;Alb^
z=Ta1hyMhIW+*4HR={3qTW>Rz7{i1~6dDAX0N>bg$uiMhGE3Px&j7Ox-s=IkGV@GnC
z>(v9g5d-?<)P#L|L7i7!I4lag^Z1paG$X{vykL>5g+tuh|Io4Xi-OK6MzSIEd>z{q
zWqC{^>N=vTY|SndnvL?pU1dZxaXp3@vtN<+qX$clU<{#TPSj!!>&p;3QMuN>1~Fp;
zN&1$OKDPu{sdDXXHz>O2CGL4RJ&V6d2Me4j>-*XNkRAWWkMBFnYHK+P%g%HbzMDt%
z>>NW!vZ%r&@^zSDAa1=<VXUR+CS>UK_~Q`6RZS;G?rXW?9laiZ7wZvU+&X445-^zI
z=GF~~_EA3<;i7VS%&x^}uZ8rO(7K1^k3c(d$PF(JT@{>#4(D_K&y@KvH-nrqNk2Wy
zdHK^>v@y|OV5!M7*5)MvnJPB&#3SGP;?Gg#>x6K2OBw%y3w5^=>?(YACP!TShqxF?
zZxU&6)Xh(xOFPzc(p<TVrv1@rcwVEQej0xEvc$*XVV!;){s^qmd3X-dg|0s1dDC&2
zfetsuJnQHjzECDxjMR60kEQs*gnfG41&3qr(KtC{(WGtUobimdarH3mrURy(e$!z_
z_Q*HJR~<f<4mzD_b@t#!9kbjbl$qFS(5D#fRY&O^M{(5=i<qm9`nuKZY8lGoo^bqQ
zFwd1FF`GS(R&sndD4rB|7n*}!-Z=K=aC~`hi5*39S#s=UFJ5QfMds*`3ktCGvTqm9
z;%%a}yM4Uam0K6vN2qi&PG1}}5y+~TcLF5VDX&(#Bi40ckSJnR84(8gaTF+vCkIV5
zUsh54fQF2cWAcX?_*zQ}@TMoZ_L20a1Pk25=T`?E`|X6o9J)5s_PXcKk37?x?<6Gi
zs1@Iqk-ZxIITA4~PmJxBmM+>4nU_UeY3rue!eVSv;_$frv&J}@jMO);t>6DNzpW5G
zS<3UFJk9EU=S1!>wAMXl&UtvXmBtb3a*r%(O^CvBU1bu-I65p3n#(M#Zhv$jN;MZ-
zEG6ymSf4ZJ&9mw*(VExHs}r2KoES6Pa80E){XQU{cTS9j1Hqi?)FjXI>#N|*v5D}C
z2VF7KLMvG-am^#th}bS~gCl`6NkP6@4sXw!A*e6E$+Al(3!Ee0J=5fBdPSESh1^v6
z`D`amR5;tl+S7*eXYU>{xxJC`OitNP+b8&26yl9Z-UfERHK0?T!~NEPZU8k!KR!_0
z7UZYLQU3;AijR6hetIZgd|2Xj!5NJexgULA5Ra97UT}66`@Ue27YpQmsWhCr?j&0P
z+s8|!%2uFkAm~wWS=mfGvLU3h^ex425b|~n+dukDzuvQuPSduwE*u=WG;`OYHDWOL
zE$9du>pSA(e;hx-N8q~cesx{P6y0c+q?RldOQY7hK(uT#*f6bL#G2i3mbUmx+9MN-
zWNbR&pmflvv#8$tiX0UCxg0s9)0sWjAq0)PGwF4Xf7-@uDWBky22hi^ntMdl&ebd|
z9+c;8?Qh~l1Ka;e!zyxv)r~qDmYy*z!-!>W518FgMl1u0PYiO}{A3R*(FtY@_Nw%f
zb^%TTCcD6F3`$rW4qEHB5s&t%??heeXg^C`7hfb3`DiqXYT|F3VjOn198Gt16~=8c
znQG|S8R_X<nUfFZ(90v-)6vih5u(3Iv1u=`9ZhU0`2rjLT?40f@*xL(RN1yTpeibJ
zO0C6oSGKs!uPJG)WhV1;(SY$$`yFqwG;b>(+*MI;a2!*_D}x0_fNR!nNUgDp-&B)*
zD6uNzqEyV0CrpjPB2`uVn4buKMRjmN-TS(;cqWk{i<VO2fn7#w6B9HV9Zgj<3b{z)
z4v)W2HnPN(Omo;0M3g55E5>0PvUr+2OUNr4r|dMD*YwTQFHzO<yez+0V?LV#Nll-s
zTSy5qeQ@5q!4XkSZx6a9bENhl<8{25)MzSgM#pdR5%ZecvBpH47_n1VnQ=9iEaH@d
z%xf8Iv?T;aXx-jWq6M0ntyyqj^i4sliLdg4hw|#f@pU^6GdDgPV(mUCn(;`_ycrHA
z#FcamYZ;cn(Ic;|vp(|rgdjZhAj5Ix$#9^L$cjs4IM5%icpp!rYiF|$$o}8>%}5#P
z3GP=kco=8C-EOYLKPM!UZ)yLHrFNGXO>Rglz9bzimJ&?cVUGIx|BnS?j<C?3ikNmJ
z<G8AjAC0j;wq(wL#CMomx!NeVOeRe(<|^}!pwnd?nJYSwaXh*6JorNAo@GLvIH)20
zoe6*4Plp_#zYDqP???UHAzx<Ul*sdMs$Z_JnV(dd<#$%jtNWdmx>GiXu>!k7=J!_E
zi)om$&tOW!m8)v*gPePa=Hl+RSokT`Af8LhuZULgH~O<1Gc5&O{$f8fI3?)$>7=${
z^ER@)YC1Yhz+;9h&N{E_lP66}tx66M>crGby5_WnOZ_yPrCM`Bl7vXi9MgqJ3<#Iw
z>qeu?;C1I5rO*SU;Q{$?@e9oQqqeG{7@640&#)Pha_*78<y+0&-uH#~NfmO*j}al0
z^^nf_nea;ie7Qtfn`BTmpZjY(aF(b6b0MgPf021b-DskLOLMKL6#u%7!8N(?&kJ@O
zhM6J2!5pYklEjkI6xV4O%6t<W5$)jQmy8xTJ_96_&T|`PqMj+qpYrBLTVxA~fYjuc
zJg2+m_i^;vZie#@Q~OFleV}AtbTUjle5S;W)_v}@7xPr%-F0x12BAJzgmnv+=ca6v
zK^xvFnZX)b%|;LN`)|CxZ9wrgv|ag2!#A_($i!r_%CCGFC1Tf=DYcr<qKY`KL$uNL
zb6wpWP8-Rdb1aqX%lvqyju|{p+bgihKxZ4PQJjTo(>~VS@r|%q>c0_6Q}c$ae7)t;
zwMm_3$yU?2uYA375f3rbA^mA2F+VS6$QSdgNb(DV?)5vuKl1BIqI+wp)qT|;PkM5&
z#P$5cZ0)n8%P<TamCq2uV|YPy#kl@BgE@@cBzMC4drSFL*vPex-c5t~bjZh2-{viY
zc~3rW+PQUWKEr*wMoAv%-PV`)9qQ^I?8|3EF4q|blbDO3No`nhO3)_mfdCh4a`~Z!
zFc)~+`^l1wb`JFQZ_cMzd^iZ&)Z}i5A#4aTUAt<kS=Vs2hGwYKRT~{w#kwZT<0yuZ
zuG;YEC|Z%+QyCpYBY1n@$b|uyf=2gnA1B`+A91w#Mq$}BR;^Ctn?#kZ<M}|+I47TP
zmNfoYb5_2^SfsjVZN61LmgFUye47Xy7~MmU%g+&}0kp{r<-oNQlli&wX%MwSVd2ry
z@!|YD`IAEs<%9Y5a8A%%s_bD<*e2&X^Yg`4-J_FR%^NWJ1wz_QxMN>_VK|RK9uJYx
z;wuw2y+g$J?48Ij5;ZU=al(8juV~EEzposf+&dsYu3RSknO`imB)hHReex$rR%Y+j
zXmw)P95l$W{+{yw{7I&${47O&iTP`Pc_d#DUA9&aR3`E#n?H?OMbTi}#<TOMhz9*M
z{J!1!Q>9qj(bJV<sU+ehN2>es%fh)qtCrdRGEM$8lU&))FV*IkiykiFbOpp^YL)y7
z$+a}f4}s**5Uon0)k^cxsB)%A8Q9XbcJ2E7D);x<8}h5|-|Nm@pFhj~efFBQ`88sI
zf&HA{Gxk`^CbjsxiOHInEx*o?PEPEn*{nBzPwk?;=FgTK2di5u*XK7#IR~q9D5xe6
z^W@Lr2Xp2oKIlUq`Ew8XEN4~o=W&KUOi=6d6}9~NV$=TWf&2xc;UL3NjbEOx<S&#`
z4@zUWNOah_pT}177fYqO>0tg6N!Vd3=~7cXb6J-jl<#6BYS}bV-A54bdN~x8?-p9=
zGi&obVrOX!90$m6lu|{9bgH}az4D=FYJyjdCWR=!De*xHpWiH+?VK7N$#0RrdUnyi
z`iywG>E8Th=1=<R-u&e*)4lnvLP~epo8M-bgtA}$qQC6TZ<n69V>G|Rs8(SGU8&_C
zW7<P`WE7L+OH#m1bcgB$7Xk7EVzsTq`|^YG$L8UY{7zet^1&`lMQ6Pt`e3`tl_J7)
z#f_u;YWb@o$Vfkyzd9nf-R-f`L=1WVh|vF?G-ZQ#ROJvrbv*w#rZ8=FpKAHXi|O^-
z1dSX;o)AecRrXb{tK^3w64&(qK9W6H9iV-W@5z^itA}3_kozp7lLzy=L|<tTMtFWW
zVxf4GIM!NzWCc4(@l&u#SGuiFJg)TKuB-5*{4ua|8;+Dex~|x)eza%%&i+CCD6Xe#
z$BxqWtA;jmE3dD=XHcDdSE<x>^-$O5%{W$?;T2t_zOMeBUR*0Bc4%nF_8s_GOxLsB
zeZ$dWrx+WW!1S`gjT?Kf!0$?LG=H147E|`^rBd%!b2$?q+!-veO6}+^_4G3GZ0#ND
z*^a_(#t^FTw%(2Cgl}FJ6lW$My0UL@%g~j*W`xU2IX0KJ@7y87&|J~TN(iOxb@vSp
zb@gw=hm#;+dkH6Q6RrZx7k;_(ZO9gwBtaw@55B3dG%z^CmCT*J#%>*Ahpk<8-xjTS
z3y1V(eEU?aQrdpyQ2)+t-ENRBb@g9P1(LF{w|}5_$Y4)uz}iK>WTdh5?A+FC>X1sM
z_Zyq(=(x2@Dv{o|wYO^{6-ZM{=&JP>>q-3~tslFYqU3`W>*^ko!^tqMMH<Qu=)jIz
zn|sj{!x{Sy<h>QWLAyp#^?_3vQOztw+WAiEx_@v80q~RAj#6(Abt#hrft$8(-Mals
zf!>PcI;=^i(tLSm0v6h=IIF~4OUx>^1dZab45f?~<|QSF$*_)4KZuuB3Qx=%KS-3%
ztl*^tcSzJoLnV0`!@Q<|K;usj8t0gnsz|=FfW}4p3rG?X6pPdtqZ#7N3}}QCMHO_t
z(EKvDZUz}T#Pm?=-k!lBGchx2@8~KG_Q@60-i;Uri+AlD+)fUcC4Q^SaHEl-?b@o@
zY~sH6R#+IZ%%4L^NuDSrGqJ6`l=XC-Aj*19OfQ*p>3d@@f}}l4$5EW_J})@6I<aR}
zd4HKG^Qy93Urp|-vbQ{0-8HqlTk58~drID!Bf>vf-I2cR?Jvs&4PiD+y|y_W+?os0
zEny~1g==rh1%<6FV6n<bVX|7_=u4r?$S(|3cTXPR`dDF;G#&GEpM~XJ1Dj4S04oy(
zUb_nl)rrDBHh&AlIK_$4T~mw~g)x;^D9gCAk8!QGs!$lHRE+Tc?Sp+iy#->DaLYv9
zaFO`|<^@oU)(Quz6W0`WBd9zwVjO>YtS~yx2Y!#8A_WBr_==<6L$>=5n$490Kc2xv
zX7A{J@*0#v3~X|W)KsiyNf{4Tr)&`trL{&_S-1i*<Wg9>>a4<Y2!cY<rWH@W!0_%X
zA1rW!zQ9q|SaP9q{cvUfB#NTcJ|;e8ekDC{rK&h1quteHFCwbDWEd%wO(6=^-NrmN
zt3r7)C|tPz;-Ij1a&rIqt5+X5aKP0&O<=V(ac%WhjEP@56KyTS&T-CQ)UeUDQ={x|
z7j_*il=q|0uso_*7%Lx;Ix|&cDjW?COkm~lJu3?}TjTW=qqQxja>`Lh$(qAh<?%wX
zYoO3KP%LzJ4fGAH3<~1-x9=P*Tq)xizOZ+ou)S1Z2-#?Q6lhbStN-f4<$e7dR~9PN
zK5fbda74vXF=Az8RS-2Dm%TI%QKz<_Cwz8~4pXS{JySd(QrN?AKQS&1gW21@QS$?=
zHIy3(XbT)dG3}?8sC+AO6~EpQq`ffHo|-3rHHMi5DcnflH3s^peq5MhTZND5Fe88J
z$Bxul<|9n<XApRPD)c*3C$Pj1GJXo;&c+2nbKv_aFBN7Mdkcb=AS)m%sL>$^7dOpy
zC<AJrZ^WfT|D@E(DlQGxNsVnrTw25}!JUXW0OFQdaUcknG_|@k#4X9swQM96ypwEF
zIwuJKXM~9S!rVm;!B#kdbvT9cLjRQ1GS$L^>Xb$tJB9K@i&L!@0K}c@H5dUP2v2QP
zEkKAn)oS61jHTWZODI|_wOWuQX>&VW8f;5X<n#<$WI}&=>I~H)1J&}zywM^fTAXgh
z0enG$5dcE?>CI{<5NxN<Q{f<lpN?=TN=9^A;qgKdwgAAk!kh1qq%BaZkp|m}lZ(N*
z=;Vj~>eSYB=gPuZbq^hFtROq*I95fn)l{I*lndi5WyH^NFoD9*IDBNTZd^zXzVA2E
zY|ip7&zSr`q@6{YDCSG)*7z$l$&_b}-{BC1YZfha2*uVcKi#sCwAL@$Bq`5YU(Mhf
z8?T*rqDzBqZGix<$&IeC&M(*`54Lr_HcV<8k?VL4R7?bdZQV({j%nBc>m#)?u&wvC
z>U~e@YJJ;0%a#$!1+Hw=)!9*QK5S=4xru?!j&h^+GiOJ+(cCxq+LwGU3)=?2#mdjZ
zwxQLjoP})zeMyys@SKP(XOLsd!FEo>mV@n_h^-;aoa>)z<u|}~uJ20I0Nc6k+LC>*
z0k(6Cr`X)^3g<=j)(G2qzBVY|xRLV~IFXI8op+k6x27<2zJHF*tqHdCeP{9}ay$Qo
zH7*Ud^Vf5F%~Sy1>H^<YX#m>={v1mfz;;1inwr#G0NVwfCs?-TFmqufzZtd*eICOw
zgw3#BILE2n4BLerotBL`#6?kVEwEh_<<<h*MNw`ouw4}8)*5Cmj@o1^Y!^q>-3r^q
zJd~?>x59Su64xf%!ptR+l5MbE5-HgR+a-~bZLnPuDLE(1T<R~k66e5nY1BgJz;@{(
z*E{CGcInd7Y}xW*rYoudChs6u0nF<%T~P(Fn9FoU6)-o<bo=T(eQz#o-BAyi3tM;8
z1Lnfky`aP97KWLgsFj4U^+c^CgsmrPCCu6~Jy9!}7iKm_Z1Z5-7_rTRZDYhX54MdF
zTYH%4jhb>hY`u|FXoszLo;o?-Ylp4(WY?7EhnY>jYvuD{+vMx0;d}F8+hj)#5Nw-H
zP?zd^3&PB1-+8A6ux*Z%TmakV1y1Aw*ftkWwI*2@X14gJ+j?6F+ZNw7-i5Gj=}<52
zdkbOPvTV6!>j*P_QJd_5tuJbm9kBI9ZL$NlzNk$u3Nx2QE@%;Kmqle;1lwhHEb_fY
zuw8Z{FG}L~v!UOgdW?=m;&J*LwL@jaTW|N&{Qz)O+wF)5f^d7IdK?hqw$ITaEGw>c
zhqug>8Gu{dVTUjfI_+rIK?@|5i%)ix2-$J!QlnEY^aoNqRVQ(01C5J}Wpbj^pdIu9
z2p_b<L1;MGtonjr8)Q#FIw1(*gLVqg5c*f99;?E|>0Q~VGl~WgewCfq01$VTmooxD
z5MI@w!a<0;$~x5sDe%>vRx1FutL^*+Bxy}LSb<=>dj0}a#KzEnTxv+Qkg3??8s`UV
z7)%>+nosarJC_!A+SSaiN<p3!EmX#3^2?p<DKj~|sIZ2UEaEX6n^61-%~~4(q$Loe
zpde;^KBCJhnT=(9@xSFp)^L0dLVq|_QB}mj4mYZ|3dA5I-dbY<0M;I{)&^0PBep6*
zu#GG}(@|2+k+XQr3E|D5zbAFQ3KuuLhvvoGMt(EO?DblU3kwIzwSugmnDCl+M$CCC
zEm^aaY_BaD0R9A`WP-#5&7$h4ZFK;Y8?|#D5Nx9hbRqykxzSUWS~ilN=&7r2HjVX(
zwuB&R@`<)RfrOH{xwIz`LY~;U*a|_BYa$^YY}eQZ&}=3e*EBgcnP^-Su>r>HG_Bc_
ziN=_xgE5HQ#@f|`frOH2nwFGm*ypudMP#C}FUn0O8vB}buxyrTW@aBz4rN2Faql$C
zmPN>TR8pCCjN7_w_QVN{FV+DCgpl#2%d8LxtKJz_NDd*@NJx$hs*$;**H($Bskvkl
zQaycz6~ZKBzo+xQX0HLZ{kEHdVB6o|tRRz+{dR)Y>@f+s)=rH9uw5IKTRPCSP3l)j
zgY8--!!jRjmig#}cb(2hK~PTEg-o+Y8?0G}44`l|JJ5k3thH%}2O+Z7uIry>j|s}8
z9YX-HP1>;^1ly!_J0RF5?HJPRF+rKK!zuu_DLeLqV4Irb$}JO=DLbq-drVLcc;{P7
zwqWxEk<Dega-dl!Ul1bXz|!@O5+Mi9IS-qAeoL5rQtByb?S(@2Bpj;r!WJy>4@c^S
zEz%4B!S+G`{0T(k7bK0WMS9_rJsl<iX!m5>3qi0w+4e#Z+CBLc9VT1EgZ`uKKmgeO
z(T+PHNwfV91lvE_4%Fh2^*`C30D$eEY>NQF_D{AafMEM4+Y?#@{Il(M0NDQ7_B#-4
z|7`mmNGR!d(vVs_7DzXwX}7I-01)FQu+c%5w>PAl<~hg;?}ju@cL&yQ4Rbf9Q#Ys6
zo!xFVRWQpb!Z>mxf;Cmo6t@!gnU|Fac3nppZ9)P>M3yQN{wPlt@cObRBYrXCGsE<6
zOgAnLP8HA;`cF&GR*9m2E0qWtH6{9k5Rrr|j14rj)T4h>nu;{EQjr4ZI|%DdX{yqu
zQr4T&)TOeL`1Ca9)kG>&pxUKXY7>ZoZ7Qr!Pg@JOQlI`a(p0D>QlSFX!X(1_j5Jkh
zQ(=8ZnmW~7LC;L%-ZU{oT>%3Jk@U<o4$h_`>6vLfoP~xL7pIb7eO8(&h9*ii0~;KK
z^;u~;k4=U3S!w1KEmU(`n0rn-^#XdCR1vdz|2b(qjYw@1gFZJ+6Bj-Z3IW+0QV8vH
z(=>7mk^0;;tz212d|uk)on}MJgi4?mtxY-$&=w77h!-z$#7KHxnq^#@D1j@?-IDg6
zpU!BqI79!ISVzo%Yno}TX2duq&}Ag%zct;Qcd1CeH9b#;A<v%^=59-;UTjOwg2cZq
z&2&c8pCcu|-IW}KzCbNG5Zc>a$$?0{-IaWfWci}Bx7cI}f)(gkrKm4Tvq38Ak_zjK
z(u-sa@cew3yCa=?g;j{9j(<m*5Q`|37lmHx6apa?s8WH@zSJoMMCwbOLU~c>Wv(hf
zR0U8i1VqxyTvY%Kv8@Uql3pfNaiviLTi;2nuCuSOt$h9HzNvi$&Ijz0fb{OdUUsmF
zv8?7t)A(OO&iqJJ+nm|Ffbfg{E_q>Jg*{GUxEd97T1d4aSsQHL^qM=<#ID3jK(x3s
zP4G&rG&jt>GM##@wGt~k|CMPQ#+fTty31J!MA?99B_OnSIV%B?dY4#9n%P`wW_PE(
z*VtwThWhSwqm1|@ixFRyW*sUTfzTJI>H|$`v(_pQ$*<B{6;`bF>NE=@WfcbjRNq1(
ztglYDtAhr@`s(yzncLyI!`$oBsW;l9vKsYY?}{2qQSV86ryHptY89vo0m<YZSF1o+
z?@2G#-UuX<d(x-L%A5e2Xz+%#r}}{?8c-b=(4;o0en42?;Pjgp=I%|W-eUD*+3Vjc
zUPh$O6aC)ox&a8Oz?@MR2<@BG4QenTQs3;lL3@~cTRQdcRw}Dv|842UCBaF!r*;O7
zx67b0H#z^7tGN<x^hqbzx4Yp21alHn69yVu(eS>srvpN}F&R)D2@ux%(hJo40@3ik
zG>cDVCGj0;7F|-M?Z#w4H5t&P5>B?Mu)ZVBx=UHn;r=uWFHMw&4|J?j7x$-Gdf8N1
z?@zP#QdZDA<6JYa0@bALG6?{(*i%+!0l+9%n#a3hR_5OVwY9W+Ou&K6f|XSQz3+-y
z$>!Z@rq7zl99*Dd&6?DRm038c%%CkXlHQ$W3a$E+>jP;|hoN?lskcC<KXY$jgN~!5
z!umjZp?1G^kLB-sVyiLz7U-<T{2LfqjR`m~vKnjFe{(aScA0_;bgaz5fp!K&Dy;t|
zGayx%=JufTob6r{tU$-gTpQS=V=k$%KA0wAqpU1X-<$R}SVII@4d|@K>>J1wSk1)r
z8@Ti=2a)vN^t!XHB-Wzui>s~~C4kOqOu>N-I>5Di%)x>4Tw7}i{r9_BO}oduTcB&<
z%&372wBM5o>-*CMnKyd={4n>ybn2tF4-#VXKbUURS<8IsHy>gYFxrAp2&h&8Li?dK
zn;%j%AW}c1uG<Ha_+e*I5LN-IRe<RC;dHaM0H7hBud@Oml0Ga$k=S>>IMt6hPY;3>
zs4W->>qnfY2g3Rh9S=Q!L74k^I`xn(8euU1<KkXK>H;a+CtM2!Q8b_y4G8Tg(oL!#
z5UHPVEp&lo`N^17yeLqsiA0lX8#fTvPsXg2<x{SP7nrgD)ha+(Kjk_n5Y|s==k)xA
zVeT{O)aPwkh|T$*aSnK)l;yK&PaPNtg@9TXAhe%NH)&e{BK5QB4)xs&CCksbvVdR(
zYFU6L)s_Va>*riq7D~N5?8*Y7UVvH_Agm9&vH)Ry*p;Ot%zZJP`l>Ap0Ym?b=|-8U
z`F@9#<x6Rn(bA|uNCm3$Kxn_@Ts07>UrO7Rbcba5<(O8=0@SjQXi{zW0mAxaogYfB
zl;ta~EFf|PYFU7=e#Mmq2<ul|Sr&!4ucuSrwPhiS>3>}&tTKcx!l!&=mLY7B3}N4J
zLl_9=Bt$0z#V(7)F5h%^0ihvK?E-}Lo6askH2kKs%OX+#Tdo6vU<GOi0-97iw+F)d
zEjOWDBzF0>vkM550@b8ISikMYAt0>Zc7w?xLEmxC7z8U&8zm6d?>J`+G{iXLhtjyD
z&M^0bbm~W}N8g*4{X9;Xn4=GD<Vz5aQxau!a=|=;C11=r=^FFQ+T<$soyT~YOpXW)
zJZ5Wwr$#t9F*<n~Q`7@hcGNj4Atw*YV=D`i6qrqJ;grq8-JDXKtng~qO4-kj&lQ-T
zfGUi00D7#3u!1a#3459&FRXqc<xf55!fKfFz*RFV*2QoqW&HuW-KK$eN=5$AEh0hK
z1*mobLi<Cvhy-GnAG$?kr`Y=uH$H>#sX%R|K<f1oHxUFH;>F8MM*<@05gngBe{q=m
z&vfdiw$Uzz@;{x=Uo84P>RJm3sX%QlKxiLz?iPsDM_p@KEc*S#t))Q}4XCXJXi^*6
zj6y(If0E{SnhZiGgt?!mQ@^qbodD&}okAywLceedflvsj3IU=0g;NNK)L%G-P7sBD
z=@bH?5Kt8YnpCS05Y}Hhg-#4}ze%TlZxuQb%HOyZ<B6ise>sIfC<Ii6fYAPzQwWIE
z|8feQC<^^H?X56208xWLtwA7?e(P!wXoweUkOPRM-=^7f7JqP}^vvJ6MF9v&KqpBY
z*zaOVlI`!@q5xtf{Z1DJo_|u9`(rxw-?pSDLHS45R!@?W{>haTgjArG6bS8~TuFgQ
z{gW%{Ns{HCU0VgAA5irJBI(agKcFGDZ54>5KijsNWwG|xbm|$NiCSbO&%dU#vfu4z
z<)DXugXfu$ksuO*W@#x96W!nu>`+<~pW=DVVtNuKOQ2~B0-=41*JRcfK+wO$a-}Rl
zCs$J=xhVV8SgtrWpp%<H(o<u(Sm8#`Ga({!k;ypF7)2noH+rqICoE;7u|6%PmFYIn
z(Pp82T1<;MZ}K?Tp=Fc#HP96`2klK>n?&73F7xZB$Fwq`20GdXXrHdM9$Ds|<)xlu
zO)nOEmX|eC!>k;N@o)AhnPh3s!3gvnM9j@zgB-f?Nrm&-&YU2HYEB@u&(>=4{3T)T
zd0y(pnx(%4%IA4DFtS9lyv4KO77&F7YHI{Sdy8koEkLT}7SDuRe1C~(aI0s-TOe40
zj#U)8)w4q&sj%Ma+3?m9sqN=`b}0jb6{rmv2<!7bJCOy#`h3qWWtIqffoG$XAXtGq
zfd|6+0&lJ^N`Z#hMk$v_e}19oohkN2eL4IBbh*l+?uDKWs*#GM7kZ1AJ7Ofg&^u$L
z7$08R(QTf$$|lO94(KGYvjU7HNh`a}Tdbi5Sdny_w^FvvL=v>O$3~Pz9Z<a~iLl=8
zHRx&=2<z>!5ovTU@@(K?iO0bXfzJNY24CdynuQit7IiQ3Y+$57q|8gb%r=Muly`V`
zu2_%;@lvM{2&q7o3WWBhu2z9aeW@zs`6q|DJH6DuTB#>Pd8fxNs}%EOk@^actvb;L
zgu#GnFd&({!Wj$*>nl9=h%GUhyuxFXSO&FXn7hkMz1n6{gz_%WMjeZi$=$9kgOCbT
z)q&97?b<RBsdu}!T$CpFDpzU{tU$*qZTVHM)TF}tDp%@L!rW`U)SIkAr$G5ySL#zl
zq1QR7Afy6SDiGS&IjKOTzD}e*7K5E43f%*3=T>tjG>#Lxz@XeFXS&3R!b%h*td5__
zwG@s-URSY!!jbCuX_Ey*TOL2C_C_|X4B^IENLD5<HulBdKoq&hV`qPhQG~AgM*3^#
z`7;D9oiaxgr98#VbP?sUl_I{;vr$S?$@Yz&jZ&T(=HBe3-fFFSDwJ>bY-sFMvFck~
zHG{A!P^}7t_ARcOfk=IeR<q|X4RdezQtz}<mqPh=k-CI+#ZuN4_j!cI!orpD)-?Ai
z$~BFREtQ4EeV*M)0l}Swn8`qC?n_0*cesiNp(0RK1j70bSMfkpe244ROT{Ypdp4{F
zf)%K15}-+4pm9_ntoM5yD?5d*u`J9z;H7@&r90<Gr}^xuROaRsLv|>ZA>aXzfUiVt
zmr2z2J)ZYlPd5j^B)>-nhm$2)it!*z{?2(U6~?#$%J$T5=J%WrMx3-3NKg=(2qNG?
z&jz$eMZpI>!f5l2JQCmU`5m1N1#4NAA%*0-20fOULcZVQypc^s#``@RR9YrO#|N0)
z+C=f6K;0lBksLnYaZ*NErA>W6Oj|VBgFfu}r*yU#c5zo`;-EXUtL9M_8Bie7@XRtZ
zpnTZlSdmRNBG|iHY6RlOKIZwScP`{uvVF{BCYds{K&O?s%nU6b^Elz8G9_O4F^_Qa
zVk48j`AN#x*~;d?*jRz{^266e)|R1#RA+4&T0ZGDyW+~w@=4c{mWgRTMR9F5oEH@6
zj4VUTr@S^-Fd14t<=IWSWip?6C{|d87NB-q5@CHv8j0#JL(4;+*%gvDL%i@aas6;^
zP@t<Hi5Gq*t{;gPekN9!KKNOhhn36Lyg+qJ%VcjJ*y<`q;)S2}=4+^N8N2iT=LqOn
zRtXRS9jgQgKj(2eQWa){9>~VN^wnkT(EAUwe6xvc(F=5ilK|nv-dtC85+Hoo<Ak2F
z5+M9M^DE0L0Yac-l>p)AJ&u-Xt`Z>pyvMl!Wo-@pFT`fzETKSM$1U?@tM?1u91V~I
zVf}))NcRSpd2PgY;<C2UV1T;VB@xyydNz6vg!PMYS?3Vj@%)umCC(HIblJ!r-j}?E
zI!G_`I8_KdT@HSTnexPTSlL)s&J_xD^(wn<U-t5@>Nr^lTzsPKcXLDkYo329{Z1br
znyHU);!ucO^~%Q7*W!N1nL{Aa;pIk`kWh^0uj%Y8M33m~+_-5bv7AU0Qm2?~0)5k4
zq|x|g93>FQ1q6Ppjv~$@e&YFObau!NJ&)oS4kMKFibCibh3wpX$6KIlN~9q4JKl1Q
z+As6kL;rgSwRYpoqCn@{WP9d&Ub|!E)FLoqogez&$FEyf&MgXbtP)lJzSpi(-DPre
z5y%lIt*r&bIN~<K*+qe_KS<Q}hjD-4^dd0o4+}&8M{$4P{GveDG9^g*BaZ{C+Ne3f
z2#oqe2SJb6*qmV$=$w_rB>$7%W?4DK2#h-LB7z=7sca(W7zLUY6cr;Oz(>6n4IKkv
zebig1;nrndCqa+6Wp=^}bbd|(ML+S{Tm$HY^(WFY)l7>+|EF;WUJNVHu}Tc*r(T=u
zz>8u1Y21NN2>qWi>9q=<04va$Nun)3^X53GassSB^G=e}XwuG3BoxDJ#Il|UE6}+O
ziHrQ)o9mp)iLn0M<7}z2o<t}nuGf=b1-g2bK*KNMdOZo&U&QsggiwsfQ6#OoC9ncr
zS!GrD%XrLP0_!h5P9tfqh0y;Mb8pL9fEDQ6X#v(>c^rLK!39`<<#F~|Sx+X)6PNX5
zSb?q$%Oc@79_P=M^<-Foqh<B{)56>zywsoVWbHI4{~+@gk$Rd;O#bLreIQ&QP+cGp
z+CO?t+IWCS{i9u~!%E_xJR8>sp%Bo~%KYk2UW+zwQepj*XX5&vzdX$S#Y^3g(W4&A
zq5O+eXt^l#SI?f;05LHDYRd<b$zR?21_<k4J$pz1NG5;v%+3sRi7@vsnbeIolhdL6
zmy9j->5|D)Gd2?tnE*8tAelThV^^I(Sf84)nE=V;sTrHeiZFLmCiM)P$qFcM%GiLw
z3d!W@E)x)$05uaJnLOQP0)+MHE)yV`Jl$n-27!)D>e)7vGoXA{#>Q*UkW6lNnSjUy
zsF?uC<Yt!%5Z0SrCO|T|*=4da%-xbny})L&63SbgxmHRhw`Oc;1B6tdwpt*xw`Oc;
z1BldHGd8rbQX0wgGj@X-1S?Sc3eco-Oi)@a5Z32s%vQ1IpBd(E%cNdp6*?2j+cMmF
zl2&`BD0I712!vFiiUC4<yHf~=)Z0}d&tDbhUXn?@)Jk0i<x4VlX}wCM-r=NzkP1|(
zKxpr9Qh`Xl!%1Bo=3bsjy~0Xe4du(7uB%1rolYtUsX&zqg!WD+6^PV3oz$~9V3JAQ
zZKa+C<tsDXw-O7SB~tHlQb9-ss#GAfcR8s*q~7JEt_gFm&ZJ&zrLKYU)y@KIMCxmt
zR1i{uDisLrYn)UdQeWewuH}SCCiMm@buE;ycT(4i)O(y%5K@6E6$tG;PAU+o_c*ER
z!rYrOsW)4x>!5s-Yx(O$>b*`X2&q7o3WWAvCl!d)d!5wvVeYM&)Z4Ap^-#VwV}my9
zMe5s}R1i{uDisLr+niJ&Qs3sJo*m}ikx9MNN<ACOcVrq(bk{#yq~7nOf{+SSsX%D&
zcT#~!z28aQ5a!;UN&TCZx&g{}JG*WWsSh}*Afy6SDiGQSoKzrEA5f{jzd^d?douQ1
zAqck*RJRW_sZBZr17Uqn#_olj6XxEVNqxvFbPkm7&9I~Rx-_lw9MR|l8E<*#OVS12
zS&*MK<L0l~!>V!{lbxtqVK+}?=&lyepRgIlm0hk6v%wXwu-Wy}TgdiW?-a*4r_<Q2
zvkKRs?Y-H31-Ym^yqA5r3YR_YUE)f?<SciRPpj@fja#1LYtR%=iK-FAcpq?{l2pp|
zfy`oE@d2^G2Qtg#__vgj#1Cd{q!fhlfNDITNws4p5Y`W7OnBS#&kb`Q$)rAJjdw1T
zA8{@3T(R9pU2TF;2&lCQg!ZGZHi1a}sB0tVg}F~;QlGX`&x7(4u9uuAQa|aWf{+SS
zsX%By>7)XY`bpPD&XZz($_*_b3<gw#0g?16XE2~4wu2-PNuSc8#rMyXNW(*}wSh1g
zP(!moSRcyRjV>Up582knK0@xZnbiHhZm$UCXEQd&?@7@<XBEnVNCal3eg%@}=Q52=
zQe{9AAI{i)1du|bfh0ovaK>)0c%tp+V_IPaI$BMQXi@eHF|7p6fsR(TSH2L-#eiST
z*zF+C#4dok&j5t>iy6CZV@&j=Sgu4TfKIM#uY4(%OHF(^wu6KtfX)uGz4GPQ4um7V
zV#i+!F7XGTX}SWT{Yu81R2Q2OfB0%FR{{<|C$|yWuf}o-ID9QGn?x9Zu53-vel0E=
z5r(hFawVhy)V&#IdeDA7)8Oijkis`&J4g%x=yYg?_8XZ--4<g9hb3rSHVGO4oenL~
zep9Y7XnP=N@U2*1i4p*veOsaZR)#LDv_uKM9m|!l0MN;8gZA68T*3n1$#}+dVnK-m
z0G)m3K>M9cvu+PE=??wx#$}U*KhTwphhl(H*;x30FV<Jq^gyTYTxh=+>&u${KVrEd
zv_K~}g!VsTxh&MbAD2zm-#}NkdC-18E*tCbAH=k>;08L{c4&VP)3V_Hq3!Y5K~~s6
zGwl-y?GH0~bL0TX3i}c3lLSEvH0ua~&_0rBGpCP%vZRg$nKg8*!$N3(6zjkm`o|eP
z;0UKInt{gk3552?8C|LaSv3D=oT;pmfzD=&p#9I-W~`DQjq6yJ#XwibozOlS*D=fD
zpIG-xF0u{=nnjU7Xn&H?H9wGb@K5cqA_!Wb@wWn@{b{CEw@KNnVi_D4Mpn8&XR{Nb
z{aI`?R=PjW*lk_Ulcg<Cw?=``{yfv7+q#~|()Jf|JCn66(6uw3830E8qQJ^FrY%4V
zbhHI%e;L!B%u+V4x09g-y0&vNw7-h$tr+^hj%ka~0v&A;+F!@Cr?AeA3oe^RKv!?4
zK>M4x-cIGLLtJmN6#{hi#^VLRsBbRiG(+5eWrG9g+V4_me;c>oWt>-t<;uPQ(8(n<
z28`sM7W%)B8-T3Efx6@Fd8a}9`wZ_~s^3}8LOqr%%VeOFyByj-#Bxt(WgZKX)h^K0
z@#)b1F|OkkEX8A5S+oKj?FwlB6w{u;S%<jbvi1bJx;O*cKgV^kGW7pDZV$4A1iJRH
z659Wc+rycx`D3}Vx&u17XF~gzSneuT^|2jf%?5OKSOx80V>_(oP=z1)Us;I(9qnpp
zZ}6kKIEzCSF|DkxfR6SoXrB_(t|5F7)5@v|=xEnK`!6x=S^@-I{I(O3wa@}x-&_mr
zQ~k)Ft>aJyL%*e!6%Nouq3HALpuN$bV|IRl>p4^r>mchEpwnSJv`>q5IGadBOe?Dq
zprbt-+M8n94a6G!sBz001L*2v1GG=~qjB>bt_}IRZa^cM{sUdVI0xEiaC^kI-*dSq
z#ARt)Hks`LO~4A)bD@2vuW>Qpc?30LTA9NF9qoD0J}ag@pRk3maVI#>hZblengXG{
z+1H3B@B&V6#Kyk>TA=d}7eM=L;{8_N3%PO>*V~2A0$sgb2<>y?db@}_MsY=51TE0D
z^^2f=t{?fyi#a9|8|h+bfzG}cL;JkgzLyYp@$FF=&$|R#pc?}&f%X<Z8UrpR&=SkN
z6k4E@dnvTH#&Wxeti)yOf)?n?)&=eJ<Fa*g@*_5AH?%-ErRj$D1^!$;XXAN29Oj61
z=z$jKbm)Qhg|QAB3E}vWv)c$Q(D|K>(B9@p<4`X#o45h=LJM^5tQXqb<94=*0~s;x
zCTM|<b`!KOifK28{)=PU&CmiJ?Ph3S9Mf(gI270M7HEO4j<-PjlDLlhhz7;9eb53O
zZ6CCE#I%=j)FaOHGH8L$W|u+x(%5E~bL}any&PJgqrDv3m&LSO2|LBKTcHIy+O5#O
zJf_`7oGI3K8?->D?>1=fjP>p3)JRO*4=vEq_Cx!Mn09;U|7%RU9a^BH-45-)#<V*K
zXvK|t2ed%94%h+hEB$C4@E9Ukaoc$ev_RK(9s})NaoZ_z9wnwNK?`)WC1~%CX$Lrf
z68DP%Xo0R@3_$y;xL*tsDvJ{bp#?f$G6?OfV_&k9*jP-v6I!67-3je$V%jS>=@Pfe
zE1(6sHhBfKuZ`Q}l^kt}X|IG9=xDEm_H{AsRRrPUvRwr&(3R~fXkQ<f?P{WKG40jR
z0v+wu(B2c%K9-wTu?~-g7U*<%EVOTkb@)4uqQv9d-$4s><J;ds`^I>DdmQ0C9uBeN
z#p9p_y1CKgpna1c&5a&UJdbBZEbZf=1)7Z?oc`mXz1P>vC%`9g<|X!LPk<Ka{Mi$r
zeRJ&3hB)LBmu(1Ipex%Dv~P*a_V)x1W4V71EzrsRduZPp%PkWrjLTMr7U;@WhW2f7
z*>-W7Ce~pWv_PlBE@<B#>oCk=nYiADp#{2n8;172xZXwxNyauCffnd=7=iX3K93d3
z*|77&+`IhLdo=9g%Lw}}zfrg9&zG>vyX{czgNQx=b<Yh5?YsTCy1xh{KJsqgo;W;T
zLMadUcH0F+Km@1}B_NU>@a?t>&=A{*5)erb_`2=F>5SZie(GyBEF@8v2mP!$g^<mN
ze(!Z|1w<lHyB?5YzLzII%#fcEh29s_N|r!JD`BDc#k8RJ$F#x<bhHu{dVfrdvi}~_
zih@8#D`BC3k7=>O2V9>Z4gxJu-8K-~5BN4L#L9+XqN_p>v_PF{0-^n&uQ%<m1LpjY
z>k}Yof!Z{H(0<6br*4^fb5zH*1rW4Aopu1B{jhIO{xb6>YU!FM2wI>vdmywQ;cBe4
zFJYmN#tKSU2&mnkB?q)0^*J6V%N<s_9Nvk`CSf6<c4-o!{g~_0Ecm!A6=y18A)rog
zNrd*}ZhFgtgm|cPK_F;>P6r7KeZsjQ79<2f<FZLu2&i3;L})+hx*iJ>LY%(dbVqv$
z3jxjUxIkz><?HS^kg(80uKR<a1!~s=Li>>G{saI*|I@x6!iQ7BLO^rGNg%YJ_Ibrg
zZAMt=GqI5*ECh7*CSjq^xalH|j^Jr*vk+RKvzdg2J{#MNu+ZmX1tly5)FG5rF|?m^
zLuf{hWjq|qm9P-d$(69s!?9e#LZ6T2N>~W!<VslR^RZmQLSKl>CSf6<E1QIcz7Us<
zu+SG{xe^uvI=K=S`l86?CzPe35f}OjPeye<sUW}K%N3s8yc#dBipF~eHE!}2<T@|A
z5?sEi70Uan+~nCc#m^|6DbHo{`yAB+5o3+FE)P@+ys^pS(}kiuJY1ALjOwlm&xDGY
z8n2YfU7(36Ugp$I2+;&ZQN?v&iAjCMw=t=V#H79&cL<3|0bPfXnABIbLwNoLVeT7#
z>U-8-%PQv^zCGl5f%wC3`u4yu2)6*#a|1wVzv;K@;R_&+>zlqgA?*7Xh>!c0^Vc9e
z6;S;(5J}&1{u*eAt-l5$>09crMH1S6+m4lj@MAzTFBAytxBUjw9|XesZFv)$HVy=R
z$G3;GLF5WFCX+;1zvJ7(*+4^V4rdE13V+x4mdh+bkV2=woF)8jtiL$k@A`Jj2Vx|B
z*Ed@}o_}GO`@Wz0v9+(P48QO55R>S4q1g8awweS{G@xn!0-^nZZx4|Hk@^GcqDdw3
zht9qr^aHAXK=k{e(+_Bft$l$=`k}M$g<{`FoRL7V0@X-BSRZjl0>b);Z;f=JpdUFS
zflvbIln`_OC{{wu{Uc{2hz+kb(nVqJQ9t!FYb03`Kk6FcMPj6%I3s~D5>Sl<g!U)S
zNI<0i#2M)#QU0gSNFekBs(wK9`>E3pXo#(mfJpkOn>6@g?iYUQ&vw!v)%^=UYbG^W
zU-bK>>xdu{fjUS4vF<P3K*gh(L@V7$YM#&(sB0V`w7>H0{*W*A^6OZxumYW2O|=6c
z&tnp;bc2t1EK{HktUx6F#tp12lZaM2X8=MjPzQG)wEyJ>cjg^LE8|RM(g4&628q!A
z)=e-d2GL4uU92LL2B1z{fYAQVO<WK`v@*_ACJjJm2bnbdKDGmshCjGLn2LuMr~@ky
z+CTW_z`9SaOd9?e+e{`6KxZ?VH2g8H3nmSJifLui0CaYcNyDFX{_FV{hq=G_sb^;O
z(2+!8{^GN7EvL6HmebpR^}VNN_4GEF<iGm%xX{JYI&R4FfTZ{l5Jm#((Iz0YH)I#+
zUNMkrydg`U=n%<L<4?)@XBC6O)JS=E;iAGiZMvi&h9o^k1~inNXV^@n={_a9YPE4P
z7fVaIF>6oYfM5k`{|3T(W7eL)0m6D?)}Fw*SkTk5-byQ1`Zv%iA^rPlSv%>57D-Rb
zE<Vi>8{QRqaP?wobT?(KI|V6plEj_f6ibpOc~jQ9Q;3mtlUQZFu?kJ{8Ch>h=Q7U0
z%de7fE!94h+iQQAOI`<;ZU2i3=kQLS8eYz9!)BTdrj?fbjBJ~pbOe&cGqUEowdY?F
z=5EfWZn3p3akQJW_T7L>q&lDNj0r+2P>l(M_Sw#uK%_p~8S@gc^mDRy^aN23ppIie
zlWKRefv`R&t8-!h5~;%HX6<n~5V-<ft|IukS(aZ?Qc_`kZq{CdzeLdUVuhv7fR0t_
z?0K=m;*+1J3VZ&gVea|a)QhYcE`{>>S$jV1QZd5|Tv<Sr1*l~KLi>WOEejB-FK}hK
zRJ47eQwW4YKvf86Qf+et!umpI!Ar#qw`J`EQ6N}>j#UKTmgNCBF$1Zv-j+2FMEO9_
z?OA)*4TQo#9Ylbz-k!COA^;7sS$TSXSD1TAHg%^pLl=}U$=Xw2U1EkioEbn!1*#c<
z(B9$907U8?&J10m?Ms~*K$HcjWdWL0YX%^!FLh?<5;MHanE?bV(6Nf(mpL<#3hT?9
z8M*|$+?fG{!ay|x5Z0GFGXM>-HA8op``2vh)z%E%Q2uMyUis=4GrZE70fbbbngIyy
zE1emDNPVR<L$_#qmoo#1vH-O#K$B|C0EG1}XNGPu!`;pdAXtHpRRrJd%s?uvcRMq5
z3wo6^0|<qIY6c*zuX1Jp8e(gPo-p^?Z0Zfx3_Vc3)^&;=F~jRzSwJWRRE2=hzRq<u
zAW~oF%F-j+zCLRoQ3K%~f$F<}NP2y?S?AqAL)@+hfq_VRebzpr)+1KACu?smfnWtX
zB_yAFvb={aeS}n4@5yp=Ndh+;!`z#)skhjoZG`eou4o&jX!km)Afy6SDiGRxom3!F
z?^UV3zfrP$bIdAb0XkMG%bR0XDa)IkLcL+`ZQ0a2tU?mUf16XNR}^}?vo#2*K$QxF
z_U+ErK%~Ci*}7L0x-VuGg@9(<_enIVEqWUR2<v^y>iL_(+&i<W2dqM}S@2FbFl-Wq
z-sPl%kP1|VfY83nDFj67yPQIsM4@-btfCN56(Z53T7`hHzS}9ZIn4cAHuZk1knBkO
zTh^XN+$;(`=%j*>3RH!F&_3uC0wVQ6r_g3m=)GBuG58?52T=Pn(4;nK;{?L`-mFG=
zAg1}fFKb_h0>KJ&tRnb**#^CQKq{>7%bGWiJl<f+eIT3qh?a$m*Tk-}S@Q-EN3tl(
z2dzm2kq9(W1(N3nvv%5?l{`L_wR1j@LY=Y#q5V+S#>9y45}mS>0t5*w(D(s?Ce<8i
z^877f?qk{1XRWDaL+4|z?zf0~AJ5vi4?vh2sHFr#`|<3&rKZmTDfGv)_OXL4lI16|
zo=yNkumT;cDF2D9z4t~cte?noJ?w`bGodXq^L!}leI}df{GwMVR`*LBqC8eCTvIv7
zZ=mp6M~&Bg&Chlab}+y0GF(`<YR%ciA|?gv%OJH$eou>EW09owh2=GVXhnWBq{gp?
z?BQ26rgp932T4{>R<9YYo;gulZTMF6+Za=o+UoV|&MI&+^C%ehbB%8G`m@hIU7jTo
z#SZc-Sl5e+Q+vh^8jbkd-UyUmK;gGGcJYHF(NWA9%2%f=B^|y-e!pWkkM|jsuSG*K
z32Lt0uy*ZPYtCN1w|d~r$?BQrd6mkU<?%C}(atpQpb(xp)7Xh$!8vo?>Dt7xGu7~r
z8}zqGv-mVu*KK`@hXrcXnnY+not>`}OCVMDX*;oG3YvR3oBEP%;<7+`IGZ*1XR<kI
zL!Y-bFNj2-u5y6n`T49}<>VxfFJx^v2c%F}E<k9%khS62oM`*Sm{wSUj#g9c3DdqX
z_mynw>$Zu@KIB)j_UXVrQSYl+Z=ESLh(ZI^O9G+&YIfl&mr9|(nq9NjtUvlB%dfd{
z8U!m)C*nYpYOnVIVf~tn(?5{saxM#V-_54}Bb#3PrS$6m?SFy-ztl!xPJaBTAis1~
z3;wsWT&>rEWgGXqS$jd@GBNe{vNmW1VlDvGwg|+0-^<#^K!LD+FFRK+Rsk{J_p<hZ
zfy=|(53;GB*!q<H-ydYT=zTK2<8sO55t<v9icO5s{(O+>1)3EkIB#flS_DMEBU$?>
z8j!3Wu}u<rB>u>aHXyVF>KFzzsdfwl!ulgO+FUMe@W)yE_AH28fjVRWVf}H|#`l1*
z{y0l~?*dZ_(4#c1&NI!cN#=)>D%TgxGfMI!DK#EW;=v@IIG-AxtgYk$rTCKZ<tAJO
zw=1qJjUIKDC6$aH&Dx8jK$DeyZ+2^#`&l;i3u{@~E&o~8F8H^KWq<A_!yt+SG~<sC
zg!boB)iMDCBK7Aw8TR~bVeVJi)PGs2vakLt=XAD-)L*+9D+pbIsyYzbUuW%G9YCc1
zI%{{%wuuFQ<N7KHg@9VCK$B{Nj6hg_lhtc94Ai;bWmA7tg|ZT)`CZmNP}3j^{oZPj
z1(68UXb+G&{e9MMl{JV4f3O-rD_H`~R74=Oe{fkghPgjyQ%}k1p>2uv{MlvMC|Ulu
z^NAo5fjU|P5%b?!djPpnviys4ryzyuPJz(=#ktc)X@Gx?X@wQ&Xf@Tk-bQJEH{`7D
zAZURaU;-lPhMWn?d0Bq0_Nlql(``{C6!p|xR?lNKNl|XhSq}~(5vX1nh?pC5)`K^R
zK2OWpU>-=JZcqTBeOj(X&jmM$vNz@I;U^HZK#c<eO{%?&(I4iXnM*xK)$`?K#xrx~
z7nw4CKT))2iFOjC?w2PQo|UstE`Xp+LS!1Kv?dYFrFr)^iLTF*f>>y1wOoF`*x=@z
zohpK8mq2ZoKv-|i+2=5U*!||5eGao<%Jpm_iYnJMX`uEo5>2Xo(gFzUvvc-I3x2uu
zdAZcBw$yUQ<as&sV;a7{T@<>-DFmXA0aYpx+FNqmos+Tvk$Q_N<oP?o+zWE4+pSbN
zjq-w=T^#QasV{U=K}ZFvR3Nl3bW(vxeW5Gn4k_ksIXlXNun^F(N-=NC5sDCnNQL#b
zoV@_|m@xO^T<WD(AvyB$V#!46=rN+uOLErVf=~#kt{MpKOL8q*Wk969Bxm<i9wQ3f
z;S>VF3UsWZ&>guJRftqr?{Es0!raSqsaIHqN>IK$X9v8JD0FAeJ|+ZWzyqpp1Cq&|
zIXmD1VZAeF-xdOr$(^}VPBkmofiU;VT<TRe6FHFc%ACDMH6WSX<*EUMRG``t2<=_2
z8h}W>%T>dGl=|+NRjL7~0~CoS)vjrPu-<LkMK%a?ugRreuL@-)!u*<CR*y>uqR?w|
z*3E!O1gbX!(p6q7osKHY2BN|1oSOkDG|EdNw6DvVHI3&FhPgN7Qg604kb_2V$k7#~
z<_9IqH|9LuumfRepc)#8N#5uT4TSZLxw(3w7)ZI^m|LQkrw2u$H|1<h83Zd(8v@Xz
z+Tk7u>zi^mraUN4=-!+S;(<^C=#-Gr|K3;$$>-jj9fTo9(!Du52=5GYZ_TCNX-g`{
zq~4li5Wa?z?v#?=hac>GJipyCEUzq@XFRwj#t#{ePO{)&hgE;(eb3ZrZ7&<S=AlHh
z+TdMAdGo_Oy%-eCowH;z&wlHxjCOrMW++W=+9H6ca$nAdKY=KHU(SYdcS?!g;anF8
z%K^0=0!^xQT|ijhp{`2`h2`$gc^dZtVL6~$4v3`tbN2aeAd>FSE!2l`fk?VPSCISQ
zo_|G{dv`ANUTZlyH1_TsTfVZLafK`@AINzR=5#v)O!5P+30)zEeNXQHtL@B#>?*E2
z{dju1+XLG?VX$QySI{1&q1|AE7aF&_$34+8;fQJM7<&fncDY<2A*m=WR*Bu%+9kB_
zD`-QA9U}<|ZN^vzvq>_WSOthhVh4d17D;%%U*<XQmSa2}{ZI1``YQ9BJb7;3b5G{W
zo3|Eifap0G9!52gx*L-sHVV?{#@HyDWznXj_FqH1f)E8=R6XC6a8!k&8KsDBO2VR6
zwRTP;xjU)cYxZj6+TCvNIkNY6N%bDH7pC}kZtpp=ce6JN(I^-j1*yB)8wF`}b8NI$
zJ4g2ZKCy!zAVfhImA$`DNTy{krHKAMvE#AMZ6x<4l|P!j+B|n(!cV^P@42$~{-nCq
z?1d@5-|anD_CAo<sRR&>g0WGMx)1Qh)zBzNqYuR3hi2LPV8VB~WD$fY=%TXs!Gu$m
ztQ64)ldvU9qKvGE624y*3w0BME-J+jB^-=nrHDS1ghfM%LR(6MwUi3FsPdyNrNK&~
zx0D7mfVcV6<lOLC4=^SGAfnq6OH4sTxB1iLM~&o>r1H2qSUV0MNwRpF#E;~`M?Ew_
z+!kOAO(1n2O)NBlXnoW}(~s2A#}fO_2!tpYXR2T*wF8krL?27Sfk@Tbj~mGoN#z+c
zNZT5pNcfbKqVA7n(36&viSQ5@?|6{9PwG)9=YnW`(u2j1WzbWWZBnR93c9EadP><#
z6qP|w#pF}1a!H@|I0GRHx~LRCtw9$>brGNT6zSg@$&RG*lJ!N~E_WpS{56*iFtvYE
zXLcsMr91wJma_*B(+6z%LW)JqIM0gFv1K6NRcYzp&LL=g=(qWu-!Q>sCe}5WO)rH9
zXOsUyn5X@p_Rfpg57QOo2*`ZamosVm4jeM<GJe?W+u5frhF^V?l~ZwJ{KGIt6P7iR
zi?`FmA*FO<XL4LzX9MZ*&LnI;P^Tz-F|jigAvA%mNyFepe<V>FDjyvWIRer2ViJy2
ztk!<QUXP^ms<}?PP+#$J`4f3=mk$Go3j)Rq0#bLE4+9XbyL=e@ME312MKugS7nMP~
zOHmoLJBn6ot&QaMq%tFoKU{08>+8Cf-{cIkR+9WTnH%&zC47e9`$P4CTh6SDhwf<o
zBRmG9v-v6YtAEdLsT$C&nh?C1@G6W34}{k4$iNGzaM!AE_jXd9p2o)sOzpQd^1iQP
zIb}~$JAu#h=v!p}AtPGOZa$s$_BJQ#*#}XBIpKy!rCApoyC<=eXJ`-a>`Cn8nN~UW
z{lw0@fp9DsBM=x$>+yG05YhJ&`(3qF_t)N1RQDGc#|(vt?oFDay1(|8qR>8%wyojU
zC(uO|GWR9*7;PyHl`Yz~hP@kQtNKLFevh^kBD%k9RUvbK*(!ApBzD49tJd3vF;Ihu
z9`M@*MD&2i#a5*jAC#gx9usuYu+gIw)fr|Vl%m?`QHtuD2cV0FeIKQ$&M^D16xF_u
zQdHkO0NqVt8%QatGt53JMYRnivE%7ltNP{v=%Qg)NMh%;QHtot@ebCA)UJ@kK6C;h
z3c6_6BvOj%46}m?AAt<_g?5%6Dn<2?1JFga(ezL$sx!<Em7;7kJ<NR&Z>j2$h=T4W
z?K?f3)Z-#wYgK2M9WKW(`%XV8MUO%h^j5VE^^;OmXPA8=(Qk*lk8P;KQ|`Xg_%t^g
zCiw6$i=TbZINd^cd*>zXmvs@uyNK|toek6d)~DT0uxzdB&@<%SOl@Nwo;J<Yp=ZO>
z=B>sy))A@ggK4em&@<5QE$wO@kscefKS~iDk@787?f7WbuGW!h?Mo+~bk28vaF(44
zRt6|N1<ELOrtSDZiY5??znX$HF*3F9Ux73+GPN&Vv{u;+J0`WX3qll(4`mS1G3lpc
z?gSz_COuJePFcs^*s*DIz%=j)=swX_*|BL6pBB_bbZpujFl?0_SNfzEqM(av=j^!D
zGUC>7pxHS2B(}=V+3~3*r>)gv5CvUS8)?U<mM2n5tK-wZj;E5fR@q2<Ra!gM#+nW^
z1ATC5U+q=t=l{k_5xpw?+jvfHt6sOBkk-Cpg*wm-j5{tUM07&h`xGxlbVB-faTijn
z-oBogHgCz}Fc@@$wd;0bTEyQIsEg>t)Q;L~)u!7?sm(bcL_rtTKG;cV5$CCtB04Fx
zgRfe(4|a0tVI61&`l!>k*vaLn(}8A_OAqs^_LQ{tE$fXAGy~(*rnTA|(JAQ(U-wc(
zr=(||WfzAxx2Ki{>p(LwE~&JJ7rCdVpK*hApxM;YU|!^&mh$1?_%PFfW}ticcv_v7
z_Wr7uB04So+BaymTKj1unUz-N*`r=>s?17l$>*nf%+6+4U66zDAQ%$}kh-%|O9nx-
z&Q9ZkXYHqYlFdou5~2uE&_(r#oRhN7D|0DDbWR!<BS9XKb4yV@B0(3G;<=@$9+7h;
z`X&0()<_nnmEWdE^gg!b2YrVQ;GELS+2++;*N;D&=nb2NDGOlAG}@GDT%A_$vP=V}
z`0A7ufiJ39F1RMG_2#Qf?fRMLtg{qB&N}Pt@5E3^1$<47_%;fN_%*4WISFFlH7QSj
z{e03U;}=O=uRquJ&)@sr|8#xI8>!>^<f=ubKDla<^qm;=;i|=H?F%O!^XK~h_jk|!
z;hC;bk6|jgLfNo5Jv!bqZDEGLIAxV38i@KOf5E`+`t*YbbzGkkk0qsnN<5ax!0!YD
z$%&V8`<{4)cHQ~mJl#AQQ}Zr;oT6*!`KN`F)ASq6sr}u4?eas1x2J4nX=;gdTbST2
zP3>&*HVu|#I3x@#2vN{Qm8~o*yRK|ynYymf*d{k!>yZYE=%UJ2t}R<twsLLRD%r~N
zvQ?e93c9GWmE~ot%2t+_t&*)=SGKAXS3wt5wsKwBs<M^q%2vr%R(NP>tLns6&_$K4
ztSDPmwz9%QW1F&->r?wJ8bTCwQDrOFr}pC@rHEed59BswD>sy)I&l?rQDrMPl%mR3
zZYV{`R&Fdsb>b@MqRLioEJc;A+*pc|t=v?)Nhhv?E~;$hrg8`>Te&H<b1mES(#*|i
zEv~pgh=MMv<m2Y_Xdf_2K5kC!tj9LJLvss>j*TWIAE1jW`M9OLI7&Wl@n>|Kl8;+G
zmP3q7Fa|sj(OXkn8UYc#wQQB7;<nU|{%s3M1?a6RskkjYIzCV+MfA3`C4TXgmj&4e
zRT`}GQ$ZJ1Qt|83U?mm5E)6EBxV;qBDXE}~Dyg`=6xAuIx0j+M6)Vf(uTxUNxW3R<
zRZ_7sJt{stK}1)U7l))`RoSYN3NTK>+QJzwtI|)!EC@t&RoN;@#cD#8T^uD9ptq`|
zVs&~{%;MUrIwf^=YDZ$WDXF-l6xAuIpo=Q0xT6$RQgKHqN>Z^VwI#2%s!mA--Azg=
z)}*%XOevykQad%cO-aStvQ;G&U|eCM5Ye^ik#4Y(inV2{Bo%jhPTE#gQUS&ZCy3~s
zsr|wZB6?>Uk3=A>kyNbnQ~*L0bkQ#$x-PX(z)_0my0TT0iuI|jytY-9RDkh!8W7R-
zX~XX;oszmf{ZjlUYnu*>*^t_i&Jd!YNA$l!bVF+Aj8lr}hSZL*ZL4y2%tlYPAVfjG
zb51~XV_L+dh*Cs1rtuYB`pQu<o5}#AQ&Pd0j#G%}ru5S>DFPAQR9>7GcCwY7Ye5u@
zNk?0?1<~K6{3fJ)1w`~WDF<rYtKB9)V@Wiv9NT-{5q$ssf{QxCo`UAnPH$i}*P;6I
zDF7x(WF~`j4jr#%bqy<8{^ivFaVkq%6!pEdec+JJzE^y2P~R`N{P2>&e>32W(@(y#
zXc^c(q>G;(_($KauJ(R<MJ!e<TKJEJvcVTz5&kLs7cF`Ht5rmk7Gb{CEJdR<^T*S}
zAFnK~jA_x&=;MQF*aldwwKtM2X=R&bh3yn=N$o>%?MjKZruHKaL}&x!hytm*HO*ss
z0phBy@o87Bo!3YnPAiX^*7K<OaGJ%RhR&1LM^al%gU|{_tsr$DN%<<fE&zzuN8*F9
zT06gyJf2pbFs<iP^YPRcQO}pw?XDF<D;Twc)ZOk{L9}jnt$o<llvZ9gt$nEZRLVAX
z<&1rlGd`VGU$UGLruga9J{{agjXvYE2Z*r*#ux!o_nGwQxTFZu=rgG;DfUrv_H0`F
zTIeT)C>WnkU?@HQG%rQ;+4S@?LjKZ6Y4Z-BpFxO%-l`PuNRK|*M3px0NbNf&eMHZt
zwQpFV5<D=@G$=&$x%98%>;VjwzZSpH*hec%&-;WDLKO5?m8(6U9vx!@rHDSC+N*wj
zl&igv*4!lJYM_fMS9>8nI{qv{T|{3<?X#_Y)VZB$?MyRRxf&Rsi4-EbGd&@0Is*~i
znSSG&<|cBr7d@!;2_Ieoy;bFEFQ!Mw1qDhGeKED4llnH2U1{Yt8xeh}xl7XoC69e|
z$#<vro&bbFV2pPlb$6$>&jv*6?$q|#^wpJl)hAgHUIF6}1w*ODb`a55<0PwEyP%Q0
zkyhR^gD#-v8>ziAe}N2oGqtxyAhd!}D@ffpQ#)-FMC+TWZSd&VNZv^+@0r$q)O;tk
zA4&R2>$|D#0f5j7My()q-%ag%-ymAwO>GZAKXr4D8w4Q=x~RIj#|@$s(LHWZ|3<Pm
zt$bhx^{3`u?`D4)v@f+UY(QuQqgIf*`_epKToA4MQv23He;Ksj`vM^fx~L4=?|q>Z
z(f!_+{<_r;cwZnyK^K+c1Kt-(5k2628PG^RN-KY|z6_w|M=2kLS5z6GsPb`I{luaQ
zO!3F5z4SRiT|MZT2gDEqW1I!4doVpNMhcKd52m*KJ3tm4@|zSw6pRl-FqHO=Hz|nd
zA-_onsH=y|R(0cn-l`NIE?ZSs53ALgdM<V}lF?aZVRl6Czi#<{|I4}ta4i4#JKG1H
zt>4wzw9BtIY_w&5uIXNJ`p^E8cTL8pTn849&e)zRmv_kJW3uXkEdI;@Q#?k+x~n_n
z^0ApkD2UF3@gW3KcWm~#7@<HqKQ^-n)gjM}%WT#GAqvLq4h*Ho#0U!_Ixe$K5*>2+
z_{_pDgeVx(E)dc2nSGiIM09*+)87u!RhcdCL5PC!YJrGel^qu^G#DydH11F!pHTKy
zfgJR{Dv(bo`>H@bq3kQ;e`02NVn>*CgWjqF`NZtF7*Z)kbYf<&oph*klQR498HyO^
z3Lv7BvSZ@{Dv0Q$%zk|C(7T|MGn*zsh=OrHHHhfs?6Yy|1|m8+voEA{=sbxjnLSn^
zM8Oy)Kt!ixwt@p9IwiB&WQX1qoto874^JKlQ83<iAfi*V<G<{sh)&H;`>Ks5Cf(CA
zn{;=CNjDf5*FZ$4Wxe7}2_iZzv#CReCf(Ds+9{@2lWx#Er%Ctp?2A4SHR+z7#q$~%
z!%Vtol-E_0ZqTo*Cfzf#&&6bfx`@umPKqB#@6gc{Gc#L2g%Ab(;%L%6GdtGDuqNFz
zGh0CI(4>1-IS@7J23=H>?pfKfao+%S5uKIUI&+66-LuOfp-DIB*Hx45+2wWBq<eN|
z%kdqWbk8aKs+D}uU8+g<oUFI^Rg>;HWnY<e&&@1_=m?W;&~G|Ty62WRohIFLGh2@D
z(4>1_d8=#E4f?IFN%y?$7#|^;bkECdfuTbmEt#L$Vljj$=;K|J?)h2E*X^on(mg*5
zi^bL2g=~z=Doe8X3+;u}ye6}!^o0sri!ys>2jcbw<6H)$?xM_o{s+;zD2p$I*Dh3a
zS)ADmWe`CDjCl-*eTy^ujS&o$kB@gYh^EE5v$Yi4*+{O<D)$rok8K%Z!N1#a+x9`L
zPBdKW(YRC5czIU6&!RC*@$!tUTWgb@>edQI{r~@iR#d@4>cpE0M8OKbsX#1Tk=eVQ
zo$Bii9%ms$!8o%7L#cg?3Pkh<#aXSpb}B^Qobj=lWBk>V@+5Kl+!J+BNTs+y0iy8c
z%s%M}qVVSI<Ws`Os5(WrWqcIp-~AXB)zC@3nCXJ(ye&H+#v3qbIqfUqV^p1r=qtIA
z{?f;&C`1#b?kNTMm07Pi^e9EsN)NT2N^n-u-7pX#M8SABgNUxmjy=gs5nZK@=@Hr~
zC#)_FR)7cH$qMkRGyC!obrD^i*(nj73h-<EZh#O4V;}$#U6a`hGa#aCGW+m#rvm(1
z50DU|po=QNugyLi;{v6Kt}RCe0sc;ZtaOF|55}LlKt%7%KJWh5s_LDYt-f_?Rdt;|
z2O(MoT~q;nUH19-^raNhb(yV~bSl8F_n-$M3dTn$i0Jz4xESw2MAv)J>r{Z>klB<G
zLKO763h*1UFUDW(C`EKb_SHCL>{Ni?=usL%6pYUX5Ydg<=VFuw5#6XL9q#}F{9Re?
z%m2=2p*q7_E0z2XP}sk#yaN>W@5<~GRh<g^cl#p_!WPi4k;4AnS?~CWqZHA*{Snux
zu)jI0{j&`~g?-TLD(r90{>wjjDWaRRfBKFMPs08^nf<)n8Nxp3mrP;*p6v56z)_0m
zJ(>NK+NrSrhphJBOs~Q|7@sZ_BKn8yOJ{j0qJPM~{ZF)7tqp7>4`!8Z7P|*h^Ffc@
z0~O>R;&6%}2XW_tacTil_o2*YgCJTT%Iqh%feJ8NGTRRgar=WYc7xcr#bY-ZDjy#&
zE{LWrS=bL<s|{3m+nU*041_2cSHD0+w`NDiVFDt$HD;jI+8|bVvdUA|wL#Q;IAbkF
z$@U<H_eZko;}+gwiXX}B(4ax;`J;X*AQ}Z@kO8UtXl5r~fHeAOW~(NHWYJ?jb|9Pv
z#-4+rv>soi1QC5Kvll4`sjJ)FX%J2WT~s~a?oOi=P1`eb8i=Ot?zBOoC$ef>CV|id
zx+VqgC$f5suau(ciL50CZZOCaxD_)8$%rR2n`J|E2aMZ<K}4U-?9C<+(I>Mo%dXZ2
zH<D+v%8Tay!PI;v%T5UHA1wDjn^j*h_rnxFo7oD+V7Y&XyC1?{FuEV4?hbc9NTWOC
zejPY6SZ;YP`wIt-P=XqY;%y9uns(p_h??gzJ8)#MF2znCbr7Opyc0k~cV@lfr~?t*
z>7#B)BY8Qi?6PhTq2|k(EyfK|zg}^z5L&^g6{PMft`$V<E3WnDjpWs=^15mLIW=GP
z!TNJ)ea*E(Xa%EIkh-tARuHYPxz?eL<jt(|wrL$o%{MbUC1j|yzU5jWw1QD9NZq$w
zD~Q&&Tx(Y&c{i)PZ(6&k`L5gAC9Qj0D}+`sY6Ypg$F+iJ-4nIeYF%>rdzq~wL5xH&
zMk6qk+A0!==zE#1A`NRK`?AW1X3#Kd?$b!r_#P&M_Gh+O24N5w4FajVKVy|fOT8dk
z_h+_PHcSQ`C`C2AKo^xk2TD;Hbf6Svczuw?cc;*+oCb`20TKNm<NV~<s)pAGS$O5B
zTDz!`e4JH2vA$eH&5yGz&XF!sUk<uK5C(zKAdtET-5?OH2i>5H)a0R3RDA(mRDC&A
zimES%N>Tc9*!yx(=nEM80wQ|Y`vM|**!yyEBN?7o#^iC{a4|K9=eELhvHCJ1x2p}|
zAuz@rkh&vsdp!X}>xkT5Pq<i3j?C?e0U-*ysQNN8w=ZE+is;DP)+{d8Z9l3M)ol+(
zH&BS^sN8OQ5YbVkC^R~+#-Ms}NRB}lRg4{-_lnsErJ=H&)pJQB8JAZknj0>m<~Vo5
zC33@fHweNYFlq&<JKhZf(K_A@x<uAqmD>pj5N-gY8^BO%Cm?``UX|Mk2$#qW6LNd4
z4MG%jQ7N8~+uK5vB03?DCm_@=Z6uTP$~5cCrPQ39+X~jD>dTbeUfqG{3mE$XQg=$;
zD^B4-v`)!w8R}9sIkgnk@C02{eVJN{sxMQcXtj1(Bbkv`=9od3QFBIa>(ZCWpqcJm
z2(4h$3Q~8bI~PRjOn2^OGH6zA`3=NV5{wU65KXgko1226vOTInG|kE_zqw4lp6vr2
z!q;H*HHheJALt;Wv*SRo)-G=(^YY5o*0sy2InRB4xw<yry9Qwp7`p~icfNNGMC*L-
z+U06;L0*kN>_Bu4j9mlKw7|OthRVmE5<(S-rUm)mof=~6<?7l(ziJSopc|of7W!4A
z6w!r#)vjnHi}K2~*0n3BxhT)#zJe>%wZ*Om!eL;HHz0Kv=a!X%XkDCJR(ge+T#{R`
zhcF0?Yi(dCwX=IcM3>|i?5|K?mih&U@Cq2c0-|ZDdj&+((%ddMh^D1}!LJZ4^GgFE
z3dUd$BDyTMgcb~yLwKsze$hy-%PTjSSAIdw>v9(C^&I<!yt2ZzLTCk}uR-dr@Cy#2
zb%kH>U&z|)bNdYyLKKV!fuYpiHUSa6J`ekps<kT{$xV6XRx{{IYTo1{@JbnUvl|4V
z6^sUf)V<ja0?~T28+4@%y2TBG5Cx+_U???%KtykGgMQgaew|lVnnAy$=C3`J{!#|r
z?gl|<1*1VAb#HfrK(yW-4XW0D)ks$7m9?hzSJYgcTT1sUX}u%2lMW!Xf>A3--8=GL
zaSjKf^^V-u6n>>{u5p7PL_rr-H`lm9lp?xD1|7wF55tdWB<u3Z1}xIWAFjIVa(j(-
z_z|*cy~gUNiiE=OS_xb<nU>b)9D3*Fh_BDT(9&euTCee{wnos_ro8f7Yioqs+N8G5
zBqbUV+PaJI)%)a@ONO=&VIu)=CAK&B1^@%wIle&quI+4>Xoe)Ya}mu#vtl&gm6O8B
zEHP%>rC=vBMq<YA^2+bcjFB?qcX@VF2s|T$8JqL!w}Y&Z`xB0BiRtp@oGFiVixJ<P
zx18Bz+S;6dOB3@RwNbQnZ(e!C+8U*{?$yBlCe9vp1dB5F<-Bxqa?3gFDsLX(_umH(
zx?n)R?}c7kXS=lB;VZVA8$qtieK{|k$Os{N|BQ(-ftB}-3VnLOFQbq?!Ld(b`t(4~
zFS$`&=+guFXX9m5IemH{UdEt~)*j56$ys%cH#oYV>gwf#Ilq{CIpPoIOy<lQjC)AI
z+=>+e;iffua6Oc>kH*VU_fXEqe4SDEkm9?k1GnV77jDH0gK)jch;PYx5!=f{eO?VW
zaa!N1d&i2kf(RekWW=}TM;+H>#J9%VC-?$mx8>Ep_2QnWgPWbvn<d-2bw<mI+w#Uq
z&HAX@mb0#C*3kMNbKVCwYxH&r+;pv$7XO&%dOcMaKCCVNF=y@9#93T?IIsSr7pGVQ
zH?7fX<HLFV<YqbQ9?nns`zB+}!}&ja8+AQuqZz!9<&|e_@Q&7HeN2xDwKX~ns>l5@
z3egQWf-W)DAJ<b^ri#)1xGvj2GWJJn>_3@TkLvxEF!qNG<&6sV6tS7M55K7LD&2YQ
zUHpj3K}@`DJh-2JWep4M_J$ks+yYPLyb~VPhg;y!m{Atkti_tAyIHF-3pcG*=br9n
zt)k@9agg<>jlmN;^2$#0#28iHk+a4i-D83$o^#zobi+}%nCj2DZZW!_^8pM~{Jalf
zA=eyELeIpZJdFcbjQI1p4Pcm#zMvFaju0Xa#~~v|{DqveBfK2(7nEh|8jq!CFXfe2
ztY>4@)=LUd>e<-PvzNVRLV5;AU1F-g>^&2s`(^cv1;L*6MzTAvyn*U^(W9qUdw28h
zk)AU>>w2)fYPqV2LNM%U6VjzuZ59Sn_?jBUCQ-z&n^H*K*DNmsq1WvRFQP6Oa$sR7
z<!m%{eH>kXE3fRcu8))6x4i4)Lf7B+xFDqKaO}F6>Tm0*Dz}R1`r95CV2a<-)7*+R
z-r%OVT6;&&b1z5y9X-(Hc*L>vUFDZntQZN$8(GDud)LE?7<KRF>=^X=sC!o_r>O(?
zbW^7o2{+X#SKQ+d0Msd2+|x~**5AuHm(8>*M#3?`Q(cR9@8zF~QA>>YdpW;LTkDL-
z_q(}LF%gafoa%~+?`tA$>h)v#``uhgYkPBEM7Co6+5*QrA92ORy*Zm=y&UnqIqxFt
zDv#$XAIK{o+EpGezaPjsjzp%74_EnvoL>edE2O7zbc~p`K2SRD<%oZf^W&g1ZGDjQ
z>!8}Yincz^E1y_fSE;R!Jxp8`+B)cuO(DABc%zD`e$XGAVssz$$0khip`4XiH7&$c
zIGQR(-67A##G(EdzTB*jx<fguvFbVHjIhJH15KU61{^PniV;7o`J$I2e%N!U3G{S$
zQ5jXlv~hyk8eXvGE!`7BPe&B?Oci1p90$Lc>LUufcf{x(QG}E<h*LbWuzQDM^$c!`
ztF@7Z-8(8rd}I;sogTG`m^P-Uj5pIJs`8kEBwMCU45p2BT|&AI$BQ7Q`q+Y5pSmqZ
z_t=7IpNUgEt}w4rtXK^<#nsxl!ZJ^lBR;OM%ySZ^O(-gp&9q6XJfX0+-6sXpCKjA)
ztfqx@8`kd3$W)(Lu!F-H-4hGmNs(#Pr+8Aq<jacXHMl9R)+QCaA>-wUPb!#yY3NSI
zw5dg9hM6{5m8TYVn@kR-O>^Bsx(&y{BBuJZB8|Gm=$;mJ_e8f$n_gJLD8w{4dQBY4
zEnyTRKD`JDV~^StOq*3y=9y_zRC!jx%8R-^C73qb2a6Eha2zaRs?YYpB1ZS@I9P%>
z#d8Xq;ZUr*3XXS`7<F?B3jpF!p9#6VC`R3!BFu1tI_|2u1qaSrvEnw|RHwUaZeh7C
z;_}Sgf+J|XKI-NcVTW6_=aG$MK~Y&u$Mpc!Z=MTy12;TCkJJNnVPQ{9h(a*zC+`Vj
z#=^qR!8%fnTwU0?Tu{WYbAq~hfL^U_WO^_ksjzTOVP9W?s0)VFU4@}E9P^;M7`v#j
zLwg|Vf?@qch16YCgp;y*)TVL~mll;3b`ht_hNT`briP2S%rBx4ufy>oimATLFQS;1
zm-$76DZaMgWOjK`h}YrhbusF$^@}JD^^cEHUyQnI3r=U(kb<#%d0`I)A?o0!I$gx&
zei2oUy5&V9J`}{LTV8~RLQn@@=l3<mdicU|^otR{uE^tkEe`d=echur4aeP3RBkfI
zO_S+26#TRzQ>O*T-RO~4h;BGKPE7S1J<^KNePfKYJ!;d@eM?cf&2&$f?pq3e&yeov
zLHDgi_0-^1A#Q-98^pAAYhg2CG2*utEpc)ormb5Gc4I5R%%H8?i^^}Ttr=?Tb{_yU
zsLalc!lqF|+Ja+SV%l2iS5S=j%HsHwf^A~jT3OgM3Z{5f!5Op~5JJ?!O?4U&tGcO^
zHLHr_<2r}xqi$8fuc`6`%z#*3ST-g^9FF;q81dD`XJYmxMtpT)*%u7n;iFrKI2<pM
z81XxNbc;iM%LQSKUsLei8S9Kb7XUXqqhC_j_;6Hp)U7Fag~jWmZcV|CNb3yM*LuXG
zx@N3!Q=PK2wcXSyJ6l^cVn|bc)U8#-YmdI6GwT@Lz5f?yn6UR%J74>=OfzT*$Le;S
z-@os`b{#LJzYS?0I*hkhTiW~e8``&@CV3PLY47Ut3KtCE#NM*FX_7KN+K6`yCMe@u
z=XZ=4lh*l@5M~y<zT4H;EEsO8(=2#>x2vyBH|x7yeeJqg-|gzN?Ph~N{Ls$!B5_ll
z&SKb5)SIJ08*w%ipNS7c)kob1e;C5dd^Z++{J}0yjykxhPMa?`793sW<*3_Ou+!8T
zbsG!zYuM#vd(Nh!`gJcZPzN{FX}`{<qTU=0+OV^!IPtV*ebj9#PXAiCOJ{PI{<f&x
zYj^2P-50+tY|1~A+pJN$+Xu1`-EbVpVyfTm16hpjyA`Ij!Ut2lnd+=}{gC0nt3l`S
zT?$T7;0@$32D&aBFr?+Yz84H0+PCF`zQfM%AA2E5e2i!u0pg&_(ljwGZC0B0-PjU0
z>^*Aftd@UmzjVMrUPAhRTMI3Giy_NU<fs=`8ruhTwQ!(Wrw)H<Hmzunt~5A|rqqjj
z3SJP`^$^qaJuyS<QJaMW?<*<~ngeIa&ig!BnH3y(zdKNf1L5dEG1c#P2a3^szdz?-
ziXZUoQ;2DB^olr?TlOhN`~lBCXJguyqVlMjHd~dq6ucRwaWp%aw$)7&Vj3Jx6H|Sw
zn<hs0RyPf%c$-HRA;S=kUKFElo8NQdP~Y+>G3vG{s+=3G;Q~Ia3;5l?Z~^-d=+~b;
z_NQ^QHUDdlp8v@8q$OQXRLAQn#*&BqdWx~+VbAzs@R7n+D}{)|G4&NA{z#F=WiD~3
zA66%O)aKyx$BW9-=JPq~_2Werw^PjtKHu&>7vdy1`dm!)?e23iy0^Q}VTzw{p9}Fh
z9DOcE-4pI}aj0)T7o+Y8_c@HupZZVmxisT6R7anSvE(WDxfn~H@_T45PJ6bfJa0~$
zE3=<1cu!9Qb#8Fl4tJW6Uc%97Vyf?Or-{+M!<`0G{9M7W>$-h~m<GptNF2)ZI13Xa
z{#?Ni?8;*1VcO23@{*Z0PnCBTSzPFt7fgH6O%q}o98D8b{Y5uTjP4hsX+3K5(fvwM
zdDV2!m+n`*+w+6&UH(uLa<SofvBk8t%P+PV@m>B<6Vui%f2hF}?{-s#xB-rC5Qp+S
zF1m;j-|eO@z|_}^${sUyfhxc5kBJ4e#XDQBTZn0Jbc2}cZ@3%8=zc@GKg|VRaD=vW
zy;)S>Eqa7&q(30=W?`$62!L-Dyq=&-D8zO+x<VYv?FlMI|6Be5h8gE?7aVV6;>zaW
zraGyAyRh3t)e(Q&r+6^<PQiXs6IVcho2@G#yi?Shy;VSXr?B<bg?R4$qH@4Iw@{|O
zU)VXi3xntO7946R-9k)*qb@Pk_ZGe4s-hU(dkYS-)U5$iywAsokTC*B)5NIT=c$D_
z)ITnILX5h7K1N_1wcn@hLd4-XM#PBkFKpT_Mtr|d+pngl9~PB^*3+xi)`vcExjOXp
zBY%_$@gf{`i>dyRFQkak{ZV|B^{l}Zf9$3SF%6DA6^C-m$;60%EYq|weN-bkTvUeF
z<GflMf)5vVlJ`*>yPs&)1dsNFC<MbV#zH*uNfFO%1}Xeg5#LA<MGP<83#t33f>#g}
zIIh7PBkPs%w8=CZr0&SN{eo~!@Wv><wi>Rx5O2WI8)B-Ds$04vraPnRwkicvJi42>
zZV0$3uGU6(6PGtecN53bF?IXV32lnja8q3B$JFgdCzT^Urfxqv!Qj|>HO{_;j5;`8
z3o+MbY~5~0G3v(FkBhT!agev!H;nkWdNt<1Ld4<td!88aadrDWPmK7udiXh{M{N;)
zo=~q$Ha{;?&nMLF_v}T%&lBBILV60v=aQJ}6YG}SiP1gL9R*W7sm|cg?I}bYZi=h5
zNp)VR_j1H1)x(M3J!*?FZEC$T%S>CW%2VsMFu6FGHm%M(pOO`#8;-igRG(H4?`p?#
zbWf|>hC<3Io?frUcr8R6Zi=h5>2=l(OudG{^m<q%@2Tb(0yEs{Ld4;wxYW;(A5C1>
zd`5J75C>=0ZBB!@h5#IgfS7AI(}#c<bu;T6KxyhU1ZLLRd8>P6367dmuPii2Es^PS
z>J}rH1V_zvM+q?%j;4yKKGz*3M)zEI6io5Fx~)wM5r>=NYHgnGOqr%~#OKv*Z5qZ=
z^S!4+dJ4y$is|Wm@2MDd^S!5H)Xk4Q?J4!(g1W7Y3b6)`*`*lq1$DMXn>BLOg1W7Y
zF2zyT)GN!(QA=g|HM+)n8Y~TtTI4+yVj3JLE@G-Ls&fvBbc@lw$a@M?yttdVLM+@A
zS8I#AiOW%oyNTndB|ae0rV$0lpdv<mNu4t~taW)}i4RE1!KK|=mt)|jxE!;z&d~`b
zF2^j5t@o%c!!gV2mFvwh%Vg^EdKRb5%YtLBtJ_Mske<OY`iiN3UA<R~Kw@-XR}U-Y
jJ<%=8SNOdmL>!Ke5r^_m#d}4J_zLco^OEp2oiqL~f+S|(

literal 0
HcmV?d00001

diff --git a/datafusion/proto/src/datafusion.rs b/datafusion/proto/src/datafusion.rs
new file mode 100644
index 0000000000000..ae5dfe14b521d
--- /dev/null
+++ b/datafusion/proto/src/datafusion.rs
@@ -0,0 +1,2864 @@
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ColumnRelation {
+    #[prost(string, tag = "1")]
+    pub relation: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Column {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub relation: ::core::option::Option<ColumnRelation>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DfField {
+    #[prost(message, optional, tag = "1")]
+    pub field: ::core::option::Option<Field>,
+    #[prost(message, optional, tag = "2")]
+    pub qualifier: ::core::option::Option<ColumnRelation>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DfSchema {
+    #[prost(message, repeated, tag = "1")]
+    pub columns: ::prost::alloc::vec::Vec<DfField>,
+    #[prost(map = "string, string", tag = "2")]
+    pub metadata: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost::alloc::string::String,
+    >,
+}
+/// logical plan
+/// LogicalPlan is a nested type
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LogicalPlanNode {
+    #[prost(
+        oneof = "logical_plan_node::LogicalPlanType",
+        tags = "1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27"
+    )]
+    pub logical_plan_type: ::core::option::Option<logical_plan_node::LogicalPlanType>,
+}
+/// Nested message and enum types in `LogicalPlanNode`.
+pub mod logical_plan_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum LogicalPlanType {
+        #[prost(message, tag = "1")]
+        ListingScan(super::ListingTableScanNode),
+        #[prost(message, tag = "3")]
+        Projection(::prost::alloc::boxed::Box<super::ProjectionNode>),
+        #[prost(message, tag = "4")]
+        Selection(::prost::alloc::boxed::Box<super::SelectionNode>),
+        #[prost(message, tag = "5")]
+        Limit(::prost::alloc::boxed::Box<super::LimitNode>),
+        #[prost(message, tag = "6")]
+        Aggregate(::prost::alloc::boxed::Box<super::AggregateNode>),
+        #[prost(message, tag = "7")]
+        Join(::prost::alloc::boxed::Box<super::JoinNode>),
+        #[prost(message, tag = "8")]
+        Sort(::prost::alloc::boxed::Box<super::SortNode>),
+        #[prost(message, tag = "9")]
+        Repartition(::prost::alloc::boxed::Box<super::RepartitionNode>),
+        #[prost(message, tag = "10")]
+        EmptyRelation(super::EmptyRelationNode),
+        #[prost(message, tag = "11")]
+        CreateExternalTable(super::CreateExternalTableNode),
+        #[prost(message, tag = "12")]
+        Explain(::prost::alloc::boxed::Box<super::ExplainNode>),
+        #[prost(message, tag = "13")]
+        Window(::prost::alloc::boxed::Box<super::WindowNode>),
+        #[prost(message, tag = "14")]
+        Analyze(::prost::alloc::boxed::Box<super::AnalyzeNode>),
+        #[prost(message, tag = "15")]
+        CrossJoin(::prost::alloc::boxed::Box<super::CrossJoinNode>),
+        #[prost(message, tag = "16")]
+        Values(super::ValuesNode),
+        #[prost(message, tag = "17")]
+        Extension(super::LogicalExtensionNode),
+        #[prost(message, tag = "18")]
+        CreateCatalogSchema(super::CreateCatalogSchemaNode),
+        #[prost(message, tag = "19")]
+        Union(super::UnionNode),
+        #[prost(message, tag = "20")]
+        CreateCatalog(super::CreateCatalogNode),
+        #[prost(message, tag = "21")]
+        SubqueryAlias(::prost::alloc::boxed::Box<super::SubqueryAliasNode>),
+        #[prost(message, tag = "22")]
+        CreateView(::prost::alloc::boxed::Box<super::CreateViewNode>),
+        #[prost(message, tag = "23")]
+        Distinct(::prost::alloc::boxed::Box<super::DistinctNode>),
+        #[prost(message, tag = "24")]
+        ViewScan(::prost::alloc::boxed::Box<super::ViewTableScanNode>),
+        #[prost(message, tag = "25")]
+        CustomScan(super::CustomTableScanNode),
+        #[prost(message, tag = "26")]
+        Prepare(::prost::alloc::boxed::Box<super::PrepareNode>),
+        #[prost(message, tag = "27")]
+        DropView(super::DropViewNode),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LogicalExtensionNode {
+    #[prost(bytes = "vec", tag = "1")]
+    pub node: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, repeated, tag = "2")]
+    pub inputs: ::prost::alloc::vec::Vec<LogicalPlanNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ProjectionColumns {
+    #[prost(string, repeated, tag = "1")]
+    pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CsvFormat {
+    #[prost(bool, tag = "1")]
+    pub has_header: bool,
+    #[prost(string, tag = "2")]
+    pub delimiter: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ParquetFormat {}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AvroFormat {}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LogicalExprNodeCollection {
+    #[prost(message, repeated, tag = "1")]
+    pub logical_expr_nodes: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ListingTableScanNode {
+    #[prost(message, optional, tag = "14")]
+    pub table_name: ::core::option::Option<OwnedTableReference>,
+    #[prost(string, repeated, tag = "2")]
+    pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(string, tag = "3")]
+    pub file_extension: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "4")]
+    pub projection: ::core::option::Option<ProjectionColumns>,
+    #[prost(message, optional, tag = "5")]
+    pub schema: ::core::option::Option<Schema>,
+    #[prost(message, repeated, tag = "6")]
+    pub filters: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(string, repeated, tag = "7")]
+    pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(bool, tag = "8")]
+    pub collect_stat: bool,
+    #[prost(uint32, tag = "9")]
+    pub target_partitions: u32,
+    #[prost(message, repeated, tag = "13")]
+    pub file_sort_order: ::prost::alloc::vec::Vec<LogicalExprNodeCollection>,
+    #[prost(oneof = "listing_table_scan_node::FileFormatType", tags = "10, 11, 12")]
+    pub file_format_type: ::core::option::Option<
+        listing_table_scan_node::FileFormatType,
+    >,
+}
+/// Nested message and enum types in `ListingTableScanNode`.
+pub mod listing_table_scan_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum FileFormatType {
+        #[prost(message, tag = "10")]
+        Csv(super::CsvFormat),
+        #[prost(message, tag = "11")]
+        Parquet(super::ParquetFormat),
+        #[prost(message, tag = "12")]
+        Avro(super::AvroFormat),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ViewTableScanNode {
+    #[prost(message, optional, tag = "6")]
+    pub table_name: ::core::option::Option<OwnedTableReference>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, optional, tag = "3")]
+    pub schema: ::core::option::Option<Schema>,
+    #[prost(message, optional, tag = "4")]
+    pub projection: ::core::option::Option<ProjectionColumns>,
+    #[prost(string, tag = "5")]
+    pub definition: ::prost::alloc::string::String,
+}
+/// Logical Plan to Scan a CustomTableProvider registered at runtime
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CustomTableScanNode {
+    #[prost(message, optional, tag = "6")]
+    pub table_name: ::core::option::Option<OwnedTableReference>,
+    #[prost(message, optional, tag = "2")]
+    pub projection: ::core::option::Option<ProjectionColumns>,
+    #[prost(message, optional, tag = "3")]
+    pub schema: ::core::option::Option<Schema>,
+    #[prost(message, repeated, tag = "4")]
+    pub filters: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(bytes = "vec", tag = "5")]
+    pub custom_table_data: ::prost::alloc::vec::Vec<u8>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ProjectionNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(oneof = "projection_node::OptionalAlias", tags = "3")]
+    pub optional_alias: ::core::option::Option<projection_node::OptionalAlias>,
+}
+/// Nested message and enum types in `ProjectionNode`.
+pub mod projection_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum OptionalAlias {
+        #[prost(string, tag = "3")]
+        Alias(::prost::alloc::string::String),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SelectionNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub expr: ::core::option::Option<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SortNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    /// Maximum number of highest/lowest rows to fetch; negative means no limit
+    #[prost(int64, tag = "3")]
+    pub fetch: i64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RepartitionNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(oneof = "repartition_node::PartitionMethod", tags = "2, 3")]
+    pub partition_method: ::core::option::Option<repartition_node::PartitionMethod>,
+}
+/// Nested message and enum types in `RepartitionNode`.
+pub mod repartition_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum PartitionMethod {
+        #[prost(uint64, tag = "2")]
+        RoundRobin(u64),
+        #[prost(message, tag = "3")]
+        Hash(super::HashRepartition),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HashRepartition {
+    #[prost(message, repeated, tag = "1")]
+    pub hash_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(uint64, tag = "2")]
+    pub partition_count: u64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct EmptyRelationNode {
+    #[prost(bool, tag = "1")]
+    pub produce_one_row: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CreateExternalTableNode {
+    #[prost(message, optional, tag = "12")]
+    pub name: ::core::option::Option<OwnedTableReference>,
+    #[prost(string, tag = "2")]
+    pub location: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub file_type: ::prost::alloc::string::String,
+    #[prost(bool, tag = "4")]
+    pub has_header: bool,
+    #[prost(message, optional, tag = "5")]
+    pub schema: ::core::option::Option<DfSchema>,
+    #[prost(string, repeated, tag = "6")]
+    pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(bool, tag = "7")]
+    pub if_not_exists: bool,
+    #[prost(string, tag = "8")]
+    pub delimiter: ::prost::alloc::string::String,
+    #[prost(string, tag = "9")]
+    pub definition: ::prost::alloc::string::String,
+    #[prost(string, tag = "10")]
+    pub file_compression_type: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "13")]
+    pub order_exprs: ::prost::alloc::vec::Vec<LogicalExprNodeCollection>,
+    #[prost(bool, tag = "14")]
+    pub unbounded: bool,
+    #[prost(map = "string, string", tag = "11")]
+    pub options: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost::alloc::string::String,
+    >,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PrepareNode {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "2")]
+    pub data_types: ::prost::alloc::vec::Vec<ArrowType>,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CreateCatalogSchemaNode {
+    #[prost(string, tag = "1")]
+    pub schema_name: ::prost::alloc::string::String,
+    #[prost(bool, tag = "2")]
+    pub if_not_exists: bool,
+    #[prost(message, optional, tag = "3")]
+    pub schema: ::core::option::Option<DfSchema>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CreateCatalogNode {
+    #[prost(string, tag = "1")]
+    pub catalog_name: ::prost::alloc::string::String,
+    #[prost(bool, tag = "2")]
+    pub if_not_exists: bool,
+    #[prost(message, optional, tag = "3")]
+    pub schema: ::core::option::Option<DfSchema>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DropViewNode {
+    #[prost(message, optional, tag = "1")]
+    pub name: ::core::option::Option<OwnedTableReference>,
+    #[prost(bool, tag = "2")]
+    pub if_exists: bool,
+    #[prost(message, optional, tag = "3")]
+    pub schema: ::core::option::Option<DfSchema>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CreateViewNode {
+    #[prost(message, optional, tag = "5")]
+    pub name: ::core::option::Option<OwnedTableReference>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(bool, tag = "3")]
+    pub or_replace: bool,
+    #[prost(string, tag = "4")]
+    pub definition: ::prost::alloc::string::String,
+}
+/// a node containing data for defining values list. unlike in SQL where it's two dimensional, here
+/// the list is flattened, and with the field n_cols it can be parsed and partitioned into rows
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ValuesNode {
+    #[prost(uint64, tag = "1")]
+    pub n_cols: u64,
+    #[prost(message, repeated, tag = "2")]
+    pub values_list: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AnalyzeNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(bool, tag = "2")]
+    pub verbose: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ExplainNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(bool, tag = "2")]
+    pub verbose: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AggregateNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub group_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(message, repeated, tag = "3")]
+    pub aggr_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct WindowNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub window_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct JoinNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub left: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub right: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(enumeration = "JoinType", tag = "3")]
+    pub join_type: i32,
+    #[prost(enumeration = "JoinConstraint", tag = "4")]
+    pub join_constraint: i32,
+    #[prost(message, repeated, tag = "5")]
+    pub left_join_key: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(message, repeated, tag = "6")]
+    pub right_join_key: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(bool, tag = "7")]
+    pub null_equals_null: bool,
+    #[prost(message, optional, tag = "8")]
+    pub filter: ::core::option::Option<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DistinctNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct UnionNode {
+    #[prost(message, repeated, tag = "1")]
+    pub inputs: ::prost::alloc::vec::Vec<LogicalPlanNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CrossJoinNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub left: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub right: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LimitNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    /// The number of rows to skip before fetch; non-positive means don't skip any
+    #[prost(int64, tag = "2")]
+    pub skip: i64,
+    /// Maximum number of rows to fetch; negative means no limit
+    #[prost(int64, tag = "3")]
+    pub fetch: i64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SelectionExecNode {
+    #[prost(message, optional, tag = "1")]
+    pub expr: ::core::option::Option<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SubqueryAliasNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
+    #[prost(message, optional, tag = "3")]
+    pub alias: ::core::option::Option<OwnedTableReference>,
+}
+/// logical expressions
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LogicalExprNode {
+    #[prost(
+        oneof = "logical_expr_node::ExprType",
+        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34"
+    )]
+    pub expr_type: ::core::option::Option<logical_expr_node::ExprType>,
+}
+/// Nested message and enum types in `LogicalExprNode`.
+pub mod logical_expr_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum ExprType {
+        /// column references
+        #[prost(message, tag = "1")]
+        Column(super::Column),
+        /// alias
+        #[prost(message, tag = "2")]
+        Alias(::prost::alloc::boxed::Box<super::AliasNode>),
+        #[prost(message, tag = "3")]
+        Literal(super::ScalarValue),
+        /// binary expressions
+        #[prost(message, tag = "4")]
+        BinaryExpr(super::BinaryExprNode),
+        /// aggregate expressions
+        #[prost(message, tag = "5")]
+        AggregateExpr(::prost::alloc::boxed::Box<super::AggregateExprNode>),
+        /// null checks
+        #[prost(message, tag = "6")]
+        IsNullExpr(::prost::alloc::boxed::Box<super::IsNull>),
+        #[prost(message, tag = "7")]
+        IsNotNullExpr(::prost::alloc::boxed::Box<super::IsNotNull>),
+        #[prost(message, tag = "8")]
+        NotExpr(::prost::alloc::boxed::Box<super::Not>),
+        #[prost(message, tag = "9")]
+        Between(::prost::alloc::boxed::Box<super::BetweenNode>),
+        #[prost(message, tag = "10")]
+        Case(::prost::alloc::boxed::Box<super::CaseNode>),
+        #[prost(message, tag = "11")]
+        Cast(::prost::alloc::boxed::Box<super::CastNode>),
+        #[prost(message, tag = "12")]
+        Sort(::prost::alloc::boxed::Box<super::SortExprNode>),
+        #[prost(message, tag = "13")]
+        Negative(::prost::alloc::boxed::Box<super::NegativeNode>),
+        #[prost(message, tag = "14")]
+        InList(::prost::alloc::boxed::Box<super::InListNode>),
+        #[prost(bool, tag = "15")]
+        Wildcard(bool),
+        #[prost(message, tag = "16")]
+        ScalarFunction(super::ScalarFunctionNode),
+        #[prost(message, tag = "17")]
+        TryCast(::prost::alloc::boxed::Box<super::TryCastNode>),
+        /// window expressions
+        #[prost(message, tag = "18")]
+        WindowExpr(::prost::alloc::boxed::Box<super::WindowExprNode>),
+        /// AggregateUDF expressions
+        #[prost(message, tag = "19")]
+        AggregateUdfExpr(::prost::alloc::boxed::Box<super::AggregateUdfExprNode>),
+        /// Scalar UDF expressions
+        #[prost(message, tag = "20")]
+        ScalarUdfExpr(super::ScalarUdfExprNode),
+        #[prost(message, tag = "21")]
+        GetIndexedField(::prost::alloc::boxed::Box<super::GetIndexedField>),
+        #[prost(message, tag = "22")]
+        GroupingSet(super::GroupingSetNode),
+        #[prost(message, tag = "23")]
+        Cube(super::CubeNode),
+        #[prost(message, tag = "24")]
+        Rollup(super::RollupNode),
+        #[prost(message, tag = "25")]
+        IsTrue(::prost::alloc::boxed::Box<super::IsTrue>),
+        #[prost(message, tag = "26")]
+        IsFalse(::prost::alloc::boxed::Box<super::IsFalse>),
+        #[prost(message, tag = "27")]
+        IsUnknown(::prost::alloc::boxed::Box<super::IsUnknown>),
+        #[prost(message, tag = "28")]
+        IsNotTrue(::prost::alloc::boxed::Box<super::IsNotTrue>),
+        #[prost(message, tag = "29")]
+        IsNotFalse(::prost::alloc::boxed::Box<super::IsNotFalse>),
+        #[prost(message, tag = "30")]
+        IsNotUnknown(::prost::alloc::boxed::Box<super::IsNotUnknown>),
+        #[prost(message, tag = "31")]
+        Like(::prost::alloc::boxed::Box<super::LikeNode>),
+        #[prost(message, tag = "32")]
+        Ilike(::prost::alloc::boxed::Box<super::ILikeNode>),
+        #[prost(message, tag = "33")]
+        SimilarTo(::prost::alloc::boxed::Box<super::SimilarToNode>),
+        #[prost(message, tag = "34")]
+        Placeholder(super::PlaceholderNode),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlaceholderNode {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(message, optional, tag = "2")]
+    pub data_type: ::core::option::Option<ArrowType>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LogicalExprList {
+    #[prost(message, repeated, tag = "1")]
+    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GroupingSetNode {
+    #[prost(message, repeated, tag = "1")]
+    pub expr: ::prost::alloc::vec::Vec<LogicalExprList>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CubeNode {
+    #[prost(message, repeated, tag = "1")]
+    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RollupNode {
+    #[prost(message, repeated, tag = "1")]
+    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetIndexedField {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub key: ::core::option::Option<ScalarValue>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsNull {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsNotNull {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsTrue {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsFalse {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsUnknown {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsNotTrue {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsNotFalse {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IsNotUnknown {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Not {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AliasNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(string, tag = "2")]
+    pub alias: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct BinaryExprNode {
+    /// Represents the operands from the left inner most expression
+    /// to the right outer most expression where each of them are chained
+    /// with the operator 'op'.
+    #[prost(message, repeated, tag = "1")]
+    pub operands: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(string, tag = "3")]
+    pub op: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct NegativeNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct InListNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub list: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(bool, tag = "3")]
+    pub negated: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarFunctionNode {
+    #[prost(enumeration = "ScalarFunction", tag = "1")]
+    pub fun: i32,
+    #[prost(message, repeated, tag = "2")]
+    pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AggregateExprNode {
+    #[prost(enumeration = "AggregateFunction", tag = "1")]
+    pub aggr_function: i32,
+    #[prost(message, repeated, tag = "2")]
+    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(bool, tag = "3")]
+    pub distinct: bool,
+    #[prost(message, optional, boxed, tag = "4")]
+    pub filter: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, repeated, tag = "5")]
+    pub order_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AggregateUdfExprNode {
+    #[prost(string, tag = "1")]
+    pub fun_name: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "2")]
+    pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub filter: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, repeated, tag = "4")]
+    pub order_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarUdfExprNode {
+    #[prost(string, tag = "1")]
+    pub fun_name: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "2")]
+    pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct WindowExprNode {
+    #[prost(message, optional, boxed, tag = "4")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, repeated, tag = "5")]
+    pub partition_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    #[prost(message, repeated, tag = "6")]
+    pub order_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
+    /// repeated LogicalExprNode filter = 7;
+    #[prost(message, optional, tag = "8")]
+    pub window_frame: ::core::option::Option<WindowFrame>,
+    #[prost(oneof = "window_expr_node::WindowFunction", tags = "1, 2")]
+    pub window_function: ::core::option::Option<window_expr_node::WindowFunction>,
+}
+/// Nested message and enum types in `WindowExprNode`.
+pub mod window_expr_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum WindowFunction {
+        #[prost(enumeration = "super::AggregateFunction", tag = "1")]
+        AggrFunction(i32),
+        /// udaf = 3
+        #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")]
+        BuiltInFunction(i32),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct BetweenNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(bool, tag = "2")]
+    pub negated: bool,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub low: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, optional, boxed, tag = "4")]
+    pub high: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LikeNode {
+    #[prost(bool, tag = "1")]
+    pub negated: bool,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(string, tag = "4")]
+    pub escape_char: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ILikeNode {
+    #[prost(bool, tag = "1")]
+    pub negated: bool,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(string, tag = "4")]
+    pub escape_char: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SimilarToNode {
+    #[prost(bool, tag = "1")]
+    pub negated: bool,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(string, tag = "4")]
+    pub escape_char: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CaseNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub when_then_expr: ::prost::alloc::vec::Vec<WhenThen>,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct WhenThen {
+    #[prost(message, optional, tag = "1")]
+    pub when_expr: ::core::option::Option<LogicalExprNode>,
+    #[prost(message, optional, tag = "2")]
+    pub then_expr: ::core::option::Option<LogicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CastNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub arrow_type: ::core::option::Option<ArrowType>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TryCastNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub arrow_type: ::core::option::Option<ArrowType>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SortExprNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
+    #[prost(bool, tag = "2")]
+    pub asc: bool,
+    #[prost(bool, tag = "3")]
+    pub nulls_first: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct WindowFrame {
+    #[prost(enumeration = "WindowFrameUnits", tag = "1")]
+    pub window_frame_units: i32,
+    #[prost(message, optional, tag = "2")]
+    pub start_bound: ::core::option::Option<WindowFrameBound>,
+    /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see <https://github.com/tokio-rs/prost/issues/430> and <https://github.com/tokio-rs/prost/pull/455>)
+    /// this syntax is ugly but is binary compatible with the "optional" keyword (see <https://stackoverflow.com/questions/42622015/how-to-define-an-optional-field-in-protobuf-3>)
+    #[prost(oneof = "window_frame::EndBound", tags = "3")]
+    pub end_bound: ::core::option::Option<window_frame::EndBound>,
+}
+/// Nested message and enum types in `WindowFrame`.
+pub mod window_frame {
+    /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see <https://github.com/tokio-rs/prost/issues/430> and <https://github.com/tokio-rs/prost/pull/455>)
+    /// this syntax is ugly but is binary compatible with the "optional" keyword (see <https://stackoverflow.com/questions/42622015/how-to-define-an-optional-field-in-protobuf-3>)
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum EndBound {
+        #[prost(message, tag = "3")]
+        Bound(super::WindowFrameBound),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct WindowFrameBound {
+    #[prost(enumeration = "WindowFrameBoundType", tag = "1")]
+    pub window_frame_bound_type: i32,
+    #[prost(message, optional, tag = "2")]
+    pub bound_value: ::core::option::Option<ScalarValue>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Schema {
+    #[prost(message, repeated, tag = "1")]
+    pub columns: ::prost::alloc::vec::Vec<Field>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Field {
+    /// name of the field
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub arrow_type: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
+    #[prost(bool, tag = "3")]
+    pub nullable: bool,
+    /// for complex data types like structs, unions
+    #[prost(message, repeated, tag = "4")]
+    pub children: ::prost::alloc::vec::Vec<Field>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FixedSizeBinary {
+    #[prost(int32, tag = "1")]
+    pub length: i32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Timestamp {
+    #[prost(enumeration = "TimeUnit", tag = "1")]
+    pub time_unit: i32,
+    #[prost(string, tag = "2")]
+    pub timezone: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Decimal {
+    #[prost(uint32, tag = "3")]
+    pub precision: u32,
+    #[prost(int32, tag = "4")]
+    pub scale: i32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct List {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FixedSizeList {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
+    #[prost(int32, tag = "2")]
+    pub list_size: i32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Dictionary {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub key: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub value: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Struct {
+    #[prost(message, repeated, tag = "1")]
+    pub sub_field_types: ::prost::alloc::vec::Vec<Field>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Map {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
+    #[prost(bool, tag = "2")]
+    pub keys_sorted: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Union {
+    #[prost(message, repeated, tag = "1")]
+    pub union_types: ::prost::alloc::vec::Vec<Field>,
+    #[prost(enumeration = "UnionMode", tag = "2")]
+    pub union_mode: i32,
+    #[prost(int32, repeated, tag = "3")]
+    pub type_ids: ::prost::alloc::vec::Vec<i32>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarListValue {
+    /// encode null explicitly to distinguish a list with a null value
+    /// from a list with no values)
+    #[prost(bool, tag = "3")]
+    pub is_null: bool,
+    #[prost(message, optional, tag = "1")]
+    pub field: ::core::option::Option<Field>,
+    #[prost(message, repeated, tag = "2")]
+    pub values: ::prost::alloc::vec::Vec<ScalarValue>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarTime32Value {
+    #[prost(oneof = "scalar_time32_value::Value", tags = "1, 2")]
+    pub value: ::core::option::Option<scalar_time32_value::Value>,
+}
+/// Nested message and enum types in `ScalarTime32Value`.
+pub mod scalar_time32_value {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Value {
+        #[prost(int32, tag = "1")]
+        Time32SecondValue(i32),
+        #[prost(int32, tag = "2")]
+        Time32MillisecondValue(i32),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarTime64Value {
+    #[prost(oneof = "scalar_time64_value::Value", tags = "1, 2")]
+    pub value: ::core::option::Option<scalar_time64_value::Value>,
+}
+/// Nested message and enum types in `ScalarTime64Value`.
+pub mod scalar_time64_value {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Value {
+        #[prost(int64, tag = "1")]
+        Time64MicrosecondValue(i64),
+        #[prost(int64, tag = "2")]
+        Time64NanosecondValue(i64),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarTimestampValue {
+    #[prost(string, tag = "5")]
+    pub timezone: ::prost::alloc::string::String,
+    #[prost(oneof = "scalar_timestamp_value::Value", tags = "1, 2, 3, 4")]
+    pub value: ::core::option::Option<scalar_timestamp_value::Value>,
+}
+/// Nested message and enum types in `ScalarTimestampValue`.
+pub mod scalar_timestamp_value {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Value {
+        #[prost(int64, tag = "1")]
+        TimeMicrosecondValue(i64),
+        #[prost(int64, tag = "2")]
+        TimeNanosecondValue(i64),
+        #[prost(int64, tag = "3")]
+        TimeSecondValue(i64),
+        #[prost(int64, tag = "4")]
+        TimeMillisecondValue(i64),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarDictionaryValue {
+    #[prost(message, optional, tag = "1")]
+    pub index_type: ::core::option::Option<ArrowType>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub value: ::core::option::Option<::prost::alloc::boxed::Box<ScalarValue>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct IntervalMonthDayNanoValue {
+    #[prost(int32, tag = "1")]
+    pub months: i32,
+    #[prost(int32, tag = "2")]
+    pub days: i32,
+    #[prost(int64, tag = "3")]
+    pub nanos: i64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct StructValue {
+    /// Note that a null struct value must have one or more fields, so we
+    /// encode a null StructValue as one witth an empty field_values
+    /// list.
+    #[prost(message, repeated, tag = "2")]
+    pub field_values: ::prost::alloc::vec::Vec<ScalarValue>,
+    #[prost(message, repeated, tag = "3")]
+    pub fields: ::prost::alloc::vec::Vec<Field>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarFixedSizeBinary {
+    #[prost(bytes = "vec", tag = "1")]
+    pub values: ::prost::alloc::vec::Vec<u8>,
+    #[prost(int32, tag = "2")]
+    pub length: i32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarValue {
+    #[prost(
+        oneof = "scalar_value::Value",
+        tags = "33, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 20, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34"
+    )]
+    pub value: ::core::option::Option<scalar_value::Value>,
+}
+/// Nested message and enum types in `ScalarValue`.
+pub mod scalar_value {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Value {
+        /// was PrimitiveScalarType null_value = 19;
+        /// Null value of any type
+        #[prost(message, tag = "33")]
+        NullValue(super::ArrowType),
+        #[prost(bool, tag = "1")]
+        BoolValue(bool),
+        #[prost(string, tag = "2")]
+        Utf8Value(::prost::alloc::string::String),
+        #[prost(string, tag = "3")]
+        LargeUtf8Value(::prost::alloc::string::String),
+        #[prost(int32, tag = "4")]
+        Int8Value(i32),
+        #[prost(int32, tag = "5")]
+        Int16Value(i32),
+        #[prost(int32, tag = "6")]
+        Int32Value(i32),
+        #[prost(int64, tag = "7")]
+        Int64Value(i64),
+        #[prost(uint32, tag = "8")]
+        Uint8Value(u32),
+        #[prost(uint32, tag = "9")]
+        Uint16Value(u32),
+        #[prost(uint32, tag = "10")]
+        Uint32Value(u32),
+        #[prost(uint64, tag = "11")]
+        Uint64Value(u64),
+        #[prost(float, tag = "12")]
+        Float32Value(f32),
+        #[prost(double, tag = "13")]
+        Float64Value(f64),
+        /// Literal Date32 value always has a unit of day
+        #[prost(int32, tag = "14")]
+        Date32Value(i32),
+        #[prost(message, tag = "15")]
+        Time32Value(super::ScalarTime32Value),
+        /// WAS: ScalarType null_list_value = 18;
+        #[prost(message, tag = "17")]
+        ListValue(super::ScalarListValue),
+        #[prost(message, tag = "20")]
+        Decimal128Value(super::Decimal128),
+        #[prost(int64, tag = "21")]
+        Date64Value(i64),
+        #[prost(int32, tag = "24")]
+        IntervalYearmonthValue(i32),
+        #[prost(int64, tag = "25")]
+        IntervalDaytimeValue(i64),
+        #[prost(message, tag = "26")]
+        TimestampValue(super::ScalarTimestampValue),
+        #[prost(message, tag = "27")]
+        DictionaryValue(::prost::alloc::boxed::Box<super::ScalarDictionaryValue>),
+        #[prost(bytes, tag = "28")]
+        BinaryValue(::prost::alloc::vec::Vec<u8>),
+        #[prost(bytes, tag = "29")]
+        LargeBinaryValue(::prost::alloc::vec::Vec<u8>),
+        #[prost(message, tag = "30")]
+        Time64Value(super::ScalarTime64Value),
+        #[prost(message, tag = "31")]
+        IntervalMonthDayNano(super::IntervalMonthDayNanoValue),
+        #[prost(message, tag = "32")]
+        StructValue(super::StructValue),
+        #[prost(message, tag = "34")]
+        FixedSizeBinaryValue(super::ScalarFixedSizeBinary),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Decimal128 {
+    #[prost(bytes = "vec", tag = "1")]
+    pub value: ::prost::alloc::vec::Vec<u8>,
+    #[prost(int64, tag = "2")]
+    pub p: i64,
+    #[prost(int64, tag = "3")]
+    pub s: i64,
+}
+/// Serialized data type
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ArrowType {
+    #[prost(
+        oneof = "arrow_type::ArrowTypeEnum",
+        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 32, 15, 16, 31, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 33"
+    )]
+    pub arrow_type_enum: ::core::option::Option<arrow_type::ArrowTypeEnum>,
+}
+/// Nested message and enum types in `ArrowType`.
+pub mod arrow_type {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum ArrowTypeEnum {
+        /// arrow::Type::NA
+        #[prost(message, tag = "1")]
+        None(super::EmptyMessage),
+        /// arrow::Type::BOOL
+        #[prost(message, tag = "2")]
+        Bool(super::EmptyMessage),
+        /// arrow::Type::UINT8
+        #[prost(message, tag = "3")]
+        Uint8(super::EmptyMessage),
+        /// arrow::Type::INT8
+        #[prost(message, tag = "4")]
+        Int8(super::EmptyMessage),
+        /// represents arrow::Type fields in src/arrow/type.h
+        #[prost(message, tag = "5")]
+        Uint16(super::EmptyMessage),
+        #[prost(message, tag = "6")]
+        Int16(super::EmptyMessage),
+        #[prost(message, tag = "7")]
+        Uint32(super::EmptyMessage),
+        #[prost(message, tag = "8")]
+        Int32(super::EmptyMessage),
+        #[prost(message, tag = "9")]
+        Uint64(super::EmptyMessage),
+        #[prost(message, tag = "10")]
+        Int64(super::EmptyMessage),
+        #[prost(message, tag = "11")]
+        Float16(super::EmptyMessage),
+        #[prost(message, tag = "12")]
+        Float32(super::EmptyMessage),
+        #[prost(message, tag = "13")]
+        Float64(super::EmptyMessage),
+        #[prost(message, tag = "14")]
+        Utf8(super::EmptyMessage),
+        #[prost(message, tag = "32")]
+        LargeUtf8(super::EmptyMessage),
+        #[prost(message, tag = "15")]
+        Binary(super::EmptyMessage),
+        #[prost(int32, tag = "16")]
+        FixedSizeBinary(i32),
+        #[prost(message, tag = "31")]
+        LargeBinary(super::EmptyMessage),
+        #[prost(message, tag = "17")]
+        Date32(super::EmptyMessage),
+        #[prost(message, tag = "18")]
+        Date64(super::EmptyMessage),
+        #[prost(enumeration = "super::TimeUnit", tag = "19")]
+        Duration(i32),
+        #[prost(message, tag = "20")]
+        Timestamp(super::Timestamp),
+        #[prost(enumeration = "super::TimeUnit", tag = "21")]
+        Time32(i32),
+        #[prost(enumeration = "super::TimeUnit", tag = "22")]
+        Time64(i32),
+        #[prost(enumeration = "super::IntervalUnit", tag = "23")]
+        Interval(i32),
+        #[prost(message, tag = "24")]
+        Decimal(super::Decimal),
+        #[prost(message, tag = "25")]
+        List(::prost::alloc::boxed::Box<super::List>),
+        #[prost(message, tag = "26")]
+        LargeList(::prost::alloc::boxed::Box<super::List>),
+        #[prost(message, tag = "27")]
+        FixedSizeList(::prost::alloc::boxed::Box<super::FixedSizeList>),
+        #[prost(message, tag = "28")]
+        Struct(super::Struct),
+        #[prost(message, tag = "29")]
+        Union(super::Union),
+        #[prost(message, tag = "30")]
+        Dictionary(::prost::alloc::boxed::Box<super::Dictionary>),
+        #[prost(message, tag = "33")]
+        Map(::prost::alloc::boxed::Box<super::Map>),
+    }
+}
+/// Useful for representing an empty enum variant in rust
+/// E.G. enum example{One, Two(i32)}
+/// maps to
+/// message example{
+///     oneof{
+///         EmptyMessage One = 1;
+///         i32 Two = 2;
+///    }
+/// }
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct EmptyMessage {}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AnalyzedLogicalPlanType {
+    #[prost(string, tag = "1")]
+    pub analyzer_name: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct OptimizedLogicalPlanType {
+    #[prost(string, tag = "1")]
+    pub optimizer_name: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct OptimizedPhysicalPlanType {
+    #[prost(string, tag = "1")]
+    pub optimizer_name: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PlanType {
+    #[prost(oneof = "plan_type::PlanTypeEnum", tags = "1, 7, 8, 2, 3, 4, 5, 6")]
+    pub plan_type_enum: ::core::option::Option<plan_type::PlanTypeEnum>,
+}
+/// Nested message and enum types in `PlanType`.
+pub mod plan_type {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum PlanTypeEnum {
+        #[prost(message, tag = "1")]
+        InitialLogicalPlan(super::EmptyMessage),
+        #[prost(message, tag = "7")]
+        AnalyzedLogicalPlan(super::AnalyzedLogicalPlanType),
+        #[prost(message, tag = "8")]
+        FinalAnalyzedLogicalPlan(super::EmptyMessage),
+        #[prost(message, tag = "2")]
+        OptimizedLogicalPlan(super::OptimizedLogicalPlanType),
+        #[prost(message, tag = "3")]
+        FinalLogicalPlan(super::EmptyMessage),
+        #[prost(message, tag = "4")]
+        InitialPhysicalPlan(super::EmptyMessage),
+        #[prost(message, tag = "5")]
+        OptimizedPhysicalPlan(super::OptimizedPhysicalPlanType),
+        #[prost(message, tag = "6")]
+        FinalPhysicalPlan(super::EmptyMessage),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct StringifiedPlan {
+    #[prost(message, optional, tag = "1")]
+    pub plan_type: ::core::option::Option<PlanType>,
+    #[prost(string, tag = "2")]
+    pub plan: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct BareTableReference {
+    #[prost(string, tag = "1")]
+    pub table: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PartialTableReference {
+    #[prost(string, tag = "1")]
+    pub schema: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FullTableReference {
+    #[prost(string, tag = "1")]
+    pub catalog: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub schema: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub table: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct OwnedTableReference {
+    #[prost(oneof = "owned_table_reference::TableReferenceEnum", tags = "1, 2, 3")]
+    pub table_reference_enum: ::core::option::Option<
+        owned_table_reference::TableReferenceEnum,
+    >,
+}
+/// Nested message and enum types in `OwnedTableReference`.
+pub mod owned_table_reference {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum TableReferenceEnum {
+        #[prost(message, tag = "1")]
+        Bare(super::BareTableReference),
+        #[prost(message, tag = "2")]
+        Partial(super::PartialTableReference),
+        #[prost(message, tag = "3")]
+        Full(super::FullTableReference),
+    }
+}
+/// PhysicalPlanNode is a nested type
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalPlanNode {
+    #[prost(
+        oneof = "physical_plan_node::PhysicalPlanType",
+        tags = "1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21"
+    )]
+    pub physical_plan_type: ::core::option::Option<physical_plan_node::PhysicalPlanType>,
+}
+/// Nested message and enum types in `PhysicalPlanNode`.
+pub mod physical_plan_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum PhysicalPlanType {
+        #[prost(message, tag = "1")]
+        ParquetScan(super::ParquetScanExecNode),
+        #[prost(message, tag = "2")]
+        CsvScan(super::CsvScanExecNode),
+        #[prost(message, tag = "3")]
+        Empty(super::EmptyExecNode),
+        #[prost(message, tag = "4")]
+        Projection(::prost::alloc::boxed::Box<super::ProjectionExecNode>),
+        #[prost(message, tag = "6")]
+        GlobalLimit(::prost::alloc::boxed::Box<super::GlobalLimitExecNode>),
+        #[prost(message, tag = "7")]
+        LocalLimit(::prost::alloc::boxed::Box<super::LocalLimitExecNode>),
+        #[prost(message, tag = "8")]
+        Aggregate(::prost::alloc::boxed::Box<super::AggregateExecNode>),
+        #[prost(message, tag = "9")]
+        HashJoin(::prost::alloc::boxed::Box<super::HashJoinExecNode>),
+        #[prost(message, tag = "10")]
+        Sort(::prost::alloc::boxed::Box<super::SortExecNode>),
+        #[prost(message, tag = "11")]
+        CoalesceBatches(::prost::alloc::boxed::Box<super::CoalesceBatchesExecNode>),
+        #[prost(message, tag = "12")]
+        Filter(::prost::alloc::boxed::Box<super::FilterExecNode>),
+        #[prost(message, tag = "13")]
+        Merge(::prost::alloc::boxed::Box<super::CoalescePartitionsExecNode>),
+        #[prost(message, tag = "14")]
+        Repartition(::prost::alloc::boxed::Box<super::RepartitionExecNode>),
+        #[prost(message, tag = "15")]
+        Window(::prost::alloc::boxed::Box<super::WindowAggExecNode>),
+        #[prost(message, tag = "16")]
+        CrossJoin(::prost::alloc::boxed::Box<super::CrossJoinExecNode>),
+        #[prost(message, tag = "17")]
+        AvroScan(super::AvroScanExecNode),
+        #[prost(message, tag = "18")]
+        Extension(super::PhysicalExtensionNode),
+        #[prost(message, tag = "19")]
+        Union(super::UnionExecNode),
+        #[prost(message, tag = "20")]
+        Explain(super::ExplainExecNode),
+        #[prost(message, tag = "21")]
+        SortPreservingMerge(
+            ::prost::alloc::boxed::Box<super::SortPreservingMergeExecNode>,
+        ),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalExtensionNode {
+    #[prost(bytes = "vec", tag = "1")]
+    pub node: ::prost::alloc::vec::Vec<u8>,
+    #[prost(message, repeated, tag = "2")]
+    pub inputs: ::prost::alloc::vec::Vec<PhysicalPlanNode>,
+}
+/// physical expressions
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalExprNode {
+    #[prost(
+        oneof = "physical_expr_node::ExprType",
+        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19"
+    )]
+    pub expr_type: ::core::option::Option<physical_expr_node::ExprType>,
+}
+/// Nested message and enum types in `PhysicalExprNode`.
+pub mod physical_expr_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum ExprType {
+        /// column references
+        #[prost(message, tag = "1")]
+        Column(super::PhysicalColumn),
+        #[prost(message, tag = "2")]
+        Literal(super::ScalarValue),
+        /// binary expressions
+        #[prost(message, tag = "3")]
+        BinaryExpr(::prost::alloc::boxed::Box<super::PhysicalBinaryExprNode>),
+        /// aggregate expressions
+        #[prost(message, tag = "4")]
+        AggregateExpr(super::PhysicalAggregateExprNode),
+        /// null checks
+        #[prost(message, tag = "5")]
+        IsNullExpr(::prost::alloc::boxed::Box<super::PhysicalIsNull>),
+        #[prost(message, tag = "6")]
+        IsNotNullExpr(::prost::alloc::boxed::Box<super::PhysicalIsNotNull>),
+        #[prost(message, tag = "7")]
+        NotExpr(::prost::alloc::boxed::Box<super::PhysicalNot>),
+        #[prost(message, tag = "8")]
+        Case(::prost::alloc::boxed::Box<super::PhysicalCaseNode>),
+        #[prost(message, tag = "9")]
+        Cast(::prost::alloc::boxed::Box<super::PhysicalCastNode>),
+        #[prost(message, tag = "10")]
+        Sort(::prost::alloc::boxed::Box<super::PhysicalSortExprNode>),
+        #[prost(message, tag = "11")]
+        Negative(::prost::alloc::boxed::Box<super::PhysicalNegativeNode>),
+        #[prost(message, tag = "12")]
+        InList(::prost::alloc::boxed::Box<super::PhysicalInListNode>),
+        #[prost(message, tag = "13")]
+        ScalarFunction(super::PhysicalScalarFunctionNode),
+        #[prost(message, tag = "14")]
+        TryCast(::prost::alloc::boxed::Box<super::PhysicalTryCastNode>),
+        /// window expressions
+        #[prost(message, tag = "15")]
+        WindowExpr(::prost::alloc::boxed::Box<super::PhysicalWindowExprNode>),
+        #[prost(message, tag = "16")]
+        ScalarUdf(super::PhysicalScalarUdfNode),
+        #[prost(message, tag = "17")]
+        DateTimeIntervalExpr(
+            ::prost::alloc::boxed::Box<super::PhysicalDateTimeIntervalExprNode>,
+        ),
+        #[prost(message, tag = "18")]
+        LikeExpr(::prost::alloc::boxed::Box<super::PhysicalLikeExprNode>),
+        #[prost(message, tag = "19")]
+        GetIndexedFieldExpr(
+            ::prost::alloc::boxed::Box<super::PhysicalGetIndexedFieldExprNode>,
+        ),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalScalarUdfNode {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "2")]
+    pub args: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(message, optional, tag = "4")]
+    pub return_type: ::core::option::Option<ArrowType>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalAggregateExprNode {
+    #[prost(message, repeated, tag = "2")]
+    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(message, repeated, tag = "5")]
+    pub ordering_req: ::prost::alloc::vec::Vec<PhysicalSortExprNode>,
+    #[prost(bool, tag = "3")]
+    pub distinct: bool,
+    #[prost(oneof = "physical_aggregate_expr_node::AggregateFunction", tags = "1, 4")]
+    pub aggregate_function: ::core::option::Option<
+        physical_aggregate_expr_node::AggregateFunction,
+    >,
+}
+/// Nested message and enum types in `PhysicalAggregateExprNode`.
+pub mod physical_aggregate_expr_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum AggregateFunction {
+        #[prost(enumeration = "super::AggregateFunction", tag = "1")]
+        AggrFunction(i32),
+        #[prost(string, tag = "4")]
+        UserDefinedAggrFunction(::prost::alloc::string::String),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalWindowExprNode {
+    #[prost(message, optional, boxed, tag = "4")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(oneof = "physical_window_expr_node::WindowFunction", tags = "1, 2")]
+    pub window_function: ::core::option::Option<
+        physical_window_expr_node::WindowFunction,
+    >,
+}
+/// Nested message and enum types in `PhysicalWindowExprNode`.
+pub mod physical_window_expr_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum WindowFunction {
+        #[prost(enumeration = "super::AggregateFunction", tag = "1")]
+        AggrFunction(i32),
+        /// udaf = 3
+        #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")]
+        BuiltInFunction(i32),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalIsNull {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalIsNotNull {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalNot {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalAliasNode {
+    #[prost(message, optional, tag = "1")]
+    pub expr: ::core::option::Option<PhysicalExprNode>,
+    #[prost(string, tag = "2")]
+    pub alias: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalBinaryExprNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub l: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub r: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(string, tag = "3")]
+    pub op: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalDateTimeIntervalExprNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub l: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub r: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(string, tag = "3")]
+    pub op: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalLikeExprNode {
+    #[prost(bool, tag = "1")]
+    pub negated: bool,
+    #[prost(bool, tag = "2")]
+    pub case_insensitive: bool,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, optional, boxed, tag = "4")]
+    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalSortExprNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(bool, tag = "2")]
+    pub asc: bool,
+    #[prost(bool, tag = "3")]
+    pub nulls_first: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalWhenThen {
+    #[prost(message, optional, tag = "1")]
+    pub when_expr: ::core::option::Option<PhysicalExprNode>,
+    #[prost(message, optional, tag = "2")]
+    pub then_expr: ::core::option::Option<PhysicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalInListNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub list: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(bool, tag = "3")]
+    pub negated: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalCaseNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub when_then_expr: ::prost::alloc::vec::Vec<PhysicalWhenThen>,
+    #[prost(message, optional, boxed, tag = "3")]
+    pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalScalarFunctionNode {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(enumeration = "ScalarFunction", tag = "2")]
+    pub fun: i32,
+    #[prost(message, repeated, tag = "3")]
+    pub args: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(message, optional, tag = "4")]
+    pub return_type: ::core::option::Option<ArrowType>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalTryCastNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub arrow_type: ::core::option::Option<ArrowType>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalCastNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub arrow_type: ::core::option::Option<ArrowType>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalNegativeNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FilterExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub expr: ::core::option::Option<PhysicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FileGroup {
+    #[prost(message, repeated, tag = "1")]
+    pub files: ::prost::alloc::vec::Vec<PartitionedFile>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScanLimit {
+    /// wrap into a message to make it optional
+    #[prost(uint32, tag = "1")]
+    pub limit: u32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalSortExprNodeCollection {
+    #[prost(message, repeated, tag = "1")]
+    pub physical_sort_expr_nodes: ::prost::alloc::vec::Vec<PhysicalSortExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FileScanExecConf {
+    #[prost(message, repeated, tag = "1")]
+    pub file_groups: ::prost::alloc::vec::Vec<FileGroup>,
+    #[prost(message, optional, tag = "2")]
+    pub schema: ::core::option::Option<Schema>,
+    #[prost(uint32, repeated, tag = "4")]
+    pub projection: ::prost::alloc::vec::Vec<u32>,
+    #[prost(message, optional, tag = "5")]
+    pub limit: ::core::option::Option<ScanLimit>,
+    #[prost(message, optional, tag = "6")]
+    pub statistics: ::core::option::Option<Statistics>,
+    #[prost(string, repeated, tag = "7")]
+    pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(string, tag = "8")]
+    pub object_store_url: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "9")]
+    pub output_ordering: ::prost::alloc::vec::Vec<PhysicalSortExprNodeCollection>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ParquetScanExecNode {
+    #[prost(message, optional, tag = "1")]
+    pub base_conf: ::core::option::Option<FileScanExecConf>,
+    #[prost(message, optional, tag = "3")]
+    pub predicate: ::core::option::Option<PhysicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CsvScanExecNode {
+    #[prost(message, optional, tag = "1")]
+    pub base_conf: ::core::option::Option<FileScanExecConf>,
+    #[prost(bool, tag = "2")]
+    pub has_header: bool,
+    #[prost(string, tag = "3")]
+    pub delimiter: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AvroScanExecNode {
+    #[prost(message, optional, tag = "1")]
+    pub base_conf: ::core::option::Option<FileScanExecConf>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct HashJoinExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub left: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub right: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, repeated, tag = "3")]
+    pub on: ::prost::alloc::vec::Vec<JoinOn>,
+    #[prost(enumeration = "JoinType", tag = "4")]
+    pub join_type: i32,
+    #[prost(enumeration = "PartitionMode", tag = "6")]
+    pub partition_mode: i32,
+    #[prost(bool, tag = "7")]
+    pub null_equals_null: bool,
+    #[prost(message, optional, tag = "8")]
+    pub filter: ::core::option::Option<JoinFilter>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct UnionExecNode {
+    #[prost(message, repeated, tag = "1")]
+    pub inputs: ::prost::alloc::vec::Vec<PhysicalPlanNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ExplainExecNode {
+    #[prost(message, optional, tag = "1")]
+    pub schema: ::core::option::Option<Schema>,
+    #[prost(message, repeated, tag = "2")]
+    pub stringified_plans: ::prost::alloc::vec::Vec<StringifiedPlan>,
+    #[prost(bool, tag = "3")]
+    pub verbose: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CrossJoinExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub left: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, optional, boxed, tag = "2")]
+    pub right: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalColumn {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(uint32, tag = "2")]
+    pub index: u32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct JoinOn {
+    #[prost(message, optional, tag = "1")]
+    pub left: ::core::option::Option<PhysicalColumn>,
+    #[prost(message, optional, tag = "2")]
+    pub right: ::core::option::Option<PhysicalColumn>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct EmptyExecNode {
+    #[prost(bool, tag = "1")]
+    pub produce_one_row: bool,
+    #[prost(message, optional, tag = "2")]
+    pub schema: ::core::option::Option<Schema>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ProjectionExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(string, repeated, tag = "3")]
+    pub expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct WindowAggExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub window_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(string, repeated, tag = "3")]
+    pub window_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(message, optional, tag = "4")]
+    pub input_schema: ::core::option::Option<Schema>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MaybeFilter {
+    #[prost(message, optional, tag = "1")]
+    pub expr: ::core::option::Option<PhysicalExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct MaybePhysicalSortExprs {
+    #[prost(message, repeated, tag = "1")]
+    pub sort_expr: ::prost::alloc::vec::Vec<PhysicalSortExprNode>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AggregateExecNode {
+    #[prost(message, repeated, tag = "1")]
+    pub group_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(message, repeated, tag = "2")]
+    pub aggr_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(enumeration = "AggregateMode", tag = "3")]
+    pub mode: i32,
+    #[prost(message, optional, boxed, tag = "4")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(string, repeated, tag = "5")]
+    pub group_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(string, repeated, tag = "6")]
+    pub aggr_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    /// we need the input schema to the partial aggregate to pass to the final aggregate
+    #[prost(message, optional, tag = "7")]
+    pub input_schema: ::core::option::Option<Schema>,
+    #[prost(message, repeated, tag = "8")]
+    pub null_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(bool, repeated, tag = "9")]
+    pub groups: ::prost::alloc::vec::Vec<bool>,
+    #[prost(message, repeated, tag = "10")]
+    pub filter_expr: ::prost::alloc::vec::Vec<MaybeFilter>,
+    #[prost(message, repeated, tag = "11")]
+    pub order_by_expr: ::prost::alloc::vec::Vec<MaybePhysicalSortExprs>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GlobalLimitExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    /// The number of rows to skip before fetch
+    #[prost(uint32, tag = "2")]
+    pub skip: u32,
+    /// Maximum number of rows to fetch; negative means no limit
+    #[prost(int64, tag = "3")]
+    pub fetch: i64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LocalLimitExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(uint32, tag = "2")]
+    pub fetch: u32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SortExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    /// Maximum number of highest/lowest rows to fetch; negative means no limit
+    #[prost(int64, tag = "3")]
+    pub fetch: i64,
+    #[prost(bool, tag = "4")]
+    pub preserve_partitioning: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SortPreservingMergeExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(message, repeated, tag = "2")]
+    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    /// Maximum number of highest/lowest rows to fetch; negative means no limit
+    #[prost(int64, tag = "3")]
+    pub fetch: i64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CoalesceBatchesExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(uint32, tag = "2")]
+    pub target_batch_size: u32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CoalescePartitionsExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalHashRepartition {
+    #[prost(message, repeated, tag = "1")]
+    pub hash_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    #[prost(uint64, tag = "2")]
+    pub partition_count: u64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RepartitionExecNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
+    #[prost(oneof = "repartition_exec_node::PartitionMethod", tags = "2, 3, 4")]
+    pub partition_method: ::core::option::Option<repartition_exec_node::PartitionMethod>,
+}
+/// Nested message and enum types in `RepartitionExecNode`.
+pub mod repartition_exec_node {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum PartitionMethod {
+        #[prost(uint64, tag = "2")]
+        RoundRobin(u64),
+        #[prost(message, tag = "3")]
+        Hash(super::PhysicalHashRepartition),
+        #[prost(uint64, tag = "4")]
+        Unknown(u64),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct JoinFilter {
+    #[prost(message, optional, tag = "1")]
+    pub expression: ::core::option::Option<PhysicalExprNode>,
+    #[prost(message, repeated, tag = "2")]
+    pub column_indices: ::prost::alloc::vec::Vec<ColumnIndex>,
+    #[prost(message, optional, tag = "3")]
+    pub schema: ::core::option::Option<Schema>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ColumnIndex {
+    #[prost(uint32, tag = "1")]
+    pub index: u32,
+    #[prost(enumeration = "JoinSide", tag = "2")]
+    pub side: i32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PartitionedFile {
+    #[prost(string, tag = "1")]
+    pub path: ::prost::alloc::string::String,
+    #[prost(uint64, tag = "2")]
+    pub size: u64,
+    #[prost(uint64, tag = "3")]
+    pub last_modified_ns: u64,
+    #[prost(message, repeated, tag = "4")]
+    pub partition_values: ::prost::alloc::vec::Vec<ScalarValue>,
+    #[prost(message, optional, tag = "5")]
+    pub range: ::core::option::Option<FileRange>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FileRange {
+    #[prost(int64, tag = "1")]
+    pub start: i64,
+    #[prost(int64, tag = "2")]
+    pub end: i64,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PartitionStats {
+    #[prost(int64, tag = "1")]
+    pub num_rows: i64,
+    #[prost(int64, tag = "2")]
+    pub num_batches: i64,
+    #[prost(int64, tag = "3")]
+    pub num_bytes: i64,
+    #[prost(message, repeated, tag = "4")]
+    pub column_stats: ::prost::alloc::vec::Vec<ColumnStats>,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Statistics {
+    #[prost(int64, tag = "1")]
+    pub num_rows: i64,
+    #[prost(int64, tag = "2")]
+    pub total_byte_size: i64,
+    #[prost(message, repeated, tag = "3")]
+    pub column_stats: ::prost::alloc::vec::Vec<ColumnStats>,
+    #[prost(bool, tag = "4")]
+    pub is_exact: bool,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ColumnStats {
+    #[prost(message, optional, tag = "1")]
+    pub min_value: ::core::option::Option<ScalarValue>,
+    #[prost(message, optional, tag = "2")]
+    pub max_value: ::core::option::Option<ScalarValue>,
+    #[prost(uint32, tag = "3")]
+    pub null_count: u32,
+    #[prost(uint32, tag = "4")]
+    pub distinct_count: u32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PhysicalGetIndexedFieldExprNode {
+    #[prost(message, optional, boxed, tag = "1")]
+    pub arg: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
+    #[prost(message, optional, tag = "2")]
+    pub key: ::core::option::Option<ScalarValue>,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum JoinType {
+    Inner = 0,
+    Left = 1,
+    Right = 2,
+    Full = 3,
+    Leftsemi = 4,
+    Leftanti = 5,
+    Rightsemi = 6,
+    Rightanti = 7,
+}
+impl JoinType {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            JoinType::Inner => "INNER",
+            JoinType::Left => "LEFT",
+            JoinType::Right => "RIGHT",
+            JoinType::Full => "FULL",
+            JoinType::Leftsemi => "LEFTSEMI",
+            JoinType::Leftanti => "LEFTANTI",
+            JoinType::Rightsemi => "RIGHTSEMI",
+            JoinType::Rightanti => "RIGHTANTI",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "INNER" => Some(Self::Inner),
+            "LEFT" => Some(Self::Left),
+            "RIGHT" => Some(Self::Right),
+            "FULL" => Some(Self::Full),
+            "LEFTSEMI" => Some(Self::Leftsemi),
+            "LEFTANTI" => Some(Self::Leftanti),
+            "RIGHTSEMI" => Some(Self::Rightsemi),
+            "RIGHTANTI" => Some(Self::Rightanti),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum JoinConstraint {
+    On = 0,
+    Using = 1,
+}
+impl JoinConstraint {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            JoinConstraint::On => "ON",
+            JoinConstraint::Using => "USING",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "ON" => Some(Self::On),
+            "USING" => Some(Self::Using),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum ScalarFunction {
+    Abs = 0,
+    Acos = 1,
+    Asin = 2,
+    Atan = 3,
+    Ascii = 4,
+    Ceil = 5,
+    Cos = 6,
+    Digest = 7,
+    Exp = 8,
+    Floor = 9,
+    Ln = 10,
+    Log = 11,
+    Log10 = 12,
+    Log2 = 13,
+    Round = 14,
+    Signum = 15,
+    Sin = 16,
+    Sqrt = 17,
+    Tan = 18,
+    Trunc = 19,
+    Array = 20,
+    RegexpMatch = 21,
+    BitLength = 22,
+    Btrim = 23,
+    CharacterLength = 24,
+    Chr = 25,
+    Concat = 26,
+    ConcatWithSeparator = 27,
+    DatePart = 28,
+    DateTrunc = 29,
+    InitCap = 30,
+    Left = 31,
+    Lpad = 32,
+    Lower = 33,
+    Ltrim = 34,
+    Md5 = 35,
+    NullIf = 36,
+    OctetLength = 37,
+    Random = 38,
+    RegexpReplace = 39,
+    Repeat = 40,
+    Replace = 41,
+    Reverse = 42,
+    Right = 43,
+    Rpad = 44,
+    Rtrim = 45,
+    Sha224 = 46,
+    Sha256 = 47,
+    Sha384 = 48,
+    Sha512 = 49,
+    SplitPart = 50,
+    StartsWith = 51,
+    Strpos = 52,
+    Substr = 53,
+    ToHex = 54,
+    ToTimestamp = 55,
+    ToTimestampMillis = 56,
+    ToTimestampMicros = 57,
+    ToTimestampSeconds = 58,
+    Now = 59,
+    Translate = 60,
+    Trim = 61,
+    Upper = 62,
+    Coalesce = 63,
+    Power = 64,
+    StructFun = 65,
+    FromUnixtime = 66,
+    Atan2 = 67,
+    DateBin = 68,
+    ArrowTypeof = 69,
+    CurrentDate = 70,
+    CurrentTime = 71,
+    Uuid = 72,
+    Cbrt = 73,
+    Acosh = 74,
+    Asinh = 75,
+    Atanh = 76,
+    Sinh = 77,
+    Cosh = 78,
+    Tanh = 79,
+    Pi = 80,
+    Degrees = 81,
+    Radians = 82,
+    Factorial = 83,
+    Lcm = 84,
+    Gcd = 85,
+    ArrayAppend = 86,
+    ArrayConcat = 87,
+    ArrayDims = 88,
+    ArrayFill = 89,
+    ArrayLength = 90,
+    ArrayNdims = 91,
+    ArrayPosition = 92,
+    ArrayPositions = 93,
+    ArrayPrepend = 94,
+    ArrayRemove = 95,
+    ArrayReplace = 96,
+    ArrayToString = 97,
+    Cardinality = 98,
+    TrimArray = 99,
+    ArrayContains = 100,
+}
+impl ScalarFunction {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            ScalarFunction::Abs => "Abs",
+            ScalarFunction::Acos => "Acos",
+            ScalarFunction::Asin => "Asin",
+            ScalarFunction::Atan => "Atan",
+            ScalarFunction::Ascii => "Ascii",
+            ScalarFunction::Ceil => "Ceil",
+            ScalarFunction::Cos => "Cos",
+            ScalarFunction::Digest => "Digest",
+            ScalarFunction::Exp => "Exp",
+            ScalarFunction::Floor => "Floor",
+            ScalarFunction::Ln => "Ln",
+            ScalarFunction::Log => "Log",
+            ScalarFunction::Log10 => "Log10",
+            ScalarFunction::Log2 => "Log2",
+            ScalarFunction::Round => "Round",
+            ScalarFunction::Signum => "Signum",
+            ScalarFunction::Sin => "Sin",
+            ScalarFunction::Sqrt => "Sqrt",
+            ScalarFunction::Tan => "Tan",
+            ScalarFunction::Trunc => "Trunc",
+            ScalarFunction::Array => "Array",
+            ScalarFunction::RegexpMatch => "RegexpMatch",
+            ScalarFunction::BitLength => "BitLength",
+            ScalarFunction::Btrim => "Btrim",
+            ScalarFunction::CharacterLength => "CharacterLength",
+            ScalarFunction::Chr => "Chr",
+            ScalarFunction::Concat => "Concat",
+            ScalarFunction::ConcatWithSeparator => "ConcatWithSeparator",
+            ScalarFunction::DatePart => "DatePart",
+            ScalarFunction::DateTrunc => "DateTrunc",
+            ScalarFunction::InitCap => "InitCap",
+            ScalarFunction::Left => "Left",
+            ScalarFunction::Lpad => "Lpad",
+            ScalarFunction::Lower => "Lower",
+            ScalarFunction::Ltrim => "Ltrim",
+            ScalarFunction::Md5 => "MD5",
+            ScalarFunction::NullIf => "NullIf",
+            ScalarFunction::OctetLength => "OctetLength",
+            ScalarFunction::Random => "Random",
+            ScalarFunction::RegexpReplace => "RegexpReplace",
+            ScalarFunction::Repeat => "Repeat",
+            ScalarFunction::Replace => "Replace",
+            ScalarFunction::Reverse => "Reverse",
+            ScalarFunction::Right => "Right",
+            ScalarFunction::Rpad => "Rpad",
+            ScalarFunction::Rtrim => "Rtrim",
+            ScalarFunction::Sha224 => "SHA224",
+            ScalarFunction::Sha256 => "SHA256",
+            ScalarFunction::Sha384 => "SHA384",
+            ScalarFunction::Sha512 => "SHA512",
+            ScalarFunction::SplitPart => "SplitPart",
+            ScalarFunction::StartsWith => "StartsWith",
+            ScalarFunction::Strpos => "Strpos",
+            ScalarFunction::Substr => "Substr",
+            ScalarFunction::ToHex => "ToHex",
+            ScalarFunction::ToTimestamp => "ToTimestamp",
+            ScalarFunction::ToTimestampMillis => "ToTimestampMillis",
+            ScalarFunction::ToTimestampMicros => "ToTimestampMicros",
+            ScalarFunction::ToTimestampSeconds => "ToTimestampSeconds",
+            ScalarFunction::Now => "Now",
+            ScalarFunction::Translate => "Translate",
+            ScalarFunction::Trim => "Trim",
+            ScalarFunction::Upper => "Upper",
+            ScalarFunction::Coalesce => "Coalesce",
+            ScalarFunction::Power => "Power",
+            ScalarFunction::StructFun => "StructFun",
+            ScalarFunction::FromUnixtime => "FromUnixtime",
+            ScalarFunction::Atan2 => "Atan2",
+            ScalarFunction::DateBin => "DateBin",
+            ScalarFunction::ArrowTypeof => "ArrowTypeof",
+            ScalarFunction::CurrentDate => "CurrentDate",
+            ScalarFunction::CurrentTime => "CurrentTime",
+            ScalarFunction::Uuid => "Uuid",
+            ScalarFunction::Cbrt => "Cbrt",
+            ScalarFunction::Acosh => "Acosh",
+            ScalarFunction::Asinh => "Asinh",
+            ScalarFunction::Atanh => "Atanh",
+            ScalarFunction::Sinh => "Sinh",
+            ScalarFunction::Cosh => "Cosh",
+            ScalarFunction::Tanh => "Tanh",
+            ScalarFunction::Pi => "Pi",
+            ScalarFunction::Degrees => "Degrees",
+            ScalarFunction::Radians => "Radians",
+            ScalarFunction::Factorial => "Factorial",
+            ScalarFunction::Lcm => "Lcm",
+            ScalarFunction::Gcd => "Gcd",
+            ScalarFunction::ArrayAppend => "ArrayAppend",
+            ScalarFunction::ArrayConcat => "ArrayConcat",
+            ScalarFunction::ArrayDims => "ArrayDims",
+            ScalarFunction::ArrayFill => "ArrayFill",
+            ScalarFunction::ArrayLength => "ArrayLength",
+            ScalarFunction::ArrayNdims => "ArrayNdims",
+            ScalarFunction::ArrayPosition => "ArrayPosition",
+            ScalarFunction::ArrayPositions => "ArrayPositions",
+            ScalarFunction::ArrayPrepend => "ArrayPrepend",
+            ScalarFunction::ArrayRemove => "ArrayRemove",
+            ScalarFunction::ArrayReplace => "ArrayReplace",
+            ScalarFunction::ArrayToString => "ArrayToString",
+            ScalarFunction::Cardinality => "Cardinality",
+            ScalarFunction::TrimArray => "TrimArray",
+            ScalarFunction::ArrayContains => "ArrayContains",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "Abs" => Some(Self::Abs),
+            "Acos" => Some(Self::Acos),
+            "Asin" => Some(Self::Asin),
+            "Atan" => Some(Self::Atan),
+            "Ascii" => Some(Self::Ascii),
+            "Ceil" => Some(Self::Ceil),
+            "Cos" => Some(Self::Cos),
+            "Digest" => Some(Self::Digest),
+            "Exp" => Some(Self::Exp),
+            "Floor" => Some(Self::Floor),
+            "Ln" => Some(Self::Ln),
+            "Log" => Some(Self::Log),
+            "Log10" => Some(Self::Log10),
+            "Log2" => Some(Self::Log2),
+            "Round" => Some(Self::Round),
+            "Signum" => Some(Self::Signum),
+            "Sin" => Some(Self::Sin),
+            "Sqrt" => Some(Self::Sqrt),
+            "Tan" => Some(Self::Tan),
+            "Trunc" => Some(Self::Trunc),
+            "Array" => Some(Self::Array),
+            "RegexpMatch" => Some(Self::RegexpMatch),
+            "BitLength" => Some(Self::BitLength),
+            "Btrim" => Some(Self::Btrim),
+            "CharacterLength" => Some(Self::CharacterLength),
+            "Chr" => Some(Self::Chr),
+            "Concat" => Some(Self::Concat),
+            "ConcatWithSeparator" => Some(Self::ConcatWithSeparator),
+            "DatePart" => Some(Self::DatePart),
+            "DateTrunc" => Some(Self::DateTrunc),
+            "InitCap" => Some(Self::InitCap),
+            "Left" => Some(Self::Left),
+            "Lpad" => Some(Self::Lpad),
+            "Lower" => Some(Self::Lower),
+            "Ltrim" => Some(Self::Ltrim),
+            "MD5" => Some(Self::Md5),
+            "NullIf" => Some(Self::NullIf),
+            "OctetLength" => Some(Self::OctetLength),
+            "Random" => Some(Self::Random),
+            "RegexpReplace" => Some(Self::RegexpReplace),
+            "Repeat" => Some(Self::Repeat),
+            "Replace" => Some(Self::Replace),
+            "Reverse" => Some(Self::Reverse),
+            "Right" => Some(Self::Right),
+            "Rpad" => Some(Self::Rpad),
+            "Rtrim" => Some(Self::Rtrim),
+            "SHA224" => Some(Self::Sha224),
+            "SHA256" => Some(Self::Sha256),
+            "SHA384" => Some(Self::Sha384),
+            "SHA512" => Some(Self::Sha512),
+            "SplitPart" => Some(Self::SplitPart),
+            "StartsWith" => Some(Self::StartsWith),
+            "Strpos" => Some(Self::Strpos),
+            "Substr" => Some(Self::Substr),
+            "ToHex" => Some(Self::ToHex),
+            "ToTimestamp" => Some(Self::ToTimestamp),
+            "ToTimestampMillis" => Some(Self::ToTimestampMillis),
+            "ToTimestampMicros" => Some(Self::ToTimestampMicros),
+            "ToTimestampSeconds" => Some(Self::ToTimestampSeconds),
+            "Now" => Some(Self::Now),
+            "Translate" => Some(Self::Translate),
+            "Trim" => Some(Self::Trim),
+            "Upper" => Some(Self::Upper),
+            "Coalesce" => Some(Self::Coalesce),
+            "Power" => Some(Self::Power),
+            "StructFun" => Some(Self::StructFun),
+            "FromUnixtime" => Some(Self::FromUnixtime),
+            "Atan2" => Some(Self::Atan2),
+            "DateBin" => Some(Self::DateBin),
+            "ArrowTypeof" => Some(Self::ArrowTypeof),
+            "CurrentDate" => Some(Self::CurrentDate),
+            "CurrentTime" => Some(Self::CurrentTime),
+            "Uuid" => Some(Self::Uuid),
+            "Cbrt" => Some(Self::Cbrt),
+            "Acosh" => Some(Self::Acosh),
+            "Asinh" => Some(Self::Asinh),
+            "Atanh" => Some(Self::Atanh),
+            "Sinh" => Some(Self::Sinh),
+            "Cosh" => Some(Self::Cosh),
+            "Tanh" => Some(Self::Tanh),
+            "Pi" => Some(Self::Pi),
+            "Degrees" => Some(Self::Degrees),
+            "Radians" => Some(Self::Radians),
+            "Factorial" => Some(Self::Factorial),
+            "Lcm" => Some(Self::Lcm),
+            "Gcd" => Some(Self::Gcd),
+            "ArrayAppend" => Some(Self::ArrayAppend),
+            "ArrayConcat" => Some(Self::ArrayConcat),
+            "ArrayDims" => Some(Self::ArrayDims),
+            "ArrayFill" => Some(Self::ArrayFill),
+            "ArrayLength" => Some(Self::ArrayLength),
+            "ArrayNdims" => Some(Self::ArrayNdims),
+            "ArrayPosition" => Some(Self::ArrayPosition),
+            "ArrayPositions" => Some(Self::ArrayPositions),
+            "ArrayPrepend" => Some(Self::ArrayPrepend),
+            "ArrayRemove" => Some(Self::ArrayRemove),
+            "ArrayReplace" => Some(Self::ArrayReplace),
+            "ArrayToString" => Some(Self::ArrayToString),
+            "Cardinality" => Some(Self::Cardinality),
+            "TrimArray" => Some(Self::TrimArray),
+            "ArrayContains" => Some(Self::ArrayContains),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum AggregateFunction {
+    Min = 0,
+    Max = 1,
+    Sum = 2,
+    Avg = 3,
+    Count = 4,
+    ApproxDistinct = 5,
+    ArrayAgg = 6,
+    Variance = 7,
+    VariancePop = 8,
+    Covariance = 9,
+    CovariancePop = 10,
+    Stddev = 11,
+    StddevPop = 12,
+    Correlation = 13,
+    ApproxPercentileCont = 14,
+    ApproxMedian = 15,
+    ApproxPercentileContWithWeight = 16,
+    Grouping = 17,
+    Median = 18,
+    BitAnd = 19,
+    BitOr = 20,
+    BitXor = 21,
+    BoolAnd = 22,
+    BoolOr = 23,
+    /// When a function with the same name exists among built-in window functions,
+    /// we append "_AGG" to obey name scoping rules.
+    FirstValueAgg = 24,
+    LastValueAgg = 25,
+}
+impl AggregateFunction {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            AggregateFunction::Min => "MIN",
+            AggregateFunction::Max => "MAX",
+            AggregateFunction::Sum => "SUM",
+            AggregateFunction::Avg => "AVG",
+            AggregateFunction::Count => "COUNT",
+            AggregateFunction::ApproxDistinct => "APPROX_DISTINCT",
+            AggregateFunction::ArrayAgg => "ARRAY_AGG",
+            AggregateFunction::Variance => "VARIANCE",
+            AggregateFunction::VariancePop => "VARIANCE_POP",
+            AggregateFunction::Covariance => "COVARIANCE",
+            AggregateFunction::CovariancePop => "COVARIANCE_POP",
+            AggregateFunction::Stddev => "STDDEV",
+            AggregateFunction::StddevPop => "STDDEV_POP",
+            AggregateFunction::Correlation => "CORRELATION",
+            AggregateFunction::ApproxPercentileCont => "APPROX_PERCENTILE_CONT",
+            AggregateFunction::ApproxMedian => "APPROX_MEDIAN",
+            AggregateFunction::ApproxPercentileContWithWeight => {
+                "APPROX_PERCENTILE_CONT_WITH_WEIGHT"
+            }
+            AggregateFunction::Grouping => "GROUPING",
+            AggregateFunction::Median => "MEDIAN",
+            AggregateFunction::BitAnd => "BIT_AND",
+            AggregateFunction::BitOr => "BIT_OR",
+            AggregateFunction::BitXor => "BIT_XOR",
+            AggregateFunction::BoolAnd => "BOOL_AND",
+            AggregateFunction::BoolOr => "BOOL_OR",
+            AggregateFunction::FirstValueAgg => "FIRST_VALUE_AGG",
+            AggregateFunction::LastValueAgg => "LAST_VALUE_AGG",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "MIN" => Some(Self::Min),
+            "MAX" => Some(Self::Max),
+            "SUM" => Some(Self::Sum),
+            "AVG" => Some(Self::Avg),
+            "COUNT" => Some(Self::Count),
+            "APPROX_DISTINCT" => Some(Self::ApproxDistinct),
+            "ARRAY_AGG" => Some(Self::ArrayAgg),
+            "VARIANCE" => Some(Self::Variance),
+            "VARIANCE_POP" => Some(Self::VariancePop),
+            "COVARIANCE" => Some(Self::Covariance),
+            "COVARIANCE_POP" => Some(Self::CovariancePop),
+            "STDDEV" => Some(Self::Stddev),
+            "STDDEV_POP" => Some(Self::StddevPop),
+            "CORRELATION" => Some(Self::Correlation),
+            "APPROX_PERCENTILE_CONT" => Some(Self::ApproxPercentileCont),
+            "APPROX_MEDIAN" => Some(Self::ApproxMedian),
+            "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => {
+                Some(Self::ApproxPercentileContWithWeight)
+            }
+            "GROUPING" => Some(Self::Grouping),
+            "MEDIAN" => Some(Self::Median),
+            "BIT_AND" => Some(Self::BitAnd),
+            "BIT_OR" => Some(Self::BitOr),
+            "BIT_XOR" => Some(Self::BitXor),
+            "BOOL_AND" => Some(Self::BoolAnd),
+            "BOOL_OR" => Some(Self::BoolOr),
+            "FIRST_VALUE_AGG" => Some(Self::FirstValueAgg),
+            "LAST_VALUE_AGG" => Some(Self::LastValueAgg),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum BuiltInWindowFunction {
+    RowNumber = 0,
+    Rank = 1,
+    DenseRank = 2,
+    PercentRank = 3,
+    CumeDist = 4,
+    Ntile = 5,
+    Lag = 6,
+    Lead = 7,
+    FirstValue = 8,
+    LastValue = 9,
+    NthValue = 10,
+}
+impl BuiltInWindowFunction {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            BuiltInWindowFunction::RowNumber => "ROW_NUMBER",
+            BuiltInWindowFunction::Rank => "RANK",
+            BuiltInWindowFunction::DenseRank => "DENSE_RANK",
+            BuiltInWindowFunction::PercentRank => "PERCENT_RANK",
+            BuiltInWindowFunction::CumeDist => "CUME_DIST",
+            BuiltInWindowFunction::Ntile => "NTILE",
+            BuiltInWindowFunction::Lag => "LAG",
+            BuiltInWindowFunction::Lead => "LEAD",
+            BuiltInWindowFunction::FirstValue => "FIRST_VALUE",
+            BuiltInWindowFunction::LastValue => "LAST_VALUE",
+            BuiltInWindowFunction::NthValue => "NTH_VALUE",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "ROW_NUMBER" => Some(Self::RowNumber),
+            "RANK" => Some(Self::Rank),
+            "DENSE_RANK" => Some(Self::DenseRank),
+            "PERCENT_RANK" => Some(Self::PercentRank),
+            "CUME_DIST" => Some(Self::CumeDist),
+            "NTILE" => Some(Self::Ntile),
+            "LAG" => Some(Self::Lag),
+            "LEAD" => Some(Self::Lead),
+            "FIRST_VALUE" => Some(Self::FirstValue),
+            "LAST_VALUE" => Some(Self::LastValue),
+            "NTH_VALUE" => Some(Self::NthValue),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum WindowFrameUnits {
+    Rows = 0,
+    Range = 1,
+    Groups = 2,
+}
+impl WindowFrameUnits {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            WindowFrameUnits::Rows => "ROWS",
+            WindowFrameUnits::Range => "RANGE",
+            WindowFrameUnits::Groups => "GROUPS",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "ROWS" => Some(Self::Rows),
+            "RANGE" => Some(Self::Range),
+            "GROUPS" => Some(Self::Groups),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum WindowFrameBoundType {
+    CurrentRow = 0,
+    Preceding = 1,
+    Following = 2,
+}
+impl WindowFrameBoundType {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            WindowFrameBoundType::CurrentRow => "CURRENT_ROW",
+            WindowFrameBoundType::Preceding => "PRECEDING",
+            WindowFrameBoundType::Following => "FOLLOWING",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "CURRENT_ROW" => Some(Self::CurrentRow),
+            "PRECEDING" => Some(Self::Preceding),
+            "FOLLOWING" => Some(Self::Following),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum DateUnit {
+    Day = 0,
+    DateMillisecond = 1,
+}
+impl DateUnit {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            DateUnit::Day => "Day",
+            DateUnit::DateMillisecond => "DateMillisecond",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "Day" => Some(Self::Day),
+            "DateMillisecond" => Some(Self::DateMillisecond),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum TimeUnit {
+    Second = 0,
+    Millisecond = 1,
+    Microsecond = 2,
+    Nanosecond = 3,
+}
+impl TimeUnit {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            TimeUnit::Second => "Second",
+            TimeUnit::Millisecond => "Millisecond",
+            TimeUnit::Microsecond => "Microsecond",
+            TimeUnit::Nanosecond => "Nanosecond",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "Second" => Some(Self::Second),
+            "Millisecond" => Some(Self::Millisecond),
+            "Microsecond" => Some(Self::Microsecond),
+            "Nanosecond" => Some(Self::Nanosecond),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum IntervalUnit {
+    YearMonth = 0,
+    DayTime = 1,
+    MonthDayNano = 2,
+}
+impl IntervalUnit {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            IntervalUnit::YearMonth => "YearMonth",
+            IntervalUnit::DayTime => "DayTime",
+            IntervalUnit::MonthDayNano => "MonthDayNano",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "YearMonth" => Some(Self::YearMonth),
+            "DayTime" => Some(Self::DayTime),
+            "MonthDayNano" => Some(Self::MonthDayNano),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum UnionMode {
+    Sparse = 0,
+    Dense = 1,
+}
+impl UnionMode {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            UnionMode::Sparse => "sparse",
+            UnionMode::Dense => "dense",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "sparse" => Some(Self::Sparse),
+            "dense" => Some(Self::Dense),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum PartitionMode {
+    CollectLeft = 0,
+    Partitioned = 1,
+    Auto = 2,
+}
+impl PartitionMode {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            PartitionMode::CollectLeft => "COLLECT_LEFT",
+            PartitionMode::Partitioned => "PARTITIONED",
+            PartitionMode::Auto => "AUTO",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "COLLECT_LEFT" => Some(Self::CollectLeft),
+            "PARTITIONED" => Some(Self::Partitioned),
+            "AUTO" => Some(Self::Auto),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum AggregateMode {
+    Partial = 0,
+    Final = 1,
+    FinalPartitioned = 2,
+    Single = 3,
+}
+impl AggregateMode {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            AggregateMode::Partial => "PARTIAL",
+            AggregateMode::Final => "FINAL",
+            AggregateMode::FinalPartitioned => "FINAL_PARTITIONED",
+            AggregateMode::Single => "SINGLE",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "PARTIAL" => Some(Self::Partial),
+            "FINAL" => Some(Self::Final),
+            "FINAL_PARTITIONED" => Some(Self::FinalPartitioned),
+            "SINGLE" => Some(Self::Single),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum JoinSide {
+    LeftSide = 0,
+    RightSide = 1,
+}
+impl JoinSide {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            JoinSide::LeftSide => "LEFT_SIDE",
+            JoinSide::RightSide => "RIGHT_SIDE",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "LEFT_SIDE" => Some(Self::LeftSide),
+            "RIGHT_SIDE" => Some(Self::RightSide),
+            _ => None,
+        }
+    }
+}
diff --git a/datafusion/proto/src/datafusion.serde.rs b/datafusion/proto/src/datafusion.serde.rs
new file mode 100644
index 0000000000000..ab8ddf4f292f8
--- /dev/null
+++ b/datafusion/proto/src/datafusion.serde.rs
@@ -0,0 +1,22857 @@
+impl serde::Serialize for AggregateExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.group_expr.is_empty() {
+            len += 1;
+        }
+        if !self.aggr_expr.is_empty() {
+            len += 1;
+        }
+        if self.mode != 0 {
+            len += 1;
+        }
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.group_expr_name.is_empty() {
+            len += 1;
+        }
+        if !self.aggr_expr_name.is_empty() {
+            len += 1;
+        }
+        if self.input_schema.is_some() {
+            len += 1;
+        }
+        if !self.null_expr.is_empty() {
+            len += 1;
+        }
+        if !self.groups.is_empty() {
+            len += 1;
+        }
+        if !self.filter_expr.is_empty() {
+            len += 1;
+        }
+        if !self.order_by_expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExecNode", len)?;
+        if !self.group_expr.is_empty() {
+            struct_ser.serialize_field("groupExpr", &self.group_expr)?;
+        }
+        if !self.aggr_expr.is_empty() {
+            struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?;
+        }
+        if self.mode != 0 {
+            let v = AggregateMode::from_i32(self.mode)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
+            struct_ser.serialize_field("mode", &v)?;
+        }
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.group_expr_name.is_empty() {
+            struct_ser.serialize_field("groupExprName", &self.group_expr_name)?;
+        }
+        if !self.aggr_expr_name.is_empty() {
+            struct_ser.serialize_field("aggrExprName", &self.aggr_expr_name)?;
+        }
+        if let Some(v) = self.input_schema.as_ref() {
+            struct_ser.serialize_field("inputSchema", v)?;
+        }
+        if !self.null_expr.is_empty() {
+            struct_ser.serialize_field("nullExpr", &self.null_expr)?;
+        }
+        if !self.groups.is_empty() {
+            struct_ser.serialize_field("groups", &self.groups)?;
+        }
+        if !self.filter_expr.is_empty() {
+            struct_ser.serialize_field("filterExpr", &self.filter_expr)?;
+        }
+        if !self.order_by_expr.is_empty() {
+            struct_ser.serialize_field("orderByExpr", &self.order_by_expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AggregateExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "group_expr",
+            "groupExpr",
+            "aggr_expr",
+            "aggrExpr",
+            "mode",
+            "input",
+            "group_expr_name",
+            "groupExprName",
+            "aggr_expr_name",
+            "aggrExprName",
+            "input_schema",
+            "inputSchema",
+            "null_expr",
+            "nullExpr",
+            "groups",
+            "filter_expr",
+            "filterExpr",
+            "order_by_expr",
+            "orderByExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            GroupExpr,
+            AggrExpr,
+            Mode,
+            Input,
+            GroupExprName,
+            AggrExprName,
+            InputSchema,
+            NullExpr,
+            Groups,
+            FilterExpr,
+            OrderByExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr),
+                            "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr),
+                            "mode" => Ok(GeneratedField::Mode),
+                            "input" => Ok(GeneratedField::Input),
+                            "groupExprName" | "group_expr_name" => Ok(GeneratedField::GroupExprName),
+                            "aggrExprName" | "aggr_expr_name" => Ok(GeneratedField::AggrExprName),
+                            "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
+                            "nullExpr" | "null_expr" => Ok(GeneratedField::NullExpr),
+                            "groups" => Ok(GeneratedField::Groups),
+                            "filterExpr" | "filter_expr" => Ok(GeneratedField::FilterExpr),
+                            "orderByExpr" | "order_by_expr" => Ok(GeneratedField::OrderByExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AggregateExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AggregateExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut group_expr__ = None;
+                let mut aggr_expr__ = None;
+                let mut mode__ = None;
+                let mut input__ = None;
+                let mut group_expr_name__ = None;
+                let mut aggr_expr_name__ = None;
+                let mut input_schema__ = None;
+                let mut null_expr__ = None;
+                let mut groups__ = None;
+                let mut filter_expr__ = None;
+                let mut order_by_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::GroupExpr => {
+                            if group_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("groupExpr"));
+                            }
+                            group_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::AggrExpr => {
+                            if aggr_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggrExpr"));
+                            }
+                            aggr_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Mode => {
+                            if mode__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("mode"));
+                            }
+                            mode__ = Some(map.next_value::<AggregateMode>()? as i32);
+                        }
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::GroupExprName => {
+                            if group_expr_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("groupExprName"));
+                            }
+                            group_expr_name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::AggrExprName => {
+                            if aggr_expr_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggrExprName"));
+                            }
+                            aggr_expr_name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::InputSchema => {
+                            if input_schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inputSchema"));
+                            }
+                            input_schema__ = map.next_value()?;
+                        }
+                        GeneratedField::NullExpr => {
+                            if null_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullExpr"));
+                            }
+                            null_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Groups => {
+                            if groups__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("groups"));
+                            }
+                            groups__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::FilterExpr => {
+                            if filter_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filterExpr"));
+                            }
+                            filter_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::OrderByExpr => {
+                            if order_by_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("orderByExpr"));
+                            }
+                            order_by_expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(AggregateExecNode {
+                    group_expr: group_expr__.unwrap_or_default(),
+                    aggr_expr: aggr_expr__.unwrap_or_default(),
+                    mode: mode__.unwrap_or_default(),
+                    input: input__,
+                    group_expr_name: group_expr_name__.unwrap_or_default(),
+                    aggr_expr_name: aggr_expr_name__.unwrap_or_default(),
+                    input_schema: input_schema__,
+                    null_expr: null_expr__.unwrap_or_default(),
+                    groups: groups__.unwrap_or_default(),
+                    filter_expr: filter_expr__.unwrap_or_default(),
+                    order_by_expr: order_by_expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AggregateExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AggregateExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.aggr_function != 0 {
+            len += 1;
+        }
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        if self.distinct {
+            len += 1;
+        }
+        if self.filter.is_some() {
+            len += 1;
+        }
+        if !self.order_by.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExprNode", len)?;
+        if self.aggr_function != 0 {
+            let v = AggregateFunction::from_i32(self.aggr_function)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.aggr_function)))?;
+            struct_ser.serialize_field("aggrFunction", &v)?;
+        }
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        if self.distinct {
+            struct_ser.serialize_field("distinct", &self.distinct)?;
+        }
+        if let Some(v) = self.filter.as_ref() {
+            struct_ser.serialize_field("filter", v)?;
+        }
+        if !self.order_by.is_empty() {
+            struct_ser.serialize_field("orderBy", &self.order_by)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AggregateExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "aggr_function",
+            "aggrFunction",
+            "expr",
+            "distinct",
+            "filter",
+            "order_by",
+            "orderBy",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            AggrFunction,
+            Expr,
+            Distinct,
+            Filter,
+            OrderBy,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "distinct" => Ok(GeneratedField::Distinct),
+                            "filter" => Ok(GeneratedField::Filter),
+                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AggregateExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AggregateExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut aggr_function__ = None;
+                let mut expr__ = None;
+                let mut distinct__ = None;
+                let mut filter__ = None;
+                let mut order_by__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::AggrFunction => {
+                            if aggr_function__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
+                            }
+                            aggr_function__ = Some(map.next_value::<AggregateFunction>()? as i32);
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Distinct => {
+                            if distinct__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("distinct"));
+                            }
+                            distinct__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Filter => {
+                            if filter__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filter"));
+                            }
+                            filter__ = map.next_value()?;
+                        }
+                        GeneratedField::OrderBy => {
+                            if order_by__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("orderBy"));
+                            }
+                            order_by__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(AggregateExprNode {
+                    aggr_function: aggr_function__.unwrap_or_default(),
+                    expr: expr__.unwrap_or_default(),
+                    distinct: distinct__.unwrap_or_default(),
+                    filter: filter__,
+                    order_by: order_by__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AggregateExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AggregateFunction {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Min => "MIN",
+            Self::Max => "MAX",
+            Self::Sum => "SUM",
+            Self::Avg => "AVG",
+            Self::Count => "COUNT",
+            Self::ApproxDistinct => "APPROX_DISTINCT",
+            Self::ArrayAgg => "ARRAY_AGG",
+            Self::Variance => "VARIANCE",
+            Self::VariancePop => "VARIANCE_POP",
+            Self::Covariance => "COVARIANCE",
+            Self::CovariancePop => "COVARIANCE_POP",
+            Self::Stddev => "STDDEV",
+            Self::StddevPop => "STDDEV_POP",
+            Self::Correlation => "CORRELATION",
+            Self::ApproxPercentileCont => "APPROX_PERCENTILE_CONT",
+            Self::ApproxMedian => "APPROX_MEDIAN",
+            Self::ApproxPercentileContWithWeight => "APPROX_PERCENTILE_CONT_WITH_WEIGHT",
+            Self::Grouping => "GROUPING",
+            Self::Median => "MEDIAN",
+            Self::BitAnd => "BIT_AND",
+            Self::BitOr => "BIT_OR",
+            Self::BitXor => "BIT_XOR",
+            Self::BoolAnd => "BOOL_AND",
+            Self::BoolOr => "BOOL_OR",
+            Self::FirstValueAgg => "FIRST_VALUE_AGG",
+            Self::LastValueAgg => "LAST_VALUE_AGG",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for AggregateFunction {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "MIN",
+            "MAX",
+            "SUM",
+            "AVG",
+            "COUNT",
+            "APPROX_DISTINCT",
+            "ARRAY_AGG",
+            "VARIANCE",
+            "VARIANCE_POP",
+            "COVARIANCE",
+            "COVARIANCE_POP",
+            "STDDEV",
+            "STDDEV_POP",
+            "CORRELATION",
+            "APPROX_PERCENTILE_CONT",
+            "APPROX_MEDIAN",
+            "APPROX_PERCENTILE_CONT_WITH_WEIGHT",
+            "GROUPING",
+            "MEDIAN",
+            "BIT_AND",
+            "BIT_OR",
+            "BIT_XOR",
+            "BOOL_AND",
+            "BOOL_OR",
+            "FIRST_VALUE_AGG",
+            "LAST_VALUE_AGG",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AggregateFunction;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(AggregateFunction::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(AggregateFunction::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "MIN" => Ok(AggregateFunction::Min),
+                    "MAX" => Ok(AggregateFunction::Max),
+                    "SUM" => Ok(AggregateFunction::Sum),
+                    "AVG" => Ok(AggregateFunction::Avg),
+                    "COUNT" => Ok(AggregateFunction::Count),
+                    "APPROX_DISTINCT" => Ok(AggregateFunction::ApproxDistinct),
+                    "ARRAY_AGG" => Ok(AggregateFunction::ArrayAgg),
+                    "VARIANCE" => Ok(AggregateFunction::Variance),
+                    "VARIANCE_POP" => Ok(AggregateFunction::VariancePop),
+                    "COVARIANCE" => Ok(AggregateFunction::Covariance),
+                    "COVARIANCE_POP" => Ok(AggregateFunction::CovariancePop),
+                    "STDDEV" => Ok(AggregateFunction::Stddev),
+                    "STDDEV_POP" => Ok(AggregateFunction::StddevPop),
+                    "CORRELATION" => Ok(AggregateFunction::Correlation),
+                    "APPROX_PERCENTILE_CONT" => Ok(AggregateFunction::ApproxPercentileCont),
+                    "APPROX_MEDIAN" => Ok(AggregateFunction::ApproxMedian),
+                    "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => Ok(AggregateFunction::ApproxPercentileContWithWeight),
+                    "GROUPING" => Ok(AggregateFunction::Grouping),
+                    "MEDIAN" => Ok(AggregateFunction::Median),
+                    "BIT_AND" => Ok(AggregateFunction::BitAnd),
+                    "BIT_OR" => Ok(AggregateFunction::BitOr),
+                    "BIT_XOR" => Ok(AggregateFunction::BitXor),
+                    "BOOL_AND" => Ok(AggregateFunction::BoolAnd),
+                    "BOOL_OR" => Ok(AggregateFunction::BoolOr),
+                    "FIRST_VALUE_AGG" => Ok(AggregateFunction::FirstValueAgg),
+                    "LAST_VALUE_AGG" => Ok(AggregateFunction::LastValueAgg),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AggregateMode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Partial => "PARTIAL",
+            Self::Final => "FINAL",
+            Self::FinalPartitioned => "FINAL_PARTITIONED",
+            Self::Single => "SINGLE",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for AggregateMode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "PARTIAL",
+            "FINAL",
+            "FINAL_PARTITIONED",
+            "SINGLE",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AggregateMode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(AggregateMode::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(AggregateMode::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "PARTIAL" => Ok(AggregateMode::Partial),
+                    "FINAL" => Ok(AggregateMode::Final),
+                    "FINAL_PARTITIONED" => Ok(AggregateMode::FinalPartitioned),
+                    "SINGLE" => Ok(AggregateMode::Single),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AggregateNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.group_expr.is_empty() {
+            len += 1;
+        }
+        if !self.aggr_expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.group_expr.is_empty() {
+            struct_ser.serialize_field("groupExpr", &self.group_expr)?;
+        }
+        if !self.aggr_expr.is_empty() {
+            struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AggregateNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "group_expr",
+            "groupExpr",
+            "aggr_expr",
+            "aggrExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            GroupExpr,
+            AggrExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr),
+                            "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AggregateNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AggregateNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut group_expr__ = None;
+                let mut aggr_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::GroupExpr => {
+                            if group_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("groupExpr"));
+                            }
+                            group_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::AggrExpr => {
+                            if aggr_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggrExpr"));
+                            }
+                            aggr_expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(AggregateNode {
+                    input: input__,
+                    group_expr: group_expr__.unwrap_or_default(),
+                    aggr_expr: aggr_expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AggregateNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AggregateUdfExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.fun_name.is_empty() {
+            len += 1;
+        }
+        if !self.args.is_empty() {
+            len += 1;
+        }
+        if self.filter.is_some() {
+            len += 1;
+        }
+        if !self.order_by.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateUDFExprNode", len)?;
+        if !self.fun_name.is_empty() {
+            struct_ser.serialize_field("funName", &self.fun_name)?;
+        }
+        if !self.args.is_empty() {
+            struct_ser.serialize_field("args", &self.args)?;
+        }
+        if let Some(v) = self.filter.as_ref() {
+            struct_ser.serialize_field("filter", v)?;
+        }
+        if !self.order_by.is_empty() {
+            struct_ser.serialize_field("orderBy", &self.order_by)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AggregateUdfExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "fun_name",
+            "funName",
+            "args",
+            "filter",
+            "order_by",
+            "orderBy",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FunName,
+            Args,
+            Filter,
+            OrderBy,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "funName" | "fun_name" => Ok(GeneratedField::FunName),
+                            "args" => Ok(GeneratedField::Args),
+                            "filter" => Ok(GeneratedField::Filter),
+                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AggregateUdfExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AggregateUDFExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateUdfExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut fun_name__ = None;
+                let mut args__ = None;
+                let mut filter__ = None;
+                let mut order_by__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::FunName => {
+                            if fun_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("funName"));
+                            }
+                            fun_name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Args => {
+                            if args__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("args"));
+                            }
+                            args__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Filter => {
+                            if filter__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filter"));
+                            }
+                            filter__ = map.next_value()?;
+                        }
+                        GeneratedField::OrderBy => {
+                            if order_by__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("orderBy"));
+                            }
+                            order_by__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(AggregateUdfExprNode {
+                    fun_name: fun_name__.unwrap_or_default(),
+                    args: args__.unwrap_or_default(),
+                    filter: filter__,
+                    order_by: order_by__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AggregateUDFExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AliasNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if !self.alias.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AliasNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if !self.alias.is_empty() {
+            struct_ser.serialize_field("alias", &self.alias)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AliasNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "alias",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            Alias,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "alias" => Ok(GeneratedField::Alias),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AliasNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AliasNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AliasNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut alias__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Alias => {
+                            if alias__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("alias"));
+                            }
+                            alias__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(AliasNode {
+                    expr: expr__,
+                    alias: alias__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AliasNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AnalyzeNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.verbose {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AnalyzeNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if self.verbose {
+            struct_ser.serialize_field("verbose", &self.verbose)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AnalyzeNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "verbose",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Verbose,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "verbose" => Ok(GeneratedField::Verbose),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AnalyzeNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AnalyzeNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AnalyzeNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut verbose__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Verbose => {
+                            if verbose__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("verbose"));
+                            }
+                            verbose__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(AnalyzeNode {
+                    input: input__,
+                    verbose: verbose__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AnalyzeNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AnalyzedLogicalPlanType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.analyzer_name.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AnalyzedLogicalPlanType", len)?;
+        if !self.analyzer_name.is_empty() {
+            struct_ser.serialize_field("analyzerName", &self.analyzer_name)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AnalyzedLogicalPlanType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "analyzer_name",
+            "analyzerName",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            AnalyzerName,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "analyzerName" | "analyzer_name" => Ok(GeneratedField::AnalyzerName),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AnalyzedLogicalPlanType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AnalyzedLogicalPlanType")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AnalyzedLogicalPlanType, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut analyzer_name__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::AnalyzerName => {
+                            if analyzer_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("analyzerName"));
+                            }
+                            analyzer_name__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(AnalyzedLogicalPlanType {
+                    analyzer_name: analyzer_name__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AnalyzedLogicalPlanType", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ArrowType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.arrow_type_enum.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ArrowType", len)?;
+        if let Some(v) = self.arrow_type_enum.as_ref() {
+            match v {
+                arrow_type::ArrowTypeEnum::None(v) => {
+                    struct_ser.serialize_field("NONE", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Bool(v) => {
+                    struct_ser.serialize_field("BOOL", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Uint8(v) => {
+                    struct_ser.serialize_field("UINT8", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Int8(v) => {
+                    struct_ser.serialize_field("INT8", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Uint16(v) => {
+                    struct_ser.serialize_field("UINT16", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Int16(v) => {
+                    struct_ser.serialize_field("INT16", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Uint32(v) => {
+                    struct_ser.serialize_field("UINT32", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Int32(v) => {
+                    struct_ser.serialize_field("INT32", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Uint64(v) => {
+                    struct_ser.serialize_field("UINT64", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Int64(v) => {
+                    struct_ser.serialize_field("INT64", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Float16(v) => {
+                    struct_ser.serialize_field("FLOAT16", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Float32(v) => {
+                    struct_ser.serialize_field("FLOAT32", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Float64(v) => {
+                    struct_ser.serialize_field("FLOAT64", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Utf8(v) => {
+                    struct_ser.serialize_field("UTF8", v)?;
+                }
+                arrow_type::ArrowTypeEnum::LargeUtf8(v) => {
+                    struct_ser.serialize_field("LARGEUTF8", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Binary(v) => {
+                    struct_ser.serialize_field("BINARY", v)?;
+                }
+                arrow_type::ArrowTypeEnum::FixedSizeBinary(v) => {
+                    struct_ser.serialize_field("FIXEDSIZEBINARY", v)?;
+                }
+                arrow_type::ArrowTypeEnum::LargeBinary(v) => {
+                    struct_ser.serialize_field("LARGEBINARY", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Date32(v) => {
+                    struct_ser.serialize_field("DATE32", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Date64(v) => {
+                    struct_ser.serialize_field("DATE64", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Duration(v) => {
+                    let v = TimeUnit::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("DURATION", &v)?;
+                }
+                arrow_type::ArrowTypeEnum::Timestamp(v) => {
+                    struct_ser.serialize_field("TIMESTAMP", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Time32(v) => {
+                    let v = TimeUnit::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("TIME32", &v)?;
+                }
+                arrow_type::ArrowTypeEnum::Time64(v) => {
+                    let v = TimeUnit::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("TIME64", &v)?;
+                }
+                arrow_type::ArrowTypeEnum::Interval(v) => {
+                    let v = IntervalUnit::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("INTERVAL", &v)?;
+                }
+                arrow_type::ArrowTypeEnum::Decimal(v) => {
+                    struct_ser.serialize_field("DECIMAL", v)?;
+                }
+                arrow_type::ArrowTypeEnum::List(v) => {
+                    struct_ser.serialize_field("LIST", v)?;
+                }
+                arrow_type::ArrowTypeEnum::LargeList(v) => {
+                    struct_ser.serialize_field("LARGELIST", v)?;
+                }
+                arrow_type::ArrowTypeEnum::FixedSizeList(v) => {
+                    struct_ser.serialize_field("FIXEDSIZELIST", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Struct(v) => {
+                    struct_ser.serialize_field("STRUCT", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Union(v) => {
+                    struct_ser.serialize_field("UNION", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Dictionary(v) => {
+                    struct_ser.serialize_field("DICTIONARY", v)?;
+                }
+                arrow_type::ArrowTypeEnum::Map(v) => {
+                    struct_ser.serialize_field("MAP", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ArrowType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "NONE",
+            "BOOL",
+            "UINT8",
+            "INT8",
+            "UINT16",
+            "INT16",
+            "UINT32",
+            "INT32",
+            "UINT64",
+            "INT64",
+            "FLOAT16",
+            "FLOAT32",
+            "FLOAT64",
+            "UTF8",
+            "LARGE_UTF8",
+            "LARGEUTF8",
+            "BINARY",
+            "FIXED_SIZE_BINARY",
+            "FIXEDSIZEBINARY",
+            "LARGE_BINARY",
+            "LARGEBINARY",
+            "DATE32",
+            "DATE64",
+            "DURATION",
+            "TIMESTAMP",
+            "TIME32",
+            "TIME64",
+            "INTERVAL",
+            "DECIMAL",
+            "LIST",
+            "LARGE_LIST",
+            "LARGELIST",
+            "FIXED_SIZE_LIST",
+            "FIXEDSIZELIST",
+            "STRUCT",
+            "UNION",
+            "DICTIONARY",
+            "MAP",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            None,
+            Bool,
+            Uint8,
+            Int8,
+            Uint16,
+            Int16,
+            Uint32,
+            Int32,
+            Uint64,
+            Int64,
+            Float16,
+            Float32,
+            Float64,
+            Utf8,
+            LargeUtf8,
+            Binary,
+            FixedSizeBinary,
+            LargeBinary,
+            Date32,
+            Date64,
+            Duration,
+            Timestamp,
+            Time32,
+            Time64,
+            Interval,
+            Decimal,
+            List,
+            LargeList,
+            FixedSizeList,
+            Struct,
+            Union,
+            Dictionary,
+            Map,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "NONE" => Ok(GeneratedField::None),
+                            "BOOL" => Ok(GeneratedField::Bool),
+                            "UINT8" => Ok(GeneratedField::Uint8),
+                            "INT8" => Ok(GeneratedField::Int8),
+                            "UINT16" => Ok(GeneratedField::Uint16),
+                            "INT16" => Ok(GeneratedField::Int16),
+                            "UINT32" => Ok(GeneratedField::Uint32),
+                            "INT32" => Ok(GeneratedField::Int32),
+                            "UINT64" => Ok(GeneratedField::Uint64),
+                            "INT64" => Ok(GeneratedField::Int64),
+                            "FLOAT16" => Ok(GeneratedField::Float16),
+                            "FLOAT32" => Ok(GeneratedField::Float32),
+                            "FLOAT64" => Ok(GeneratedField::Float64),
+                            "UTF8" => Ok(GeneratedField::Utf8),
+                            "LARGEUTF8" | "LARGE_UTF8" => Ok(GeneratedField::LargeUtf8),
+                            "BINARY" => Ok(GeneratedField::Binary),
+                            "FIXEDSIZEBINARY" | "FIXED_SIZE_BINARY" => Ok(GeneratedField::FixedSizeBinary),
+                            "LARGEBINARY" | "LARGE_BINARY" => Ok(GeneratedField::LargeBinary),
+                            "DATE32" => Ok(GeneratedField::Date32),
+                            "DATE64" => Ok(GeneratedField::Date64),
+                            "DURATION" => Ok(GeneratedField::Duration),
+                            "TIMESTAMP" => Ok(GeneratedField::Timestamp),
+                            "TIME32" => Ok(GeneratedField::Time32),
+                            "TIME64" => Ok(GeneratedField::Time64),
+                            "INTERVAL" => Ok(GeneratedField::Interval),
+                            "DECIMAL" => Ok(GeneratedField::Decimal),
+                            "LIST" => Ok(GeneratedField::List),
+                            "LARGELIST" | "LARGE_LIST" => Ok(GeneratedField::LargeList),
+                            "FIXEDSIZELIST" | "FIXED_SIZE_LIST" => Ok(GeneratedField::FixedSizeList),
+                            "STRUCT" => Ok(GeneratedField::Struct),
+                            "UNION" => Ok(GeneratedField::Union),
+                            "DICTIONARY" => Ok(GeneratedField::Dictionary),
+                            "MAP" => Ok(GeneratedField::Map),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ArrowType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ArrowType")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ArrowType, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut arrow_type_enum__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::None => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("NONE"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::None)
+;
+                        }
+                        GeneratedField::Bool => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("BOOL"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Bool)
+;
+                        }
+                        GeneratedField::Uint8 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("UINT8"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint8)
+;
+                        }
+                        GeneratedField::Int8 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("INT8"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int8)
+;
+                        }
+                        GeneratedField::Uint16 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("UINT16"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint16)
+;
+                        }
+                        GeneratedField::Int16 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("INT16"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int16)
+;
+                        }
+                        GeneratedField::Uint32 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("UINT32"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint32)
+;
+                        }
+                        GeneratedField::Int32 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("INT32"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int32)
+;
+                        }
+                        GeneratedField::Uint64 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("UINT64"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint64)
+;
+                        }
+                        GeneratedField::Int64 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("INT64"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int64)
+;
+                        }
+                        GeneratedField::Float16 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FLOAT16"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float16)
+;
+                        }
+                        GeneratedField::Float32 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FLOAT32"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float32)
+;
+                        }
+                        GeneratedField::Float64 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FLOAT64"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float64)
+;
+                        }
+                        GeneratedField::Utf8 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("UTF8"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Utf8)
+;
+                        }
+                        GeneratedField::LargeUtf8 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("LARGEUTF8"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeUtf8)
+;
+                        }
+                        GeneratedField::Binary => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("BINARY"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Binary)
+;
+                        }
+                        GeneratedField::FixedSizeBinary => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FIXEDSIZEBINARY"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| arrow_type::ArrowTypeEnum::FixedSizeBinary(x.0));
+                        }
+                        GeneratedField::LargeBinary => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("LARGEBINARY"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeBinary)
+;
+                        }
+                        GeneratedField::Date32 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("DATE32"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date32)
+;
+                        }
+                        GeneratedField::Date64 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("DATE64"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date64)
+;
+                        }
+                        GeneratedField::Duration => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("DURATION"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Duration(x as i32));
+                        }
+                        GeneratedField::Timestamp => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("TIMESTAMP"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Timestamp)
+;
+                        }
+                        GeneratedField::Time32 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("TIME32"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Time32(x as i32));
+                        }
+                        GeneratedField::Time64 => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("TIME64"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Time64(x as i32));
+                        }
+                        GeneratedField::Interval => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("INTERVAL"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<IntervalUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Interval(x as i32));
+                        }
+                        GeneratedField::Decimal => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("DECIMAL"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Decimal)
+;
+                        }
+                        GeneratedField::List => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("LIST"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::List)
+;
+                        }
+                        GeneratedField::LargeList => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("LARGELIST"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeList)
+;
+                        }
+                        GeneratedField::FixedSizeList => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FIXEDSIZELIST"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::FixedSizeList)
+;
+                        }
+                        GeneratedField::Struct => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("STRUCT"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Struct)
+;
+                        }
+                        GeneratedField::Union => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("UNION"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Union)
+;
+                        }
+                        GeneratedField::Dictionary => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("DICTIONARY"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Dictionary)
+;
+                        }
+                        GeneratedField::Map => {
+                            if arrow_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("MAP"));
+                            }
+                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Map)
+;
+                        }
+                    }
+                }
+                Ok(ArrowType {
+                    arrow_type_enum: arrow_type_enum__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ArrowType", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AvroFormat {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct("datafusion.AvroFormat", len)?;
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AvroFormat {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                            Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AvroFormat;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AvroFormat")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AvroFormat, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                while map.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(AvroFormat {
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AvroFormat", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for AvroScanExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.base_conf.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.AvroScanExecNode", len)?;
+        if let Some(v) = self.base_conf.as_ref() {
+            struct_ser.serialize_field("baseConf", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for AvroScanExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "base_conf",
+            "baseConf",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            BaseConf,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = AvroScanExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.AvroScanExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<AvroScanExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut base_conf__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::BaseConf => {
+                            if base_conf__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("baseConf"));
+                            }
+                            base_conf__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(AvroScanExecNode {
+                    base_conf: base_conf__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.AvroScanExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for BareTableReference {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.table.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.BareTableReference", len)?;
+        if !self.table.is_empty() {
+            struct_ser.serialize_field("table", &self.table)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for BareTableReference {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "table",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Table,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "table" => Ok(GeneratedField::Table),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = BareTableReference;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.BareTableReference")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<BareTableReference, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut table__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Table => {
+                            if table__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("table"));
+                            }
+                            table__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(BareTableReference {
+                    table: table__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.BareTableReference", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for BetweenNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.negated {
+            len += 1;
+        }
+        if self.low.is_some() {
+            len += 1;
+        }
+        if self.high.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.BetweenNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if self.negated {
+            struct_ser.serialize_field("negated", &self.negated)?;
+        }
+        if let Some(v) = self.low.as_ref() {
+            struct_ser.serialize_field("low", v)?;
+        }
+        if let Some(v) = self.high.as_ref() {
+            struct_ser.serialize_field("high", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for BetweenNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "negated",
+            "low",
+            "high",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            Negated,
+            Low,
+            High,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "negated" => Ok(GeneratedField::Negated),
+                            "low" => Ok(GeneratedField::Low),
+                            "high" => Ok(GeneratedField::High),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = BetweenNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.BetweenNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<BetweenNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut negated__ = None;
+                let mut low__ = None;
+                let mut high__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Negated => {
+                            if negated__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negated"));
+                            }
+                            negated__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Low => {
+                            if low__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("low"));
+                            }
+                            low__ = map.next_value()?;
+                        }
+                        GeneratedField::High => {
+                            if high__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("high"));
+                            }
+                            high__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(BetweenNode {
+                    expr: expr__,
+                    negated: negated__.unwrap_or_default(),
+                    low: low__,
+                    high: high__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.BetweenNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for BinaryExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.operands.is_empty() {
+            len += 1;
+        }
+        if !self.op.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.BinaryExprNode", len)?;
+        if !self.operands.is_empty() {
+            struct_ser.serialize_field("operands", &self.operands)?;
+        }
+        if !self.op.is_empty() {
+            struct_ser.serialize_field("op", &self.op)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for BinaryExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "operands",
+            "op",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Operands,
+            Op,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "operands" => Ok(GeneratedField::Operands),
+                            "op" => Ok(GeneratedField::Op),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = BinaryExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.BinaryExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<BinaryExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut operands__ = None;
+                let mut op__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Operands => {
+                            if operands__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("operands"));
+                            }
+                            operands__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Op => {
+                            if op__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("op"));
+                            }
+                            op__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(BinaryExprNode {
+                    operands: operands__.unwrap_or_default(),
+                    op: op__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.BinaryExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for BuiltInWindowFunction {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::RowNumber => "ROW_NUMBER",
+            Self::Rank => "RANK",
+            Self::DenseRank => "DENSE_RANK",
+            Self::PercentRank => "PERCENT_RANK",
+            Self::CumeDist => "CUME_DIST",
+            Self::Ntile => "NTILE",
+            Self::Lag => "LAG",
+            Self::Lead => "LEAD",
+            Self::FirstValue => "FIRST_VALUE",
+            Self::LastValue => "LAST_VALUE",
+            Self::NthValue => "NTH_VALUE",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for BuiltInWindowFunction {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "ROW_NUMBER",
+            "RANK",
+            "DENSE_RANK",
+            "PERCENT_RANK",
+            "CUME_DIST",
+            "NTILE",
+            "LAG",
+            "LEAD",
+            "FIRST_VALUE",
+            "LAST_VALUE",
+            "NTH_VALUE",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = BuiltInWindowFunction;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(BuiltInWindowFunction::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(BuiltInWindowFunction::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "ROW_NUMBER" => Ok(BuiltInWindowFunction::RowNumber),
+                    "RANK" => Ok(BuiltInWindowFunction::Rank),
+                    "DENSE_RANK" => Ok(BuiltInWindowFunction::DenseRank),
+                    "PERCENT_RANK" => Ok(BuiltInWindowFunction::PercentRank),
+                    "CUME_DIST" => Ok(BuiltInWindowFunction::CumeDist),
+                    "NTILE" => Ok(BuiltInWindowFunction::Ntile),
+                    "LAG" => Ok(BuiltInWindowFunction::Lag),
+                    "LEAD" => Ok(BuiltInWindowFunction::Lead),
+                    "FIRST_VALUE" => Ok(BuiltInWindowFunction::FirstValue),
+                    "LAST_VALUE" => Ok(BuiltInWindowFunction::LastValue),
+                    "NTH_VALUE" => Ok(BuiltInWindowFunction::NthValue),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CaseNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if !self.when_then_expr.is_empty() {
+            len += 1;
+        }
+        if self.else_expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CaseNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if !self.when_then_expr.is_empty() {
+            struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?;
+        }
+        if let Some(v) = self.else_expr.as_ref() {
+            struct_ser.serialize_field("elseExpr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CaseNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "when_then_expr",
+            "whenThenExpr",
+            "else_expr",
+            "elseExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            WhenThenExpr,
+            ElseExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr),
+                            "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CaseNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CaseNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CaseNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut when_then_expr__ = None;
+                let mut else_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::WhenThenExpr => {
+                            if when_then_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("whenThenExpr"));
+                            }
+                            when_then_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::ElseExpr => {
+                            if else_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("elseExpr"));
+                            }
+                            else_expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(CaseNode {
+                    expr: expr__,
+                    when_then_expr: when_then_expr__.unwrap_or_default(),
+                    else_expr: else_expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CaseNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CastNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.arrow_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CastNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.arrow_type.as_ref() {
+            struct_ser.serialize_field("arrowType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CastNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "arrow_type",
+            "arrowType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            ArrowType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CastNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CastNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CastNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut arrow_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::ArrowType => {
+                            if arrow_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("arrowType"));
+                            }
+                            arrow_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(CastNode {
+                    expr: expr__,
+                    arrow_type: arrow_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CastNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CoalesceBatchesExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.target_batch_size != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CoalesceBatchesExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if self.target_batch_size != 0 {
+            struct_ser.serialize_field("targetBatchSize", &self.target_batch_size)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CoalesceBatchesExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "target_batch_size",
+            "targetBatchSize",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            TargetBatchSize,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "targetBatchSize" | "target_batch_size" => Ok(GeneratedField::TargetBatchSize),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CoalesceBatchesExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CoalesceBatchesExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CoalesceBatchesExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut target_batch_size__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::TargetBatchSize => {
+                            if target_batch_size__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("targetBatchSize"));
+                            }
+                            target_batch_size__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(CoalesceBatchesExecNode {
+                    input: input__,
+                    target_batch_size: target_batch_size__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CoalesceBatchesExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CoalescePartitionsExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CoalescePartitionsExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CoalescePartitionsExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CoalescePartitionsExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CoalescePartitionsExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CoalescePartitionsExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(CoalescePartitionsExecNode {
+                    input: input__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CoalescePartitionsExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Column {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if self.relation.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Column", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if let Some(v) = self.relation.as_ref() {
+            struct_ser.serialize_field("relation", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Column {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "relation",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Relation,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "relation" => Ok(GeneratedField::Relation),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Column;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Column")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Column, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut relation__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Relation => {
+                            if relation__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relation"));
+                            }
+                            relation__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(Column {
+                    name: name__.unwrap_or_default(),
+                    relation: relation__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Column", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ColumnIndex {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.index != 0 {
+            len += 1;
+        }
+        if self.side != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ColumnIndex", len)?;
+        if self.index != 0 {
+            struct_ser.serialize_field("index", &self.index)?;
+        }
+        if self.side != 0 {
+            let v = JoinSide::from_i32(self.side)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.side)))?;
+            struct_ser.serialize_field("side", &v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ColumnIndex {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "index",
+            "side",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Index,
+            Side,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "index" => Ok(GeneratedField::Index),
+                            "side" => Ok(GeneratedField::Side),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ColumnIndex;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ColumnIndex")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ColumnIndex, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut index__ = None;
+                let mut side__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Index => {
+                            if index__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("index"));
+                            }
+                            index__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Side => {
+                            if side__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("side"));
+                            }
+                            side__ = Some(map.next_value::<JoinSide>()? as i32);
+                        }
+                    }
+                }
+                Ok(ColumnIndex {
+                    index: index__.unwrap_or_default(),
+                    side: side__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ColumnIndex", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ColumnRelation {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.relation.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ColumnRelation", len)?;
+        if !self.relation.is_empty() {
+            struct_ser.serialize_field("relation", &self.relation)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ColumnRelation {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "relation",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Relation,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "relation" => Ok(GeneratedField::Relation),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ColumnRelation;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ColumnRelation")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ColumnRelation, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut relation__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Relation => {
+                            if relation__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("relation"));
+                            }
+                            relation__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ColumnRelation {
+                    relation: relation__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ColumnRelation", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ColumnStats {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.min_value.is_some() {
+            len += 1;
+        }
+        if self.max_value.is_some() {
+            len += 1;
+        }
+        if self.null_count != 0 {
+            len += 1;
+        }
+        if self.distinct_count != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ColumnStats", len)?;
+        if let Some(v) = self.min_value.as_ref() {
+            struct_ser.serialize_field("minValue", v)?;
+        }
+        if let Some(v) = self.max_value.as_ref() {
+            struct_ser.serialize_field("maxValue", v)?;
+        }
+        if self.null_count != 0 {
+            struct_ser.serialize_field("nullCount", &self.null_count)?;
+        }
+        if self.distinct_count != 0 {
+            struct_ser.serialize_field("distinctCount", &self.distinct_count)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ColumnStats {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "min_value",
+            "minValue",
+            "max_value",
+            "maxValue",
+            "null_count",
+            "nullCount",
+            "distinct_count",
+            "distinctCount",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            MinValue,
+            MaxValue,
+            NullCount,
+            DistinctCount,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "minValue" | "min_value" => Ok(GeneratedField::MinValue),
+                            "maxValue" | "max_value" => Ok(GeneratedField::MaxValue),
+                            "nullCount" | "null_count" => Ok(GeneratedField::NullCount),
+                            "distinctCount" | "distinct_count" => Ok(GeneratedField::DistinctCount),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ColumnStats;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ColumnStats")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ColumnStats, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut min_value__ = None;
+                let mut max_value__ = None;
+                let mut null_count__ = None;
+                let mut distinct_count__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::MinValue => {
+                            if min_value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("minValue"));
+                            }
+                            min_value__ = map.next_value()?;
+                        }
+                        GeneratedField::MaxValue => {
+                            if max_value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("maxValue"));
+                            }
+                            max_value__ = map.next_value()?;
+                        }
+                        GeneratedField::NullCount => {
+                            if null_count__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullCount"));
+                            }
+                            null_count__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::DistinctCount => {
+                            if distinct_count__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("distinctCount"));
+                            }
+                            distinct_count__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(ColumnStats {
+                    min_value: min_value__,
+                    max_value: max_value__,
+                    null_count: null_count__.unwrap_or_default(),
+                    distinct_count: distinct_count__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ColumnStats", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CreateCatalogNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.catalog_name.is_empty() {
+            len += 1;
+        }
+        if self.if_not_exists {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogNode", len)?;
+        if !self.catalog_name.is_empty() {
+            struct_ser.serialize_field("catalogName", &self.catalog_name)?;
+        }
+        if self.if_not_exists {
+            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CreateCatalogNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "catalog_name",
+            "catalogName",
+            "if_not_exists",
+            "ifNotExists",
+            "schema",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            CatalogName,
+            IfNotExists,
+            Schema,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
+                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
+                            "schema" => Ok(GeneratedField::Schema),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CreateCatalogNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CreateCatalogNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateCatalogNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut catalog_name__ = None;
+                let mut if_not_exists__ = None;
+                let mut schema__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::CatalogName => {
+                            if catalog_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("catalogName"));
+                            }
+                            catalog_name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::IfNotExists => {
+                            if if_not_exists__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
+                            }
+                            if_not_exists__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(CreateCatalogNode {
+                    catalog_name: catalog_name__.unwrap_or_default(),
+                    if_not_exists: if_not_exists__.unwrap_or_default(),
+                    schema: schema__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CreateCatalogNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CreateCatalogSchemaNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.schema_name.is_empty() {
+            len += 1;
+        }
+        if self.if_not_exists {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogSchemaNode", len)?;
+        if !self.schema_name.is_empty() {
+            struct_ser.serialize_field("schemaName", &self.schema_name)?;
+        }
+        if self.if_not_exists {
+            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "schema_name",
+            "schemaName",
+            "if_not_exists",
+            "ifNotExists",
+            "schema",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SchemaName,
+            IfNotExists,
+            Schema,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
+                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
+                            "schema" => Ok(GeneratedField::Schema),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CreateCatalogSchemaNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CreateCatalogSchemaNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateCatalogSchemaNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut schema_name__ = None;
+                let mut if_not_exists__ = None;
+                let mut schema__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::SchemaName => {
+                            if schema_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schemaName"));
+                            }
+                            schema_name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::IfNotExists => {
+                            if if_not_exists__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
+                            }
+                            if_not_exists__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(CreateCatalogSchemaNode {
+                    schema_name: schema_name__.unwrap_or_default(),
+                    if_not_exists: if_not_exists__.unwrap_or_default(),
+                    schema: schema__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CreateCatalogSchemaNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CreateExternalTableNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.name.is_some() {
+            len += 1;
+        }
+        if !self.location.is_empty() {
+            len += 1;
+        }
+        if !self.file_type.is_empty() {
+            len += 1;
+        }
+        if self.has_header {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        if !self.table_partition_cols.is_empty() {
+            len += 1;
+        }
+        if self.if_not_exists {
+            len += 1;
+        }
+        if !self.delimiter.is_empty() {
+            len += 1;
+        }
+        if !self.definition.is_empty() {
+            len += 1;
+        }
+        if !self.file_compression_type.is_empty() {
+            len += 1;
+        }
+        if !self.order_exprs.is_empty() {
+            len += 1;
+        }
+        if self.unbounded {
+            len += 1;
+        }
+        if !self.options.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CreateExternalTableNode", len)?;
+        if let Some(v) = self.name.as_ref() {
+            struct_ser.serialize_field("name", v)?;
+        }
+        if !self.location.is_empty() {
+            struct_ser.serialize_field("location", &self.location)?;
+        }
+        if !self.file_type.is_empty() {
+            struct_ser.serialize_field("fileType", &self.file_type)?;
+        }
+        if self.has_header {
+            struct_ser.serialize_field("hasHeader", &self.has_header)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        if !self.table_partition_cols.is_empty() {
+            struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?;
+        }
+        if self.if_not_exists {
+            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
+        }
+        if !self.delimiter.is_empty() {
+            struct_ser.serialize_field("delimiter", &self.delimiter)?;
+        }
+        if !self.definition.is_empty() {
+            struct_ser.serialize_field("definition", &self.definition)?;
+        }
+        if !self.file_compression_type.is_empty() {
+            struct_ser.serialize_field("fileCompressionType", &self.file_compression_type)?;
+        }
+        if !self.order_exprs.is_empty() {
+            struct_ser.serialize_field("orderExprs", &self.order_exprs)?;
+        }
+        if self.unbounded {
+            struct_ser.serialize_field("unbounded", &self.unbounded)?;
+        }
+        if !self.options.is_empty() {
+            struct_ser.serialize_field("options", &self.options)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CreateExternalTableNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "location",
+            "file_type",
+            "fileType",
+            "has_header",
+            "hasHeader",
+            "schema",
+            "table_partition_cols",
+            "tablePartitionCols",
+            "if_not_exists",
+            "ifNotExists",
+            "delimiter",
+            "definition",
+            "file_compression_type",
+            "fileCompressionType",
+            "order_exprs",
+            "orderExprs",
+            "unbounded",
+            "options",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Location,
+            FileType,
+            HasHeader,
+            Schema,
+            TablePartitionCols,
+            IfNotExists,
+            Delimiter,
+            Definition,
+            FileCompressionType,
+            OrderExprs,
+            Unbounded,
+            Options,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "location" => Ok(GeneratedField::Location),
+                            "fileType" | "file_type" => Ok(GeneratedField::FileType),
+                            "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
+                            "schema" => Ok(GeneratedField::Schema),
+                            "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
+                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
+                            "delimiter" => Ok(GeneratedField::Delimiter),
+                            "definition" => Ok(GeneratedField::Definition),
+                            "fileCompressionType" | "file_compression_type" => Ok(GeneratedField::FileCompressionType),
+                            "orderExprs" | "order_exprs" => Ok(GeneratedField::OrderExprs),
+                            "unbounded" => Ok(GeneratedField::Unbounded),
+                            "options" => Ok(GeneratedField::Options),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CreateExternalTableNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CreateExternalTableNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateExternalTableNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut location__ = None;
+                let mut file_type__ = None;
+                let mut has_header__ = None;
+                let mut schema__ = None;
+                let mut table_partition_cols__ = None;
+                let mut if_not_exists__ = None;
+                let mut delimiter__ = None;
+                let mut definition__ = None;
+                let mut file_compression_type__ = None;
+                let mut order_exprs__ = None;
+                let mut unbounded__ = None;
+                let mut options__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = map.next_value()?;
+                        }
+                        GeneratedField::Location => {
+                            if location__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("location"));
+                            }
+                            location__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::FileType => {
+                            if file_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fileType"));
+                            }
+                            file_type__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::HasHeader => {
+                            if has_header__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hasHeader"));
+                            }
+                            has_header__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                        GeneratedField::TablePartitionCols => {
+                            if table_partition_cols__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tablePartitionCols"));
+                            }
+                            table_partition_cols__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::IfNotExists => {
+                            if if_not_exists__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
+                            }
+                            if_not_exists__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Delimiter => {
+                            if delimiter__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("delimiter"));
+                            }
+                            delimiter__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Definition => {
+                            if definition__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("definition"));
+                            }
+                            definition__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::FileCompressionType => {
+                            if file_compression_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fileCompressionType"));
+                            }
+                            file_compression_type__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::OrderExprs => {
+                            if order_exprs__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("orderExprs"));
+                            }
+                            order_exprs__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Unbounded => {
+                            if unbounded__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("unbounded"));
+                            }
+                            unbounded__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Options => {
+                            if options__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("options"));
+                            }
+                            options__ = Some(
+                                map.next_value::<std::collections::HashMap<_, _>>()?
+                            );
+                        }
+                    }
+                }
+                Ok(CreateExternalTableNode {
+                    name: name__,
+                    location: location__.unwrap_or_default(),
+                    file_type: file_type__.unwrap_or_default(),
+                    has_header: has_header__.unwrap_or_default(),
+                    schema: schema__,
+                    table_partition_cols: table_partition_cols__.unwrap_or_default(),
+                    if_not_exists: if_not_exists__.unwrap_or_default(),
+                    delimiter: delimiter__.unwrap_or_default(),
+                    definition: definition__.unwrap_or_default(),
+                    file_compression_type: file_compression_type__.unwrap_or_default(),
+                    order_exprs: order_exprs__.unwrap_or_default(),
+                    unbounded: unbounded__.unwrap_or_default(),
+                    options: options__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CreateExternalTableNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CreateViewNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.name.is_some() {
+            len += 1;
+        }
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.or_replace {
+            len += 1;
+        }
+        if !self.definition.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CreateViewNode", len)?;
+        if let Some(v) = self.name.as_ref() {
+            struct_ser.serialize_field("name", v)?;
+        }
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if self.or_replace {
+            struct_ser.serialize_field("orReplace", &self.or_replace)?;
+        }
+        if !self.definition.is_empty() {
+            struct_ser.serialize_field("definition", &self.definition)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CreateViewNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "input",
+            "or_replace",
+            "orReplace",
+            "definition",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Input,
+            OrReplace,
+            Definition,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "input" => Ok(GeneratedField::Input),
+                            "orReplace" | "or_replace" => Ok(GeneratedField::OrReplace),
+                            "definition" => Ok(GeneratedField::Definition),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CreateViewNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CreateViewNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateViewNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut input__ = None;
+                let mut or_replace__ = None;
+                let mut definition__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = map.next_value()?;
+                        }
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::OrReplace => {
+                            if or_replace__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("orReplace"));
+                            }
+                            or_replace__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Definition => {
+                            if definition__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("definition"));
+                            }
+                            definition__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(CreateViewNode {
+                    name: name__,
+                    input: input__,
+                    or_replace: or_replace__.unwrap_or_default(),
+                    definition: definition__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CreateViewNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CrossJoinExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.left.is_some() {
+            len += 1;
+        }
+        if self.right.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinExecNode", len)?;
+        if let Some(v) = self.left.as_ref() {
+            struct_ser.serialize_field("left", v)?;
+        }
+        if let Some(v) = self.right.as_ref() {
+            struct_ser.serialize_field("right", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CrossJoinExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "left",
+            "right",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Left,
+            Right,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "left" => Ok(GeneratedField::Left),
+                            "right" => Ok(GeneratedField::Right),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CrossJoinExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CrossJoinExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CrossJoinExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut left__ = None;
+                let mut right__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Left => {
+                            if left__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("left"));
+                            }
+                            left__ = map.next_value()?;
+                        }
+                        GeneratedField::Right => {
+                            if right__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("right"));
+                            }
+                            right__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(CrossJoinExecNode {
+                    left: left__,
+                    right: right__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CrossJoinExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CrossJoinNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.left.is_some() {
+            len += 1;
+        }
+        if self.right.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinNode", len)?;
+        if let Some(v) = self.left.as_ref() {
+            struct_ser.serialize_field("left", v)?;
+        }
+        if let Some(v) = self.right.as_ref() {
+            struct_ser.serialize_field("right", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CrossJoinNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "left",
+            "right",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Left,
+            Right,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "left" => Ok(GeneratedField::Left),
+                            "right" => Ok(GeneratedField::Right),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CrossJoinNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CrossJoinNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CrossJoinNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut left__ = None;
+                let mut right__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Left => {
+                            if left__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("left"));
+                            }
+                            left__ = map.next_value()?;
+                        }
+                        GeneratedField::Right => {
+                            if right__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("right"));
+                            }
+                            right__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(CrossJoinNode {
+                    left: left__,
+                    right: right__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CrossJoinNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CsvFormat {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.has_header {
+            len += 1;
+        }
+        if !self.delimiter.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CsvFormat", len)?;
+        if self.has_header {
+            struct_ser.serialize_field("hasHeader", &self.has_header)?;
+        }
+        if !self.delimiter.is_empty() {
+            struct_ser.serialize_field("delimiter", &self.delimiter)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CsvFormat {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "has_header",
+            "hasHeader",
+            "delimiter",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            HasHeader,
+            Delimiter,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
+                            "delimiter" => Ok(GeneratedField::Delimiter),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CsvFormat;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CsvFormat")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CsvFormat, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut has_header__ = None;
+                let mut delimiter__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::HasHeader => {
+                            if has_header__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hasHeader"));
+                            }
+                            has_header__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Delimiter => {
+                            if delimiter__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("delimiter"));
+                            }
+                            delimiter__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(CsvFormat {
+                    has_header: has_header__.unwrap_or_default(),
+                    delimiter: delimiter__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CsvFormat", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CsvScanExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.base_conf.is_some() {
+            len += 1;
+        }
+        if self.has_header {
+            len += 1;
+        }
+        if !self.delimiter.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CsvScanExecNode", len)?;
+        if let Some(v) = self.base_conf.as_ref() {
+            struct_ser.serialize_field("baseConf", v)?;
+        }
+        if self.has_header {
+            struct_ser.serialize_field("hasHeader", &self.has_header)?;
+        }
+        if !self.delimiter.is_empty() {
+            struct_ser.serialize_field("delimiter", &self.delimiter)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CsvScanExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "base_conf",
+            "baseConf",
+            "has_header",
+            "hasHeader",
+            "delimiter",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            BaseConf,
+            HasHeader,
+            Delimiter,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf),
+                            "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
+                            "delimiter" => Ok(GeneratedField::Delimiter),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CsvScanExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CsvScanExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CsvScanExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut base_conf__ = None;
+                let mut has_header__ = None;
+                let mut delimiter__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::BaseConf => {
+                            if base_conf__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("baseConf"));
+                            }
+                            base_conf__ = map.next_value()?;
+                        }
+                        GeneratedField::HasHeader => {
+                            if has_header__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hasHeader"));
+                            }
+                            has_header__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Delimiter => {
+                            if delimiter__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("delimiter"));
+                            }
+                            delimiter__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(CsvScanExecNode {
+                    base_conf: base_conf__,
+                    has_header: has_header__.unwrap_or_default(),
+                    delimiter: delimiter__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CsvScanExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CubeNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CubeNode", len)?;
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CubeNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CubeNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CubeNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CubeNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(CubeNode {
+                    expr: expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CubeNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for CustomTableScanNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.table_name.is_some() {
+            len += 1;
+        }
+        if self.projection.is_some() {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        if !self.filters.is_empty() {
+            len += 1;
+        }
+        if !self.custom_table_data.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.CustomTableScanNode", len)?;
+        if let Some(v) = self.table_name.as_ref() {
+            struct_ser.serialize_field("tableName", v)?;
+        }
+        if let Some(v) = self.projection.as_ref() {
+            struct_ser.serialize_field("projection", v)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        if !self.filters.is_empty() {
+            struct_ser.serialize_field("filters", &self.filters)?;
+        }
+        if !self.custom_table_data.is_empty() {
+            struct_ser.serialize_field("customTableData", pbjson::private::base64::encode(&self.custom_table_data).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for CustomTableScanNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "table_name",
+            "tableName",
+            "projection",
+            "schema",
+            "filters",
+            "custom_table_data",
+            "customTableData",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            TableName,
+            Projection,
+            Schema,
+            Filters,
+            CustomTableData,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
+                            "projection" => Ok(GeneratedField::Projection),
+                            "schema" => Ok(GeneratedField::Schema),
+                            "filters" => Ok(GeneratedField::Filters),
+                            "customTableData" | "custom_table_data" => Ok(GeneratedField::CustomTableData),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = CustomTableScanNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.CustomTableScanNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<CustomTableScanNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut table_name__ = None;
+                let mut projection__ = None;
+                let mut schema__ = None;
+                let mut filters__ = None;
+                let mut custom_table_data__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::TableName => {
+                            if table_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tableName"));
+                            }
+                            table_name__ = map.next_value()?;
+                        }
+                        GeneratedField::Projection => {
+                            if projection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("projection"));
+                            }
+                            projection__ = map.next_value()?;
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                        GeneratedField::Filters => {
+                            if filters__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filters"));
+                            }
+                            filters__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::CustomTableData => {
+                            if custom_table_data__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("customTableData"));
+                            }
+                            custom_table_data__ = 
+                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(CustomTableScanNode {
+                    table_name: table_name__,
+                    projection: projection__,
+                    schema: schema__,
+                    filters: filters__.unwrap_or_default(),
+                    custom_table_data: custom_table_data__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.CustomTableScanNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for DateUnit {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Day => "Day",
+            Self::DateMillisecond => "DateMillisecond",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for DateUnit {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "Day",
+            "DateMillisecond",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DateUnit;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(DateUnit::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(DateUnit::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "Day" => Ok(DateUnit::Day),
+                    "DateMillisecond" => Ok(DateUnit::DateMillisecond),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Decimal {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.precision != 0 {
+            len += 1;
+        }
+        if self.scale != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Decimal", len)?;
+        if self.precision != 0 {
+            struct_ser.serialize_field("precision", &self.precision)?;
+        }
+        if self.scale != 0 {
+            struct_ser.serialize_field("scale", &self.scale)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Decimal {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "precision",
+            "scale",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Precision,
+            Scale,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "precision" => Ok(GeneratedField::Precision),
+                            "scale" => Ok(GeneratedField::Scale),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Decimal;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Decimal")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Decimal, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut precision__ = None;
+                let mut scale__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Precision => {
+                            if precision__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("precision"));
+                            }
+                            precision__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Scale => {
+                            if scale__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("scale"));
+                            }
+                            scale__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(Decimal {
+                    precision: precision__.unwrap_or_default(),
+                    scale: scale__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Decimal", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Decimal128 {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.value.is_empty() {
+            len += 1;
+        }
+        if self.p != 0 {
+            len += 1;
+        }
+        if self.s != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Decimal128", len)?;
+        if !self.value.is_empty() {
+            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
+        }
+        if self.p != 0 {
+            struct_ser.serialize_field("p", ToString::to_string(&self.p).as_str())?;
+        }
+        if self.s != 0 {
+            struct_ser.serialize_field("s", ToString::to_string(&self.s).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Decimal128 {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "value",
+            "p",
+            "s",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Value,
+            P,
+            S,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "value" => Ok(GeneratedField::Value),
+                            "p" => Ok(GeneratedField::P),
+                            "s" => Ok(GeneratedField::S),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Decimal128;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Decimal128")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Decimal128, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut value__ = None;
+                let mut p__ = None;
+                let mut s__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("value"));
+                            }
+                            value__ = 
+                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::P => {
+                            if p__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("p"));
+                            }
+                            p__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::S => {
+                            if s__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("s"));
+                            }
+                            s__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(Decimal128 {
+                    value: value__.unwrap_or_default(),
+                    p: p__.unwrap_or_default(),
+                    s: s__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Decimal128", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for DfField {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.field.is_some() {
+            len += 1;
+        }
+        if self.qualifier.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.DfField", len)?;
+        if let Some(v) = self.field.as_ref() {
+            struct_ser.serialize_field("field", v)?;
+        }
+        if let Some(v) = self.qualifier.as_ref() {
+            struct_ser.serialize_field("qualifier", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for DfField {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "field",
+            "qualifier",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Field,
+            Qualifier,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "field" => Ok(GeneratedField::Field),
+                            "qualifier" => Ok(GeneratedField::Qualifier),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DfField;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.DfField")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<DfField, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut field__ = None;
+                let mut qualifier__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Field => {
+                            if field__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("field"));
+                            }
+                            field__ = map.next_value()?;
+                        }
+                        GeneratedField::Qualifier => {
+                            if qualifier__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("qualifier"));
+                            }
+                            qualifier__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(DfField {
+                    field: field__,
+                    qualifier: qualifier__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.DfField", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for DfSchema {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.columns.is_empty() {
+            len += 1;
+        }
+        if !self.metadata.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.DfSchema", len)?;
+        if !self.columns.is_empty() {
+            struct_ser.serialize_field("columns", &self.columns)?;
+        }
+        if !self.metadata.is_empty() {
+            struct_ser.serialize_field("metadata", &self.metadata)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for DfSchema {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "columns",
+            "metadata",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Columns,
+            Metadata,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "columns" => Ok(GeneratedField::Columns),
+                            "metadata" => Ok(GeneratedField::Metadata),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DfSchema;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.DfSchema")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<DfSchema, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut columns__ = None;
+                let mut metadata__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Columns => {
+                            if columns__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("columns"));
+                            }
+                            columns__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Metadata => {
+                            if metadata__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("metadata"));
+                            }
+                            metadata__ = Some(
+                                map.next_value::<std::collections::HashMap<_, _>>()?
+                            );
+                        }
+                    }
+                }
+                Ok(DfSchema {
+                    columns: columns__.unwrap_or_default(),
+                    metadata: metadata__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.DfSchema", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Dictionary {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.key.is_some() {
+            len += 1;
+        }
+        if self.value.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Dictionary", len)?;
+        if let Some(v) = self.key.as_ref() {
+            struct_ser.serialize_field("key", v)?;
+        }
+        if let Some(v) = self.value.as_ref() {
+            struct_ser.serialize_field("value", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Dictionary {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "key",
+            "value",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Key,
+            Value,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "key" => Ok(GeneratedField::Key),
+                            "value" => Ok(GeneratedField::Value),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Dictionary;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Dictionary")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Dictionary, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut key__ = None;
+                let mut value__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = map.next_value()?;
+                        }
+                        GeneratedField::Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("value"));
+                            }
+                            value__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(Dictionary {
+                    key: key__,
+                    value: value__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Dictionary", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for DistinctNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.DistinctNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for DistinctNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DistinctNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.DistinctNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<DistinctNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(DistinctNode {
+                    input: input__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.DistinctNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for DropViewNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.name.is_some() {
+            len += 1;
+        }
+        if self.if_exists {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.DropViewNode", len)?;
+        if let Some(v) = self.name.as_ref() {
+            struct_ser.serialize_field("name", v)?;
+        }
+        if self.if_exists {
+            struct_ser.serialize_field("ifExists", &self.if_exists)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for DropViewNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "if_exists",
+            "ifExists",
+            "schema",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            IfExists,
+            Schema,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "ifExists" | "if_exists" => Ok(GeneratedField::IfExists),
+                            "schema" => Ok(GeneratedField::Schema),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = DropViewNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.DropViewNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<DropViewNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut if_exists__ = None;
+                let mut schema__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = map.next_value()?;
+                        }
+                        GeneratedField::IfExists => {
+                            if if_exists__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ifExists"));
+                            }
+                            if_exists__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(DropViewNode {
+                    name: name__,
+                    if_exists: if_exists__.unwrap_or_default(),
+                    schema: schema__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.DropViewNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for EmptyExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.produce_one_row {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.EmptyExecNode", len)?;
+        if self.produce_one_row {
+            struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for EmptyExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "produce_one_row",
+            "produceOneRow",
+            "schema",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ProduceOneRow,
+            Schema,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow),
+                            "schema" => Ok(GeneratedField::Schema),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = EmptyExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.EmptyExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<EmptyExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut produce_one_row__ = None;
+                let mut schema__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::ProduceOneRow => {
+                            if produce_one_row__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("produceOneRow"));
+                            }
+                            produce_one_row__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(EmptyExecNode {
+                    produce_one_row: produce_one_row__.unwrap_or_default(),
+                    schema: schema__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.EmptyExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for EmptyMessage {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct("datafusion.EmptyMessage", len)?;
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for EmptyMessage {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                            Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = EmptyMessage;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.EmptyMessage")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<EmptyMessage, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                while map.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(EmptyMessage {
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.EmptyMessage", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for EmptyRelationNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.produce_one_row {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.EmptyRelationNode", len)?;
+        if self.produce_one_row {
+            struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for EmptyRelationNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "produce_one_row",
+            "produceOneRow",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ProduceOneRow,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = EmptyRelationNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.EmptyRelationNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<EmptyRelationNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut produce_one_row__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::ProduceOneRow => {
+                            if produce_one_row__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("produceOneRow"));
+                            }
+                            produce_one_row__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(EmptyRelationNode {
+                    produce_one_row: produce_one_row__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.EmptyRelationNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ExplainExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.schema.is_some() {
+            len += 1;
+        }
+        if !self.stringified_plans.is_empty() {
+            len += 1;
+        }
+        if self.verbose {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ExplainExecNode", len)?;
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        if !self.stringified_plans.is_empty() {
+            struct_ser.serialize_field("stringifiedPlans", &self.stringified_plans)?;
+        }
+        if self.verbose {
+            struct_ser.serialize_field("verbose", &self.verbose)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ExplainExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "schema",
+            "stringified_plans",
+            "stringifiedPlans",
+            "verbose",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Schema,
+            StringifiedPlans,
+            Verbose,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "schema" => Ok(GeneratedField::Schema),
+                            "stringifiedPlans" | "stringified_plans" => Ok(GeneratedField::StringifiedPlans),
+                            "verbose" => Ok(GeneratedField::Verbose),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ExplainExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ExplainExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ExplainExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut schema__ = None;
+                let mut stringified_plans__ = None;
+                let mut verbose__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                        GeneratedField::StringifiedPlans => {
+                            if stringified_plans__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("stringifiedPlans"));
+                            }
+                            stringified_plans__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Verbose => {
+                            if verbose__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("verbose"));
+                            }
+                            verbose__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ExplainExecNode {
+                    schema: schema__,
+                    stringified_plans: stringified_plans__.unwrap_or_default(),
+                    verbose: verbose__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ExplainExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ExplainNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.verbose {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ExplainNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if self.verbose {
+            struct_ser.serialize_field("verbose", &self.verbose)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ExplainNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "verbose",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Verbose,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "verbose" => Ok(GeneratedField::Verbose),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ExplainNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ExplainNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ExplainNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut verbose__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Verbose => {
+                            if verbose__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("verbose"));
+                            }
+                            verbose__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ExplainNode {
+                    input: input__,
+                    verbose: verbose__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ExplainNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Field {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if self.arrow_type.is_some() {
+            len += 1;
+        }
+        if self.nullable {
+            len += 1;
+        }
+        if !self.children.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Field", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if let Some(v) = self.arrow_type.as_ref() {
+            struct_ser.serialize_field("arrowType", v)?;
+        }
+        if self.nullable {
+            struct_ser.serialize_field("nullable", &self.nullable)?;
+        }
+        if !self.children.is_empty() {
+            struct_ser.serialize_field("children", &self.children)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Field {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "arrow_type",
+            "arrowType",
+            "nullable",
+            "children",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            ArrowType,
+            Nullable,
+            Children,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
+                            "nullable" => Ok(GeneratedField::Nullable),
+                            "children" => Ok(GeneratedField::Children),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Field;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Field")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Field, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut arrow_type__ = None;
+                let mut nullable__ = None;
+                let mut children__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::ArrowType => {
+                            if arrow_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("arrowType"));
+                            }
+                            arrow_type__ = map.next_value()?;
+                        }
+                        GeneratedField::Nullable => {
+                            if nullable__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullable"));
+                            }
+                            nullable__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Children => {
+                            if children__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("children"));
+                            }
+                            children__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(Field {
+                    name: name__.unwrap_or_default(),
+                    arrow_type: arrow_type__,
+                    nullable: nullable__.unwrap_or_default(),
+                    children: children__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Field", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for FileGroup {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.files.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.FileGroup", len)?;
+        if !self.files.is_empty() {
+            struct_ser.serialize_field("files", &self.files)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for FileGroup {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "files",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Files,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "files" => Ok(GeneratedField::Files),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FileGroup;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.FileGroup")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<FileGroup, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut files__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Files => {
+                            if files__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("files"));
+                            }
+                            files__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(FileGroup {
+                    files: files__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.FileGroup", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for FileRange {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.start != 0 {
+            len += 1;
+        }
+        if self.end != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.FileRange", len)?;
+        if self.start != 0 {
+            struct_ser.serialize_field("start", ToString::to_string(&self.start).as_str())?;
+        }
+        if self.end != 0 {
+            struct_ser.serialize_field("end", ToString::to_string(&self.end).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for FileRange {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "start",
+            "end",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Start,
+            End,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "start" => Ok(GeneratedField::Start),
+                            "end" => Ok(GeneratedField::End),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FileRange;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.FileRange")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<FileRange, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut start__ = None;
+                let mut end__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Start => {
+                            if start__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("start"));
+                            }
+                            start__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::End => {
+                            if end__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("end"));
+                            }
+                            end__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(FileRange {
+                    start: start__.unwrap_or_default(),
+                    end: end__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.FileRange", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for FileScanExecConf {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.file_groups.is_empty() {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        if !self.projection.is_empty() {
+            len += 1;
+        }
+        if self.limit.is_some() {
+            len += 1;
+        }
+        if self.statistics.is_some() {
+            len += 1;
+        }
+        if !self.table_partition_cols.is_empty() {
+            len += 1;
+        }
+        if !self.object_store_url.is_empty() {
+            len += 1;
+        }
+        if !self.output_ordering.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.FileScanExecConf", len)?;
+        if !self.file_groups.is_empty() {
+            struct_ser.serialize_field("fileGroups", &self.file_groups)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        if !self.projection.is_empty() {
+            struct_ser.serialize_field("projection", &self.projection)?;
+        }
+        if let Some(v) = self.limit.as_ref() {
+            struct_ser.serialize_field("limit", v)?;
+        }
+        if let Some(v) = self.statistics.as_ref() {
+            struct_ser.serialize_field("statistics", v)?;
+        }
+        if !self.table_partition_cols.is_empty() {
+            struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?;
+        }
+        if !self.object_store_url.is_empty() {
+            struct_ser.serialize_field("objectStoreUrl", &self.object_store_url)?;
+        }
+        if !self.output_ordering.is_empty() {
+            struct_ser.serialize_field("outputOrdering", &self.output_ordering)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for FileScanExecConf {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "file_groups",
+            "fileGroups",
+            "schema",
+            "projection",
+            "limit",
+            "statistics",
+            "table_partition_cols",
+            "tablePartitionCols",
+            "object_store_url",
+            "objectStoreUrl",
+            "output_ordering",
+            "outputOrdering",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FileGroups,
+            Schema,
+            Projection,
+            Limit,
+            Statistics,
+            TablePartitionCols,
+            ObjectStoreUrl,
+            OutputOrdering,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fileGroups" | "file_groups" => Ok(GeneratedField::FileGroups),
+                            "schema" => Ok(GeneratedField::Schema),
+                            "projection" => Ok(GeneratedField::Projection),
+                            "limit" => Ok(GeneratedField::Limit),
+                            "statistics" => Ok(GeneratedField::Statistics),
+                            "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
+                            "objectStoreUrl" | "object_store_url" => Ok(GeneratedField::ObjectStoreUrl),
+                            "outputOrdering" | "output_ordering" => Ok(GeneratedField::OutputOrdering),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FileScanExecConf;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.FileScanExecConf")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<FileScanExecConf, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut file_groups__ = None;
+                let mut schema__ = None;
+                let mut projection__ = None;
+                let mut limit__ = None;
+                let mut statistics__ = None;
+                let mut table_partition_cols__ = None;
+                let mut object_store_url__ = None;
+                let mut output_ordering__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::FileGroups => {
+                            if file_groups__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fileGroups"));
+                            }
+                            file_groups__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                        GeneratedField::Projection => {
+                            if projection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("projection"));
+                            }
+                            projection__ = 
+                                Some(map.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter().map(|x| x.0).collect())
+                            ;
+                        }
+                        GeneratedField::Limit => {
+                            if limit__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("limit"));
+                            }
+                            limit__ = map.next_value()?;
+                        }
+                        GeneratedField::Statistics => {
+                            if statistics__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("statistics"));
+                            }
+                            statistics__ = map.next_value()?;
+                        }
+                        GeneratedField::TablePartitionCols => {
+                            if table_partition_cols__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tablePartitionCols"));
+                            }
+                            table_partition_cols__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::ObjectStoreUrl => {
+                            if object_store_url__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("objectStoreUrl"));
+                            }
+                            object_store_url__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::OutputOrdering => {
+                            if output_ordering__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("outputOrdering"));
+                            }
+                            output_ordering__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(FileScanExecConf {
+                    file_groups: file_groups__.unwrap_or_default(),
+                    schema: schema__,
+                    projection: projection__.unwrap_or_default(),
+                    limit: limit__,
+                    statistics: statistics__,
+                    table_partition_cols: table_partition_cols__.unwrap_or_default(),
+                    object_store_url: object_store_url__.unwrap_or_default(),
+                    output_ordering: output_ordering__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.FileScanExecConf", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for FilterExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.FilterExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for FilterExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FilterExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.FilterExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<FilterExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(FilterExecNode {
+                    input: input__,
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.FilterExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for FixedSizeBinary {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.length != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeBinary", len)?;
+        if self.length != 0 {
+            struct_ser.serialize_field("length", &self.length)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for FixedSizeBinary {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "length",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Length,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "length" => Ok(GeneratedField::Length),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FixedSizeBinary;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.FixedSizeBinary")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<FixedSizeBinary, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut length__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Length => {
+                            if length__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("length"));
+                            }
+                            length__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(FixedSizeBinary {
+                    length: length__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.FixedSizeBinary", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for FixedSizeList {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.field_type.is_some() {
+            len += 1;
+        }
+        if self.list_size != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeList", len)?;
+        if let Some(v) = self.field_type.as_ref() {
+            struct_ser.serialize_field("fieldType", v)?;
+        }
+        if self.list_size != 0 {
+            struct_ser.serialize_field("listSize", &self.list_size)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for FixedSizeList {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "field_type",
+            "fieldType",
+            "list_size",
+            "listSize",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FieldType,
+            ListSize,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
+                            "listSize" | "list_size" => Ok(GeneratedField::ListSize),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FixedSizeList;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.FixedSizeList")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<FixedSizeList, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut field_type__ = None;
+                let mut list_size__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::FieldType => {
+                            if field_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fieldType"));
+                            }
+                            field_type__ = map.next_value()?;
+                        }
+                        GeneratedField::ListSize => {
+                            if list_size__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("listSize"));
+                            }
+                            list_size__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(FixedSizeList {
+                    field_type: field_type__,
+                    list_size: list_size__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.FixedSizeList", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for FullTableReference {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.catalog.is_empty() {
+            len += 1;
+        }
+        if !self.schema.is_empty() {
+            len += 1;
+        }
+        if !self.table.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.FullTableReference", len)?;
+        if !self.catalog.is_empty() {
+            struct_ser.serialize_field("catalog", &self.catalog)?;
+        }
+        if !self.schema.is_empty() {
+            struct_ser.serialize_field("schema", &self.schema)?;
+        }
+        if !self.table.is_empty() {
+            struct_ser.serialize_field("table", &self.table)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for FullTableReference {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "catalog",
+            "schema",
+            "table",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Catalog,
+            Schema,
+            Table,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "catalog" => Ok(GeneratedField::Catalog),
+                            "schema" => Ok(GeneratedField::Schema),
+                            "table" => Ok(GeneratedField::Table),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = FullTableReference;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.FullTableReference")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<FullTableReference, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut catalog__ = None;
+                let mut schema__ = None;
+                let mut table__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Catalog => {
+                            if catalog__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("catalog"));
+                            }
+                            catalog__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Table => {
+                            if table__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("table"));
+                            }
+                            table__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(FullTableReference {
+                    catalog: catalog__.unwrap_or_default(),
+                    schema: schema__.unwrap_or_default(),
+                    table: table__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.FullTableReference", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for GetIndexedField {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.key.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.GetIndexedField", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.key.as_ref() {
+            struct_ser.serialize_field("key", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for GetIndexedField {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "key",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            Key,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "key" => Ok(GeneratedField::Key),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = GetIndexedField;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.GetIndexedField")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<GetIndexedField, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut key__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(GetIndexedField {
+                    expr: expr__,
+                    key: key__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.GetIndexedField", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for GlobalLimitExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.skip != 0 {
+            len += 1;
+        }
+        if self.fetch != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.GlobalLimitExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if self.skip != 0 {
+            struct_ser.serialize_field("skip", &self.skip)?;
+        }
+        if self.fetch != 0 {
+            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for GlobalLimitExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "skip",
+            "fetch",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Skip,
+            Fetch,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "skip" => Ok(GeneratedField::Skip),
+                            "fetch" => Ok(GeneratedField::Fetch),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = GlobalLimitExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.GlobalLimitExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<GlobalLimitExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut skip__ = None;
+                let mut fetch__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Skip => {
+                            if skip__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("skip"));
+                            }
+                            skip__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Fetch => {
+                            if fetch__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fetch"));
+                            }
+                            fetch__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(GlobalLimitExecNode {
+                    input: input__,
+                    skip: skip__.unwrap_or_default(),
+                    fetch: fetch__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.GlobalLimitExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for GroupingSetNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.GroupingSetNode", len)?;
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for GroupingSetNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = GroupingSetNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.GroupingSetNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<GroupingSetNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(GroupingSetNode {
+                    expr: expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.GroupingSetNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for HashJoinExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.left.is_some() {
+            len += 1;
+        }
+        if self.right.is_some() {
+            len += 1;
+        }
+        if !self.on.is_empty() {
+            len += 1;
+        }
+        if self.join_type != 0 {
+            len += 1;
+        }
+        if self.partition_mode != 0 {
+            len += 1;
+        }
+        if self.null_equals_null {
+            len += 1;
+        }
+        if self.filter.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.HashJoinExecNode", len)?;
+        if let Some(v) = self.left.as_ref() {
+            struct_ser.serialize_field("left", v)?;
+        }
+        if let Some(v) = self.right.as_ref() {
+            struct_ser.serialize_field("right", v)?;
+        }
+        if !self.on.is_empty() {
+            struct_ser.serialize_field("on", &self.on)?;
+        }
+        if self.join_type != 0 {
+            let v = JoinType::from_i32(self.join_type)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
+            struct_ser.serialize_field("joinType", &v)?;
+        }
+        if self.partition_mode != 0 {
+            let v = PartitionMode::from_i32(self.partition_mode)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.partition_mode)))?;
+            struct_ser.serialize_field("partitionMode", &v)?;
+        }
+        if self.null_equals_null {
+            struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?;
+        }
+        if let Some(v) = self.filter.as_ref() {
+            struct_ser.serialize_field("filter", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for HashJoinExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "left",
+            "right",
+            "on",
+            "join_type",
+            "joinType",
+            "partition_mode",
+            "partitionMode",
+            "null_equals_null",
+            "nullEqualsNull",
+            "filter",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Left,
+            Right,
+            On,
+            JoinType,
+            PartitionMode,
+            NullEqualsNull,
+            Filter,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "left" => Ok(GeneratedField::Left),
+                            "right" => Ok(GeneratedField::Right),
+                            "on" => Ok(GeneratedField::On),
+                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
+                            "partitionMode" | "partition_mode" => Ok(GeneratedField::PartitionMode),
+                            "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull),
+                            "filter" => Ok(GeneratedField::Filter),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = HashJoinExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.HashJoinExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<HashJoinExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut left__ = None;
+                let mut right__ = None;
+                let mut on__ = None;
+                let mut join_type__ = None;
+                let mut partition_mode__ = None;
+                let mut null_equals_null__ = None;
+                let mut filter__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Left => {
+                            if left__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("left"));
+                            }
+                            left__ = map.next_value()?;
+                        }
+                        GeneratedField::Right => {
+                            if right__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("right"));
+                            }
+                            right__ = map.next_value()?;
+                        }
+                        GeneratedField::On => {
+                            if on__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("on"));
+                            }
+                            on__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::JoinType => {
+                            if join_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("joinType"));
+                            }
+                            join_type__ = Some(map.next_value::<JoinType>()? as i32);
+                        }
+                        GeneratedField::PartitionMode => {
+                            if partition_mode__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("partitionMode"));
+                            }
+                            partition_mode__ = Some(map.next_value::<PartitionMode>()? as i32);
+                        }
+                        GeneratedField::NullEqualsNull => {
+                            if null_equals_null__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullEqualsNull"));
+                            }
+                            null_equals_null__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Filter => {
+                            if filter__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filter"));
+                            }
+                            filter__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(HashJoinExecNode {
+                    left: left__,
+                    right: right__,
+                    on: on__.unwrap_or_default(),
+                    join_type: join_type__.unwrap_or_default(),
+                    partition_mode: partition_mode__.unwrap_or_default(),
+                    null_equals_null: null_equals_null__.unwrap_or_default(),
+                    filter: filter__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.HashJoinExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for HashRepartition {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.hash_expr.is_empty() {
+            len += 1;
+        }
+        if self.partition_count != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.HashRepartition", len)?;
+        if !self.hash_expr.is_empty() {
+            struct_ser.serialize_field("hashExpr", &self.hash_expr)?;
+        }
+        if self.partition_count != 0 {
+            struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for HashRepartition {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "hash_expr",
+            "hashExpr",
+            "partition_count",
+            "partitionCount",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            HashExpr,
+            PartitionCount,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr),
+                            "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = HashRepartition;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.HashRepartition")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<HashRepartition, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut hash_expr__ = None;
+                let mut partition_count__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::HashExpr => {
+                            if hash_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hashExpr"));
+                            }
+                            hash_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::PartitionCount => {
+                            if partition_count__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("partitionCount"));
+                            }
+                            partition_count__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(HashRepartition {
+                    hash_expr: hash_expr__.unwrap_or_default(),
+                    partition_count: partition_count__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.HashRepartition", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ILikeNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.negated {
+            len += 1;
+        }
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.pattern.is_some() {
+            len += 1;
+        }
+        if !self.escape_char.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ILikeNode", len)?;
+        if self.negated {
+            struct_ser.serialize_field("negated", &self.negated)?;
+        }
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.pattern.as_ref() {
+            struct_ser.serialize_field("pattern", v)?;
+        }
+        if !self.escape_char.is_empty() {
+            struct_ser.serialize_field("escapeChar", &self.escape_char)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ILikeNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "negated",
+            "expr",
+            "pattern",
+            "escape_char",
+            "escapeChar",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Negated,
+            Expr,
+            Pattern,
+            EscapeChar,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "negated" => Ok(GeneratedField::Negated),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "pattern" => Ok(GeneratedField::Pattern),
+                            "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ILikeNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ILikeNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ILikeNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut negated__ = None;
+                let mut expr__ = None;
+                let mut pattern__ = None;
+                let mut escape_char__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Negated => {
+                            if negated__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negated"));
+                            }
+                            negated__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Pattern => {
+                            if pattern__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pattern"));
+                            }
+                            pattern__ = map.next_value()?;
+                        }
+                        GeneratedField::EscapeChar => {
+                            if escape_char__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("escapeChar"));
+                            }
+                            escape_char__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ILikeNode {
+                    negated: negated__.unwrap_or_default(),
+                    expr: expr__,
+                    pattern: pattern__,
+                    escape_char: escape_char__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ILikeNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for InListNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if !self.list.is_empty() {
+            len += 1;
+        }
+        if self.negated {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.InListNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if !self.list.is_empty() {
+            struct_ser.serialize_field("list", &self.list)?;
+        }
+        if self.negated {
+            struct_ser.serialize_field("negated", &self.negated)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for InListNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "list",
+            "negated",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            List,
+            Negated,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "list" => Ok(GeneratedField::List),
+                            "negated" => Ok(GeneratedField::Negated),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = InListNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.InListNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<InListNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut list__ = None;
+                let mut negated__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::List => {
+                            if list__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("list"));
+                            }
+                            list__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Negated => {
+                            if negated__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negated"));
+                            }
+                            negated__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(InListNode {
+                    expr: expr__,
+                    list: list__.unwrap_or_default(),
+                    negated: negated__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.InListNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IntervalMonthDayNanoValue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.months != 0 {
+            len += 1;
+        }
+        if self.days != 0 {
+            len += 1;
+        }
+        if self.nanos != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IntervalMonthDayNanoValue", len)?;
+        if self.months != 0 {
+            struct_ser.serialize_field("months", &self.months)?;
+        }
+        if self.days != 0 {
+            struct_ser.serialize_field("days", &self.days)?;
+        }
+        if self.nanos != 0 {
+            struct_ser.serialize_field("nanos", ToString::to_string(&self.nanos).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "months",
+            "days",
+            "nanos",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Months,
+            Days,
+            Nanos,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "months" => Ok(GeneratedField::Months),
+                            "days" => Ok(GeneratedField::Days),
+                            "nanos" => Ok(GeneratedField::Nanos),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IntervalMonthDayNanoValue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IntervalMonthDayNanoValue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IntervalMonthDayNanoValue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut months__ = None;
+                let mut days__ = None;
+                let mut nanos__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Months => {
+                            if months__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("months"));
+                            }
+                            months__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Days => {
+                            if days__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("days"));
+                            }
+                            days__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Nanos => {
+                            if nanos__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nanos"));
+                            }
+                            nanos__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(IntervalMonthDayNanoValue {
+                    months: months__.unwrap_or_default(),
+                    days: days__.unwrap_or_default(),
+                    nanos: nanos__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IntervalMonthDayNanoValue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IntervalUnit {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::YearMonth => "YearMonth",
+            Self::DayTime => "DayTime",
+            Self::MonthDayNano => "MonthDayNano",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for IntervalUnit {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "YearMonth",
+            "DayTime",
+            "MonthDayNano",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IntervalUnit;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(IntervalUnit::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(IntervalUnit::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "YearMonth" => Ok(IntervalUnit::YearMonth),
+                    "DayTime" => Ok(IntervalUnit::DayTime),
+                    "MonthDayNano" => Ok(IntervalUnit::MonthDayNano),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsFalse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsFalse", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsFalse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsFalse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsFalse")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsFalse, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsFalse {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsFalse", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsNotFalse {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotFalse", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsNotFalse {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsNotFalse;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsNotFalse")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotFalse, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsNotFalse {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsNotFalse", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsNotNull {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotNull", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsNotNull {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsNotNull;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsNotNull")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotNull, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsNotNull {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsNotNull", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsNotTrue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotTrue", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsNotTrue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsNotTrue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsNotTrue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotTrue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsNotTrue {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsNotTrue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsNotUnknown {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotUnknown", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsNotUnknown {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsNotUnknown;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsNotUnknown")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotUnknown, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsNotUnknown {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsNotUnknown", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsNull {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsNull", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsNull {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsNull;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsNull")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNull, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsNull {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsNull", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsTrue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsTrue", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsTrue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsTrue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsTrue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsTrue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsTrue {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsTrue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for IsUnknown {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.IsUnknown", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for IsUnknown {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = IsUnknown;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.IsUnknown")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsUnknown, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(IsUnknown {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.IsUnknown", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for JoinConstraint {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::On => "ON",
+            Self::Using => "USING",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for JoinConstraint {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "ON",
+            "USING",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = JoinConstraint;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(JoinConstraint::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(JoinConstraint::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "ON" => Ok(JoinConstraint::On),
+                    "USING" => Ok(JoinConstraint::Using),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for JoinFilter {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expression.is_some() {
+            len += 1;
+        }
+        if !self.column_indices.is_empty() {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.JoinFilter", len)?;
+        if let Some(v) = self.expression.as_ref() {
+            struct_ser.serialize_field("expression", v)?;
+        }
+        if !self.column_indices.is_empty() {
+            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for JoinFilter {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expression",
+            "column_indices",
+            "columnIndices",
+            "schema",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expression,
+            ColumnIndices,
+            Schema,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expression" => Ok(GeneratedField::Expression),
+                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
+                            "schema" => Ok(GeneratedField::Schema),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = JoinFilter;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.JoinFilter")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<JoinFilter, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expression__ = None;
+                let mut column_indices__ = None;
+                let mut schema__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expression => {
+                            if expression__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expression"));
+                            }
+                            expression__ = map.next_value()?;
+                        }
+                        GeneratedField::ColumnIndices => {
+                            if column_indices__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("columnIndices"));
+                            }
+                            column_indices__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(JoinFilter {
+                    expression: expression__,
+                    column_indices: column_indices__.unwrap_or_default(),
+                    schema: schema__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.JoinFilter", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for JoinNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.left.is_some() {
+            len += 1;
+        }
+        if self.right.is_some() {
+            len += 1;
+        }
+        if self.join_type != 0 {
+            len += 1;
+        }
+        if self.join_constraint != 0 {
+            len += 1;
+        }
+        if !self.left_join_key.is_empty() {
+            len += 1;
+        }
+        if !self.right_join_key.is_empty() {
+            len += 1;
+        }
+        if self.null_equals_null {
+            len += 1;
+        }
+        if self.filter.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.JoinNode", len)?;
+        if let Some(v) = self.left.as_ref() {
+            struct_ser.serialize_field("left", v)?;
+        }
+        if let Some(v) = self.right.as_ref() {
+            struct_ser.serialize_field("right", v)?;
+        }
+        if self.join_type != 0 {
+            let v = JoinType::from_i32(self.join_type)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
+            struct_ser.serialize_field("joinType", &v)?;
+        }
+        if self.join_constraint != 0 {
+            let v = JoinConstraint::from_i32(self.join_constraint)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_constraint)))?;
+            struct_ser.serialize_field("joinConstraint", &v)?;
+        }
+        if !self.left_join_key.is_empty() {
+            struct_ser.serialize_field("leftJoinKey", &self.left_join_key)?;
+        }
+        if !self.right_join_key.is_empty() {
+            struct_ser.serialize_field("rightJoinKey", &self.right_join_key)?;
+        }
+        if self.null_equals_null {
+            struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?;
+        }
+        if let Some(v) = self.filter.as_ref() {
+            struct_ser.serialize_field("filter", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for JoinNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "left",
+            "right",
+            "join_type",
+            "joinType",
+            "join_constraint",
+            "joinConstraint",
+            "left_join_key",
+            "leftJoinKey",
+            "right_join_key",
+            "rightJoinKey",
+            "null_equals_null",
+            "nullEqualsNull",
+            "filter",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Left,
+            Right,
+            JoinType,
+            JoinConstraint,
+            LeftJoinKey,
+            RightJoinKey,
+            NullEqualsNull,
+            Filter,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "left" => Ok(GeneratedField::Left),
+                            "right" => Ok(GeneratedField::Right),
+                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
+                            "joinConstraint" | "join_constraint" => Ok(GeneratedField::JoinConstraint),
+                            "leftJoinKey" | "left_join_key" => Ok(GeneratedField::LeftJoinKey),
+                            "rightJoinKey" | "right_join_key" => Ok(GeneratedField::RightJoinKey),
+                            "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull),
+                            "filter" => Ok(GeneratedField::Filter),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = JoinNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.JoinNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<JoinNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut left__ = None;
+                let mut right__ = None;
+                let mut join_type__ = None;
+                let mut join_constraint__ = None;
+                let mut left_join_key__ = None;
+                let mut right_join_key__ = None;
+                let mut null_equals_null__ = None;
+                let mut filter__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Left => {
+                            if left__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("left"));
+                            }
+                            left__ = map.next_value()?;
+                        }
+                        GeneratedField::Right => {
+                            if right__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("right"));
+                            }
+                            right__ = map.next_value()?;
+                        }
+                        GeneratedField::JoinType => {
+                            if join_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("joinType"));
+                            }
+                            join_type__ = Some(map.next_value::<JoinType>()? as i32);
+                        }
+                        GeneratedField::JoinConstraint => {
+                            if join_constraint__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("joinConstraint"));
+                            }
+                            join_constraint__ = Some(map.next_value::<JoinConstraint>()? as i32);
+                        }
+                        GeneratedField::LeftJoinKey => {
+                            if left_join_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("leftJoinKey"));
+                            }
+                            left_join_key__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::RightJoinKey => {
+                            if right_join_key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("rightJoinKey"));
+                            }
+                            right_join_key__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::NullEqualsNull => {
+                            if null_equals_null__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullEqualsNull"));
+                            }
+                            null_equals_null__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Filter => {
+                            if filter__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filter"));
+                            }
+                            filter__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(JoinNode {
+                    left: left__,
+                    right: right__,
+                    join_type: join_type__.unwrap_or_default(),
+                    join_constraint: join_constraint__.unwrap_or_default(),
+                    left_join_key: left_join_key__.unwrap_or_default(),
+                    right_join_key: right_join_key__.unwrap_or_default(),
+                    null_equals_null: null_equals_null__.unwrap_or_default(),
+                    filter: filter__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.JoinNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for JoinOn {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.left.is_some() {
+            len += 1;
+        }
+        if self.right.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.JoinOn", len)?;
+        if let Some(v) = self.left.as_ref() {
+            struct_ser.serialize_field("left", v)?;
+        }
+        if let Some(v) = self.right.as_ref() {
+            struct_ser.serialize_field("right", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for JoinOn {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "left",
+            "right",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Left,
+            Right,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "left" => Ok(GeneratedField::Left),
+                            "right" => Ok(GeneratedField::Right),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = JoinOn;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.JoinOn")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<JoinOn, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut left__ = None;
+                let mut right__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Left => {
+                            if left__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("left"));
+                            }
+                            left__ = map.next_value()?;
+                        }
+                        GeneratedField::Right => {
+                            if right__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("right"));
+                            }
+                            right__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(JoinOn {
+                    left: left__,
+                    right: right__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.JoinOn", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for JoinSide {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::LeftSide => "LEFT_SIDE",
+            Self::RightSide => "RIGHT_SIDE",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for JoinSide {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "LEFT_SIDE",
+            "RIGHT_SIDE",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = JoinSide;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(JoinSide::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(JoinSide::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "LEFT_SIDE" => Ok(JoinSide::LeftSide),
+                    "RIGHT_SIDE" => Ok(JoinSide::RightSide),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for JoinType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Inner => "INNER",
+            Self::Left => "LEFT",
+            Self::Right => "RIGHT",
+            Self::Full => "FULL",
+            Self::Leftsemi => "LEFTSEMI",
+            Self::Leftanti => "LEFTANTI",
+            Self::Rightsemi => "RIGHTSEMI",
+            Self::Rightanti => "RIGHTANTI",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for JoinType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "INNER",
+            "LEFT",
+            "RIGHT",
+            "FULL",
+            "LEFTSEMI",
+            "LEFTANTI",
+            "RIGHTSEMI",
+            "RIGHTANTI",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = JoinType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(JoinType::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(JoinType::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "INNER" => Ok(JoinType::Inner),
+                    "LEFT" => Ok(JoinType::Left),
+                    "RIGHT" => Ok(JoinType::Right),
+                    "FULL" => Ok(JoinType::Full),
+                    "LEFTSEMI" => Ok(JoinType::Leftsemi),
+                    "LEFTANTI" => Ok(JoinType::Leftanti),
+                    "RIGHTSEMI" => Ok(JoinType::Rightsemi),
+                    "RIGHTANTI" => Ok(JoinType::Rightanti),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LikeNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.negated {
+            len += 1;
+        }
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.pattern.is_some() {
+            len += 1;
+        }
+        if !self.escape_char.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LikeNode", len)?;
+        if self.negated {
+            struct_ser.serialize_field("negated", &self.negated)?;
+        }
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.pattern.as_ref() {
+            struct_ser.serialize_field("pattern", v)?;
+        }
+        if !self.escape_char.is_empty() {
+            struct_ser.serialize_field("escapeChar", &self.escape_char)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LikeNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "negated",
+            "expr",
+            "pattern",
+            "escape_char",
+            "escapeChar",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Negated,
+            Expr,
+            Pattern,
+            EscapeChar,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "negated" => Ok(GeneratedField::Negated),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "pattern" => Ok(GeneratedField::Pattern),
+                            "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LikeNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LikeNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LikeNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut negated__ = None;
+                let mut expr__ = None;
+                let mut pattern__ = None;
+                let mut escape_char__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Negated => {
+                            if negated__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negated"));
+                            }
+                            negated__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Pattern => {
+                            if pattern__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pattern"));
+                            }
+                            pattern__ = map.next_value()?;
+                        }
+                        GeneratedField::EscapeChar => {
+                            if escape_char__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("escapeChar"));
+                            }
+                            escape_char__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(LikeNode {
+                    negated: negated__.unwrap_or_default(),
+                    expr: expr__,
+                    pattern: pattern__,
+                    escape_char: escape_char__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LikeNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LimitNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.skip != 0 {
+            len += 1;
+        }
+        if self.fetch != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LimitNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if self.skip != 0 {
+            struct_ser.serialize_field("skip", ToString::to_string(&self.skip).as_str())?;
+        }
+        if self.fetch != 0 {
+            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LimitNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "skip",
+            "fetch",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Skip,
+            Fetch,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "skip" => Ok(GeneratedField::Skip),
+                            "fetch" => Ok(GeneratedField::Fetch),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LimitNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LimitNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LimitNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut skip__ = None;
+                let mut fetch__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Skip => {
+                            if skip__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("skip"));
+                            }
+                            skip__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Fetch => {
+                            if fetch__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fetch"));
+                            }
+                            fetch__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(LimitNode {
+                    input: input__,
+                    skip: skip__.unwrap_or_default(),
+                    fetch: fetch__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LimitNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for List {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.field_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.List", len)?;
+        if let Some(v) = self.field_type.as_ref() {
+            struct_ser.serialize_field("fieldType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for List {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "field_type",
+            "fieldType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FieldType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = List;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.List")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<List, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut field_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::FieldType => {
+                            if field_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fieldType"));
+                            }
+                            field_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(List {
+                    field_type: field_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.List", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ListingTableScanNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.table_name.is_some() {
+            len += 1;
+        }
+        if !self.paths.is_empty() {
+            len += 1;
+        }
+        if !self.file_extension.is_empty() {
+            len += 1;
+        }
+        if self.projection.is_some() {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        if !self.filters.is_empty() {
+            len += 1;
+        }
+        if !self.table_partition_cols.is_empty() {
+            len += 1;
+        }
+        if self.collect_stat {
+            len += 1;
+        }
+        if self.target_partitions != 0 {
+            len += 1;
+        }
+        if !self.file_sort_order.is_empty() {
+            len += 1;
+        }
+        if self.file_format_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ListingTableScanNode", len)?;
+        if let Some(v) = self.table_name.as_ref() {
+            struct_ser.serialize_field("tableName", v)?;
+        }
+        if !self.paths.is_empty() {
+            struct_ser.serialize_field("paths", &self.paths)?;
+        }
+        if !self.file_extension.is_empty() {
+            struct_ser.serialize_field("fileExtension", &self.file_extension)?;
+        }
+        if let Some(v) = self.projection.as_ref() {
+            struct_ser.serialize_field("projection", v)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        if !self.filters.is_empty() {
+            struct_ser.serialize_field("filters", &self.filters)?;
+        }
+        if !self.table_partition_cols.is_empty() {
+            struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?;
+        }
+        if self.collect_stat {
+            struct_ser.serialize_field("collectStat", &self.collect_stat)?;
+        }
+        if self.target_partitions != 0 {
+            struct_ser.serialize_field("targetPartitions", &self.target_partitions)?;
+        }
+        if !self.file_sort_order.is_empty() {
+            struct_ser.serialize_field("fileSortOrder", &self.file_sort_order)?;
+        }
+        if let Some(v) = self.file_format_type.as_ref() {
+            match v {
+                listing_table_scan_node::FileFormatType::Csv(v) => {
+                    struct_ser.serialize_field("csv", v)?;
+                }
+                listing_table_scan_node::FileFormatType::Parquet(v) => {
+                    struct_ser.serialize_field("parquet", v)?;
+                }
+                listing_table_scan_node::FileFormatType::Avro(v) => {
+                    struct_ser.serialize_field("avro", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ListingTableScanNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "table_name",
+            "tableName",
+            "paths",
+            "file_extension",
+            "fileExtension",
+            "projection",
+            "schema",
+            "filters",
+            "table_partition_cols",
+            "tablePartitionCols",
+            "collect_stat",
+            "collectStat",
+            "target_partitions",
+            "targetPartitions",
+            "file_sort_order",
+            "fileSortOrder",
+            "csv",
+            "parquet",
+            "avro",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            TableName,
+            Paths,
+            FileExtension,
+            Projection,
+            Schema,
+            Filters,
+            TablePartitionCols,
+            CollectStat,
+            TargetPartitions,
+            FileSortOrder,
+            Csv,
+            Parquet,
+            Avro,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
+                            "paths" => Ok(GeneratedField::Paths),
+                            "fileExtension" | "file_extension" => Ok(GeneratedField::FileExtension),
+                            "projection" => Ok(GeneratedField::Projection),
+                            "schema" => Ok(GeneratedField::Schema),
+                            "filters" => Ok(GeneratedField::Filters),
+                            "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
+                            "collectStat" | "collect_stat" => Ok(GeneratedField::CollectStat),
+                            "targetPartitions" | "target_partitions" => Ok(GeneratedField::TargetPartitions),
+                            "fileSortOrder" | "file_sort_order" => Ok(GeneratedField::FileSortOrder),
+                            "csv" => Ok(GeneratedField::Csv),
+                            "parquet" => Ok(GeneratedField::Parquet),
+                            "avro" => Ok(GeneratedField::Avro),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ListingTableScanNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ListingTableScanNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ListingTableScanNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut table_name__ = None;
+                let mut paths__ = None;
+                let mut file_extension__ = None;
+                let mut projection__ = None;
+                let mut schema__ = None;
+                let mut filters__ = None;
+                let mut table_partition_cols__ = None;
+                let mut collect_stat__ = None;
+                let mut target_partitions__ = None;
+                let mut file_sort_order__ = None;
+                let mut file_format_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::TableName => {
+                            if table_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tableName"));
+                            }
+                            table_name__ = map.next_value()?;
+                        }
+                        GeneratedField::Paths => {
+                            if paths__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("paths"));
+                            }
+                            paths__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::FileExtension => {
+                            if file_extension__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fileExtension"));
+                            }
+                            file_extension__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Projection => {
+                            if projection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("projection"));
+                            }
+                            projection__ = map.next_value()?;
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                        GeneratedField::Filters => {
+                            if filters__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filters"));
+                            }
+                            filters__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::TablePartitionCols => {
+                            if table_partition_cols__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tablePartitionCols"));
+                            }
+                            table_partition_cols__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::CollectStat => {
+                            if collect_stat__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("collectStat"));
+                            }
+                            collect_stat__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::TargetPartitions => {
+                            if target_partitions__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("targetPartitions"));
+                            }
+                            target_partitions__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::FileSortOrder => {
+                            if file_sort_order__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fileSortOrder"));
+                            }
+                            file_sort_order__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Csv => {
+                            if file_format_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("csv"));
+                            }
+                            file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Csv)
+;
+                        }
+                        GeneratedField::Parquet => {
+                            if file_format_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("parquet"));
+                            }
+                            file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Parquet)
+;
+                        }
+                        GeneratedField::Avro => {
+                            if file_format_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("avro"));
+                            }
+                            file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Avro)
+;
+                        }
+                    }
+                }
+                Ok(ListingTableScanNode {
+                    table_name: table_name__,
+                    paths: paths__.unwrap_or_default(),
+                    file_extension: file_extension__.unwrap_or_default(),
+                    projection: projection__,
+                    schema: schema__,
+                    filters: filters__.unwrap_or_default(),
+                    table_partition_cols: table_partition_cols__.unwrap_or_default(),
+                    collect_stat: collect_stat__.unwrap_or_default(),
+                    target_partitions: target_partitions__.unwrap_or_default(),
+                    file_sort_order: file_sort_order__.unwrap_or_default(),
+                    file_format_type: file_format_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ListingTableScanNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LocalLimitExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.fetch != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LocalLimitExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if self.fetch != 0 {
+            struct_ser.serialize_field("fetch", &self.fetch)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LocalLimitExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "fetch",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Fetch,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "fetch" => Ok(GeneratedField::Fetch),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LocalLimitExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LocalLimitExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LocalLimitExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut fetch__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Fetch => {
+                            if fetch__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fetch"));
+                            }
+                            fetch__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(LocalLimitExecNode {
+                    input: input__,
+                    fetch: fetch__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LocalLimitExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LogicalExprList {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprList", len)?;
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LogicalExprList {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LogicalExprList;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LogicalExprList")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExprList, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(LogicalExprList {
+                    expr: expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LogicalExprList", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LogicalExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNode", len)?;
+        if let Some(v) = self.expr_type.as_ref() {
+            match v {
+                logical_expr_node::ExprType::Column(v) => {
+                    struct_ser.serialize_field("column", v)?;
+                }
+                logical_expr_node::ExprType::Alias(v) => {
+                    struct_ser.serialize_field("alias", v)?;
+                }
+                logical_expr_node::ExprType::Literal(v) => {
+                    struct_ser.serialize_field("literal", v)?;
+                }
+                logical_expr_node::ExprType::BinaryExpr(v) => {
+                    struct_ser.serialize_field("binaryExpr", v)?;
+                }
+                logical_expr_node::ExprType::AggregateExpr(v) => {
+                    struct_ser.serialize_field("aggregateExpr", v)?;
+                }
+                logical_expr_node::ExprType::IsNullExpr(v) => {
+                    struct_ser.serialize_field("isNullExpr", v)?;
+                }
+                logical_expr_node::ExprType::IsNotNullExpr(v) => {
+                    struct_ser.serialize_field("isNotNullExpr", v)?;
+                }
+                logical_expr_node::ExprType::NotExpr(v) => {
+                    struct_ser.serialize_field("notExpr", v)?;
+                }
+                logical_expr_node::ExprType::Between(v) => {
+                    struct_ser.serialize_field("between", v)?;
+                }
+                logical_expr_node::ExprType::Case(v) => {
+                    struct_ser.serialize_field("case", v)?;
+                }
+                logical_expr_node::ExprType::Cast(v) => {
+                    struct_ser.serialize_field("cast", v)?;
+                }
+                logical_expr_node::ExprType::Sort(v) => {
+                    struct_ser.serialize_field("sort", v)?;
+                }
+                logical_expr_node::ExprType::Negative(v) => {
+                    struct_ser.serialize_field("negative", v)?;
+                }
+                logical_expr_node::ExprType::InList(v) => {
+                    struct_ser.serialize_field("inList", v)?;
+                }
+                logical_expr_node::ExprType::Wildcard(v) => {
+                    struct_ser.serialize_field("wildcard", v)?;
+                }
+                logical_expr_node::ExprType::ScalarFunction(v) => {
+                    struct_ser.serialize_field("scalarFunction", v)?;
+                }
+                logical_expr_node::ExprType::TryCast(v) => {
+                    struct_ser.serialize_field("tryCast", v)?;
+                }
+                logical_expr_node::ExprType::WindowExpr(v) => {
+                    struct_ser.serialize_field("windowExpr", v)?;
+                }
+                logical_expr_node::ExprType::AggregateUdfExpr(v) => {
+                    struct_ser.serialize_field("aggregateUdfExpr", v)?;
+                }
+                logical_expr_node::ExprType::ScalarUdfExpr(v) => {
+                    struct_ser.serialize_field("scalarUdfExpr", v)?;
+                }
+                logical_expr_node::ExprType::GetIndexedField(v) => {
+                    struct_ser.serialize_field("getIndexedField", v)?;
+                }
+                logical_expr_node::ExprType::GroupingSet(v) => {
+                    struct_ser.serialize_field("groupingSet", v)?;
+                }
+                logical_expr_node::ExprType::Cube(v) => {
+                    struct_ser.serialize_field("cube", v)?;
+                }
+                logical_expr_node::ExprType::Rollup(v) => {
+                    struct_ser.serialize_field("rollup", v)?;
+                }
+                logical_expr_node::ExprType::IsTrue(v) => {
+                    struct_ser.serialize_field("isTrue", v)?;
+                }
+                logical_expr_node::ExprType::IsFalse(v) => {
+                    struct_ser.serialize_field("isFalse", v)?;
+                }
+                logical_expr_node::ExprType::IsUnknown(v) => {
+                    struct_ser.serialize_field("isUnknown", v)?;
+                }
+                logical_expr_node::ExprType::IsNotTrue(v) => {
+                    struct_ser.serialize_field("isNotTrue", v)?;
+                }
+                logical_expr_node::ExprType::IsNotFalse(v) => {
+                    struct_ser.serialize_field("isNotFalse", v)?;
+                }
+                logical_expr_node::ExprType::IsNotUnknown(v) => {
+                    struct_ser.serialize_field("isNotUnknown", v)?;
+                }
+                logical_expr_node::ExprType::Like(v) => {
+                    struct_ser.serialize_field("like", v)?;
+                }
+                logical_expr_node::ExprType::Ilike(v) => {
+                    struct_ser.serialize_field("ilike", v)?;
+                }
+                logical_expr_node::ExprType::SimilarTo(v) => {
+                    struct_ser.serialize_field("similarTo", v)?;
+                }
+                logical_expr_node::ExprType::Placeholder(v) => {
+                    struct_ser.serialize_field("placeholder", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LogicalExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "column",
+            "alias",
+            "literal",
+            "binary_expr",
+            "binaryExpr",
+            "aggregate_expr",
+            "aggregateExpr",
+            "is_null_expr",
+            "isNullExpr",
+            "is_not_null_expr",
+            "isNotNullExpr",
+            "not_expr",
+            "notExpr",
+            "between",
+            "case_",
+            "case",
+            "cast",
+            "sort",
+            "negative",
+            "in_list",
+            "inList",
+            "wildcard",
+            "scalar_function",
+            "scalarFunction",
+            "try_cast",
+            "tryCast",
+            "window_expr",
+            "windowExpr",
+            "aggregate_udf_expr",
+            "aggregateUdfExpr",
+            "scalar_udf_expr",
+            "scalarUdfExpr",
+            "get_indexed_field",
+            "getIndexedField",
+            "grouping_set",
+            "groupingSet",
+            "cube",
+            "rollup",
+            "is_true",
+            "isTrue",
+            "is_false",
+            "isFalse",
+            "is_unknown",
+            "isUnknown",
+            "is_not_true",
+            "isNotTrue",
+            "is_not_false",
+            "isNotFalse",
+            "is_not_unknown",
+            "isNotUnknown",
+            "like",
+            "ilike",
+            "similar_to",
+            "similarTo",
+            "placeholder",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Column,
+            Alias,
+            Literal,
+            BinaryExpr,
+            AggregateExpr,
+            IsNullExpr,
+            IsNotNullExpr,
+            NotExpr,
+            Between,
+            Case,
+            Cast,
+            Sort,
+            Negative,
+            InList,
+            Wildcard,
+            ScalarFunction,
+            TryCast,
+            WindowExpr,
+            AggregateUdfExpr,
+            ScalarUdfExpr,
+            GetIndexedField,
+            GroupingSet,
+            Cube,
+            Rollup,
+            IsTrue,
+            IsFalse,
+            IsUnknown,
+            IsNotTrue,
+            IsNotFalse,
+            IsNotUnknown,
+            Like,
+            Ilike,
+            SimilarTo,
+            Placeholder,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "column" => Ok(GeneratedField::Column),
+                            "alias" => Ok(GeneratedField::Alias),
+                            "literal" => Ok(GeneratedField::Literal),
+                            "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr),
+                            "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr),
+                            "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr),
+                            "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr),
+                            "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr),
+                            "between" => Ok(GeneratedField::Between),
+                            "case" | "case_" => Ok(GeneratedField::Case),
+                            "cast" => Ok(GeneratedField::Cast),
+                            "sort" => Ok(GeneratedField::Sort),
+                            "negative" => Ok(GeneratedField::Negative),
+                            "inList" | "in_list" => Ok(GeneratedField::InList),
+                            "wildcard" => Ok(GeneratedField::Wildcard),
+                            "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction),
+                            "tryCast" | "try_cast" => Ok(GeneratedField::TryCast),
+                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
+                            "aggregateUdfExpr" | "aggregate_udf_expr" => Ok(GeneratedField::AggregateUdfExpr),
+                            "scalarUdfExpr" | "scalar_udf_expr" => Ok(GeneratedField::ScalarUdfExpr),
+                            "getIndexedField" | "get_indexed_field" => Ok(GeneratedField::GetIndexedField),
+                            "groupingSet" | "grouping_set" => Ok(GeneratedField::GroupingSet),
+                            "cube" => Ok(GeneratedField::Cube),
+                            "rollup" => Ok(GeneratedField::Rollup),
+                            "isTrue" | "is_true" => Ok(GeneratedField::IsTrue),
+                            "isFalse" | "is_false" => Ok(GeneratedField::IsFalse),
+                            "isUnknown" | "is_unknown" => Ok(GeneratedField::IsUnknown),
+                            "isNotTrue" | "is_not_true" => Ok(GeneratedField::IsNotTrue),
+                            "isNotFalse" | "is_not_false" => Ok(GeneratedField::IsNotFalse),
+                            "isNotUnknown" | "is_not_unknown" => Ok(GeneratedField::IsNotUnknown),
+                            "like" => Ok(GeneratedField::Like),
+                            "ilike" => Ok(GeneratedField::Ilike),
+                            "similarTo" | "similar_to" => Ok(GeneratedField::SimilarTo),
+                            "placeholder" => Ok(GeneratedField::Placeholder),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LogicalExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LogicalExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Column => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("column"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Column)
+;
+                        }
+                        GeneratedField::Alias => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("alias"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Alias)
+;
+                        }
+                        GeneratedField::Literal => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("literal"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Literal)
+;
+                        }
+                        GeneratedField::BinaryExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("binaryExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::BinaryExpr)
+;
+                        }
+                        GeneratedField::AggregateExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggregateExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateExpr)
+;
+                        }
+                        GeneratedField::IsNullExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNullExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNullExpr)
+;
+                        }
+                        GeneratedField::IsNotNullExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNotNullExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotNullExpr)
+;
+                        }
+                        GeneratedField::NotExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("notExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::NotExpr)
+;
+                        }
+                        GeneratedField::Between => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("between"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Between)
+;
+                        }
+                        GeneratedField::Case => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("case"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Case)
+;
+                        }
+                        GeneratedField::Cast => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("cast"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cast)
+;
+                        }
+                        GeneratedField::Sort => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sort"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Sort)
+;
+                        }
+                        GeneratedField::Negative => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negative"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Negative)
+;
+                        }
+                        GeneratedField::InList => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inList"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::InList)
+;
+                        }
+                        GeneratedField::Wildcard => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("wildcard"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Wildcard);
+                        }
+                        GeneratedField::ScalarFunction => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("scalarFunction"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarFunction)
+;
+                        }
+                        GeneratedField::TryCast => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tryCast"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::TryCast)
+;
+                        }
+                        GeneratedField::WindowExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::WindowExpr)
+;
+                        }
+                        GeneratedField::AggregateUdfExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggregateUdfExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateUdfExpr)
+;
+                        }
+                        GeneratedField::ScalarUdfExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("scalarUdfExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarUdfExpr)
+;
+                        }
+                        GeneratedField::GetIndexedField => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("getIndexedField"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GetIndexedField)
+;
+                        }
+                        GeneratedField::GroupingSet => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("groupingSet"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GroupingSet)
+;
+                        }
+                        GeneratedField::Cube => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("cube"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cube)
+;
+                        }
+                        GeneratedField::Rollup => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("rollup"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Rollup)
+;
+                        }
+                        GeneratedField::IsTrue => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isTrue"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsTrue)
+;
+                        }
+                        GeneratedField::IsFalse => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isFalse"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsFalse)
+;
+                        }
+                        GeneratedField::IsUnknown => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isUnknown"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsUnknown)
+;
+                        }
+                        GeneratedField::IsNotTrue => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNotTrue"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotTrue)
+;
+                        }
+                        GeneratedField::IsNotFalse => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNotFalse"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotFalse)
+;
+                        }
+                        GeneratedField::IsNotUnknown => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNotUnknown"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotUnknown)
+;
+                        }
+                        GeneratedField::Like => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("like"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Like)
+;
+                        }
+                        GeneratedField::Ilike => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("ilike"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Ilike)
+;
+                        }
+                        GeneratedField::SimilarTo => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("similarTo"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::SimilarTo)
+;
+                        }
+                        GeneratedField::Placeholder => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("placeholder"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Placeholder)
+;
+                        }
+                    }
+                }
+                Ok(LogicalExprNode {
+                    expr_type: expr_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LogicalExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LogicalExprNodeCollection {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.logical_expr_nodes.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNodeCollection", len)?;
+        if !self.logical_expr_nodes.is_empty() {
+            struct_ser.serialize_field("logicalExprNodes", &self.logical_expr_nodes)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LogicalExprNodeCollection {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "logical_expr_nodes",
+            "logicalExprNodes",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            LogicalExprNodes,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "logicalExprNodes" | "logical_expr_nodes" => Ok(GeneratedField::LogicalExprNodes),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LogicalExprNodeCollection;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LogicalExprNodeCollection")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExprNodeCollection, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut logical_expr_nodes__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::LogicalExprNodes => {
+                            if logical_expr_nodes__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("logicalExprNodes"));
+                            }
+                            logical_expr_nodes__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(LogicalExprNodeCollection {
+                    logical_expr_nodes: logical_expr_nodes__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LogicalExprNodeCollection", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LogicalExtensionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.node.is_empty() {
+            len += 1;
+        }
+        if !self.inputs.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExtensionNode", len)?;
+        if !self.node.is_empty() {
+            struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?;
+        }
+        if !self.inputs.is_empty() {
+            struct_ser.serialize_field("inputs", &self.inputs)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LogicalExtensionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "node",
+            "inputs",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Node,
+            Inputs,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "node" => Ok(GeneratedField::Node),
+                            "inputs" => Ok(GeneratedField::Inputs),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LogicalExtensionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LogicalExtensionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExtensionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut node__ = None;
+                let mut inputs__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Node => {
+                            if node__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("node"));
+                            }
+                            node__ = 
+                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Inputs => {
+                            if inputs__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inputs"));
+                            }
+                            inputs__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(LogicalExtensionNode {
+                    node: node__.unwrap_or_default(),
+                    inputs: inputs__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LogicalExtensionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for LogicalPlanNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.logical_plan_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalPlanNode", len)?;
+        if let Some(v) = self.logical_plan_type.as_ref() {
+            match v {
+                logical_plan_node::LogicalPlanType::ListingScan(v) => {
+                    struct_ser.serialize_field("listingScan", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Projection(v) => {
+                    struct_ser.serialize_field("projection", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Selection(v) => {
+                    struct_ser.serialize_field("selection", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Limit(v) => {
+                    struct_ser.serialize_field("limit", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Aggregate(v) => {
+                    struct_ser.serialize_field("aggregate", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Join(v) => {
+                    struct_ser.serialize_field("join", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Sort(v) => {
+                    struct_ser.serialize_field("sort", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Repartition(v) => {
+                    struct_ser.serialize_field("repartition", v)?;
+                }
+                logical_plan_node::LogicalPlanType::EmptyRelation(v) => {
+                    struct_ser.serialize_field("emptyRelation", v)?;
+                }
+                logical_plan_node::LogicalPlanType::CreateExternalTable(v) => {
+                    struct_ser.serialize_field("createExternalTable", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Explain(v) => {
+                    struct_ser.serialize_field("explain", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Window(v) => {
+                    struct_ser.serialize_field("window", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Analyze(v) => {
+                    struct_ser.serialize_field("analyze", v)?;
+                }
+                logical_plan_node::LogicalPlanType::CrossJoin(v) => {
+                    struct_ser.serialize_field("crossJoin", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Values(v) => {
+                    struct_ser.serialize_field("values", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Extension(v) => {
+                    struct_ser.serialize_field("extension", v)?;
+                }
+                logical_plan_node::LogicalPlanType::CreateCatalogSchema(v) => {
+                    struct_ser.serialize_field("createCatalogSchema", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Union(v) => {
+                    struct_ser.serialize_field("union", v)?;
+                }
+                logical_plan_node::LogicalPlanType::CreateCatalog(v) => {
+                    struct_ser.serialize_field("createCatalog", v)?;
+                }
+                logical_plan_node::LogicalPlanType::SubqueryAlias(v) => {
+                    struct_ser.serialize_field("subqueryAlias", v)?;
+                }
+                logical_plan_node::LogicalPlanType::CreateView(v) => {
+                    struct_ser.serialize_field("createView", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Distinct(v) => {
+                    struct_ser.serialize_field("distinct", v)?;
+                }
+                logical_plan_node::LogicalPlanType::ViewScan(v) => {
+                    struct_ser.serialize_field("viewScan", v)?;
+                }
+                logical_plan_node::LogicalPlanType::CustomScan(v) => {
+                    struct_ser.serialize_field("customScan", v)?;
+                }
+                logical_plan_node::LogicalPlanType::Prepare(v) => {
+                    struct_ser.serialize_field("prepare", v)?;
+                }
+                logical_plan_node::LogicalPlanType::DropView(v) => {
+                    struct_ser.serialize_field("dropView", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for LogicalPlanNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "listing_scan",
+            "listingScan",
+            "projection",
+            "selection",
+            "limit",
+            "aggregate",
+            "join",
+            "sort",
+            "repartition",
+            "empty_relation",
+            "emptyRelation",
+            "create_external_table",
+            "createExternalTable",
+            "explain",
+            "window",
+            "analyze",
+            "cross_join",
+            "crossJoin",
+            "values",
+            "extension",
+            "create_catalog_schema",
+            "createCatalogSchema",
+            "union",
+            "create_catalog",
+            "createCatalog",
+            "subquery_alias",
+            "subqueryAlias",
+            "create_view",
+            "createView",
+            "distinct",
+            "view_scan",
+            "viewScan",
+            "custom_scan",
+            "customScan",
+            "prepare",
+            "drop_view",
+            "dropView",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ListingScan,
+            Projection,
+            Selection,
+            Limit,
+            Aggregate,
+            Join,
+            Sort,
+            Repartition,
+            EmptyRelation,
+            CreateExternalTable,
+            Explain,
+            Window,
+            Analyze,
+            CrossJoin,
+            Values,
+            Extension,
+            CreateCatalogSchema,
+            Union,
+            CreateCatalog,
+            SubqueryAlias,
+            CreateView,
+            Distinct,
+            ViewScan,
+            CustomScan,
+            Prepare,
+            DropView,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "listingScan" | "listing_scan" => Ok(GeneratedField::ListingScan),
+                            "projection" => Ok(GeneratedField::Projection),
+                            "selection" => Ok(GeneratedField::Selection),
+                            "limit" => Ok(GeneratedField::Limit),
+                            "aggregate" => Ok(GeneratedField::Aggregate),
+                            "join" => Ok(GeneratedField::Join),
+                            "sort" => Ok(GeneratedField::Sort),
+                            "repartition" => Ok(GeneratedField::Repartition),
+                            "emptyRelation" | "empty_relation" => Ok(GeneratedField::EmptyRelation),
+                            "createExternalTable" | "create_external_table" => Ok(GeneratedField::CreateExternalTable),
+                            "explain" => Ok(GeneratedField::Explain),
+                            "window" => Ok(GeneratedField::Window),
+                            "analyze" => Ok(GeneratedField::Analyze),
+                            "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin),
+                            "values" => Ok(GeneratedField::Values),
+                            "extension" => Ok(GeneratedField::Extension),
+                            "createCatalogSchema" | "create_catalog_schema" => Ok(GeneratedField::CreateCatalogSchema),
+                            "union" => Ok(GeneratedField::Union),
+                            "createCatalog" | "create_catalog" => Ok(GeneratedField::CreateCatalog),
+                            "subqueryAlias" | "subquery_alias" => Ok(GeneratedField::SubqueryAlias),
+                            "createView" | "create_view" => Ok(GeneratedField::CreateView),
+                            "distinct" => Ok(GeneratedField::Distinct),
+                            "viewScan" | "view_scan" => Ok(GeneratedField::ViewScan),
+                            "customScan" | "custom_scan" => Ok(GeneratedField::CustomScan),
+                            "prepare" => Ok(GeneratedField::Prepare),
+                            "dropView" | "drop_view" => Ok(GeneratedField::DropView),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = LogicalPlanNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.LogicalPlanNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalPlanNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut logical_plan_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::ListingScan => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("listingScan"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ListingScan)
+;
+                        }
+                        GeneratedField::Projection => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("projection"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Projection)
+;
+                        }
+                        GeneratedField::Selection => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("selection"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Selection)
+;
+                        }
+                        GeneratedField::Limit => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("limit"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Limit)
+;
+                        }
+                        GeneratedField::Aggregate => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggregate"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Aggregate)
+;
+                        }
+                        GeneratedField::Join => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("join"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Join)
+;
+                        }
+                        GeneratedField::Sort => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sort"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Sort)
+;
+                        }
+                        GeneratedField::Repartition => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("repartition"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Repartition)
+;
+                        }
+                        GeneratedField::EmptyRelation => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("emptyRelation"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::EmptyRelation)
+;
+                        }
+                        GeneratedField::CreateExternalTable => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("createExternalTable"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateExternalTable)
+;
+                        }
+                        GeneratedField::Explain => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("explain"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Explain)
+;
+                        }
+                        GeneratedField::Window => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("window"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Window)
+;
+                        }
+                        GeneratedField::Analyze => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("analyze"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Analyze)
+;
+                        }
+                        GeneratedField::CrossJoin => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("crossJoin"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CrossJoin)
+;
+                        }
+                        GeneratedField::Values => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("values"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Values)
+;
+                        }
+                        GeneratedField::Extension => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("extension"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Extension)
+;
+                        }
+                        GeneratedField::CreateCatalogSchema => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("createCatalogSchema"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalogSchema)
+;
+                        }
+                        GeneratedField::Union => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("union"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Union)
+;
+                        }
+                        GeneratedField::CreateCatalog => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("createCatalog"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalog)
+;
+                        }
+                        GeneratedField::SubqueryAlias => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("subqueryAlias"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::SubqueryAlias)
+;
+                        }
+                        GeneratedField::CreateView => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("createView"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateView)
+;
+                        }
+                        GeneratedField::Distinct => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("distinct"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Distinct)
+;
+                        }
+                        GeneratedField::ViewScan => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("viewScan"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ViewScan)
+;
+                        }
+                        GeneratedField::CustomScan => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("customScan"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CustomScan)
+;
+                        }
+                        GeneratedField::Prepare => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("prepare"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Prepare)
+;
+                        }
+                        GeneratedField::DropView => {
+                            if logical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dropView"));
+                            }
+                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::DropView)
+;
+                        }
+                    }
+                }
+                Ok(LogicalPlanNode {
+                    logical_plan_type: logical_plan_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.LogicalPlanNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Map {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.field_type.is_some() {
+            len += 1;
+        }
+        if self.keys_sorted {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Map", len)?;
+        if let Some(v) = self.field_type.as_ref() {
+            struct_ser.serialize_field("fieldType", v)?;
+        }
+        if self.keys_sorted {
+            struct_ser.serialize_field("keysSorted", &self.keys_sorted)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Map {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "field_type",
+            "fieldType",
+            "keys_sorted",
+            "keysSorted",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FieldType,
+            KeysSorted,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
+                            "keysSorted" | "keys_sorted" => Ok(GeneratedField::KeysSorted),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Map;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Map")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Map, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut field_type__ = None;
+                let mut keys_sorted__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::FieldType => {
+                            if field_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fieldType"));
+                            }
+                            field_type__ = map.next_value()?;
+                        }
+                        GeneratedField::KeysSorted => {
+                            if keys_sorted__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("keysSorted"));
+                            }
+                            keys_sorted__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(Map {
+                    field_type: field_type__,
+                    keys_sorted: keys_sorted__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Map", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for MaybeFilter {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.MaybeFilter", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for MaybeFilter {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MaybeFilter;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.MaybeFilter")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<MaybeFilter, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(MaybeFilter {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.MaybeFilter", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for MaybePhysicalSortExprs {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.sort_expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.MaybePhysicalSortExprs", len)?;
+        if !self.sort_expr.is_empty() {
+            struct_ser.serialize_field("sortExpr", &self.sort_expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for MaybePhysicalSortExprs {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sort_expr",
+            "sortExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SortExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "sortExpr" | "sort_expr" => Ok(GeneratedField::SortExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = MaybePhysicalSortExprs;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.MaybePhysicalSortExprs")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<MaybePhysicalSortExprs, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut sort_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::SortExpr => {
+                            if sort_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sortExpr"));
+                            }
+                            sort_expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(MaybePhysicalSortExprs {
+                    sort_expr: sort_expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.MaybePhysicalSortExprs", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for NegativeNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.NegativeNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for NegativeNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = NegativeNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.NegativeNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<NegativeNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(NegativeNode {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.NegativeNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Not {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Not", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Not {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Not;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Not")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Not, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(Not {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Not", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for OptimizedLogicalPlanType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.optimizer_name.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedLogicalPlanType", len)?;
+        if !self.optimizer_name.is_empty() {
+            struct_ser.serialize_field("optimizerName", &self.optimizer_name)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "optimizer_name",
+            "optimizerName",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            OptimizerName,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = OptimizedLogicalPlanType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.OptimizedLogicalPlanType")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<OptimizedLogicalPlanType, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut optimizer_name__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::OptimizerName => {
+                            if optimizer_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("optimizerName"));
+                            }
+                            optimizer_name__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(OptimizedLogicalPlanType {
+                    optimizer_name: optimizer_name__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.OptimizedLogicalPlanType", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for OptimizedPhysicalPlanType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.optimizer_name.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedPhysicalPlanType", len)?;
+        if !self.optimizer_name.is_empty() {
+            struct_ser.serialize_field("optimizerName", &self.optimizer_name)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "optimizer_name",
+            "optimizerName",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            OptimizerName,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = OptimizedPhysicalPlanType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.OptimizedPhysicalPlanType")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<OptimizedPhysicalPlanType, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut optimizer_name__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::OptimizerName => {
+                            if optimizer_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("optimizerName"));
+                            }
+                            optimizer_name__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(OptimizedPhysicalPlanType {
+                    optimizer_name: optimizer_name__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.OptimizedPhysicalPlanType", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for OwnedTableReference {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.table_reference_enum.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.OwnedTableReference", len)?;
+        if let Some(v) = self.table_reference_enum.as_ref() {
+            match v {
+                owned_table_reference::TableReferenceEnum::Bare(v) => {
+                    struct_ser.serialize_field("bare", v)?;
+                }
+                owned_table_reference::TableReferenceEnum::Partial(v) => {
+                    struct_ser.serialize_field("partial", v)?;
+                }
+                owned_table_reference::TableReferenceEnum::Full(v) => {
+                    struct_ser.serialize_field("full", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for OwnedTableReference {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "bare",
+            "partial",
+            "full",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Bare,
+            Partial,
+            Full,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "bare" => Ok(GeneratedField::Bare),
+                            "partial" => Ok(GeneratedField::Partial),
+                            "full" => Ok(GeneratedField::Full),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = OwnedTableReference;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.OwnedTableReference")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<OwnedTableReference, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut table_reference_enum__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Bare => {
+                            if table_reference_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("bare"));
+                            }
+                            table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Bare)
+;
+                        }
+                        GeneratedField::Partial => {
+                            if table_reference_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("partial"));
+                            }
+                            table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Partial)
+;
+                        }
+                        GeneratedField::Full => {
+                            if table_reference_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("full"));
+                            }
+                            table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Full)
+;
+                        }
+                    }
+                }
+                Ok(OwnedTableReference {
+                    table_reference_enum: table_reference_enum__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.OwnedTableReference", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ParquetFormat {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let len = 0;
+        let struct_ser = serializer.serialize_struct("datafusion.ParquetFormat", len)?;
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ParquetFormat {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                            Err(serde::de::Error::unknown_field(value, FIELDS))
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ParquetFormat;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ParquetFormat")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ParquetFormat, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                while map.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                }
+                Ok(ParquetFormat {
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ParquetFormat", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ParquetScanExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.base_conf.is_some() {
+            len += 1;
+        }
+        if self.predicate.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ParquetScanExecNode", len)?;
+        if let Some(v) = self.base_conf.as_ref() {
+            struct_ser.serialize_field("baseConf", v)?;
+        }
+        if let Some(v) = self.predicate.as_ref() {
+            struct_ser.serialize_field("predicate", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ParquetScanExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "base_conf",
+            "baseConf",
+            "predicate",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            BaseConf,
+            Predicate,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf),
+                            "predicate" => Ok(GeneratedField::Predicate),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ParquetScanExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ParquetScanExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ParquetScanExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut base_conf__ = None;
+                let mut predicate__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::BaseConf => {
+                            if base_conf__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("baseConf"));
+                            }
+                            base_conf__ = map.next_value()?;
+                        }
+                        GeneratedField::Predicate => {
+                            if predicate__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("predicate"));
+                            }
+                            predicate__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(ParquetScanExecNode {
+                    base_conf: base_conf__,
+                    predicate: predicate__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ParquetScanExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PartialTableReference {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.schema.is_empty() {
+            len += 1;
+        }
+        if !self.table.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PartialTableReference", len)?;
+        if !self.schema.is_empty() {
+            struct_ser.serialize_field("schema", &self.schema)?;
+        }
+        if !self.table.is_empty() {
+            struct_ser.serialize_field("table", &self.table)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PartialTableReference {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "schema",
+            "table",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Schema,
+            Table,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "schema" => Ok(GeneratedField::Schema),
+                            "table" => Ok(GeneratedField::Table),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PartialTableReference;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PartialTableReference")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PartialTableReference, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut schema__ = None;
+                let mut table__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Table => {
+                            if table__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("table"));
+                            }
+                            table__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PartialTableReference {
+                    schema: schema__.unwrap_or_default(),
+                    table: table__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PartialTableReference", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PartitionMode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::CollectLeft => "COLLECT_LEFT",
+            Self::Partitioned => "PARTITIONED",
+            Self::Auto => "AUTO",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for PartitionMode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "COLLECT_LEFT",
+            "PARTITIONED",
+            "AUTO",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PartitionMode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(PartitionMode::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(PartitionMode::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "COLLECT_LEFT" => Ok(PartitionMode::CollectLeft),
+                    "PARTITIONED" => Ok(PartitionMode::Partitioned),
+                    "AUTO" => Ok(PartitionMode::Auto),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PartitionStats {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.num_rows != 0 {
+            len += 1;
+        }
+        if self.num_batches != 0 {
+            len += 1;
+        }
+        if self.num_bytes != 0 {
+            len += 1;
+        }
+        if !self.column_stats.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PartitionStats", len)?;
+        if self.num_rows != 0 {
+            struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?;
+        }
+        if self.num_batches != 0 {
+            struct_ser.serialize_field("numBatches", ToString::to_string(&self.num_batches).as_str())?;
+        }
+        if self.num_bytes != 0 {
+            struct_ser.serialize_field("numBytes", ToString::to_string(&self.num_bytes).as_str())?;
+        }
+        if !self.column_stats.is_empty() {
+            struct_ser.serialize_field("columnStats", &self.column_stats)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PartitionStats {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "num_rows",
+            "numRows",
+            "num_batches",
+            "numBatches",
+            "num_bytes",
+            "numBytes",
+            "column_stats",
+            "columnStats",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NumRows,
+            NumBatches,
+            NumBytes,
+            ColumnStats,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "numRows" | "num_rows" => Ok(GeneratedField::NumRows),
+                            "numBatches" | "num_batches" => Ok(GeneratedField::NumBatches),
+                            "numBytes" | "num_bytes" => Ok(GeneratedField::NumBytes),
+                            "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PartitionStats;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PartitionStats")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PartitionStats, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut num_rows__ = None;
+                let mut num_batches__ = None;
+                let mut num_bytes__ = None;
+                let mut column_stats__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::NumRows => {
+                            if num_rows__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("numRows"));
+                            }
+                            num_rows__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::NumBatches => {
+                            if num_batches__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("numBatches"));
+                            }
+                            num_batches__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::NumBytes => {
+                            if num_bytes__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("numBytes"));
+                            }
+                            num_bytes__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::ColumnStats => {
+                            if column_stats__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("columnStats"));
+                            }
+                            column_stats__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PartitionStats {
+                    num_rows: num_rows__.unwrap_or_default(),
+                    num_batches: num_batches__.unwrap_or_default(),
+                    num_bytes: num_bytes__.unwrap_or_default(),
+                    column_stats: column_stats__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PartitionStats", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PartitionedFile {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.path.is_empty() {
+            len += 1;
+        }
+        if self.size != 0 {
+            len += 1;
+        }
+        if self.last_modified_ns != 0 {
+            len += 1;
+        }
+        if !self.partition_values.is_empty() {
+            len += 1;
+        }
+        if self.range.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PartitionedFile", len)?;
+        if !self.path.is_empty() {
+            struct_ser.serialize_field("path", &self.path)?;
+        }
+        if self.size != 0 {
+            struct_ser.serialize_field("size", ToString::to_string(&self.size).as_str())?;
+        }
+        if self.last_modified_ns != 0 {
+            struct_ser.serialize_field("lastModifiedNs", ToString::to_string(&self.last_modified_ns).as_str())?;
+        }
+        if !self.partition_values.is_empty() {
+            struct_ser.serialize_field("partitionValues", &self.partition_values)?;
+        }
+        if let Some(v) = self.range.as_ref() {
+            struct_ser.serialize_field("range", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PartitionedFile {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "path",
+            "size",
+            "last_modified_ns",
+            "lastModifiedNs",
+            "partition_values",
+            "partitionValues",
+            "range",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Path,
+            Size,
+            LastModifiedNs,
+            PartitionValues,
+            Range,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "path" => Ok(GeneratedField::Path),
+                            "size" => Ok(GeneratedField::Size),
+                            "lastModifiedNs" | "last_modified_ns" => Ok(GeneratedField::LastModifiedNs),
+                            "partitionValues" | "partition_values" => Ok(GeneratedField::PartitionValues),
+                            "range" => Ok(GeneratedField::Range),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PartitionedFile;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PartitionedFile")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PartitionedFile, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut path__ = None;
+                let mut size__ = None;
+                let mut last_modified_ns__ = None;
+                let mut partition_values__ = None;
+                let mut range__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Path => {
+                            if path__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("path"));
+                            }
+                            path__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Size => {
+                            if size__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("size"));
+                            }
+                            size__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::LastModifiedNs => {
+                            if last_modified_ns__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("lastModifiedNs"));
+                            }
+                            last_modified_ns__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::PartitionValues => {
+                            if partition_values__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("partitionValues"));
+                            }
+                            partition_values__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Range => {
+                            if range__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("range"));
+                            }
+                            range__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PartitionedFile {
+                    path: path__.unwrap_or_default(),
+                    size: size__.unwrap_or_default(),
+                    last_modified_ns: last_modified_ns__.unwrap_or_default(),
+                    partition_values: partition_values__.unwrap_or_default(),
+                    range: range__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PartitionedFile", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalAggregateExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        if !self.ordering_req.is_empty() {
+            len += 1;
+        }
+        if self.distinct {
+            len += 1;
+        }
+        if self.aggregate_function.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAggregateExprNode", len)?;
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        if !self.ordering_req.is_empty() {
+            struct_ser.serialize_field("orderingReq", &self.ordering_req)?;
+        }
+        if self.distinct {
+            struct_ser.serialize_field("distinct", &self.distinct)?;
+        }
+        if let Some(v) = self.aggregate_function.as_ref() {
+            match v {
+                physical_aggregate_expr_node::AggregateFunction::AggrFunction(v) => {
+                    let v = AggregateFunction::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("aggrFunction", &v)?;
+                }
+                physical_aggregate_expr_node::AggregateFunction::UserDefinedAggrFunction(v) => {
+                    struct_ser.serialize_field("userDefinedAggrFunction", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalAggregateExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "ordering_req",
+            "orderingReq",
+            "distinct",
+            "aggr_function",
+            "aggrFunction",
+            "user_defined_aggr_function",
+            "userDefinedAggrFunction",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            OrderingReq,
+            Distinct,
+            AggrFunction,
+            UserDefinedAggrFunction,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "orderingReq" | "ordering_req" => Ok(GeneratedField::OrderingReq),
+                            "distinct" => Ok(GeneratedField::Distinct),
+                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
+                            "userDefinedAggrFunction" | "user_defined_aggr_function" => Ok(GeneratedField::UserDefinedAggrFunction),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalAggregateExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalAggregateExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalAggregateExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut ordering_req__ = None;
+                let mut distinct__ = None;
+                let mut aggregate_function__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::OrderingReq => {
+                            if ordering_req__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("orderingReq"));
+                            }
+                            ordering_req__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Distinct => {
+                            if distinct__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("distinct"));
+                            }
+                            distinct__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::AggrFunction => {
+                            if aggregate_function__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
+                            }
+                            aggregate_function__ = map.next_value::<::std::option::Option<AggregateFunction>>()?.map(|x| physical_aggregate_expr_node::AggregateFunction::AggrFunction(x as i32));
+                        }
+                        GeneratedField::UserDefinedAggrFunction => {
+                            if aggregate_function__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("userDefinedAggrFunction"));
+                            }
+                            aggregate_function__ = map.next_value::<::std::option::Option<_>>()?.map(physical_aggregate_expr_node::AggregateFunction::UserDefinedAggrFunction);
+                        }
+                    }
+                }
+                Ok(PhysicalAggregateExprNode {
+                    expr: expr__.unwrap_or_default(),
+                    ordering_req: ordering_req__.unwrap_or_default(),
+                    distinct: distinct__.unwrap_or_default(),
+                    aggregate_function: aggregate_function__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalAggregateExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalAliasNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if !self.alias.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAliasNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if !self.alias.is_empty() {
+            struct_ser.serialize_field("alias", &self.alias)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalAliasNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "alias",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            Alias,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "alias" => Ok(GeneratedField::Alias),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalAliasNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalAliasNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalAliasNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut alias__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Alias => {
+                            if alias__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("alias"));
+                            }
+                            alias__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PhysicalAliasNode {
+                    expr: expr__,
+                    alias: alias__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalAliasNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalBinaryExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.l.is_some() {
+            len += 1;
+        }
+        if self.r.is_some() {
+            len += 1;
+        }
+        if !self.op.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalBinaryExprNode", len)?;
+        if let Some(v) = self.l.as_ref() {
+            struct_ser.serialize_field("l", v)?;
+        }
+        if let Some(v) = self.r.as_ref() {
+            struct_ser.serialize_field("r", v)?;
+        }
+        if !self.op.is_empty() {
+            struct_ser.serialize_field("op", &self.op)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalBinaryExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "l",
+            "r",
+            "op",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            L,
+            R,
+            Op,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "l" => Ok(GeneratedField::L),
+                            "r" => Ok(GeneratedField::R),
+                            "op" => Ok(GeneratedField::Op),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalBinaryExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalBinaryExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalBinaryExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut l__ = None;
+                let mut r__ = None;
+                let mut op__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::L => {
+                            if l__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("l"));
+                            }
+                            l__ = map.next_value()?;
+                        }
+                        GeneratedField::R => {
+                            if r__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("r"));
+                            }
+                            r__ = map.next_value()?;
+                        }
+                        GeneratedField::Op => {
+                            if op__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("op"));
+                            }
+                            op__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PhysicalBinaryExprNode {
+                    l: l__,
+                    r: r__,
+                    op: op__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalBinaryExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalCaseNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if !self.when_then_expr.is_empty() {
+            len += 1;
+        }
+        if self.else_expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCaseNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if !self.when_then_expr.is_empty() {
+            struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?;
+        }
+        if let Some(v) = self.else_expr.as_ref() {
+            struct_ser.serialize_field("elseExpr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalCaseNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "when_then_expr",
+            "whenThenExpr",
+            "else_expr",
+            "elseExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            WhenThenExpr,
+            ElseExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr),
+                            "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalCaseNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalCaseNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalCaseNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut when_then_expr__ = None;
+                let mut else_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::WhenThenExpr => {
+                            if when_then_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("whenThenExpr"));
+                            }
+                            when_then_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::ElseExpr => {
+                            if else_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("elseExpr"));
+                            }
+                            else_expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalCaseNode {
+                    expr: expr__,
+                    when_then_expr: when_then_expr__.unwrap_or_default(),
+                    else_expr: else_expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalCaseNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalCastNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.arrow_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCastNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.arrow_type.as_ref() {
+            struct_ser.serialize_field("arrowType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalCastNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "arrow_type",
+            "arrowType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            ArrowType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalCastNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalCastNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalCastNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut arrow_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::ArrowType => {
+                            if arrow_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("arrowType"));
+                            }
+                            arrow_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalCastNode {
+                    expr: expr__,
+                    arrow_type: arrow_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalCastNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalColumn {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if self.index != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalColumn", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if self.index != 0 {
+            struct_ser.serialize_field("index", &self.index)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalColumn {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "index",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Index,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "index" => Ok(GeneratedField::Index),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalColumn;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalColumn")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalColumn, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut index__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Index => {
+                            if index__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("index"));
+                            }
+                            index__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(PhysicalColumn {
+                    name: name__.unwrap_or_default(),
+                    index: index__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalColumn", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalDateTimeIntervalExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.l.is_some() {
+            len += 1;
+        }
+        if self.r.is_some() {
+            len += 1;
+        }
+        if !self.op.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", len)?;
+        if let Some(v) = self.l.as_ref() {
+            struct_ser.serialize_field("l", v)?;
+        }
+        if let Some(v) = self.r.as_ref() {
+            struct_ser.serialize_field("r", v)?;
+        }
+        if !self.op.is_empty() {
+            struct_ser.serialize_field("op", &self.op)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalDateTimeIntervalExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "l",
+            "r",
+            "op",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            L,
+            R,
+            Op,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "l" => Ok(GeneratedField::L),
+                            "r" => Ok(GeneratedField::R),
+                            "op" => Ok(GeneratedField::Op),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalDateTimeIntervalExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalDateTimeIntervalExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalDateTimeIntervalExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut l__ = None;
+                let mut r__ = None;
+                let mut op__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::L => {
+                            if l__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("l"));
+                            }
+                            l__ = map.next_value()?;
+                        }
+                        GeneratedField::R => {
+                            if r__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("r"));
+                            }
+                            r__ = map.next_value()?;
+                        }
+                        GeneratedField::Op => {
+                            if op__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("op"));
+                            }
+                            op__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PhysicalDateTimeIntervalExprNode {
+                    l: l__,
+                    r: r__,
+                    op: op__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExprNode", len)?;
+        if let Some(v) = self.expr_type.as_ref() {
+            match v {
+                physical_expr_node::ExprType::Column(v) => {
+                    struct_ser.serialize_field("column", v)?;
+                }
+                physical_expr_node::ExprType::Literal(v) => {
+                    struct_ser.serialize_field("literal", v)?;
+                }
+                physical_expr_node::ExprType::BinaryExpr(v) => {
+                    struct_ser.serialize_field("binaryExpr", v)?;
+                }
+                physical_expr_node::ExprType::AggregateExpr(v) => {
+                    struct_ser.serialize_field("aggregateExpr", v)?;
+                }
+                physical_expr_node::ExprType::IsNullExpr(v) => {
+                    struct_ser.serialize_field("isNullExpr", v)?;
+                }
+                physical_expr_node::ExprType::IsNotNullExpr(v) => {
+                    struct_ser.serialize_field("isNotNullExpr", v)?;
+                }
+                physical_expr_node::ExprType::NotExpr(v) => {
+                    struct_ser.serialize_field("notExpr", v)?;
+                }
+                physical_expr_node::ExprType::Case(v) => {
+                    struct_ser.serialize_field("case", v)?;
+                }
+                physical_expr_node::ExprType::Cast(v) => {
+                    struct_ser.serialize_field("cast", v)?;
+                }
+                physical_expr_node::ExprType::Sort(v) => {
+                    struct_ser.serialize_field("sort", v)?;
+                }
+                physical_expr_node::ExprType::Negative(v) => {
+                    struct_ser.serialize_field("negative", v)?;
+                }
+                physical_expr_node::ExprType::InList(v) => {
+                    struct_ser.serialize_field("inList", v)?;
+                }
+                physical_expr_node::ExprType::ScalarFunction(v) => {
+                    struct_ser.serialize_field("scalarFunction", v)?;
+                }
+                physical_expr_node::ExprType::TryCast(v) => {
+                    struct_ser.serialize_field("tryCast", v)?;
+                }
+                physical_expr_node::ExprType::WindowExpr(v) => {
+                    struct_ser.serialize_field("windowExpr", v)?;
+                }
+                physical_expr_node::ExprType::ScalarUdf(v) => {
+                    struct_ser.serialize_field("scalarUdf", v)?;
+                }
+                physical_expr_node::ExprType::DateTimeIntervalExpr(v) => {
+                    struct_ser.serialize_field("dateTimeIntervalExpr", v)?;
+                }
+                physical_expr_node::ExprType::LikeExpr(v) => {
+                    struct_ser.serialize_field("likeExpr", v)?;
+                }
+                physical_expr_node::ExprType::GetIndexedFieldExpr(v) => {
+                    struct_ser.serialize_field("getIndexedFieldExpr", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "column",
+            "literal",
+            "binary_expr",
+            "binaryExpr",
+            "aggregate_expr",
+            "aggregateExpr",
+            "is_null_expr",
+            "isNullExpr",
+            "is_not_null_expr",
+            "isNotNullExpr",
+            "not_expr",
+            "notExpr",
+            "case_",
+            "case",
+            "cast",
+            "sort",
+            "negative",
+            "in_list",
+            "inList",
+            "scalar_function",
+            "scalarFunction",
+            "try_cast",
+            "tryCast",
+            "window_expr",
+            "windowExpr",
+            "scalar_udf",
+            "scalarUdf",
+            "date_time_interval_expr",
+            "dateTimeIntervalExpr",
+            "like_expr",
+            "likeExpr",
+            "get_indexed_field_expr",
+            "getIndexedFieldExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Column,
+            Literal,
+            BinaryExpr,
+            AggregateExpr,
+            IsNullExpr,
+            IsNotNullExpr,
+            NotExpr,
+            Case,
+            Cast,
+            Sort,
+            Negative,
+            InList,
+            ScalarFunction,
+            TryCast,
+            WindowExpr,
+            ScalarUdf,
+            DateTimeIntervalExpr,
+            LikeExpr,
+            GetIndexedFieldExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "column" => Ok(GeneratedField::Column),
+                            "literal" => Ok(GeneratedField::Literal),
+                            "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr),
+                            "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr),
+                            "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr),
+                            "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr),
+                            "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr),
+                            "case" | "case_" => Ok(GeneratedField::Case),
+                            "cast" => Ok(GeneratedField::Cast),
+                            "sort" => Ok(GeneratedField::Sort),
+                            "negative" => Ok(GeneratedField::Negative),
+                            "inList" | "in_list" => Ok(GeneratedField::InList),
+                            "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction),
+                            "tryCast" | "try_cast" => Ok(GeneratedField::TryCast),
+                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
+                            "scalarUdf" | "scalar_udf" => Ok(GeneratedField::ScalarUdf),
+                            "dateTimeIntervalExpr" | "date_time_interval_expr" => Ok(GeneratedField::DateTimeIntervalExpr),
+                            "likeExpr" | "like_expr" => Ok(GeneratedField::LikeExpr),
+                            "getIndexedFieldExpr" | "get_indexed_field_expr" => Ok(GeneratedField::GetIndexedFieldExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Column => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("column"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Column)
+;
+                        }
+                        GeneratedField::Literal => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("literal"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Literal)
+;
+                        }
+                        GeneratedField::BinaryExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("binaryExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::BinaryExpr)
+;
+                        }
+                        GeneratedField::AggregateExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggregateExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::AggregateExpr)
+;
+                        }
+                        GeneratedField::IsNullExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNullExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNullExpr)
+;
+                        }
+                        GeneratedField::IsNotNullExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNotNullExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNotNullExpr)
+;
+                        }
+                        GeneratedField::NotExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("notExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::NotExpr)
+;
+                        }
+                        GeneratedField::Case => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("case"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Case)
+;
+                        }
+                        GeneratedField::Cast => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("cast"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Cast)
+;
+                        }
+                        GeneratedField::Sort => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sort"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Sort)
+;
+                        }
+                        GeneratedField::Negative => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negative"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Negative)
+;
+                        }
+                        GeneratedField::InList => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inList"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::InList)
+;
+                        }
+                        GeneratedField::ScalarFunction => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("scalarFunction"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarFunction)
+;
+                        }
+                        GeneratedField::TryCast => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tryCast"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::TryCast)
+;
+                        }
+                        GeneratedField::WindowExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::WindowExpr)
+;
+                        }
+                        GeneratedField::ScalarUdf => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("scalarUdf"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarUdf)
+;
+                        }
+                        GeneratedField::DateTimeIntervalExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dateTimeIntervalExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::DateTimeIntervalExpr)
+;
+                        }
+                        GeneratedField::LikeExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("likeExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::LikeExpr)
+;
+                        }
+                        GeneratedField::GetIndexedFieldExpr => {
+                            if expr_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("getIndexedFieldExpr"));
+                            }
+                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::GetIndexedFieldExpr)
+;
+                        }
+                    }
+                }
+                Ok(PhysicalExprNode {
+                    expr_type: expr_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalExtensionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.node.is_empty() {
+            len += 1;
+        }
+        if !self.inputs.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExtensionNode", len)?;
+        if !self.node.is_empty() {
+            struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?;
+        }
+        if !self.inputs.is_empty() {
+            struct_ser.serialize_field("inputs", &self.inputs)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalExtensionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "node",
+            "inputs",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Node,
+            Inputs,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "node" => Ok(GeneratedField::Node),
+                            "inputs" => Ok(GeneratedField::Inputs),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalExtensionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalExtensionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalExtensionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut node__ = None;
+                let mut inputs__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Node => {
+                            if node__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("node"));
+                            }
+                            node__ = 
+                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Inputs => {
+                            if inputs__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inputs"));
+                            }
+                            inputs__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PhysicalExtensionNode {
+                    node: node__.unwrap_or_default(),
+                    inputs: inputs__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalExtensionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalGetIndexedFieldExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.arg.is_some() {
+            len += 1;
+        }
+        if self.key.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalGetIndexedFieldExprNode", len)?;
+        if let Some(v) = self.arg.as_ref() {
+            struct_ser.serialize_field("arg", v)?;
+        }
+        if let Some(v) = self.key.as_ref() {
+            struct_ser.serialize_field("key", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalGetIndexedFieldExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "arg",
+            "key",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Arg,
+            Key,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "arg" => Ok(GeneratedField::Arg),
+                            "key" => Ok(GeneratedField::Key),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalGetIndexedFieldExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalGetIndexedFieldExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalGetIndexedFieldExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut arg__ = None;
+                let mut key__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Arg => {
+                            if arg__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("arg"));
+                            }
+                            arg__ = map.next_value()?;
+                        }
+                        GeneratedField::Key => {
+                            if key__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("key"));
+                            }
+                            key__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalGetIndexedFieldExprNode {
+                    arg: arg__,
+                    key: key__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalGetIndexedFieldExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalHashRepartition {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.hash_expr.is_empty() {
+            len += 1;
+        }
+        if self.partition_count != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalHashRepartition", len)?;
+        if !self.hash_expr.is_empty() {
+            struct_ser.serialize_field("hashExpr", &self.hash_expr)?;
+        }
+        if self.partition_count != 0 {
+            struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalHashRepartition {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "hash_expr",
+            "hashExpr",
+            "partition_count",
+            "partitionCount",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            HashExpr,
+            PartitionCount,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr),
+                            "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalHashRepartition;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalHashRepartition")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalHashRepartition, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut hash_expr__ = None;
+                let mut partition_count__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::HashExpr => {
+                            if hash_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hashExpr"));
+                            }
+                            hash_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::PartitionCount => {
+                            if partition_count__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("partitionCount"));
+                            }
+                            partition_count__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(PhysicalHashRepartition {
+                    hash_expr: hash_expr__.unwrap_or_default(),
+                    partition_count: partition_count__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalHashRepartition", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalInListNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if !self.list.is_empty() {
+            len += 1;
+        }
+        if self.negated {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalInListNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if !self.list.is_empty() {
+            struct_ser.serialize_field("list", &self.list)?;
+        }
+        if self.negated {
+            struct_ser.serialize_field("negated", &self.negated)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalInListNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "list",
+            "negated",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            List,
+            Negated,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "list" => Ok(GeneratedField::List),
+                            "negated" => Ok(GeneratedField::Negated),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalInListNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalInListNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalInListNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut list__ = None;
+                let mut negated__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::List => {
+                            if list__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("list"));
+                            }
+                            list__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Negated => {
+                            if negated__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negated"));
+                            }
+                            negated__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PhysicalInListNode {
+                    expr: expr__,
+                    list: list__.unwrap_or_default(),
+                    negated: negated__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalInListNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalIsNotNull {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNotNull", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalIsNotNull {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalIsNotNull;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalIsNotNull")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalIsNotNull, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalIsNotNull {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalIsNotNull", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalIsNull {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNull", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalIsNull {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalIsNull;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalIsNull")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalIsNull, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalIsNull {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalIsNull", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalLikeExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.negated {
+            len += 1;
+        }
+        if self.case_insensitive {
+            len += 1;
+        }
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.pattern.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalLikeExprNode", len)?;
+        if self.negated {
+            struct_ser.serialize_field("negated", &self.negated)?;
+        }
+        if self.case_insensitive {
+            struct_ser.serialize_field("caseInsensitive", &self.case_insensitive)?;
+        }
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.pattern.as_ref() {
+            struct_ser.serialize_field("pattern", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalLikeExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "negated",
+            "case_insensitive",
+            "caseInsensitive",
+            "expr",
+            "pattern",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Negated,
+            CaseInsensitive,
+            Expr,
+            Pattern,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "negated" => Ok(GeneratedField::Negated),
+                            "caseInsensitive" | "case_insensitive" => Ok(GeneratedField::CaseInsensitive),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "pattern" => Ok(GeneratedField::Pattern),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalLikeExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalLikeExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalLikeExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut negated__ = None;
+                let mut case_insensitive__ = None;
+                let mut expr__ = None;
+                let mut pattern__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Negated => {
+                            if negated__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negated"));
+                            }
+                            negated__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::CaseInsensitive => {
+                            if case_insensitive__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("caseInsensitive"));
+                            }
+                            case_insensitive__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Pattern => {
+                            if pattern__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pattern"));
+                            }
+                            pattern__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalLikeExprNode {
+                    negated: negated__.unwrap_or_default(),
+                    case_insensitive: case_insensitive__.unwrap_or_default(),
+                    expr: expr__,
+                    pattern: pattern__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalLikeExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalNegativeNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNegativeNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalNegativeNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalNegativeNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalNegativeNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalNegativeNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalNegativeNode {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalNegativeNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalNot {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNot", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalNot {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalNot;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalNot")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalNot, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalNot {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalNot", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalPlanNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.physical_plan_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalPlanNode", len)?;
+        if let Some(v) = self.physical_plan_type.as_ref() {
+            match v {
+                physical_plan_node::PhysicalPlanType::ParquetScan(v) => {
+                    struct_ser.serialize_field("parquetScan", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::CsvScan(v) => {
+                    struct_ser.serialize_field("csvScan", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Empty(v) => {
+                    struct_ser.serialize_field("empty", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Projection(v) => {
+                    struct_ser.serialize_field("projection", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::GlobalLimit(v) => {
+                    struct_ser.serialize_field("globalLimit", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::LocalLimit(v) => {
+                    struct_ser.serialize_field("localLimit", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Aggregate(v) => {
+                    struct_ser.serialize_field("aggregate", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::HashJoin(v) => {
+                    struct_ser.serialize_field("hashJoin", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Sort(v) => {
+                    struct_ser.serialize_field("sort", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::CoalesceBatches(v) => {
+                    struct_ser.serialize_field("coalesceBatches", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Filter(v) => {
+                    struct_ser.serialize_field("filter", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Merge(v) => {
+                    struct_ser.serialize_field("merge", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Repartition(v) => {
+                    struct_ser.serialize_field("repartition", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Window(v) => {
+                    struct_ser.serialize_field("window", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::CrossJoin(v) => {
+                    struct_ser.serialize_field("crossJoin", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::AvroScan(v) => {
+                    struct_ser.serialize_field("avroScan", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Extension(v) => {
+                    struct_ser.serialize_field("extension", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Union(v) => {
+                    struct_ser.serialize_field("union", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::Explain(v) => {
+                    struct_ser.serialize_field("explain", v)?;
+                }
+                physical_plan_node::PhysicalPlanType::SortPreservingMerge(v) => {
+                    struct_ser.serialize_field("sortPreservingMerge", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalPlanNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "parquet_scan",
+            "parquetScan",
+            "csv_scan",
+            "csvScan",
+            "empty",
+            "projection",
+            "global_limit",
+            "globalLimit",
+            "local_limit",
+            "localLimit",
+            "aggregate",
+            "hash_join",
+            "hashJoin",
+            "sort",
+            "coalesce_batches",
+            "coalesceBatches",
+            "filter",
+            "merge",
+            "repartition",
+            "window",
+            "cross_join",
+            "crossJoin",
+            "avro_scan",
+            "avroScan",
+            "extension",
+            "union",
+            "explain",
+            "sort_preserving_merge",
+            "sortPreservingMerge",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            ParquetScan,
+            CsvScan,
+            Empty,
+            Projection,
+            GlobalLimit,
+            LocalLimit,
+            Aggregate,
+            HashJoin,
+            Sort,
+            CoalesceBatches,
+            Filter,
+            Merge,
+            Repartition,
+            Window,
+            CrossJoin,
+            AvroScan,
+            Extension,
+            Union,
+            Explain,
+            SortPreservingMerge,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "parquetScan" | "parquet_scan" => Ok(GeneratedField::ParquetScan),
+                            "csvScan" | "csv_scan" => Ok(GeneratedField::CsvScan),
+                            "empty" => Ok(GeneratedField::Empty),
+                            "projection" => Ok(GeneratedField::Projection),
+                            "globalLimit" | "global_limit" => Ok(GeneratedField::GlobalLimit),
+                            "localLimit" | "local_limit" => Ok(GeneratedField::LocalLimit),
+                            "aggregate" => Ok(GeneratedField::Aggregate),
+                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
+                            "sort" => Ok(GeneratedField::Sort),
+                            "coalesceBatches" | "coalesce_batches" => Ok(GeneratedField::CoalesceBatches),
+                            "filter" => Ok(GeneratedField::Filter),
+                            "merge" => Ok(GeneratedField::Merge),
+                            "repartition" => Ok(GeneratedField::Repartition),
+                            "window" => Ok(GeneratedField::Window),
+                            "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin),
+                            "avroScan" | "avro_scan" => Ok(GeneratedField::AvroScan),
+                            "extension" => Ok(GeneratedField::Extension),
+                            "union" => Ok(GeneratedField::Union),
+                            "explain" => Ok(GeneratedField::Explain),
+                            "sortPreservingMerge" | "sort_preserving_merge" => Ok(GeneratedField::SortPreservingMerge),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalPlanNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalPlanNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalPlanNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut physical_plan_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::ParquetScan => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("parquetScan"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::ParquetScan)
+;
+                        }
+                        GeneratedField::CsvScan => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("csvScan"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CsvScan)
+;
+                        }
+                        GeneratedField::Empty => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("empty"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Empty)
+;
+                        }
+                        GeneratedField::Projection => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("projection"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Projection)
+;
+                        }
+                        GeneratedField::GlobalLimit => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("globalLimit"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::GlobalLimit)
+;
+                        }
+                        GeneratedField::LocalLimit => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("localLimit"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::LocalLimit)
+;
+                        }
+                        GeneratedField::Aggregate => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggregate"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Aggregate)
+;
+                        }
+                        GeneratedField::HashJoin => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hashJoin"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::HashJoin)
+;
+                        }
+                        GeneratedField::Sort => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sort"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Sort)
+;
+                        }
+                        GeneratedField::CoalesceBatches => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("coalesceBatches"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CoalesceBatches)
+;
+                        }
+                        GeneratedField::Filter => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("filter"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Filter)
+;
+                        }
+                        GeneratedField::Merge => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("merge"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Merge)
+;
+                        }
+                        GeneratedField::Repartition => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("repartition"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Repartition)
+;
+                        }
+                        GeneratedField::Window => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("window"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Window)
+;
+                        }
+                        GeneratedField::CrossJoin => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("crossJoin"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CrossJoin)
+;
+                        }
+                        GeneratedField::AvroScan => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("avroScan"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::AvroScan)
+;
+                        }
+                        GeneratedField::Extension => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("extension"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Extension)
+;
+                        }
+                        GeneratedField::Union => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("union"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Union)
+;
+                        }
+                        GeneratedField::Explain => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("explain"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Explain)
+;
+                        }
+                        GeneratedField::SortPreservingMerge => {
+                            if physical_plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("sortPreservingMerge"));
+                            }
+                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::SortPreservingMerge)
+;
+                        }
+                    }
+                }
+                Ok(PhysicalPlanNode {
+                    physical_plan_type: physical_plan_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalPlanNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalScalarFunctionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if self.fun != 0 {
+            len += 1;
+        }
+        if !self.args.is_empty() {
+            len += 1;
+        }
+        if self.return_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarFunctionNode", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if self.fun != 0 {
+            let v = ScalarFunction::from_i32(self.fun)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?;
+            struct_ser.serialize_field("fun", &v)?;
+        }
+        if !self.args.is_empty() {
+            struct_ser.serialize_field("args", &self.args)?;
+        }
+        if let Some(v) = self.return_type.as_ref() {
+            struct_ser.serialize_field("returnType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalScalarFunctionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "fun",
+            "args",
+            "return_type",
+            "returnType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Fun,
+            Args,
+            ReturnType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "fun" => Ok(GeneratedField::Fun),
+                            "args" => Ok(GeneratedField::Args),
+                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalScalarFunctionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalScalarFunctionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalScalarFunctionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut fun__ = None;
+                let mut args__ = None;
+                let mut return_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Fun => {
+                            if fun__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fun"));
+                            }
+                            fun__ = Some(map.next_value::<ScalarFunction>()? as i32);
+                        }
+                        GeneratedField::Args => {
+                            if args__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("args"));
+                            }
+                            args__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::ReturnType => {
+                            if return_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("returnType"));
+                            }
+                            return_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalScalarFunctionNode {
+                    name: name__.unwrap_or_default(),
+                    fun: fun__.unwrap_or_default(),
+                    args: args__.unwrap_or_default(),
+                    return_type: return_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalScalarFunctionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalScalarUdfNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if !self.args.is_empty() {
+            len += 1;
+        }
+        if self.return_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarUdfNode", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if !self.args.is_empty() {
+            struct_ser.serialize_field("args", &self.args)?;
+        }
+        if let Some(v) = self.return_type.as_ref() {
+            struct_ser.serialize_field("returnType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalScalarUdfNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "args",
+            "return_type",
+            "returnType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            Args,
+            ReturnType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "args" => Ok(GeneratedField::Args),
+                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalScalarUdfNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalScalarUdfNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalScalarUdfNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut args__ = None;
+                let mut return_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Args => {
+                            if args__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("args"));
+                            }
+                            args__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::ReturnType => {
+                            if return_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("returnType"));
+                            }
+                            return_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalScalarUdfNode {
+                    name: name__.unwrap_or_default(),
+                    args: args__.unwrap_or_default(),
+                    return_type: return_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalScalarUdfNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalSortExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.asc {
+            len += 1;
+        }
+        if self.nulls_first {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalSortExprNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if self.asc {
+            struct_ser.serialize_field("asc", &self.asc)?;
+        }
+        if self.nulls_first {
+            struct_ser.serialize_field("nullsFirst", &self.nulls_first)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalSortExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "asc",
+            "nulls_first",
+            "nullsFirst",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            Asc,
+            NullsFirst,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "asc" => Ok(GeneratedField::Asc),
+                            "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalSortExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalSortExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalSortExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut asc__ = None;
+                let mut nulls_first__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Asc => {
+                            if asc__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("asc"));
+                            }
+                            asc__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::NullsFirst => {
+                            if nulls_first__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullsFirst"));
+                            }
+                            nulls_first__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PhysicalSortExprNode {
+                    expr: expr__,
+                    asc: asc__.unwrap_or_default(),
+                    nulls_first: nulls_first__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalSortExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalSortExprNodeCollection {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.physical_sort_expr_nodes.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalSortExprNodeCollection", len)?;
+        if !self.physical_sort_expr_nodes.is_empty() {
+            struct_ser.serialize_field("physicalSortExprNodes", &self.physical_sort_expr_nodes)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalSortExprNodeCollection {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "physical_sort_expr_nodes",
+            "physicalSortExprNodes",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PhysicalSortExprNodes,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "physicalSortExprNodes" | "physical_sort_expr_nodes" => Ok(GeneratedField::PhysicalSortExprNodes),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalSortExprNodeCollection;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalSortExprNodeCollection")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalSortExprNodeCollection, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut physical_sort_expr_nodes__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::PhysicalSortExprNodes => {
+                            if physical_sort_expr_nodes__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("physicalSortExprNodes"));
+                            }
+                            physical_sort_expr_nodes__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(PhysicalSortExprNodeCollection {
+                    physical_sort_expr_nodes: physical_sort_expr_nodes__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalSortExprNodeCollection", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalTryCastNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.arrow_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalTryCastNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.arrow_type.as_ref() {
+            struct_ser.serialize_field("arrowType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalTryCastNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "arrow_type",
+            "arrowType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            ArrowType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalTryCastNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalTryCastNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalTryCastNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut arrow_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::ArrowType => {
+                            if arrow_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("arrowType"));
+                            }
+                            arrow_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalTryCastNode {
+                    expr: expr__,
+                    arrow_type: arrow_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalTryCastNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalWhenThen {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.when_expr.is_some() {
+            len += 1;
+        }
+        if self.then_expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWhenThen", len)?;
+        if let Some(v) = self.when_expr.as_ref() {
+            struct_ser.serialize_field("whenExpr", v)?;
+        }
+        if let Some(v) = self.then_expr.as_ref() {
+            struct_ser.serialize_field("thenExpr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalWhenThen {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "when_expr",
+            "whenExpr",
+            "then_expr",
+            "thenExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            WhenExpr,
+            ThenExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr),
+                            "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalWhenThen;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalWhenThen")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalWhenThen, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut when_expr__ = None;
+                let mut then_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::WhenExpr => {
+                            if when_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("whenExpr"));
+                            }
+                            when_expr__ = map.next_value()?;
+                        }
+                        GeneratedField::ThenExpr => {
+                            if then_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("thenExpr"));
+                            }
+                            then_expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PhysicalWhenThen {
+                    when_expr: when_expr__,
+                    then_expr: then_expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalWhenThen", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PhysicalWindowExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.window_function.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWindowExprNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.window_function.as_ref() {
+            match v {
+                physical_window_expr_node::WindowFunction::AggrFunction(v) => {
+                    let v = AggregateFunction::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("aggrFunction", &v)?;
+                }
+                physical_window_expr_node::WindowFunction::BuiltInFunction(v) => {
+                    let v = BuiltInWindowFunction::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("builtInFunction", &v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PhysicalWindowExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "aggr_function",
+            "aggrFunction",
+            "built_in_function",
+            "builtInFunction",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            AggrFunction,
+            BuiltInFunction,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
+                            "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PhysicalWindowExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PhysicalWindowExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalWindowExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut window_function__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::AggrFunction => {
+                            if window_function__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
+                            }
+                            window_function__ = map.next_value::<::std::option::Option<AggregateFunction>>()?.map(|x| physical_window_expr_node::WindowFunction::AggrFunction(x as i32));
+                        }
+                        GeneratedField::BuiltInFunction => {
+                            if window_function__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("builtInFunction"));
+                            }
+                            window_function__ = map.next_value::<::std::option::Option<BuiltInWindowFunction>>()?.map(|x| physical_window_expr_node::WindowFunction::BuiltInFunction(x as i32));
+                        }
+                    }
+                }
+                Ok(PhysicalWindowExprNode {
+                    expr: expr__,
+                    window_function: window_function__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PhysicalWindowExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PlaceholderNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.id.is_empty() {
+            len += 1;
+        }
+        if self.data_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PlaceholderNode", len)?;
+        if !self.id.is_empty() {
+            struct_ser.serialize_field("id", &self.id)?;
+        }
+        if let Some(v) = self.data_type.as_ref() {
+            struct_ser.serialize_field("dataType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PlaceholderNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "id",
+            "data_type",
+            "dataType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Id,
+            DataType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "id" => Ok(GeneratedField::Id),
+                            "dataType" | "data_type" => Ok(GeneratedField::DataType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PlaceholderNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PlaceholderNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PlaceholderNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut id__ = None;
+                let mut data_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Id => {
+                            if id__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("id"));
+                            }
+                            id__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::DataType => {
+                            if data_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dataType"));
+                            }
+                            data_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PlaceholderNode {
+                    id: id__.unwrap_or_default(),
+                    data_type: data_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PlaceholderNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PlanType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.plan_type_enum.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PlanType", len)?;
+        if let Some(v) = self.plan_type_enum.as_ref() {
+            match v {
+                plan_type::PlanTypeEnum::InitialLogicalPlan(v) => {
+                    struct_ser.serialize_field("InitialLogicalPlan", v)?;
+                }
+                plan_type::PlanTypeEnum::AnalyzedLogicalPlan(v) => {
+                    struct_ser.serialize_field("AnalyzedLogicalPlan", v)?;
+                }
+                plan_type::PlanTypeEnum::FinalAnalyzedLogicalPlan(v) => {
+                    struct_ser.serialize_field("FinalAnalyzedLogicalPlan", v)?;
+                }
+                plan_type::PlanTypeEnum::OptimizedLogicalPlan(v) => {
+                    struct_ser.serialize_field("OptimizedLogicalPlan", v)?;
+                }
+                plan_type::PlanTypeEnum::FinalLogicalPlan(v) => {
+                    struct_ser.serialize_field("FinalLogicalPlan", v)?;
+                }
+                plan_type::PlanTypeEnum::InitialPhysicalPlan(v) => {
+                    struct_ser.serialize_field("InitialPhysicalPlan", v)?;
+                }
+                plan_type::PlanTypeEnum::OptimizedPhysicalPlan(v) => {
+                    struct_ser.serialize_field("OptimizedPhysicalPlan", v)?;
+                }
+                plan_type::PlanTypeEnum::FinalPhysicalPlan(v) => {
+                    struct_ser.serialize_field("FinalPhysicalPlan", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PlanType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "InitialLogicalPlan",
+            "AnalyzedLogicalPlan",
+            "FinalAnalyzedLogicalPlan",
+            "OptimizedLogicalPlan",
+            "FinalLogicalPlan",
+            "InitialPhysicalPlan",
+            "OptimizedPhysicalPlan",
+            "FinalPhysicalPlan",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            InitialLogicalPlan,
+            AnalyzedLogicalPlan,
+            FinalAnalyzedLogicalPlan,
+            OptimizedLogicalPlan,
+            FinalLogicalPlan,
+            InitialPhysicalPlan,
+            OptimizedPhysicalPlan,
+            FinalPhysicalPlan,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "InitialLogicalPlan" => Ok(GeneratedField::InitialLogicalPlan),
+                            "AnalyzedLogicalPlan" => Ok(GeneratedField::AnalyzedLogicalPlan),
+                            "FinalAnalyzedLogicalPlan" => Ok(GeneratedField::FinalAnalyzedLogicalPlan),
+                            "OptimizedLogicalPlan" => Ok(GeneratedField::OptimizedLogicalPlan),
+                            "FinalLogicalPlan" => Ok(GeneratedField::FinalLogicalPlan),
+                            "InitialPhysicalPlan" => Ok(GeneratedField::InitialPhysicalPlan),
+                            "OptimizedPhysicalPlan" => Ok(GeneratedField::OptimizedPhysicalPlan),
+                            "FinalPhysicalPlan" => Ok(GeneratedField::FinalPhysicalPlan),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PlanType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PlanType")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PlanType, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut plan_type_enum__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::InitialLogicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("InitialLogicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialLogicalPlan)
+;
+                        }
+                        GeneratedField::AnalyzedLogicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("AnalyzedLogicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::AnalyzedLogicalPlan)
+;
+                        }
+                        GeneratedField::FinalAnalyzedLogicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FinalAnalyzedLogicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalAnalyzedLogicalPlan)
+;
+                        }
+                        GeneratedField::OptimizedLogicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("OptimizedLogicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedLogicalPlan)
+;
+                        }
+                        GeneratedField::FinalLogicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FinalLogicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalLogicalPlan)
+;
+                        }
+                        GeneratedField::InitialPhysicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialPhysicalPlan)
+;
+                        }
+                        GeneratedField::OptimizedPhysicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedPhysicalPlan)
+;
+                        }
+                        GeneratedField::FinalPhysicalPlan => {
+                            if plan_type_enum__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan"));
+                            }
+                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalPhysicalPlan)
+;
+                        }
+                    }
+                }
+                Ok(PlanType {
+                    plan_type_enum: plan_type_enum__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PlanType", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for PrepareNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.name.is_empty() {
+            len += 1;
+        }
+        if !self.data_types.is_empty() {
+            len += 1;
+        }
+        if self.input.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.PrepareNode", len)?;
+        if !self.name.is_empty() {
+            struct_ser.serialize_field("name", &self.name)?;
+        }
+        if !self.data_types.is_empty() {
+            struct_ser.serialize_field("dataTypes", &self.data_types)?;
+        }
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for PrepareNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "name",
+            "data_types",
+            "dataTypes",
+            "input",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Name,
+            DataTypes,
+            Input,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "name" => Ok(GeneratedField::Name),
+                            "dataTypes" | "data_types" => Ok(GeneratedField::DataTypes),
+                            "input" => Ok(GeneratedField::Input),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = PrepareNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.PrepareNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<PrepareNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut name__ = None;
+                let mut data_types__ = None;
+                let mut input__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Name => {
+                            if name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("name"));
+                            }
+                            name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::DataTypes => {
+                            if data_types__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dataTypes"));
+                            }
+                            data_types__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(PrepareNode {
+                    name: name__.unwrap_or_default(),
+                    data_types: data_types__.unwrap_or_default(),
+                    input: input__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.PrepareNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ProjectionColumns {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.columns.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionColumns", len)?;
+        if !self.columns.is_empty() {
+            struct_ser.serialize_field("columns", &self.columns)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ProjectionColumns {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "columns",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Columns,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "columns" => Ok(GeneratedField::Columns),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ProjectionColumns;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ProjectionColumns")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ProjectionColumns, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut columns__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Columns => {
+                            if columns__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("columns"));
+                            }
+                            columns__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ProjectionColumns {
+                    columns: columns__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ProjectionColumns", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ProjectionExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        if !self.expr_name.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        if !self.expr_name.is_empty() {
+            struct_ser.serialize_field("exprName", &self.expr_name)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ProjectionExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "expr",
+            "expr_name",
+            "exprName",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Expr,
+            ExprName,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "exprName" | "expr_name" => Ok(GeneratedField::ExprName),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ProjectionExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ProjectionExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ProjectionExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut expr__ = None;
+                let mut expr_name__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::ExprName => {
+                            if expr_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("exprName"));
+                            }
+                            expr_name__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ProjectionExecNode {
+                    input: input__,
+                    expr: expr__.unwrap_or_default(),
+                    expr_name: expr_name__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ProjectionExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ProjectionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        if self.optional_alias.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        if let Some(v) = self.optional_alias.as_ref() {
+            match v {
+                projection_node::OptionalAlias::Alias(v) => {
+                    struct_ser.serialize_field("alias", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ProjectionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "expr",
+            "alias",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Expr,
+            Alias,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "alias" => Ok(GeneratedField::Alias),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ProjectionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ProjectionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ProjectionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut expr__ = None;
+                let mut optional_alias__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Alias => {
+                            if optional_alias__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("alias"));
+                            }
+                            optional_alias__ = map.next_value::<::std::option::Option<_>>()?.map(projection_node::OptionalAlias::Alias);
+                        }
+                    }
+                }
+                Ok(ProjectionNode {
+                    input: input__,
+                    expr: expr__.unwrap_or_default(),
+                    optional_alias: optional_alias__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ProjectionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for RepartitionExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.partition_method.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if let Some(v) = self.partition_method.as_ref() {
+            match v {
+                repartition_exec_node::PartitionMethod::RoundRobin(v) => {
+                    struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?;
+                }
+                repartition_exec_node::PartitionMethod::Hash(v) => {
+                    struct_ser.serialize_field("hash", v)?;
+                }
+                repartition_exec_node::PartitionMethod::Unknown(v) => {
+                    struct_ser.serialize_field("unknown", ToString::to_string(&v).as_str())?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for RepartitionExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "round_robin",
+            "roundRobin",
+            "hash",
+            "unknown",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            RoundRobin,
+            Hash,
+            Unknown,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin),
+                            "hash" => Ok(GeneratedField::Hash),
+                            "unknown" => Ok(GeneratedField::Unknown),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = RepartitionExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.RepartitionExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<RepartitionExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut partition_method__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::RoundRobin => {
+                            if partition_method__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("roundRobin"));
+                            }
+                            partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::RoundRobin(x.0));
+                        }
+                        GeneratedField::Hash => {
+                            if partition_method__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hash"));
+                            }
+                            partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_exec_node::PartitionMethod::Hash)
+;
+                        }
+                        GeneratedField::Unknown => {
+                            if partition_method__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("unknown"));
+                            }
+                            partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::Unknown(x.0));
+                        }
+                    }
+                }
+                Ok(RepartitionExecNode {
+                    input: input__,
+                    partition_method: partition_method__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.RepartitionExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for RepartitionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.partition_method.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if let Some(v) = self.partition_method.as_ref() {
+            match v {
+                repartition_node::PartitionMethod::RoundRobin(v) => {
+                    struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?;
+                }
+                repartition_node::PartitionMethod::Hash(v) => {
+                    struct_ser.serialize_field("hash", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for RepartitionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "round_robin",
+            "roundRobin",
+            "hash",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            RoundRobin,
+            Hash,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin),
+                            "hash" => Ok(GeneratedField::Hash),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = RepartitionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.RepartitionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<RepartitionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut partition_method__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::RoundRobin => {
+                            if partition_method__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("roundRobin"));
+                            }
+                            partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_node::PartitionMethod::RoundRobin(x.0));
+                        }
+                        GeneratedField::Hash => {
+                            if partition_method__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("hash"));
+                            }
+                            partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_node::PartitionMethod::Hash)
+;
+                        }
+                    }
+                }
+                Ok(RepartitionNode {
+                    input: input__,
+                    partition_method: partition_method__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.RepartitionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for RollupNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.RollupNode", len)?;
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for RollupNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = RollupNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.RollupNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<RollupNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(RollupNode {
+                    expr: expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.RollupNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarDictionaryValue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.index_type.is_some() {
+            len += 1;
+        }
+        if self.value.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarDictionaryValue", len)?;
+        if let Some(v) = self.index_type.as_ref() {
+            struct_ser.serialize_field("indexType", v)?;
+        }
+        if let Some(v) = self.value.as_ref() {
+            struct_ser.serialize_field("value", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "index_type",
+            "indexType",
+            "value",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IndexType,
+            Value,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "indexType" | "index_type" => Ok(GeneratedField::IndexType),
+                            "value" => Ok(GeneratedField::Value),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarDictionaryValue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarDictionaryValue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarDictionaryValue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut index_type__ = None;
+                let mut value__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::IndexType => {
+                            if index_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("indexType"));
+                            }
+                            index_type__ = map.next_value()?;
+                        }
+                        GeneratedField::Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("value"));
+                            }
+                            value__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(ScalarDictionaryValue {
+                    index_type: index_type__,
+                    value: value__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarFixedSizeBinary {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.values.is_empty() {
+            len += 1;
+        }
+        if self.length != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFixedSizeBinary", len)?;
+        if !self.values.is_empty() {
+            struct_ser.serialize_field("values", pbjson::private::base64::encode(&self.values).as_str())?;
+        }
+        if self.length != 0 {
+            struct_ser.serialize_field("length", &self.length)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarFixedSizeBinary {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "values",
+            "length",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Values,
+            Length,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "values" => Ok(GeneratedField::Values),
+                            "length" => Ok(GeneratedField::Length),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarFixedSizeBinary;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarFixedSizeBinary")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarFixedSizeBinary, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut values__ = None;
+                let mut length__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Values => {
+                            if values__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("values"));
+                            }
+                            values__ = 
+                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::Length => {
+                            if length__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("length"));
+                            }
+                            length__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(ScalarFixedSizeBinary {
+                    values: values__.unwrap_or_default(),
+                    length: length__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarFixedSizeBinary", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarFunction {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Abs => "Abs",
+            Self::Acos => "Acos",
+            Self::Asin => "Asin",
+            Self::Atan => "Atan",
+            Self::Ascii => "Ascii",
+            Self::Ceil => "Ceil",
+            Self::Cos => "Cos",
+            Self::Digest => "Digest",
+            Self::Exp => "Exp",
+            Self::Floor => "Floor",
+            Self::Ln => "Ln",
+            Self::Log => "Log",
+            Self::Log10 => "Log10",
+            Self::Log2 => "Log2",
+            Self::Round => "Round",
+            Self::Signum => "Signum",
+            Self::Sin => "Sin",
+            Self::Sqrt => "Sqrt",
+            Self::Tan => "Tan",
+            Self::Trunc => "Trunc",
+            Self::Array => "Array",
+            Self::RegexpMatch => "RegexpMatch",
+            Self::BitLength => "BitLength",
+            Self::Btrim => "Btrim",
+            Self::CharacterLength => "CharacterLength",
+            Self::Chr => "Chr",
+            Self::Concat => "Concat",
+            Self::ConcatWithSeparator => "ConcatWithSeparator",
+            Self::DatePart => "DatePart",
+            Self::DateTrunc => "DateTrunc",
+            Self::InitCap => "InitCap",
+            Self::Left => "Left",
+            Self::Lpad => "Lpad",
+            Self::Lower => "Lower",
+            Self::Ltrim => "Ltrim",
+            Self::Md5 => "MD5",
+            Self::NullIf => "NullIf",
+            Self::OctetLength => "OctetLength",
+            Self::Random => "Random",
+            Self::RegexpReplace => "RegexpReplace",
+            Self::Repeat => "Repeat",
+            Self::Replace => "Replace",
+            Self::Reverse => "Reverse",
+            Self::Right => "Right",
+            Self::Rpad => "Rpad",
+            Self::Rtrim => "Rtrim",
+            Self::Sha224 => "SHA224",
+            Self::Sha256 => "SHA256",
+            Self::Sha384 => "SHA384",
+            Self::Sha512 => "SHA512",
+            Self::SplitPart => "SplitPart",
+            Self::StartsWith => "StartsWith",
+            Self::Strpos => "Strpos",
+            Self::Substr => "Substr",
+            Self::ToHex => "ToHex",
+            Self::ToTimestamp => "ToTimestamp",
+            Self::ToTimestampMillis => "ToTimestampMillis",
+            Self::ToTimestampMicros => "ToTimestampMicros",
+            Self::ToTimestampSeconds => "ToTimestampSeconds",
+            Self::Now => "Now",
+            Self::Translate => "Translate",
+            Self::Trim => "Trim",
+            Self::Upper => "Upper",
+            Self::Coalesce => "Coalesce",
+            Self::Power => "Power",
+            Self::StructFun => "StructFun",
+            Self::FromUnixtime => "FromUnixtime",
+            Self::Atan2 => "Atan2",
+            Self::DateBin => "DateBin",
+            Self::ArrowTypeof => "ArrowTypeof",
+            Self::CurrentDate => "CurrentDate",
+            Self::CurrentTime => "CurrentTime",
+            Self::Uuid => "Uuid",
+            Self::Cbrt => "Cbrt",
+            Self::Acosh => "Acosh",
+            Self::Asinh => "Asinh",
+            Self::Atanh => "Atanh",
+            Self::Sinh => "Sinh",
+            Self::Cosh => "Cosh",
+            Self::Tanh => "Tanh",
+            Self::Pi => "Pi",
+            Self::Degrees => "Degrees",
+            Self::Radians => "Radians",
+            Self::Factorial => "Factorial",
+            Self::Lcm => "Lcm",
+            Self::Gcd => "Gcd",
+            Self::ArrayAppend => "ArrayAppend",
+            Self::ArrayConcat => "ArrayConcat",
+            Self::ArrayDims => "ArrayDims",
+            Self::ArrayFill => "ArrayFill",
+            Self::ArrayLength => "ArrayLength",
+            Self::ArrayNdims => "ArrayNdims",
+            Self::ArrayPosition => "ArrayPosition",
+            Self::ArrayPositions => "ArrayPositions",
+            Self::ArrayPrepend => "ArrayPrepend",
+            Self::ArrayRemove => "ArrayRemove",
+            Self::ArrayReplace => "ArrayReplace",
+            Self::ArrayToString => "ArrayToString",
+            Self::Cardinality => "Cardinality",
+            Self::TrimArray => "TrimArray",
+            Self::ArrayContains => "ArrayContains",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarFunction {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "Abs",
+            "Acos",
+            "Asin",
+            "Atan",
+            "Ascii",
+            "Ceil",
+            "Cos",
+            "Digest",
+            "Exp",
+            "Floor",
+            "Ln",
+            "Log",
+            "Log10",
+            "Log2",
+            "Round",
+            "Signum",
+            "Sin",
+            "Sqrt",
+            "Tan",
+            "Trunc",
+            "Array",
+            "RegexpMatch",
+            "BitLength",
+            "Btrim",
+            "CharacterLength",
+            "Chr",
+            "Concat",
+            "ConcatWithSeparator",
+            "DatePart",
+            "DateTrunc",
+            "InitCap",
+            "Left",
+            "Lpad",
+            "Lower",
+            "Ltrim",
+            "MD5",
+            "NullIf",
+            "OctetLength",
+            "Random",
+            "RegexpReplace",
+            "Repeat",
+            "Replace",
+            "Reverse",
+            "Right",
+            "Rpad",
+            "Rtrim",
+            "SHA224",
+            "SHA256",
+            "SHA384",
+            "SHA512",
+            "SplitPart",
+            "StartsWith",
+            "Strpos",
+            "Substr",
+            "ToHex",
+            "ToTimestamp",
+            "ToTimestampMillis",
+            "ToTimestampMicros",
+            "ToTimestampSeconds",
+            "Now",
+            "Translate",
+            "Trim",
+            "Upper",
+            "Coalesce",
+            "Power",
+            "StructFun",
+            "FromUnixtime",
+            "Atan2",
+            "DateBin",
+            "ArrowTypeof",
+            "CurrentDate",
+            "CurrentTime",
+            "Uuid",
+            "Cbrt",
+            "Acosh",
+            "Asinh",
+            "Atanh",
+            "Sinh",
+            "Cosh",
+            "Tanh",
+            "Pi",
+            "Degrees",
+            "Radians",
+            "Factorial",
+            "Lcm",
+            "Gcd",
+            "ArrayAppend",
+            "ArrayConcat",
+            "ArrayDims",
+            "ArrayFill",
+            "ArrayLength",
+            "ArrayNdims",
+            "ArrayPosition",
+            "ArrayPositions",
+            "ArrayPrepend",
+            "ArrayRemove",
+            "ArrayReplace",
+            "ArrayToString",
+            "Cardinality",
+            "TrimArray",
+            "ArrayContains",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarFunction;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(ScalarFunction::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(ScalarFunction::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "Abs" => Ok(ScalarFunction::Abs),
+                    "Acos" => Ok(ScalarFunction::Acos),
+                    "Asin" => Ok(ScalarFunction::Asin),
+                    "Atan" => Ok(ScalarFunction::Atan),
+                    "Ascii" => Ok(ScalarFunction::Ascii),
+                    "Ceil" => Ok(ScalarFunction::Ceil),
+                    "Cos" => Ok(ScalarFunction::Cos),
+                    "Digest" => Ok(ScalarFunction::Digest),
+                    "Exp" => Ok(ScalarFunction::Exp),
+                    "Floor" => Ok(ScalarFunction::Floor),
+                    "Ln" => Ok(ScalarFunction::Ln),
+                    "Log" => Ok(ScalarFunction::Log),
+                    "Log10" => Ok(ScalarFunction::Log10),
+                    "Log2" => Ok(ScalarFunction::Log2),
+                    "Round" => Ok(ScalarFunction::Round),
+                    "Signum" => Ok(ScalarFunction::Signum),
+                    "Sin" => Ok(ScalarFunction::Sin),
+                    "Sqrt" => Ok(ScalarFunction::Sqrt),
+                    "Tan" => Ok(ScalarFunction::Tan),
+                    "Trunc" => Ok(ScalarFunction::Trunc),
+                    "Array" => Ok(ScalarFunction::Array),
+                    "RegexpMatch" => Ok(ScalarFunction::RegexpMatch),
+                    "BitLength" => Ok(ScalarFunction::BitLength),
+                    "Btrim" => Ok(ScalarFunction::Btrim),
+                    "CharacterLength" => Ok(ScalarFunction::CharacterLength),
+                    "Chr" => Ok(ScalarFunction::Chr),
+                    "Concat" => Ok(ScalarFunction::Concat),
+                    "ConcatWithSeparator" => Ok(ScalarFunction::ConcatWithSeparator),
+                    "DatePart" => Ok(ScalarFunction::DatePart),
+                    "DateTrunc" => Ok(ScalarFunction::DateTrunc),
+                    "InitCap" => Ok(ScalarFunction::InitCap),
+                    "Left" => Ok(ScalarFunction::Left),
+                    "Lpad" => Ok(ScalarFunction::Lpad),
+                    "Lower" => Ok(ScalarFunction::Lower),
+                    "Ltrim" => Ok(ScalarFunction::Ltrim),
+                    "MD5" => Ok(ScalarFunction::Md5),
+                    "NullIf" => Ok(ScalarFunction::NullIf),
+                    "OctetLength" => Ok(ScalarFunction::OctetLength),
+                    "Random" => Ok(ScalarFunction::Random),
+                    "RegexpReplace" => Ok(ScalarFunction::RegexpReplace),
+                    "Repeat" => Ok(ScalarFunction::Repeat),
+                    "Replace" => Ok(ScalarFunction::Replace),
+                    "Reverse" => Ok(ScalarFunction::Reverse),
+                    "Right" => Ok(ScalarFunction::Right),
+                    "Rpad" => Ok(ScalarFunction::Rpad),
+                    "Rtrim" => Ok(ScalarFunction::Rtrim),
+                    "SHA224" => Ok(ScalarFunction::Sha224),
+                    "SHA256" => Ok(ScalarFunction::Sha256),
+                    "SHA384" => Ok(ScalarFunction::Sha384),
+                    "SHA512" => Ok(ScalarFunction::Sha512),
+                    "SplitPart" => Ok(ScalarFunction::SplitPart),
+                    "StartsWith" => Ok(ScalarFunction::StartsWith),
+                    "Strpos" => Ok(ScalarFunction::Strpos),
+                    "Substr" => Ok(ScalarFunction::Substr),
+                    "ToHex" => Ok(ScalarFunction::ToHex),
+                    "ToTimestamp" => Ok(ScalarFunction::ToTimestamp),
+                    "ToTimestampMillis" => Ok(ScalarFunction::ToTimestampMillis),
+                    "ToTimestampMicros" => Ok(ScalarFunction::ToTimestampMicros),
+                    "ToTimestampSeconds" => Ok(ScalarFunction::ToTimestampSeconds),
+                    "Now" => Ok(ScalarFunction::Now),
+                    "Translate" => Ok(ScalarFunction::Translate),
+                    "Trim" => Ok(ScalarFunction::Trim),
+                    "Upper" => Ok(ScalarFunction::Upper),
+                    "Coalesce" => Ok(ScalarFunction::Coalesce),
+                    "Power" => Ok(ScalarFunction::Power),
+                    "StructFun" => Ok(ScalarFunction::StructFun),
+                    "FromUnixtime" => Ok(ScalarFunction::FromUnixtime),
+                    "Atan2" => Ok(ScalarFunction::Atan2),
+                    "DateBin" => Ok(ScalarFunction::DateBin),
+                    "ArrowTypeof" => Ok(ScalarFunction::ArrowTypeof),
+                    "CurrentDate" => Ok(ScalarFunction::CurrentDate),
+                    "CurrentTime" => Ok(ScalarFunction::CurrentTime),
+                    "Uuid" => Ok(ScalarFunction::Uuid),
+                    "Cbrt" => Ok(ScalarFunction::Cbrt),
+                    "Acosh" => Ok(ScalarFunction::Acosh),
+                    "Asinh" => Ok(ScalarFunction::Asinh),
+                    "Atanh" => Ok(ScalarFunction::Atanh),
+                    "Sinh" => Ok(ScalarFunction::Sinh),
+                    "Cosh" => Ok(ScalarFunction::Cosh),
+                    "Tanh" => Ok(ScalarFunction::Tanh),
+                    "Pi" => Ok(ScalarFunction::Pi),
+                    "Degrees" => Ok(ScalarFunction::Degrees),
+                    "Radians" => Ok(ScalarFunction::Radians),
+                    "Factorial" => Ok(ScalarFunction::Factorial),
+                    "Lcm" => Ok(ScalarFunction::Lcm),
+                    "Gcd" => Ok(ScalarFunction::Gcd),
+                    "ArrayAppend" => Ok(ScalarFunction::ArrayAppend),
+                    "ArrayConcat" => Ok(ScalarFunction::ArrayConcat),
+                    "ArrayDims" => Ok(ScalarFunction::ArrayDims),
+                    "ArrayFill" => Ok(ScalarFunction::ArrayFill),
+                    "ArrayLength" => Ok(ScalarFunction::ArrayLength),
+                    "ArrayNdims" => Ok(ScalarFunction::ArrayNdims),
+                    "ArrayPosition" => Ok(ScalarFunction::ArrayPosition),
+                    "ArrayPositions" => Ok(ScalarFunction::ArrayPositions),
+                    "ArrayPrepend" => Ok(ScalarFunction::ArrayPrepend),
+                    "ArrayRemove" => Ok(ScalarFunction::ArrayRemove),
+                    "ArrayReplace" => Ok(ScalarFunction::ArrayReplace),
+                    "ArrayToString" => Ok(ScalarFunction::ArrayToString),
+                    "Cardinality" => Ok(ScalarFunction::Cardinality),
+                    "TrimArray" => Ok(ScalarFunction::TrimArray),
+                    "ArrayContains" => Ok(ScalarFunction::ArrayContains),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarFunctionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.fun != 0 {
+            len += 1;
+        }
+        if !self.args.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFunctionNode", len)?;
+        if self.fun != 0 {
+            let v = ScalarFunction::from_i32(self.fun)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?;
+            struct_ser.serialize_field("fun", &v)?;
+        }
+        if !self.args.is_empty() {
+            struct_ser.serialize_field("args", &self.args)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarFunctionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "fun",
+            "args",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Fun,
+            Args,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fun" => Ok(GeneratedField::Fun),
+                            "args" => Ok(GeneratedField::Args),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarFunctionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarFunctionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarFunctionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut fun__ = None;
+                let mut args__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Fun => {
+                            if fun__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fun"));
+                            }
+                            fun__ = Some(map.next_value::<ScalarFunction>()? as i32);
+                        }
+                        GeneratedField::Args => {
+                            if args__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("args"));
+                            }
+                            args__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ScalarFunctionNode {
+                    fun: fun__.unwrap_or_default(),
+                    args: args__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarFunctionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarListValue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.is_null {
+            len += 1;
+        }
+        if self.field.is_some() {
+            len += 1;
+        }
+        if !self.values.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarListValue", len)?;
+        if self.is_null {
+            struct_ser.serialize_field("isNull", &self.is_null)?;
+        }
+        if let Some(v) = self.field.as_ref() {
+            struct_ser.serialize_field("field", v)?;
+        }
+        if !self.values.is_empty() {
+            struct_ser.serialize_field("values", &self.values)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarListValue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "is_null",
+            "isNull",
+            "field",
+            "values",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            IsNull,
+            Field,
+            Values,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "isNull" | "is_null" => Ok(GeneratedField::IsNull),
+                            "field" => Ok(GeneratedField::Field),
+                            "values" => Ok(GeneratedField::Values),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarListValue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarListValue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarListValue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut is_null__ = None;
+                let mut field__ = None;
+                let mut values__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::IsNull => {
+                            if is_null__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isNull"));
+                            }
+                            is_null__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Field => {
+                            if field__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("field"));
+                            }
+                            field__ = map.next_value()?;
+                        }
+                        GeneratedField::Values => {
+                            if values__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("values"));
+                            }
+                            values__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ScalarListValue {
+                    is_null: is_null__.unwrap_or_default(),
+                    field: field__,
+                    values: values__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarListValue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarTime32Value {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.value.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime32Value", len)?;
+        if let Some(v) = self.value.as_ref() {
+            match v {
+                scalar_time32_value::Value::Time32SecondValue(v) => {
+                    struct_ser.serialize_field("time32SecondValue", v)?;
+                }
+                scalar_time32_value::Value::Time32MillisecondValue(v) => {
+                    struct_ser.serialize_field("time32MillisecondValue", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarTime32Value {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "time32_second_value",
+            "time32SecondValue",
+            "time32_millisecond_value",
+            "time32MillisecondValue",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Time32SecondValue,
+            Time32MillisecondValue,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "time32SecondValue" | "time32_second_value" => Ok(GeneratedField::Time32SecondValue),
+                            "time32MillisecondValue" | "time32_millisecond_value" => Ok(GeneratedField::Time32MillisecondValue),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarTime32Value;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarTime32Value")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarTime32Value, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut value__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Time32SecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("time32SecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32SecondValue(x.0));
+                        }
+                        GeneratedField::Time32MillisecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("time32MillisecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32MillisecondValue(x.0));
+                        }
+                    }
+                }
+                Ok(ScalarTime32Value {
+                    value: value__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarTime32Value", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarTime64Value {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.value.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime64Value", len)?;
+        if let Some(v) = self.value.as_ref() {
+            match v {
+                scalar_time64_value::Value::Time64MicrosecondValue(v) => {
+                    struct_ser.serialize_field("time64MicrosecondValue", ToString::to_string(&v).as_str())?;
+                }
+                scalar_time64_value::Value::Time64NanosecondValue(v) => {
+                    struct_ser.serialize_field("time64NanosecondValue", ToString::to_string(&v).as_str())?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarTime64Value {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "time64_microsecond_value",
+            "time64MicrosecondValue",
+            "time64_nanosecond_value",
+            "time64NanosecondValue",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Time64MicrosecondValue,
+            Time64NanosecondValue,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "time64MicrosecondValue" | "time64_microsecond_value" => Ok(GeneratedField::Time64MicrosecondValue),
+                            "time64NanosecondValue" | "time64_nanosecond_value" => Ok(GeneratedField::Time64NanosecondValue),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarTime64Value;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarTime64Value")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarTime64Value, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut value__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Time64MicrosecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("time64MicrosecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64MicrosecondValue(x.0));
+                        }
+                        GeneratedField::Time64NanosecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("time64NanosecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64NanosecondValue(x.0));
+                        }
+                    }
+                }
+                Ok(ScalarTime64Value {
+                    value: value__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarTime64Value", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarTimestampValue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.timezone.is_empty() {
+            len += 1;
+        }
+        if self.value.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTimestampValue", len)?;
+        if !self.timezone.is_empty() {
+            struct_ser.serialize_field("timezone", &self.timezone)?;
+        }
+        if let Some(v) = self.value.as_ref() {
+            match v {
+                scalar_timestamp_value::Value::TimeMicrosecondValue(v) => {
+                    struct_ser.serialize_field("timeMicrosecondValue", ToString::to_string(&v).as_str())?;
+                }
+                scalar_timestamp_value::Value::TimeNanosecondValue(v) => {
+                    struct_ser.serialize_field("timeNanosecondValue", ToString::to_string(&v).as_str())?;
+                }
+                scalar_timestamp_value::Value::TimeSecondValue(v) => {
+                    struct_ser.serialize_field("timeSecondValue", ToString::to_string(&v).as_str())?;
+                }
+                scalar_timestamp_value::Value::TimeMillisecondValue(v) => {
+                    struct_ser.serialize_field("timeMillisecondValue", ToString::to_string(&v).as_str())?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarTimestampValue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "timezone",
+            "time_microsecond_value",
+            "timeMicrosecondValue",
+            "time_nanosecond_value",
+            "timeNanosecondValue",
+            "time_second_value",
+            "timeSecondValue",
+            "time_millisecond_value",
+            "timeMillisecondValue",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Timezone,
+            TimeMicrosecondValue,
+            TimeNanosecondValue,
+            TimeSecondValue,
+            TimeMillisecondValue,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "timezone" => Ok(GeneratedField::Timezone),
+                            "timeMicrosecondValue" | "time_microsecond_value" => Ok(GeneratedField::TimeMicrosecondValue),
+                            "timeNanosecondValue" | "time_nanosecond_value" => Ok(GeneratedField::TimeNanosecondValue),
+                            "timeSecondValue" | "time_second_value" => Ok(GeneratedField::TimeSecondValue),
+                            "timeMillisecondValue" | "time_millisecond_value" => Ok(GeneratedField::TimeMillisecondValue),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarTimestampValue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarTimestampValue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarTimestampValue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut timezone__ = None;
+                let mut value__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Timezone => {
+                            if timezone__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timezone"));
+                            }
+                            timezone__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::TimeMicrosecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeMicrosecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMicrosecondValue(x.0));
+                        }
+                        GeneratedField::TimeNanosecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeNanosecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeNanosecondValue(x.0));
+                        }
+                        GeneratedField::TimeSecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeSecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeSecondValue(x.0));
+                        }
+                        GeneratedField::TimeMillisecondValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeMillisecondValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMillisecondValue(x.0));
+                        }
+                    }
+                }
+                Ok(ScalarTimestampValue {
+                    timezone: timezone__.unwrap_or_default(),
+                    value: value__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarTimestampValue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarUdfExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.fun_name.is_empty() {
+            len += 1;
+        }
+        if !self.args.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarUDFExprNode", len)?;
+        if !self.fun_name.is_empty() {
+            struct_ser.serialize_field("funName", &self.fun_name)?;
+        }
+        if !self.args.is_empty() {
+            struct_ser.serialize_field("args", &self.args)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "fun_name",
+            "funName",
+            "args",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FunName,
+            Args,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "funName" | "fun_name" => Ok(GeneratedField::FunName),
+                            "args" => Ok(GeneratedField::Args),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarUdfExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarUDFExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarUdfExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut fun_name__ = None;
+                let mut args__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::FunName => {
+                            if fun_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("funName"));
+                            }
+                            fun_name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Args => {
+                            if args__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("args"));
+                            }
+                            args__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ScalarUdfExprNode {
+                    fun_name: fun_name__.unwrap_or_default(),
+                    args: args__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarUDFExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScalarValue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.value.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarValue", len)?;
+        if let Some(v) = self.value.as_ref() {
+            match v {
+                scalar_value::Value::NullValue(v) => {
+                    struct_ser.serialize_field("nullValue", v)?;
+                }
+                scalar_value::Value::BoolValue(v) => {
+                    struct_ser.serialize_field("boolValue", v)?;
+                }
+                scalar_value::Value::Utf8Value(v) => {
+                    struct_ser.serialize_field("utf8Value", v)?;
+                }
+                scalar_value::Value::LargeUtf8Value(v) => {
+                    struct_ser.serialize_field("largeUtf8Value", v)?;
+                }
+                scalar_value::Value::Int8Value(v) => {
+                    struct_ser.serialize_field("int8Value", v)?;
+                }
+                scalar_value::Value::Int16Value(v) => {
+                    struct_ser.serialize_field("int16Value", v)?;
+                }
+                scalar_value::Value::Int32Value(v) => {
+                    struct_ser.serialize_field("int32Value", v)?;
+                }
+                scalar_value::Value::Int64Value(v) => {
+                    struct_ser.serialize_field("int64Value", ToString::to_string(&v).as_str())?;
+                }
+                scalar_value::Value::Uint8Value(v) => {
+                    struct_ser.serialize_field("uint8Value", v)?;
+                }
+                scalar_value::Value::Uint16Value(v) => {
+                    struct_ser.serialize_field("uint16Value", v)?;
+                }
+                scalar_value::Value::Uint32Value(v) => {
+                    struct_ser.serialize_field("uint32Value", v)?;
+                }
+                scalar_value::Value::Uint64Value(v) => {
+                    struct_ser.serialize_field("uint64Value", ToString::to_string(&v).as_str())?;
+                }
+                scalar_value::Value::Float32Value(v) => {
+                    struct_ser.serialize_field("float32Value", v)?;
+                }
+                scalar_value::Value::Float64Value(v) => {
+                    struct_ser.serialize_field("float64Value", v)?;
+                }
+                scalar_value::Value::Date32Value(v) => {
+                    struct_ser.serialize_field("date32Value", v)?;
+                }
+                scalar_value::Value::Time32Value(v) => {
+                    struct_ser.serialize_field("time32Value", v)?;
+                }
+                scalar_value::Value::ListValue(v) => {
+                    struct_ser.serialize_field("listValue", v)?;
+                }
+                scalar_value::Value::Decimal128Value(v) => {
+                    struct_ser.serialize_field("decimal128Value", v)?;
+                }
+                scalar_value::Value::Date64Value(v) => {
+                    struct_ser.serialize_field("date64Value", ToString::to_string(&v).as_str())?;
+                }
+                scalar_value::Value::IntervalYearmonthValue(v) => {
+                    struct_ser.serialize_field("intervalYearmonthValue", v)?;
+                }
+                scalar_value::Value::IntervalDaytimeValue(v) => {
+                    struct_ser.serialize_field("intervalDaytimeValue", ToString::to_string(&v).as_str())?;
+                }
+                scalar_value::Value::TimestampValue(v) => {
+                    struct_ser.serialize_field("timestampValue", v)?;
+                }
+                scalar_value::Value::DictionaryValue(v) => {
+                    struct_ser.serialize_field("dictionaryValue", v)?;
+                }
+                scalar_value::Value::BinaryValue(v) => {
+                    struct_ser.serialize_field("binaryValue", pbjson::private::base64::encode(&v).as_str())?;
+                }
+                scalar_value::Value::LargeBinaryValue(v) => {
+                    struct_ser.serialize_field("largeBinaryValue", pbjson::private::base64::encode(&v).as_str())?;
+                }
+                scalar_value::Value::Time64Value(v) => {
+                    struct_ser.serialize_field("time64Value", v)?;
+                }
+                scalar_value::Value::IntervalMonthDayNano(v) => {
+                    struct_ser.serialize_field("intervalMonthDayNano", v)?;
+                }
+                scalar_value::Value::StructValue(v) => {
+                    struct_ser.serialize_field("structValue", v)?;
+                }
+                scalar_value::Value::FixedSizeBinaryValue(v) => {
+                    struct_ser.serialize_field("fixedSizeBinaryValue", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScalarValue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "null_value",
+            "nullValue",
+            "bool_value",
+            "boolValue",
+            "utf8_value",
+            "utf8Value",
+            "large_utf8_value",
+            "largeUtf8Value",
+            "int8_value",
+            "int8Value",
+            "int16_value",
+            "int16Value",
+            "int32_value",
+            "int32Value",
+            "int64_value",
+            "int64Value",
+            "uint8_value",
+            "uint8Value",
+            "uint16_value",
+            "uint16Value",
+            "uint32_value",
+            "uint32Value",
+            "uint64_value",
+            "uint64Value",
+            "float32_value",
+            "float32Value",
+            "float64_value",
+            "float64Value",
+            "date_32_value",
+            "date32Value",
+            "time32_value",
+            "time32Value",
+            "list_value",
+            "listValue",
+            "decimal128_value",
+            "decimal128Value",
+            "date_64_value",
+            "date64Value",
+            "interval_yearmonth_value",
+            "intervalYearmonthValue",
+            "interval_daytime_value",
+            "intervalDaytimeValue",
+            "timestamp_value",
+            "timestampValue",
+            "dictionary_value",
+            "dictionaryValue",
+            "binary_value",
+            "binaryValue",
+            "large_binary_value",
+            "largeBinaryValue",
+            "time64_value",
+            "time64Value",
+            "interval_month_day_nano",
+            "intervalMonthDayNano",
+            "struct_value",
+            "structValue",
+            "fixed_size_binary_value",
+            "fixedSizeBinaryValue",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NullValue,
+            BoolValue,
+            Utf8Value,
+            LargeUtf8Value,
+            Int8Value,
+            Int16Value,
+            Int32Value,
+            Int64Value,
+            Uint8Value,
+            Uint16Value,
+            Uint32Value,
+            Uint64Value,
+            Float32Value,
+            Float64Value,
+            Date32Value,
+            Time32Value,
+            ListValue,
+            Decimal128Value,
+            Date64Value,
+            IntervalYearmonthValue,
+            IntervalDaytimeValue,
+            TimestampValue,
+            DictionaryValue,
+            BinaryValue,
+            LargeBinaryValue,
+            Time64Value,
+            IntervalMonthDayNano,
+            StructValue,
+            FixedSizeBinaryValue,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "nullValue" | "null_value" => Ok(GeneratedField::NullValue),
+                            "boolValue" | "bool_value" => Ok(GeneratedField::BoolValue),
+                            "utf8Value" | "utf8_value" => Ok(GeneratedField::Utf8Value),
+                            "largeUtf8Value" | "large_utf8_value" => Ok(GeneratedField::LargeUtf8Value),
+                            "int8Value" | "int8_value" => Ok(GeneratedField::Int8Value),
+                            "int16Value" | "int16_value" => Ok(GeneratedField::Int16Value),
+                            "int32Value" | "int32_value" => Ok(GeneratedField::Int32Value),
+                            "int64Value" | "int64_value" => Ok(GeneratedField::Int64Value),
+                            "uint8Value" | "uint8_value" => Ok(GeneratedField::Uint8Value),
+                            "uint16Value" | "uint16_value" => Ok(GeneratedField::Uint16Value),
+                            "uint32Value" | "uint32_value" => Ok(GeneratedField::Uint32Value),
+                            "uint64Value" | "uint64_value" => Ok(GeneratedField::Uint64Value),
+                            "float32Value" | "float32_value" => Ok(GeneratedField::Float32Value),
+                            "float64Value" | "float64_value" => Ok(GeneratedField::Float64Value),
+                            "date32Value" | "date_32_value" => Ok(GeneratedField::Date32Value),
+                            "time32Value" | "time32_value" => Ok(GeneratedField::Time32Value),
+                            "listValue" | "list_value" => Ok(GeneratedField::ListValue),
+                            "decimal128Value" | "decimal128_value" => Ok(GeneratedField::Decimal128Value),
+                            "date64Value" | "date_64_value" => Ok(GeneratedField::Date64Value),
+                            "intervalYearmonthValue" | "interval_yearmonth_value" => Ok(GeneratedField::IntervalYearmonthValue),
+                            "intervalDaytimeValue" | "interval_daytime_value" => Ok(GeneratedField::IntervalDaytimeValue),
+                            "timestampValue" | "timestamp_value" => Ok(GeneratedField::TimestampValue),
+                            "dictionaryValue" | "dictionary_value" => Ok(GeneratedField::DictionaryValue),
+                            "binaryValue" | "binary_value" => Ok(GeneratedField::BinaryValue),
+                            "largeBinaryValue" | "large_binary_value" => Ok(GeneratedField::LargeBinaryValue),
+                            "time64Value" | "time64_value" => Ok(GeneratedField::Time64Value),
+                            "intervalMonthDayNano" | "interval_month_day_nano" => Ok(GeneratedField::IntervalMonthDayNano),
+                            "structValue" | "struct_value" => Ok(GeneratedField::StructValue),
+                            "fixedSizeBinaryValue" | "fixed_size_binary_value" => Ok(GeneratedField::FixedSizeBinaryValue),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScalarValue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScalarValue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarValue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut value__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::NullValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::NullValue)
+;
+                        }
+                        GeneratedField::BoolValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("boolValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::BoolValue);
+                        }
+                        GeneratedField::Utf8Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("utf8Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Utf8Value);
+                        }
+                        GeneratedField::LargeUtf8Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("largeUtf8Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::LargeUtf8Value);
+                        }
+                        GeneratedField::Int8Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("int8Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int8Value(x.0));
+                        }
+                        GeneratedField::Int16Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("int16Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int16Value(x.0));
+                        }
+                        GeneratedField::Int32Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("int32Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int32Value(x.0));
+                        }
+                        GeneratedField::Int64Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("int64Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int64Value(x.0));
+                        }
+                        GeneratedField::Uint8Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("uint8Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint8Value(x.0));
+                        }
+                        GeneratedField::Uint16Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("uint16Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint16Value(x.0));
+                        }
+                        GeneratedField::Uint32Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("uint32Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint32Value(x.0));
+                        }
+                        GeneratedField::Uint64Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("uint64Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint64Value(x.0));
+                        }
+                        GeneratedField::Float32Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("float32Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float32Value(x.0));
+                        }
+                        GeneratedField::Float64Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("float64Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float64Value(x.0));
+                        }
+                        GeneratedField::Date32Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("date32Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date32Value(x.0));
+                        }
+                        GeneratedField::Time32Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("time32Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time32Value)
+;
+                        }
+                        GeneratedField::ListValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("listValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::ListValue)
+;
+                        }
+                        GeneratedField::Decimal128Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("decimal128Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Decimal128Value)
+;
+                        }
+                        GeneratedField::Date64Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("date64Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date64Value(x.0));
+                        }
+                        GeneratedField::IntervalYearmonthValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("intervalYearmonthValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalYearmonthValue(x.0));
+                        }
+                        GeneratedField::IntervalDaytimeValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("intervalDaytimeValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalDaytimeValue(x.0));
+                        }
+                        GeneratedField::TimestampValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timestampValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::TimestampValue)
+;
+                        }
+                        GeneratedField::DictionaryValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("dictionaryValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::DictionaryValue)
+;
+                        }
+                        GeneratedField::BinaryValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("binaryValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::BinaryValue(x.0));
+                        }
+                        GeneratedField::LargeBinaryValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("largeBinaryValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::LargeBinaryValue(x.0));
+                        }
+                        GeneratedField::Time64Value => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("time64Value"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time64Value)
+;
+                        }
+                        GeneratedField::IntervalMonthDayNano => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("intervalMonthDayNano"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::IntervalMonthDayNano)
+;
+                        }
+                        GeneratedField::StructValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("structValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::StructValue)
+;
+                        }
+                        GeneratedField::FixedSizeBinaryValue => {
+                            if value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fixedSizeBinaryValue"));
+                            }
+                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::FixedSizeBinaryValue)
+;
+                        }
+                    }
+                }
+                Ok(ScalarValue {
+                    value: value__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScalarValue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ScanLimit {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.limit != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ScanLimit", len)?;
+        if self.limit != 0 {
+            struct_ser.serialize_field("limit", &self.limit)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ScanLimit {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "limit",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Limit,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "limit" => Ok(GeneratedField::Limit),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ScanLimit;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ScanLimit")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScanLimit, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut limit__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Limit => {
+                            if limit__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("limit"));
+                            }
+                            limit__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(ScanLimit {
+                    limit: limit__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ScanLimit", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Schema {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.columns.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Schema", len)?;
+        if !self.columns.is_empty() {
+            struct_ser.serialize_field("columns", &self.columns)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Schema {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "columns",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Columns,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "columns" => Ok(GeneratedField::Columns),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Schema;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Schema")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Schema, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut columns__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Columns => {
+                            if columns__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("columns"));
+                            }
+                            columns__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(Schema {
+                    columns: columns__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Schema", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SelectionExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SelectionExecNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SelectionExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SelectionExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SelectionExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SelectionExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(SelectionExecNode {
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SelectionExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SelectionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SelectionNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SelectionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "expr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Expr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "expr" => Ok(GeneratedField::Expr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SelectionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SelectionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SelectionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(SelectionNode {
+                    input: input__,
+                    expr: expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SimilarToNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.negated {
+            len += 1;
+        }
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.pattern.is_some() {
+            len += 1;
+        }
+        if !self.escape_char.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?;
+        if self.negated {
+            struct_ser.serialize_field("negated", &self.negated)?;
+        }
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.pattern.as_ref() {
+            struct_ser.serialize_field("pattern", v)?;
+        }
+        if !self.escape_char.is_empty() {
+            struct_ser.serialize_field("escapeChar", &self.escape_char)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SimilarToNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "negated",
+            "expr",
+            "pattern",
+            "escape_char",
+            "escapeChar",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Negated,
+            Expr,
+            Pattern,
+            EscapeChar,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "negated" => Ok(GeneratedField::Negated),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "pattern" => Ok(GeneratedField::Pattern),
+                            "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SimilarToNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SimilarToNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SimilarToNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut negated__ = None;
+                let mut expr__ = None;
+                let mut pattern__ = None;
+                let mut escape_char__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Negated => {
+                            if negated__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("negated"));
+                            }
+                            negated__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Pattern => {
+                            if pattern__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("pattern"));
+                            }
+                            pattern__ = map.next_value()?;
+                        }
+                        GeneratedField::EscapeChar => {
+                            if escape_char__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("escapeChar"));
+                            }
+                            escape_char__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(SimilarToNode {
+                    negated: negated__.unwrap_or_default(),
+                    expr: expr__,
+                    pattern: pattern__,
+                    escape_char: escape_char__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SimilarToNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SortExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        if self.fetch != 0 {
+            len += 1;
+        }
+        if self.preserve_partitioning {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SortExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        if self.fetch != 0 {
+            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
+        }
+        if self.preserve_partitioning {
+            struct_ser.serialize_field("preservePartitioning", &self.preserve_partitioning)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SortExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "expr",
+            "fetch",
+            "preserve_partitioning",
+            "preservePartitioning",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Expr,
+            Fetch,
+            PreservePartitioning,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "fetch" => Ok(GeneratedField::Fetch),
+                            "preservePartitioning" | "preserve_partitioning" => Ok(GeneratedField::PreservePartitioning),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SortExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SortExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut expr__ = None;
+                let mut fetch__ = None;
+                let mut preserve_partitioning__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Fetch => {
+                            if fetch__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fetch"));
+                            }
+                            fetch__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::PreservePartitioning => {
+                            if preserve_partitioning__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("preservePartitioning"));
+                            }
+                            preserve_partitioning__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(SortExecNode {
+                    input: input__,
+                    expr: expr__.unwrap_or_default(),
+                    fetch: fetch__.unwrap_or_default(),
+                    preserve_partitioning: preserve_partitioning__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SortExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SortExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.asc {
+            len += 1;
+        }
+        if self.nulls_first {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SortExprNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if self.asc {
+            struct_ser.serialize_field("asc", &self.asc)?;
+        }
+        if self.nulls_first {
+            struct_ser.serialize_field("nullsFirst", &self.nulls_first)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SortExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "asc",
+            "nulls_first",
+            "nullsFirst",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            Asc,
+            NullsFirst,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "asc" => Ok(GeneratedField::Asc),
+                            "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SortExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SortExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut asc__ = None;
+                let mut nulls_first__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::Asc => {
+                            if asc__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("asc"));
+                            }
+                            asc__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::NullsFirst => {
+                            if nulls_first__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nullsFirst"));
+                            }
+                            nulls_first__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(SortExprNode {
+                    expr: expr__,
+                    asc: asc__.unwrap_or_default(),
+                    nulls_first: nulls_first__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SortExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SortNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        if self.fetch != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SortNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        if self.fetch != 0 {
+            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SortNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "expr",
+            "fetch",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Expr,
+            Fetch,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "fetch" => Ok(GeneratedField::Fetch),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SortNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SortNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut expr__ = None;
+                let mut fetch__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Fetch => {
+                            if fetch__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fetch"));
+                            }
+                            fetch__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(SortNode {
+                    input: input__,
+                    expr: expr__.unwrap_or_default(),
+                    fetch: fetch__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SortNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SortPreservingMergeExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.expr.is_empty() {
+            len += 1;
+        }
+        if self.fetch != 0 {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SortPreservingMergeExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.expr.is_empty() {
+            struct_ser.serialize_field("expr", &self.expr)?;
+        }
+        if self.fetch != 0 {
+            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "expr",
+            "fetch",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Expr,
+            Fetch,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "expr" => Ok(GeneratedField::Expr),
+                            "fetch" => Ok(GeneratedField::Fetch),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SortPreservingMergeExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SortPreservingMergeExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortPreservingMergeExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut expr__ = None;
+                let mut fetch__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Fetch => {
+                            if fetch__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fetch"));
+                            }
+                            fetch__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                    }
+                }
+                Ok(SortPreservingMergeExecNode {
+                    input: input__,
+                    expr: expr__.unwrap_or_default(),
+                    fetch: fetch__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SortPreservingMergeExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Statistics {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.num_rows != 0 {
+            len += 1;
+        }
+        if self.total_byte_size != 0 {
+            len += 1;
+        }
+        if !self.column_stats.is_empty() {
+            len += 1;
+        }
+        if self.is_exact {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Statistics", len)?;
+        if self.num_rows != 0 {
+            struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?;
+        }
+        if self.total_byte_size != 0 {
+            struct_ser.serialize_field("totalByteSize", ToString::to_string(&self.total_byte_size).as_str())?;
+        }
+        if !self.column_stats.is_empty() {
+            struct_ser.serialize_field("columnStats", &self.column_stats)?;
+        }
+        if self.is_exact {
+            struct_ser.serialize_field("isExact", &self.is_exact)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Statistics {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "num_rows",
+            "numRows",
+            "total_byte_size",
+            "totalByteSize",
+            "column_stats",
+            "columnStats",
+            "is_exact",
+            "isExact",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NumRows,
+            TotalByteSize,
+            ColumnStats,
+            IsExact,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "numRows" | "num_rows" => Ok(GeneratedField::NumRows),
+                            "totalByteSize" | "total_byte_size" => Ok(GeneratedField::TotalByteSize),
+                            "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats),
+                            "isExact" | "is_exact" => Ok(GeneratedField::IsExact),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Statistics;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Statistics")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Statistics, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut num_rows__ = None;
+                let mut total_byte_size__ = None;
+                let mut column_stats__ = None;
+                let mut is_exact__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::NumRows => {
+                            if num_rows__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("numRows"));
+                            }
+                            num_rows__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::TotalByteSize => {
+                            if total_byte_size__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("totalByteSize"));
+                            }
+                            total_byte_size__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::ColumnStats => {
+                            if column_stats__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("columnStats"));
+                            }
+                            column_stats__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::IsExact => {
+                            if is_exact__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("isExact"));
+                            }
+                            is_exact__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(Statistics {
+                    num_rows: num_rows__.unwrap_or_default(),
+                    total_byte_size: total_byte_size__.unwrap_or_default(),
+                    column_stats: column_stats__.unwrap_or_default(),
+                    is_exact: is_exact__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Statistics", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for StringifiedPlan {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.plan_type.is_some() {
+            len += 1;
+        }
+        if !self.plan.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.StringifiedPlan", len)?;
+        if let Some(v) = self.plan_type.as_ref() {
+            struct_ser.serialize_field("planType", v)?;
+        }
+        if !self.plan.is_empty() {
+            struct_ser.serialize_field("plan", &self.plan)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for StringifiedPlan {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "plan_type",
+            "planType",
+            "plan",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            PlanType,
+            Plan,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "planType" | "plan_type" => Ok(GeneratedField::PlanType),
+                            "plan" => Ok(GeneratedField::Plan),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = StringifiedPlan;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.StringifiedPlan")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<StringifiedPlan, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut plan_type__ = None;
+                let mut plan__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::PlanType => {
+                            if plan_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("planType"));
+                            }
+                            plan_type__ = map.next_value()?;
+                        }
+                        GeneratedField::Plan => {
+                            if plan__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("plan"));
+                            }
+                            plan__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(StringifiedPlan {
+                    plan_type: plan_type__,
+                    plan: plan__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.StringifiedPlan", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Struct {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.sub_field_types.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Struct", len)?;
+        if !self.sub_field_types.is_empty() {
+            struct_ser.serialize_field("subFieldTypes", &self.sub_field_types)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Struct {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sub_field_types",
+            "subFieldTypes",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            SubFieldTypes,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "subFieldTypes" | "sub_field_types" => Ok(GeneratedField::SubFieldTypes),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Struct;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Struct")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Struct, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut sub_field_types__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::SubFieldTypes => {
+                            if sub_field_types__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("subFieldTypes"));
+                            }
+                            sub_field_types__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(Struct {
+                    sub_field_types: sub_field_types__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Struct", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for StructValue {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.field_values.is_empty() {
+            len += 1;
+        }
+        if !self.fields.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.StructValue", len)?;
+        if !self.field_values.is_empty() {
+            struct_ser.serialize_field("fieldValues", &self.field_values)?;
+        }
+        if !self.fields.is_empty() {
+            struct_ser.serialize_field("fields", &self.fields)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for StructValue {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "field_values",
+            "fieldValues",
+            "fields",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            FieldValues,
+            Fields,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "fieldValues" | "field_values" => Ok(GeneratedField::FieldValues),
+                            "fields" => Ok(GeneratedField::Fields),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = StructValue;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.StructValue")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<StructValue, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut field_values__ = None;
+                let mut fields__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::FieldValues => {
+                            if field_values__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fieldValues"));
+                            }
+                            field_values__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::Fields => {
+                            if fields__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fields"));
+                            }
+                            fields__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(StructValue {
+                    field_values: field_values__.unwrap_or_default(),
+                    fields: fields__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.StructValue", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for SubqueryAliasNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.alias.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.SubqueryAliasNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if let Some(v) = self.alias.as_ref() {
+            struct_ser.serialize_field("alias", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for SubqueryAliasNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "alias",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            Alias,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "alias" => Ok(GeneratedField::Alias),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = SubqueryAliasNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.SubqueryAliasNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<SubqueryAliasNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut alias__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Alias => {
+                            if alias__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("alias"));
+                            }
+                            alias__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(SubqueryAliasNode {
+                    input: input__,
+                    alias: alias__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.SubqueryAliasNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for TimeUnit {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Second => "Second",
+            Self::Millisecond => "Millisecond",
+            Self::Microsecond => "Microsecond",
+            Self::Nanosecond => "Nanosecond",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for TimeUnit {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "Second",
+            "Millisecond",
+            "Microsecond",
+            "Nanosecond",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = TimeUnit;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(TimeUnit::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(TimeUnit::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "Second" => Ok(TimeUnit::Second),
+                    "Millisecond" => Ok(TimeUnit::Millisecond),
+                    "Microsecond" => Ok(TimeUnit::Microsecond),
+                    "Nanosecond" => Ok(TimeUnit::Nanosecond),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Timestamp {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.time_unit != 0 {
+            len += 1;
+        }
+        if !self.timezone.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Timestamp", len)?;
+        if self.time_unit != 0 {
+            let v = TimeUnit::from_i32(self.time_unit)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.time_unit)))?;
+            struct_ser.serialize_field("timeUnit", &v)?;
+        }
+        if !self.timezone.is_empty() {
+            struct_ser.serialize_field("timezone", &self.timezone)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Timestamp {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "time_unit",
+            "timeUnit",
+            "timezone",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            TimeUnit,
+            Timezone,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "timeUnit" | "time_unit" => Ok(GeneratedField::TimeUnit),
+                            "timezone" => Ok(GeneratedField::Timezone),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Timestamp;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Timestamp")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Timestamp, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut time_unit__ = None;
+                let mut timezone__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::TimeUnit => {
+                            if time_unit__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timeUnit"));
+                            }
+                            time_unit__ = Some(map.next_value::<TimeUnit>()? as i32);
+                        }
+                        GeneratedField::Timezone => {
+                            if timezone__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("timezone"));
+                            }
+                            timezone__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(Timestamp {
+                    time_unit: time_unit__.unwrap_or_default(),
+                    timezone: timezone__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Timestamp", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for TryCastNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if self.arrow_type.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.TryCastNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if let Some(v) = self.arrow_type.as_ref() {
+            struct_ser.serialize_field("arrowType", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for TryCastNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "arrow_type",
+            "arrowType",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            ArrowType,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = TryCastNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.TryCastNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<TryCastNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut arrow_type__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::ArrowType => {
+                            if arrow_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("arrowType"));
+                            }
+                            arrow_type__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(TryCastNode {
+                    expr: expr__,
+                    arrow_type: arrow_type__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.TryCastNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for Union {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.union_types.is_empty() {
+            len += 1;
+        }
+        if self.union_mode != 0 {
+            len += 1;
+        }
+        if !self.type_ids.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.Union", len)?;
+        if !self.union_types.is_empty() {
+            struct_ser.serialize_field("unionTypes", &self.union_types)?;
+        }
+        if self.union_mode != 0 {
+            let v = UnionMode::from_i32(self.union_mode)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.union_mode)))?;
+            struct_ser.serialize_field("unionMode", &v)?;
+        }
+        if !self.type_ids.is_empty() {
+            struct_ser.serialize_field("typeIds", &self.type_ids)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for Union {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "union_types",
+            "unionTypes",
+            "union_mode",
+            "unionMode",
+            "type_ids",
+            "typeIds",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            UnionTypes,
+            UnionMode,
+            TypeIds,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "unionTypes" | "union_types" => Ok(GeneratedField::UnionTypes),
+                            "unionMode" | "union_mode" => Ok(GeneratedField::UnionMode),
+                            "typeIds" | "type_ids" => Ok(GeneratedField::TypeIds),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = Union;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.Union")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Union, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut union_types__ = None;
+                let mut union_mode__ = None;
+                let mut type_ids__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::UnionTypes => {
+                            if union_types__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("unionTypes"));
+                            }
+                            union_types__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::UnionMode => {
+                            if union_mode__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("unionMode"));
+                            }
+                            union_mode__ = Some(map.next_value::<UnionMode>()? as i32);
+                        }
+                        GeneratedField::TypeIds => {
+                            if type_ids__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("typeIds"));
+                            }
+                            type_ids__ = 
+                                Some(map.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                    .into_iter().map(|x| x.0).collect())
+                            ;
+                        }
+                    }
+                }
+                Ok(Union {
+                    union_types: union_types__.unwrap_or_default(),
+                    union_mode: union_mode__.unwrap_or_default(),
+                    type_ids: type_ids__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.Union", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for UnionExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.inputs.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.UnionExecNode", len)?;
+        if !self.inputs.is_empty() {
+            struct_ser.serialize_field("inputs", &self.inputs)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for UnionExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "inputs",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Inputs,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "inputs" => Ok(GeneratedField::Inputs),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = UnionExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.UnionExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<UnionExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut inputs__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Inputs => {
+                            if inputs__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inputs"));
+                            }
+                            inputs__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(UnionExecNode {
+                    inputs: inputs__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.UnionExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for UnionMode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Sparse => "sparse",
+            Self::Dense => "dense",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for UnionMode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "sparse",
+            "dense",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = UnionMode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(UnionMode::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(UnionMode::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "sparse" => Ok(UnionMode::Sparse),
+                    "dense" => Ok(UnionMode::Dense),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for UnionNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if !self.inputs.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.UnionNode", len)?;
+        if !self.inputs.is_empty() {
+            struct_ser.serialize_field("inputs", &self.inputs)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for UnionNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "inputs",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Inputs,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "inputs" => Ok(GeneratedField::Inputs),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = UnionNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.UnionNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<UnionNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut inputs__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Inputs => {
+                            if inputs__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inputs"));
+                            }
+                            inputs__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(UnionNode {
+                    inputs: inputs__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.UnionNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ValuesNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.n_cols != 0 {
+            len += 1;
+        }
+        if !self.values_list.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ValuesNode", len)?;
+        if self.n_cols != 0 {
+            struct_ser.serialize_field("nCols", ToString::to_string(&self.n_cols).as_str())?;
+        }
+        if !self.values_list.is_empty() {
+            struct_ser.serialize_field("valuesList", &self.values_list)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ValuesNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "n_cols",
+            "nCols",
+            "values_list",
+            "valuesList",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            NCols,
+            ValuesList,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "nCols" | "n_cols" => Ok(GeneratedField::NCols),
+                            "valuesList" | "values_list" => Ok(GeneratedField::ValuesList),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ValuesNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ValuesNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ValuesNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut n_cols__ = None;
+                let mut values_list__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::NCols => {
+                            if n_cols__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("nCols"));
+                            }
+                            n_cols__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
+                        GeneratedField::ValuesList => {
+                            if values_list__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("valuesList"));
+                            }
+                            values_list__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ValuesNode {
+                    n_cols: n_cols__.unwrap_or_default(),
+                    values_list: values_list__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ValuesNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for ViewTableScanNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.table_name.is_some() {
+            len += 1;
+        }
+        if self.input.is_some() {
+            len += 1;
+        }
+        if self.schema.is_some() {
+            len += 1;
+        }
+        if self.projection.is_some() {
+            len += 1;
+        }
+        if !self.definition.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.ViewTableScanNode", len)?;
+        if let Some(v) = self.table_name.as_ref() {
+            struct_ser.serialize_field("tableName", v)?;
+        }
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if let Some(v) = self.schema.as_ref() {
+            struct_ser.serialize_field("schema", v)?;
+        }
+        if let Some(v) = self.projection.as_ref() {
+            struct_ser.serialize_field("projection", v)?;
+        }
+        if !self.definition.is_empty() {
+            struct_ser.serialize_field("definition", &self.definition)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for ViewTableScanNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "table_name",
+            "tableName",
+            "input",
+            "schema",
+            "projection",
+            "definition",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            TableName,
+            Input,
+            Schema,
+            Projection,
+            Definition,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
+                            "input" => Ok(GeneratedField::Input),
+                            "schema" => Ok(GeneratedField::Schema),
+                            "projection" => Ok(GeneratedField::Projection),
+                            "definition" => Ok(GeneratedField::Definition),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = ViewTableScanNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.ViewTableScanNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<ViewTableScanNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut table_name__ = None;
+                let mut input__ = None;
+                let mut schema__ = None;
+                let mut projection__ = None;
+                let mut definition__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::TableName => {
+                            if table_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("tableName"));
+                            }
+                            table_name__ = map.next_value()?;
+                        }
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::Schema => {
+                            if schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("schema"));
+                            }
+                            schema__ = map.next_value()?;
+                        }
+                        GeneratedField::Projection => {
+                            if projection__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("projection"));
+                            }
+                            projection__ = map.next_value()?;
+                        }
+                        GeneratedField::Definition => {
+                            if definition__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("definition"));
+                            }
+                            definition__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(ViewTableScanNode {
+                    table_name: table_name__,
+                    input: input__,
+                    schema: schema__,
+                    projection: projection__,
+                    definition: definition__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.ViewTableScanNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WhenThen {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.when_expr.is_some() {
+            len += 1;
+        }
+        if self.then_expr.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.WhenThen", len)?;
+        if let Some(v) = self.when_expr.as_ref() {
+            struct_ser.serialize_field("whenExpr", v)?;
+        }
+        if let Some(v) = self.then_expr.as_ref() {
+            struct_ser.serialize_field("thenExpr", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for WhenThen {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "when_expr",
+            "whenExpr",
+            "then_expr",
+            "thenExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            WhenExpr,
+            ThenExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr),
+                            "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WhenThen;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.WhenThen")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<WhenThen, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut when_expr__ = None;
+                let mut then_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::WhenExpr => {
+                            if when_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("whenExpr"));
+                            }
+                            when_expr__ = map.next_value()?;
+                        }
+                        GeneratedField::ThenExpr => {
+                            if then_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("thenExpr"));
+                            }
+                            then_expr__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(WhenThen {
+                    when_expr: when_expr__,
+                    then_expr: then_expr__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.WhenThen", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WindowAggExecNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.window_expr.is_empty() {
+            len += 1;
+        }
+        if !self.window_expr_name.is_empty() {
+            len += 1;
+        }
+        if self.input_schema.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.WindowAggExecNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.window_expr.is_empty() {
+            struct_ser.serialize_field("windowExpr", &self.window_expr)?;
+        }
+        if !self.window_expr_name.is_empty() {
+            struct_ser.serialize_field("windowExprName", &self.window_expr_name)?;
+        }
+        if let Some(v) = self.input_schema.as_ref() {
+            struct_ser.serialize_field("inputSchema", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for WindowAggExecNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "window_expr",
+            "windowExpr",
+            "window_expr_name",
+            "windowExprName",
+            "input_schema",
+            "inputSchema",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            WindowExpr,
+            WindowExprName,
+            InputSchema,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
+                            "windowExprName" | "window_expr_name" => Ok(GeneratedField::WindowExprName),
+                            "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WindowAggExecNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.WindowAggExecNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowAggExecNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut window_expr__ = None;
+                let mut window_expr_name__ = None;
+                let mut input_schema__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::WindowExpr => {
+                            if window_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowExpr"));
+                            }
+                            window_expr__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::WindowExprName => {
+                            if window_expr_name__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowExprName"));
+                            }
+                            window_expr_name__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::InputSchema => {
+                            if input_schema__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("inputSchema"));
+                            }
+                            input_schema__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(WindowAggExecNode {
+                    input: input__,
+                    window_expr: window_expr__.unwrap_or_default(),
+                    window_expr_name: window_expr_name__.unwrap_or_default(),
+                    input_schema: input_schema__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.WindowAggExecNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WindowExprNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.expr.is_some() {
+            len += 1;
+        }
+        if !self.partition_by.is_empty() {
+            len += 1;
+        }
+        if !self.order_by.is_empty() {
+            len += 1;
+        }
+        if self.window_frame.is_some() {
+            len += 1;
+        }
+        if self.window_function.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.WindowExprNode", len)?;
+        if let Some(v) = self.expr.as_ref() {
+            struct_ser.serialize_field("expr", v)?;
+        }
+        if !self.partition_by.is_empty() {
+            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
+        }
+        if !self.order_by.is_empty() {
+            struct_ser.serialize_field("orderBy", &self.order_by)?;
+        }
+        if let Some(v) = self.window_frame.as_ref() {
+            struct_ser.serialize_field("windowFrame", v)?;
+        }
+        if let Some(v) = self.window_function.as_ref() {
+            match v {
+                window_expr_node::WindowFunction::AggrFunction(v) => {
+                    let v = AggregateFunction::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("aggrFunction", &v)?;
+                }
+                window_expr_node::WindowFunction::BuiltInFunction(v) => {
+                    let v = BuiltInWindowFunction::from_i32(*v)
+                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
+                    struct_ser.serialize_field("builtInFunction", &v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for WindowExprNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "expr",
+            "partition_by",
+            "partitionBy",
+            "order_by",
+            "orderBy",
+            "window_frame",
+            "windowFrame",
+            "aggr_function",
+            "aggrFunction",
+            "built_in_function",
+            "builtInFunction",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Expr,
+            PartitionBy,
+            OrderBy,
+            WindowFrame,
+            AggrFunction,
+            BuiltInFunction,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "expr" => Ok(GeneratedField::Expr),
+                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
+                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
+                            "windowFrame" | "window_frame" => Ok(GeneratedField::WindowFrame),
+                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
+                            "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WindowExprNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.WindowExprNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowExprNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut expr__ = None;
+                let mut partition_by__ = None;
+                let mut order_by__ = None;
+                let mut window_frame__ = None;
+                let mut window_function__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Expr => {
+                            if expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("expr"));
+                            }
+                            expr__ = map.next_value()?;
+                        }
+                        GeneratedField::PartitionBy => {
+                            if partition_by__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("partitionBy"));
+                            }
+                            partition_by__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::OrderBy => {
+                            if order_by__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("orderBy"));
+                            }
+                            order_by__ = Some(map.next_value()?);
+                        }
+                        GeneratedField::WindowFrame => {
+                            if window_frame__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowFrame"));
+                            }
+                            window_frame__ = map.next_value()?;
+                        }
+                        GeneratedField::AggrFunction => {
+                            if window_function__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
+                            }
+                            window_function__ = map.next_value::<::std::option::Option<AggregateFunction>>()?.map(|x| window_expr_node::WindowFunction::AggrFunction(x as i32));
+                        }
+                        GeneratedField::BuiltInFunction => {
+                            if window_function__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("builtInFunction"));
+                            }
+                            window_function__ = map.next_value::<::std::option::Option<BuiltInWindowFunction>>()?.map(|x| window_expr_node::WindowFunction::BuiltInFunction(x as i32));
+                        }
+                    }
+                }
+                Ok(WindowExprNode {
+                    expr: expr__,
+                    partition_by: partition_by__.unwrap_or_default(),
+                    order_by: order_by__.unwrap_or_default(),
+                    window_frame: window_frame__,
+                    window_function: window_function__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.WindowExprNode", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WindowFrame {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.window_frame_units != 0 {
+            len += 1;
+        }
+        if self.start_bound.is_some() {
+            len += 1;
+        }
+        if self.end_bound.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrame", len)?;
+        if self.window_frame_units != 0 {
+            let v = WindowFrameUnits::from_i32(self.window_frame_units)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_units)))?;
+            struct_ser.serialize_field("windowFrameUnits", &v)?;
+        }
+        if let Some(v) = self.start_bound.as_ref() {
+            struct_ser.serialize_field("startBound", v)?;
+        }
+        if let Some(v) = self.end_bound.as_ref() {
+            match v {
+                window_frame::EndBound::Bound(v) => {
+                    struct_ser.serialize_field("bound", v)?;
+                }
+            }
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for WindowFrame {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "window_frame_units",
+            "windowFrameUnits",
+            "start_bound",
+            "startBound",
+            "bound",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            WindowFrameUnits,
+            StartBound,
+            Bound,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "windowFrameUnits" | "window_frame_units" => Ok(GeneratedField::WindowFrameUnits),
+                            "startBound" | "start_bound" => Ok(GeneratedField::StartBound),
+                            "bound" => Ok(GeneratedField::Bound),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WindowFrame;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.WindowFrame")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowFrame, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut window_frame_units__ = None;
+                let mut start_bound__ = None;
+                let mut end_bound__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::WindowFrameUnits => {
+                            if window_frame_units__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowFrameUnits"));
+                            }
+                            window_frame_units__ = Some(map.next_value::<WindowFrameUnits>()? as i32);
+                        }
+                        GeneratedField::StartBound => {
+                            if start_bound__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("startBound"));
+                            }
+                            start_bound__ = map.next_value()?;
+                        }
+                        GeneratedField::Bound => {
+                            if end_bound__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("bound"));
+                            }
+                            end_bound__ = map.next_value::<::std::option::Option<_>>()?.map(window_frame::EndBound::Bound)
+;
+                        }
+                    }
+                }
+                Ok(WindowFrame {
+                    window_frame_units: window_frame_units__.unwrap_or_default(),
+                    start_bound: start_bound__,
+                    end_bound: end_bound__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.WindowFrame", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WindowFrameBound {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.window_frame_bound_type != 0 {
+            len += 1;
+        }
+        if self.bound_value.is_some() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrameBound", len)?;
+        if self.window_frame_bound_type != 0 {
+            let v = WindowFrameBoundType::from_i32(self.window_frame_bound_type)
+                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_bound_type)))?;
+            struct_ser.serialize_field("windowFrameBoundType", &v)?;
+        }
+        if let Some(v) = self.bound_value.as_ref() {
+            struct_ser.serialize_field("boundValue", v)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for WindowFrameBound {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "window_frame_bound_type",
+            "windowFrameBoundType",
+            "bound_value",
+            "boundValue",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            WindowFrameBoundType,
+            BoundValue,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "windowFrameBoundType" | "window_frame_bound_type" => Ok(GeneratedField::WindowFrameBoundType),
+                            "boundValue" | "bound_value" => Ok(GeneratedField::BoundValue),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WindowFrameBound;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.WindowFrameBound")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowFrameBound, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut window_frame_bound_type__ = None;
+                let mut bound_value__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::WindowFrameBoundType => {
+                            if window_frame_bound_type__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowFrameBoundType"));
+                            }
+                            window_frame_bound_type__ = Some(map.next_value::<WindowFrameBoundType>()? as i32);
+                        }
+                        GeneratedField::BoundValue => {
+                            if bound_value__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("boundValue"));
+                            }
+                            bound_value__ = map.next_value()?;
+                        }
+                    }
+                }
+                Ok(WindowFrameBound {
+                    window_frame_bound_type: window_frame_bound_type__.unwrap_or_default(),
+                    bound_value: bound_value__,
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.WindowFrameBound", FIELDS, GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WindowFrameBoundType {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::CurrentRow => "CURRENT_ROW",
+            Self::Preceding => "PRECEDING",
+            Self::Following => "FOLLOWING",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for WindowFrameBoundType {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "CURRENT_ROW",
+            "PRECEDING",
+            "FOLLOWING",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WindowFrameBoundType;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(WindowFrameBoundType::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(WindowFrameBoundType::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "CURRENT_ROW" => Ok(WindowFrameBoundType::CurrentRow),
+                    "PRECEDING" => Ok(WindowFrameBoundType::Preceding),
+                    "FOLLOWING" => Ok(WindowFrameBoundType::Following),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WindowFrameUnits {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let variant = match self {
+            Self::Rows => "ROWS",
+            Self::Range => "RANGE",
+            Self::Groups => "GROUPS",
+        };
+        serializer.serialize_str(variant)
+    }
+}
+impl<'de> serde::Deserialize<'de> for WindowFrameUnits {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "ROWS",
+            "RANGE",
+            "GROUPS",
+        ];
+
+        struct GeneratedVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WindowFrameUnits;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(formatter, "expected one of: {:?}", &FIELDS)
+            }
+
+            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(WindowFrameUnits::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
+                    })
+            }
+
+            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                use std::convert::TryFrom;
+                i32::try_from(v)
+                    .ok()
+                    .and_then(WindowFrameUnits::from_i32)
+                    .ok_or_else(|| {
+                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
+                    })
+            }
+
+            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match value {
+                    "ROWS" => Ok(WindowFrameUnits::Rows),
+                    "RANGE" => Ok(WindowFrameUnits::Range),
+                    "GROUPS" => Ok(WindowFrameUnits::Groups),
+                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
+                }
+            }
+        }
+        deserializer.deserialize_any(GeneratedVisitor)
+    }
+}
+impl serde::Serialize for WindowNode {
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut len = 0;
+        if self.input.is_some() {
+            len += 1;
+        }
+        if !self.window_expr.is_empty() {
+            len += 1;
+        }
+        let mut struct_ser = serializer.serialize_struct("datafusion.WindowNode", len)?;
+        if let Some(v) = self.input.as_ref() {
+            struct_ser.serialize_field("input", v)?;
+        }
+        if !self.window_expr.is_empty() {
+            struct_ser.serialize_field("windowExpr", &self.window_expr)?;
+        }
+        struct_ser.end()
+    }
+}
+impl<'de> serde::Deserialize<'de> for WindowNode {
+    #[allow(deprecated)]
+    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        const FIELDS: &[&str] = &[
+            "input",
+            "window_expr",
+            "windowExpr",
+        ];
+
+        #[allow(clippy::enum_variant_names)]
+        enum GeneratedField {
+            Input,
+            WindowExpr,
+        }
+        impl<'de> serde::Deserialize<'de> for GeneratedField {
+            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                struct GeneratedVisitor;
+
+                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+                    type Value = GeneratedField;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                        write!(formatter, "expected one of: {:?}", &FIELDS)
+                    }
+
+                    #[allow(unused_variables)]
+                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            "input" => Ok(GeneratedField::Input),
+                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
+                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+                deserializer.deserialize_identifier(GeneratedVisitor)
+            }
+        }
+        struct GeneratedVisitor;
+        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+            type Value = WindowNode;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                formatter.write_str("struct datafusion.WindowNode")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowNode, V::Error>
+                where
+                    V: serde::de::MapAccess<'de>,
+            {
+                let mut input__ = None;
+                let mut window_expr__ = None;
+                while let Some(k) = map.next_key()? {
+                    match k {
+                        GeneratedField::Input => {
+                            if input__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("input"));
+                            }
+                            input__ = map.next_value()?;
+                        }
+                        GeneratedField::WindowExpr => {
+                            if window_expr__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("windowExpr"));
+                            }
+                            window_expr__ = Some(map.next_value()?);
+                        }
+                    }
+                }
+                Ok(WindowNode {
+                    input: input__,
+                    window_expr: window_expr__.unwrap_or_default(),
+                })
+            }
+        }
+        deserializer.deserialize_struct("datafusion.WindowNode", FIELDS, GeneratedVisitor)
+    }
+}
diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs
index 42397e3da239b..ab8ddf4f292f8 100644
--- a/datafusion/proto/src/generated/pbjson.rs
+++ b/datafusion/proto/src/generated/pbjson.rs
@@ -20269,6 +20269,9 @@ impl serde::Serialize for SortPreservingMergeExecNode {
         if !self.expr.is_empty() {
             len += 1;
         }
+        if self.fetch != 0 {
+            len += 1;
+        }
         let mut struct_ser = serializer.serialize_struct("datafusion.SortPreservingMergeExecNode", len)?;
         if let Some(v) = self.input.as_ref() {
             struct_ser.serialize_field("input", v)?;
@@ -20276,6 +20279,9 @@ impl serde::Serialize for SortPreservingMergeExecNode {
         if !self.expr.is_empty() {
             struct_ser.serialize_field("expr", &self.expr)?;
         }
+        if self.fetch != 0 {
+            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
+        }
         struct_ser.end()
     }
 }
@@ -20288,12 +20294,14 @@ impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode {
         const FIELDS: &[&str] = &[
             "input",
             "expr",
+            "fetch",
         ];
 
         #[allow(clippy::enum_variant_names)]
         enum GeneratedField {
             Input,
             Expr,
+            Fetch,
         }
         impl<'de> serde::Deserialize<'de> for GeneratedField {
             fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
@@ -20317,6 +20325,7 @@ impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode {
                         match value {
                             "input" => Ok(GeneratedField::Input),
                             "expr" => Ok(GeneratedField::Expr),
+                            "fetch" => Ok(GeneratedField::Fetch),
                             _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
                         }
                     }
@@ -20338,6 +20347,7 @@ impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode {
             {
                 let mut input__ = None;
                 let mut expr__ = None;
+                let mut fetch__ = None;
                 while let Some(k) = map.next_key()? {
                     match k {
                         GeneratedField::Input => {
@@ -20352,11 +20362,20 @@ impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode {
                             }
                             expr__ = Some(map.next_value()?);
                         }
+                        GeneratedField::Fetch => {
+                            if fetch__.is_some() {
+                                return Err(serde::de::Error::duplicate_field("fetch"));
+                            }
+                            fetch__ = 
+                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                            ;
+                        }
                     }
                 }
                 Ok(SortPreservingMergeExecNode {
                     input: input__,
                     expr: expr__.unwrap_or_default(),
+                    fetch: fetch__.unwrap_or_default(),
                 })
             }
         }
diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs
index 31086deead1ac..ae5dfe14b521d 100644
--- a/datafusion/proto/src/generated/prost.rs
+++ b/datafusion/proto/src/generated/prost.rs
@@ -1923,6 +1923,9 @@ pub struct SortPreservingMergeExecNode {
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
     #[prost(message, repeated, tag = "2")]
     pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
+    /// Maximum number of highest/lowest rows to fetch; negative means no limit
+    #[prost(int64, tag = "3")]
+    pub fetch: i64,
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs
index 1daa1c2e4b9cb..ba1e9e0b0916a 100644
--- a/datafusion/proto/src/physical_plan/mod.rs
+++ b/datafusion/proto/src/physical_plan/mod.rs
@@ -1144,6 +1144,7 @@ impl AsExecutionPlan for PhysicalPlanNode {
                     Box::new(protobuf::SortPreservingMergeExecNode {
                         input: Some(Box::new(input)),
                         expr,
+                        fetch: exec.fetch().map(|f|f as i64).unwrap_or(-1)
                     }),
                 )),
             })

From 2e0ca35ef8e933de9c33c100f81fdfd1c56c1f2c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 16:28:37 +0200
Subject: [PATCH 02/15] Add fetch to sortpreservingmergeexec

---
 datafusion/proto/proto/proto_descriptor.bin |   Bin 86986 -> 0 bytes
 datafusion/proto/src/datafusion.rs          |  2864 ---
 datafusion/proto/src/datafusion.serde.rs    | 22857 ------------------
 3 files changed, 25721 deletions(-)
 delete mode 100644 datafusion/proto/proto/proto_descriptor.bin
 delete mode 100644 datafusion/proto/src/datafusion.rs
 delete mode 100644 datafusion/proto/src/datafusion.serde.rs

diff --git a/datafusion/proto/proto/proto_descriptor.bin b/datafusion/proto/proto/proto_descriptor.bin
deleted file mode 100644
index 448c1eda25bb487fcc6da0a86ef23f86b42f626b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 86986
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

diff --git a/datafusion/proto/src/datafusion.rs b/datafusion/proto/src/datafusion.rs
deleted file mode 100644
index ae5dfe14b521d..0000000000000
--- a/datafusion/proto/src/datafusion.rs
+++ /dev/null
@@ -1,2864 +0,0 @@
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ColumnRelation {
-    #[prost(string, tag = "1")]
-    pub relation: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Column {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "2")]
-    pub relation: ::core::option::Option<ColumnRelation>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DfField {
-    #[prost(message, optional, tag = "1")]
-    pub field: ::core::option::Option<Field>,
-    #[prost(message, optional, tag = "2")]
-    pub qualifier: ::core::option::Option<ColumnRelation>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DfSchema {
-    #[prost(message, repeated, tag = "1")]
-    pub columns: ::prost::alloc::vec::Vec<DfField>,
-    #[prost(map = "string, string", tag = "2")]
-    pub metadata: ::std::collections::HashMap<
-        ::prost::alloc::string::String,
-        ::prost::alloc::string::String,
-    >,
-}
-/// logical plan
-/// LogicalPlan is a nested type
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogicalPlanNode {
-    #[prost(
-        oneof = "logical_plan_node::LogicalPlanType",
-        tags = "1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27"
-    )]
-    pub logical_plan_type: ::core::option::Option<logical_plan_node::LogicalPlanType>,
-}
-/// Nested message and enum types in `LogicalPlanNode`.
-pub mod logical_plan_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum LogicalPlanType {
-        #[prost(message, tag = "1")]
-        ListingScan(super::ListingTableScanNode),
-        #[prost(message, tag = "3")]
-        Projection(::prost::alloc::boxed::Box<super::ProjectionNode>),
-        #[prost(message, tag = "4")]
-        Selection(::prost::alloc::boxed::Box<super::SelectionNode>),
-        #[prost(message, tag = "5")]
-        Limit(::prost::alloc::boxed::Box<super::LimitNode>),
-        #[prost(message, tag = "6")]
-        Aggregate(::prost::alloc::boxed::Box<super::AggregateNode>),
-        #[prost(message, tag = "7")]
-        Join(::prost::alloc::boxed::Box<super::JoinNode>),
-        #[prost(message, tag = "8")]
-        Sort(::prost::alloc::boxed::Box<super::SortNode>),
-        #[prost(message, tag = "9")]
-        Repartition(::prost::alloc::boxed::Box<super::RepartitionNode>),
-        #[prost(message, tag = "10")]
-        EmptyRelation(super::EmptyRelationNode),
-        #[prost(message, tag = "11")]
-        CreateExternalTable(super::CreateExternalTableNode),
-        #[prost(message, tag = "12")]
-        Explain(::prost::alloc::boxed::Box<super::ExplainNode>),
-        #[prost(message, tag = "13")]
-        Window(::prost::alloc::boxed::Box<super::WindowNode>),
-        #[prost(message, tag = "14")]
-        Analyze(::prost::alloc::boxed::Box<super::AnalyzeNode>),
-        #[prost(message, tag = "15")]
-        CrossJoin(::prost::alloc::boxed::Box<super::CrossJoinNode>),
-        #[prost(message, tag = "16")]
-        Values(super::ValuesNode),
-        #[prost(message, tag = "17")]
-        Extension(super::LogicalExtensionNode),
-        #[prost(message, tag = "18")]
-        CreateCatalogSchema(super::CreateCatalogSchemaNode),
-        #[prost(message, tag = "19")]
-        Union(super::UnionNode),
-        #[prost(message, tag = "20")]
-        CreateCatalog(super::CreateCatalogNode),
-        #[prost(message, tag = "21")]
-        SubqueryAlias(::prost::alloc::boxed::Box<super::SubqueryAliasNode>),
-        #[prost(message, tag = "22")]
-        CreateView(::prost::alloc::boxed::Box<super::CreateViewNode>),
-        #[prost(message, tag = "23")]
-        Distinct(::prost::alloc::boxed::Box<super::DistinctNode>),
-        #[prost(message, tag = "24")]
-        ViewScan(::prost::alloc::boxed::Box<super::ViewTableScanNode>),
-        #[prost(message, tag = "25")]
-        CustomScan(super::CustomTableScanNode),
-        #[prost(message, tag = "26")]
-        Prepare(::prost::alloc::boxed::Box<super::PrepareNode>),
-        #[prost(message, tag = "27")]
-        DropView(super::DropViewNode),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogicalExtensionNode {
-    #[prost(bytes = "vec", tag = "1")]
-    pub node: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, repeated, tag = "2")]
-    pub inputs: ::prost::alloc::vec::Vec<LogicalPlanNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ProjectionColumns {
-    #[prost(string, repeated, tag = "1")]
-    pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CsvFormat {
-    #[prost(bool, tag = "1")]
-    pub has_header: bool,
-    #[prost(string, tag = "2")]
-    pub delimiter: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ParquetFormat {}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AvroFormat {}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogicalExprNodeCollection {
-    #[prost(message, repeated, tag = "1")]
-    pub logical_expr_nodes: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ListingTableScanNode {
-    #[prost(message, optional, tag = "14")]
-    pub table_name: ::core::option::Option<OwnedTableReference>,
-    #[prost(string, repeated, tag = "2")]
-    pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(string, tag = "3")]
-    pub file_extension: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "4")]
-    pub projection: ::core::option::Option<ProjectionColumns>,
-    #[prost(message, optional, tag = "5")]
-    pub schema: ::core::option::Option<Schema>,
-    #[prost(message, repeated, tag = "6")]
-    pub filters: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(string, repeated, tag = "7")]
-    pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(bool, tag = "8")]
-    pub collect_stat: bool,
-    #[prost(uint32, tag = "9")]
-    pub target_partitions: u32,
-    #[prost(message, repeated, tag = "13")]
-    pub file_sort_order: ::prost::alloc::vec::Vec<LogicalExprNodeCollection>,
-    #[prost(oneof = "listing_table_scan_node::FileFormatType", tags = "10, 11, 12")]
-    pub file_format_type: ::core::option::Option<
-        listing_table_scan_node::FileFormatType,
-    >,
-}
-/// Nested message and enum types in `ListingTableScanNode`.
-pub mod listing_table_scan_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum FileFormatType {
-        #[prost(message, tag = "10")]
-        Csv(super::CsvFormat),
-        #[prost(message, tag = "11")]
-        Parquet(super::ParquetFormat),
-        #[prost(message, tag = "12")]
-        Avro(super::AvroFormat),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ViewTableScanNode {
-    #[prost(message, optional, tag = "6")]
-    pub table_name: ::core::option::Option<OwnedTableReference>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, tag = "3")]
-    pub schema: ::core::option::Option<Schema>,
-    #[prost(message, optional, tag = "4")]
-    pub projection: ::core::option::Option<ProjectionColumns>,
-    #[prost(string, tag = "5")]
-    pub definition: ::prost::alloc::string::String,
-}
-/// Logical Plan to Scan a CustomTableProvider registered at runtime
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CustomTableScanNode {
-    #[prost(message, optional, tag = "6")]
-    pub table_name: ::core::option::Option<OwnedTableReference>,
-    #[prost(message, optional, tag = "2")]
-    pub projection: ::core::option::Option<ProjectionColumns>,
-    #[prost(message, optional, tag = "3")]
-    pub schema: ::core::option::Option<Schema>,
-    #[prost(message, repeated, tag = "4")]
-    pub filters: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(bytes = "vec", tag = "5")]
-    pub custom_table_data: ::prost::alloc::vec::Vec<u8>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ProjectionNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(oneof = "projection_node::OptionalAlias", tags = "3")]
-    pub optional_alias: ::core::option::Option<projection_node::OptionalAlias>,
-}
-/// Nested message and enum types in `ProjectionNode`.
-pub mod projection_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum OptionalAlias {
-        #[prost(string, tag = "3")]
-        Alias(::prost::alloc::string::String),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SelectionNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub expr: ::core::option::Option<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SortNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    /// Maximum number of highest/lowest rows to fetch; negative means no limit
-    #[prost(int64, tag = "3")]
-    pub fetch: i64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct RepartitionNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(oneof = "repartition_node::PartitionMethod", tags = "2, 3")]
-    pub partition_method: ::core::option::Option<repartition_node::PartitionMethod>,
-}
-/// Nested message and enum types in `RepartitionNode`.
-pub mod repartition_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum PartitionMethod {
-        #[prost(uint64, tag = "2")]
-        RoundRobin(u64),
-        #[prost(message, tag = "3")]
-        Hash(super::HashRepartition),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct HashRepartition {
-    #[prost(message, repeated, tag = "1")]
-    pub hash_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(uint64, tag = "2")]
-    pub partition_count: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EmptyRelationNode {
-    #[prost(bool, tag = "1")]
-    pub produce_one_row: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CreateExternalTableNode {
-    #[prost(message, optional, tag = "12")]
-    pub name: ::core::option::Option<OwnedTableReference>,
-    #[prost(string, tag = "2")]
-    pub location: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub file_type: ::prost::alloc::string::String,
-    #[prost(bool, tag = "4")]
-    pub has_header: bool,
-    #[prost(message, optional, tag = "5")]
-    pub schema: ::core::option::Option<DfSchema>,
-    #[prost(string, repeated, tag = "6")]
-    pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(bool, tag = "7")]
-    pub if_not_exists: bool,
-    #[prost(string, tag = "8")]
-    pub delimiter: ::prost::alloc::string::String,
-    #[prost(string, tag = "9")]
-    pub definition: ::prost::alloc::string::String,
-    #[prost(string, tag = "10")]
-    pub file_compression_type: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "13")]
-    pub order_exprs: ::prost::alloc::vec::Vec<LogicalExprNodeCollection>,
-    #[prost(bool, tag = "14")]
-    pub unbounded: bool,
-    #[prost(map = "string, string", tag = "11")]
-    pub options: ::std::collections::HashMap<
-        ::prost::alloc::string::String,
-        ::prost::alloc::string::String,
-    >,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PrepareNode {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub data_types: ::prost::alloc::vec::Vec<ArrowType>,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CreateCatalogSchemaNode {
-    #[prost(string, tag = "1")]
-    pub schema_name: ::prost::alloc::string::String,
-    #[prost(bool, tag = "2")]
-    pub if_not_exists: bool,
-    #[prost(message, optional, tag = "3")]
-    pub schema: ::core::option::Option<DfSchema>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CreateCatalogNode {
-    #[prost(string, tag = "1")]
-    pub catalog_name: ::prost::alloc::string::String,
-    #[prost(bool, tag = "2")]
-    pub if_not_exists: bool,
-    #[prost(message, optional, tag = "3")]
-    pub schema: ::core::option::Option<DfSchema>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DropViewNode {
-    #[prost(message, optional, tag = "1")]
-    pub name: ::core::option::Option<OwnedTableReference>,
-    #[prost(bool, tag = "2")]
-    pub if_exists: bool,
-    #[prost(message, optional, tag = "3")]
-    pub schema: ::core::option::Option<DfSchema>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CreateViewNode {
-    #[prost(message, optional, tag = "5")]
-    pub name: ::core::option::Option<OwnedTableReference>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(bool, tag = "3")]
-    pub or_replace: bool,
-    #[prost(string, tag = "4")]
-    pub definition: ::prost::alloc::string::String,
-}
-/// a node containing data for defining values list. unlike in SQL where it's two dimensional, here
-/// the list is flattened, and with the field n_cols it can be parsed and partitioned into rows
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ValuesNode {
-    #[prost(uint64, tag = "1")]
-    pub n_cols: u64,
-    #[prost(message, repeated, tag = "2")]
-    pub values_list: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AnalyzeNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(bool, tag = "2")]
-    pub verbose: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ExplainNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(bool, tag = "2")]
-    pub verbose: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AggregateNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub group_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(message, repeated, tag = "3")]
-    pub aggr_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct WindowNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub window_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct JoinNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub left: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub right: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(enumeration = "JoinType", tag = "3")]
-    pub join_type: i32,
-    #[prost(enumeration = "JoinConstraint", tag = "4")]
-    pub join_constraint: i32,
-    #[prost(message, repeated, tag = "5")]
-    pub left_join_key: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(message, repeated, tag = "6")]
-    pub right_join_key: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(bool, tag = "7")]
-    pub null_equals_null: bool,
-    #[prost(message, optional, tag = "8")]
-    pub filter: ::core::option::Option<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct DistinctNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct UnionNode {
-    #[prost(message, repeated, tag = "1")]
-    pub inputs: ::prost::alloc::vec::Vec<LogicalPlanNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CrossJoinNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub left: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub right: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LimitNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    /// The number of rows to skip before fetch; non-positive means don't skip any
-    #[prost(int64, tag = "2")]
-    pub skip: i64,
-    /// Maximum number of rows to fetch; negative means no limit
-    #[prost(int64, tag = "3")]
-    pub fetch: i64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SelectionExecNode {
-    #[prost(message, optional, tag = "1")]
-    pub expr: ::core::option::Option<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SubqueryAliasNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, tag = "3")]
-    pub alias: ::core::option::Option<OwnedTableReference>,
-}
-/// logical expressions
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogicalExprNode {
-    #[prost(
-        oneof = "logical_expr_node::ExprType",
-        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34"
-    )]
-    pub expr_type: ::core::option::Option<logical_expr_node::ExprType>,
-}
-/// Nested message and enum types in `LogicalExprNode`.
-pub mod logical_expr_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum ExprType {
-        /// column references
-        #[prost(message, tag = "1")]
-        Column(super::Column),
-        /// alias
-        #[prost(message, tag = "2")]
-        Alias(::prost::alloc::boxed::Box<super::AliasNode>),
-        #[prost(message, tag = "3")]
-        Literal(super::ScalarValue),
-        /// binary expressions
-        #[prost(message, tag = "4")]
-        BinaryExpr(super::BinaryExprNode),
-        /// aggregate expressions
-        #[prost(message, tag = "5")]
-        AggregateExpr(::prost::alloc::boxed::Box<super::AggregateExprNode>),
-        /// null checks
-        #[prost(message, tag = "6")]
-        IsNullExpr(::prost::alloc::boxed::Box<super::IsNull>),
-        #[prost(message, tag = "7")]
-        IsNotNullExpr(::prost::alloc::boxed::Box<super::IsNotNull>),
-        #[prost(message, tag = "8")]
-        NotExpr(::prost::alloc::boxed::Box<super::Not>),
-        #[prost(message, tag = "9")]
-        Between(::prost::alloc::boxed::Box<super::BetweenNode>),
-        #[prost(message, tag = "10")]
-        Case(::prost::alloc::boxed::Box<super::CaseNode>),
-        #[prost(message, tag = "11")]
-        Cast(::prost::alloc::boxed::Box<super::CastNode>),
-        #[prost(message, tag = "12")]
-        Sort(::prost::alloc::boxed::Box<super::SortExprNode>),
-        #[prost(message, tag = "13")]
-        Negative(::prost::alloc::boxed::Box<super::NegativeNode>),
-        #[prost(message, tag = "14")]
-        InList(::prost::alloc::boxed::Box<super::InListNode>),
-        #[prost(bool, tag = "15")]
-        Wildcard(bool),
-        #[prost(message, tag = "16")]
-        ScalarFunction(super::ScalarFunctionNode),
-        #[prost(message, tag = "17")]
-        TryCast(::prost::alloc::boxed::Box<super::TryCastNode>),
-        /// window expressions
-        #[prost(message, tag = "18")]
-        WindowExpr(::prost::alloc::boxed::Box<super::WindowExprNode>),
-        /// AggregateUDF expressions
-        #[prost(message, tag = "19")]
-        AggregateUdfExpr(::prost::alloc::boxed::Box<super::AggregateUdfExprNode>),
-        /// Scalar UDF expressions
-        #[prost(message, tag = "20")]
-        ScalarUdfExpr(super::ScalarUdfExprNode),
-        #[prost(message, tag = "21")]
-        GetIndexedField(::prost::alloc::boxed::Box<super::GetIndexedField>),
-        #[prost(message, tag = "22")]
-        GroupingSet(super::GroupingSetNode),
-        #[prost(message, tag = "23")]
-        Cube(super::CubeNode),
-        #[prost(message, tag = "24")]
-        Rollup(super::RollupNode),
-        #[prost(message, tag = "25")]
-        IsTrue(::prost::alloc::boxed::Box<super::IsTrue>),
-        #[prost(message, tag = "26")]
-        IsFalse(::prost::alloc::boxed::Box<super::IsFalse>),
-        #[prost(message, tag = "27")]
-        IsUnknown(::prost::alloc::boxed::Box<super::IsUnknown>),
-        #[prost(message, tag = "28")]
-        IsNotTrue(::prost::alloc::boxed::Box<super::IsNotTrue>),
-        #[prost(message, tag = "29")]
-        IsNotFalse(::prost::alloc::boxed::Box<super::IsNotFalse>),
-        #[prost(message, tag = "30")]
-        IsNotUnknown(::prost::alloc::boxed::Box<super::IsNotUnknown>),
-        #[prost(message, tag = "31")]
-        Like(::prost::alloc::boxed::Box<super::LikeNode>),
-        #[prost(message, tag = "32")]
-        Ilike(::prost::alloc::boxed::Box<super::ILikeNode>),
-        #[prost(message, tag = "33")]
-        SimilarTo(::prost::alloc::boxed::Box<super::SimilarToNode>),
-        #[prost(message, tag = "34")]
-        Placeholder(super::PlaceholderNode),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PlaceholderNode {
-    #[prost(string, tag = "1")]
-    pub id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "2")]
-    pub data_type: ::core::option::Option<ArrowType>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LogicalExprList {
-    #[prost(message, repeated, tag = "1")]
-    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GroupingSetNode {
-    #[prost(message, repeated, tag = "1")]
-    pub expr: ::prost::alloc::vec::Vec<LogicalExprList>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CubeNode {
-    #[prost(message, repeated, tag = "1")]
-    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct RollupNode {
-    #[prost(message, repeated, tag = "1")]
-    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetIndexedField {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub key: ::core::option::Option<ScalarValue>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsNull {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsNotNull {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsTrue {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsFalse {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsUnknown {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsNotTrue {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsNotFalse {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IsNotUnknown {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Not {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AliasNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag = "2")]
-    pub alias: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BinaryExprNode {
-    /// Represents the operands from the left inner most expression
-    /// to the right outer most expression where each of them are chained
-    /// with the operator 'op'.
-    #[prost(message, repeated, tag = "1")]
-    pub operands: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(string, tag = "3")]
-    pub op: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct NegativeNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct InListNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub list: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(bool, tag = "3")]
-    pub negated: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarFunctionNode {
-    #[prost(enumeration = "ScalarFunction", tag = "1")]
-    pub fun: i32,
-    #[prost(message, repeated, tag = "2")]
-    pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AggregateExprNode {
-    #[prost(enumeration = "AggregateFunction", tag = "1")]
-    pub aggr_function: i32,
-    #[prost(message, repeated, tag = "2")]
-    pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(bool, tag = "3")]
-    pub distinct: bool,
-    #[prost(message, optional, boxed, tag = "4")]
-    pub filter: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag = "5")]
-    pub order_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AggregateUdfExprNode {
-    #[prost(string, tag = "1")]
-    pub fun_name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub filter: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag = "4")]
-    pub order_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarUdfExprNode {
-    #[prost(string, tag = "1")]
-    pub fun_name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct WindowExprNode {
-    #[prost(message, optional, boxed, tag = "4")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag = "5")]
-    pub partition_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(message, repeated, tag = "6")]
-    pub order_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    /// repeated LogicalExprNode filter = 7;
-    #[prost(message, optional, tag = "8")]
-    pub window_frame: ::core::option::Option<WindowFrame>,
-    #[prost(oneof = "window_expr_node::WindowFunction", tags = "1, 2")]
-    pub window_function: ::core::option::Option<window_expr_node::WindowFunction>,
-}
-/// Nested message and enum types in `WindowExprNode`.
-pub mod window_expr_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum WindowFunction {
-        #[prost(enumeration = "super::AggregateFunction", tag = "1")]
-        AggrFunction(i32),
-        /// udaf = 3
-        #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")]
-        BuiltInFunction(i32),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BetweenNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(bool, tag = "2")]
-    pub negated: bool,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub low: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag = "4")]
-    pub high: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LikeNode {
-    #[prost(bool, tag = "1")]
-    pub negated: bool,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag = "4")]
-    pub escape_char: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ILikeNode {
-    #[prost(bool, tag = "1")]
-    pub negated: bool,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag = "4")]
-    pub escape_char: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SimilarToNode {
-    #[prost(bool, tag = "1")]
-    pub negated: bool,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag = "4")]
-    pub escape_char: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CaseNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub when_then_expr: ::prost::alloc::vec::Vec<WhenThen>,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct WhenThen {
-    #[prost(message, optional, tag = "1")]
-    pub when_expr: ::core::option::Option<LogicalExprNode>,
-    #[prost(message, optional, tag = "2")]
-    pub then_expr: ::core::option::Option<LogicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CastNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub arrow_type: ::core::option::Option<ArrowType>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct TryCastNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub arrow_type: ::core::option::Option<ArrowType>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SortExprNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(bool, tag = "2")]
-    pub asc: bool,
-    #[prost(bool, tag = "3")]
-    pub nulls_first: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct WindowFrame {
-    #[prost(enumeration = "WindowFrameUnits", tag = "1")]
-    pub window_frame_units: i32,
-    #[prost(message, optional, tag = "2")]
-    pub start_bound: ::core::option::Option<WindowFrameBound>,
-    /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see <https://github.com/tokio-rs/prost/issues/430> and <https://github.com/tokio-rs/prost/pull/455>)
-    /// this syntax is ugly but is binary compatible with the "optional" keyword (see <https://stackoverflow.com/questions/42622015/how-to-define-an-optional-field-in-protobuf-3>)
-    #[prost(oneof = "window_frame::EndBound", tags = "3")]
-    pub end_bound: ::core::option::Option<window_frame::EndBound>,
-}
-/// Nested message and enum types in `WindowFrame`.
-pub mod window_frame {
-    /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see <https://github.com/tokio-rs/prost/issues/430> and <https://github.com/tokio-rs/prost/pull/455>)
-    /// this syntax is ugly but is binary compatible with the "optional" keyword (see <https://stackoverflow.com/questions/42622015/how-to-define-an-optional-field-in-protobuf-3>)
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum EndBound {
-        #[prost(message, tag = "3")]
-        Bound(super::WindowFrameBound),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct WindowFrameBound {
-    #[prost(enumeration = "WindowFrameBoundType", tag = "1")]
-    pub window_frame_bound_type: i32,
-    #[prost(message, optional, tag = "2")]
-    pub bound_value: ::core::option::Option<ScalarValue>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Schema {
-    #[prost(message, repeated, tag = "1")]
-    pub columns: ::prost::alloc::vec::Vec<Field>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Field {
-    /// name of the field
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub arrow_type: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
-    #[prost(bool, tag = "3")]
-    pub nullable: bool,
-    /// for complex data types like structs, unions
-    #[prost(message, repeated, tag = "4")]
-    pub children: ::prost::alloc::vec::Vec<Field>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FixedSizeBinary {
-    #[prost(int32, tag = "1")]
-    pub length: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Timestamp {
-    #[prost(enumeration = "TimeUnit", tag = "1")]
-    pub time_unit: i32,
-    #[prost(string, tag = "2")]
-    pub timezone: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Decimal {
-    #[prost(uint32, tag = "3")]
-    pub precision: u32,
-    #[prost(int32, tag = "4")]
-    pub scale: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct List {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FixedSizeList {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
-    #[prost(int32, tag = "2")]
-    pub list_size: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Dictionary {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub key: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub value: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Struct {
-    #[prost(message, repeated, tag = "1")]
-    pub sub_field_types: ::prost::alloc::vec::Vec<Field>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Map {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
-    #[prost(bool, tag = "2")]
-    pub keys_sorted: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Union {
-    #[prost(message, repeated, tag = "1")]
-    pub union_types: ::prost::alloc::vec::Vec<Field>,
-    #[prost(enumeration = "UnionMode", tag = "2")]
-    pub union_mode: i32,
-    #[prost(int32, repeated, tag = "3")]
-    pub type_ids: ::prost::alloc::vec::Vec<i32>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarListValue {
-    /// encode null explicitly to distinguish a list with a null value
-    /// from a list with no values)
-    #[prost(bool, tag = "3")]
-    pub is_null: bool,
-    #[prost(message, optional, tag = "1")]
-    pub field: ::core::option::Option<Field>,
-    #[prost(message, repeated, tag = "2")]
-    pub values: ::prost::alloc::vec::Vec<ScalarValue>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarTime32Value {
-    #[prost(oneof = "scalar_time32_value::Value", tags = "1, 2")]
-    pub value: ::core::option::Option<scalar_time32_value::Value>,
-}
-/// Nested message and enum types in `ScalarTime32Value`.
-pub mod scalar_time32_value {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Value {
-        #[prost(int32, tag = "1")]
-        Time32SecondValue(i32),
-        #[prost(int32, tag = "2")]
-        Time32MillisecondValue(i32),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarTime64Value {
-    #[prost(oneof = "scalar_time64_value::Value", tags = "1, 2")]
-    pub value: ::core::option::Option<scalar_time64_value::Value>,
-}
-/// Nested message and enum types in `ScalarTime64Value`.
-pub mod scalar_time64_value {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Value {
-        #[prost(int64, tag = "1")]
-        Time64MicrosecondValue(i64),
-        #[prost(int64, tag = "2")]
-        Time64NanosecondValue(i64),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarTimestampValue {
-    #[prost(string, tag = "5")]
-    pub timezone: ::prost::alloc::string::String,
-    #[prost(oneof = "scalar_timestamp_value::Value", tags = "1, 2, 3, 4")]
-    pub value: ::core::option::Option<scalar_timestamp_value::Value>,
-}
-/// Nested message and enum types in `ScalarTimestampValue`.
-pub mod scalar_timestamp_value {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Value {
-        #[prost(int64, tag = "1")]
-        TimeMicrosecondValue(i64),
-        #[prost(int64, tag = "2")]
-        TimeNanosecondValue(i64),
-        #[prost(int64, tag = "3")]
-        TimeSecondValue(i64),
-        #[prost(int64, tag = "4")]
-        TimeMillisecondValue(i64),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarDictionaryValue {
-    #[prost(message, optional, tag = "1")]
-    pub index_type: ::core::option::Option<ArrowType>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub value: ::core::option::Option<::prost::alloc::boxed::Box<ScalarValue>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntervalMonthDayNanoValue {
-    #[prost(int32, tag = "1")]
-    pub months: i32,
-    #[prost(int32, tag = "2")]
-    pub days: i32,
-    #[prost(int64, tag = "3")]
-    pub nanos: i64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StructValue {
-    /// Note that a null struct value must have one or more fields, so we
-    /// encode a null StructValue as one witth an empty field_values
-    /// list.
-    #[prost(message, repeated, tag = "2")]
-    pub field_values: ::prost::alloc::vec::Vec<ScalarValue>,
-    #[prost(message, repeated, tag = "3")]
-    pub fields: ::prost::alloc::vec::Vec<Field>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarFixedSizeBinary {
-    #[prost(bytes = "vec", tag = "1")]
-    pub values: ::prost::alloc::vec::Vec<u8>,
-    #[prost(int32, tag = "2")]
-    pub length: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScalarValue {
-    #[prost(
-        oneof = "scalar_value::Value",
-        tags = "33, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 20, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34"
-    )]
-    pub value: ::core::option::Option<scalar_value::Value>,
-}
-/// Nested message and enum types in `ScalarValue`.
-pub mod scalar_value {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Value {
-        /// was PrimitiveScalarType null_value = 19;
-        /// Null value of any type
-        #[prost(message, tag = "33")]
-        NullValue(super::ArrowType),
-        #[prost(bool, tag = "1")]
-        BoolValue(bool),
-        #[prost(string, tag = "2")]
-        Utf8Value(::prost::alloc::string::String),
-        #[prost(string, tag = "3")]
-        LargeUtf8Value(::prost::alloc::string::String),
-        #[prost(int32, tag = "4")]
-        Int8Value(i32),
-        #[prost(int32, tag = "5")]
-        Int16Value(i32),
-        #[prost(int32, tag = "6")]
-        Int32Value(i32),
-        #[prost(int64, tag = "7")]
-        Int64Value(i64),
-        #[prost(uint32, tag = "8")]
-        Uint8Value(u32),
-        #[prost(uint32, tag = "9")]
-        Uint16Value(u32),
-        #[prost(uint32, tag = "10")]
-        Uint32Value(u32),
-        #[prost(uint64, tag = "11")]
-        Uint64Value(u64),
-        #[prost(float, tag = "12")]
-        Float32Value(f32),
-        #[prost(double, tag = "13")]
-        Float64Value(f64),
-        /// Literal Date32 value always has a unit of day
-        #[prost(int32, tag = "14")]
-        Date32Value(i32),
-        #[prost(message, tag = "15")]
-        Time32Value(super::ScalarTime32Value),
-        /// WAS: ScalarType null_list_value = 18;
-        #[prost(message, tag = "17")]
-        ListValue(super::ScalarListValue),
-        #[prost(message, tag = "20")]
-        Decimal128Value(super::Decimal128),
-        #[prost(int64, tag = "21")]
-        Date64Value(i64),
-        #[prost(int32, tag = "24")]
-        IntervalYearmonthValue(i32),
-        #[prost(int64, tag = "25")]
-        IntervalDaytimeValue(i64),
-        #[prost(message, tag = "26")]
-        TimestampValue(super::ScalarTimestampValue),
-        #[prost(message, tag = "27")]
-        DictionaryValue(::prost::alloc::boxed::Box<super::ScalarDictionaryValue>),
-        #[prost(bytes, tag = "28")]
-        BinaryValue(::prost::alloc::vec::Vec<u8>),
-        #[prost(bytes, tag = "29")]
-        LargeBinaryValue(::prost::alloc::vec::Vec<u8>),
-        #[prost(message, tag = "30")]
-        Time64Value(super::ScalarTime64Value),
-        #[prost(message, tag = "31")]
-        IntervalMonthDayNano(super::IntervalMonthDayNanoValue),
-        #[prost(message, tag = "32")]
-        StructValue(super::StructValue),
-        #[prost(message, tag = "34")]
-        FixedSizeBinaryValue(super::ScalarFixedSizeBinary),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Decimal128 {
-    #[prost(bytes = "vec", tag = "1")]
-    pub value: ::prost::alloc::vec::Vec<u8>,
-    #[prost(int64, tag = "2")]
-    pub p: i64,
-    #[prost(int64, tag = "3")]
-    pub s: i64,
-}
-/// Serialized data type
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ArrowType {
-    #[prost(
-        oneof = "arrow_type::ArrowTypeEnum",
-        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 32, 15, 16, 31, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 33"
-    )]
-    pub arrow_type_enum: ::core::option::Option<arrow_type::ArrowTypeEnum>,
-}
-/// Nested message and enum types in `ArrowType`.
-pub mod arrow_type {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum ArrowTypeEnum {
-        /// arrow::Type::NA
-        #[prost(message, tag = "1")]
-        None(super::EmptyMessage),
-        /// arrow::Type::BOOL
-        #[prost(message, tag = "2")]
-        Bool(super::EmptyMessage),
-        /// arrow::Type::UINT8
-        #[prost(message, tag = "3")]
-        Uint8(super::EmptyMessage),
-        /// arrow::Type::INT8
-        #[prost(message, tag = "4")]
-        Int8(super::EmptyMessage),
-        /// represents arrow::Type fields in src/arrow/type.h
-        #[prost(message, tag = "5")]
-        Uint16(super::EmptyMessage),
-        #[prost(message, tag = "6")]
-        Int16(super::EmptyMessage),
-        #[prost(message, tag = "7")]
-        Uint32(super::EmptyMessage),
-        #[prost(message, tag = "8")]
-        Int32(super::EmptyMessage),
-        #[prost(message, tag = "9")]
-        Uint64(super::EmptyMessage),
-        #[prost(message, tag = "10")]
-        Int64(super::EmptyMessage),
-        #[prost(message, tag = "11")]
-        Float16(super::EmptyMessage),
-        #[prost(message, tag = "12")]
-        Float32(super::EmptyMessage),
-        #[prost(message, tag = "13")]
-        Float64(super::EmptyMessage),
-        #[prost(message, tag = "14")]
-        Utf8(super::EmptyMessage),
-        #[prost(message, tag = "32")]
-        LargeUtf8(super::EmptyMessage),
-        #[prost(message, tag = "15")]
-        Binary(super::EmptyMessage),
-        #[prost(int32, tag = "16")]
-        FixedSizeBinary(i32),
-        #[prost(message, tag = "31")]
-        LargeBinary(super::EmptyMessage),
-        #[prost(message, tag = "17")]
-        Date32(super::EmptyMessage),
-        #[prost(message, tag = "18")]
-        Date64(super::EmptyMessage),
-        #[prost(enumeration = "super::TimeUnit", tag = "19")]
-        Duration(i32),
-        #[prost(message, tag = "20")]
-        Timestamp(super::Timestamp),
-        #[prost(enumeration = "super::TimeUnit", tag = "21")]
-        Time32(i32),
-        #[prost(enumeration = "super::TimeUnit", tag = "22")]
-        Time64(i32),
-        #[prost(enumeration = "super::IntervalUnit", tag = "23")]
-        Interval(i32),
-        #[prost(message, tag = "24")]
-        Decimal(super::Decimal),
-        #[prost(message, tag = "25")]
-        List(::prost::alloc::boxed::Box<super::List>),
-        #[prost(message, tag = "26")]
-        LargeList(::prost::alloc::boxed::Box<super::List>),
-        #[prost(message, tag = "27")]
-        FixedSizeList(::prost::alloc::boxed::Box<super::FixedSizeList>),
-        #[prost(message, tag = "28")]
-        Struct(super::Struct),
-        #[prost(message, tag = "29")]
-        Union(super::Union),
-        #[prost(message, tag = "30")]
-        Dictionary(::prost::alloc::boxed::Box<super::Dictionary>),
-        #[prost(message, tag = "33")]
-        Map(::prost::alloc::boxed::Box<super::Map>),
-    }
-}
-/// Useful for representing an empty enum variant in rust
-/// E.G. enum example{One, Two(i32)}
-/// maps to
-/// message example{
-///     oneof{
-///         EmptyMessage One = 1;
-///         i32 Two = 2;
-///    }
-/// }
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EmptyMessage {}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AnalyzedLogicalPlanType {
-    #[prost(string, tag = "1")]
-    pub analyzer_name: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct OptimizedLogicalPlanType {
-    #[prost(string, tag = "1")]
-    pub optimizer_name: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct OptimizedPhysicalPlanType {
-    #[prost(string, tag = "1")]
-    pub optimizer_name: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PlanType {
-    #[prost(oneof = "plan_type::PlanTypeEnum", tags = "1, 7, 8, 2, 3, 4, 5, 6")]
-    pub plan_type_enum: ::core::option::Option<plan_type::PlanTypeEnum>,
-}
-/// Nested message and enum types in `PlanType`.
-pub mod plan_type {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum PlanTypeEnum {
-        #[prost(message, tag = "1")]
-        InitialLogicalPlan(super::EmptyMessage),
-        #[prost(message, tag = "7")]
-        AnalyzedLogicalPlan(super::AnalyzedLogicalPlanType),
-        #[prost(message, tag = "8")]
-        FinalAnalyzedLogicalPlan(super::EmptyMessage),
-        #[prost(message, tag = "2")]
-        OptimizedLogicalPlan(super::OptimizedLogicalPlanType),
-        #[prost(message, tag = "3")]
-        FinalLogicalPlan(super::EmptyMessage),
-        #[prost(message, tag = "4")]
-        InitialPhysicalPlan(super::EmptyMessage),
-        #[prost(message, tag = "5")]
-        OptimizedPhysicalPlan(super::OptimizedPhysicalPlanType),
-        #[prost(message, tag = "6")]
-        FinalPhysicalPlan(super::EmptyMessage),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StringifiedPlan {
-    #[prost(message, optional, tag = "1")]
-    pub plan_type: ::core::option::Option<PlanType>,
-    #[prost(string, tag = "2")]
-    pub plan: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BareTableReference {
-    #[prost(string, tag = "1")]
-    pub table: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PartialTableReference {
-    #[prost(string, tag = "1")]
-    pub schema: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub table: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FullTableReference {
-    #[prost(string, tag = "1")]
-    pub catalog: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub schema: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub table: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct OwnedTableReference {
-    #[prost(oneof = "owned_table_reference::TableReferenceEnum", tags = "1, 2, 3")]
-    pub table_reference_enum: ::core::option::Option<
-        owned_table_reference::TableReferenceEnum,
-    >,
-}
-/// Nested message and enum types in `OwnedTableReference`.
-pub mod owned_table_reference {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum TableReferenceEnum {
-        #[prost(message, tag = "1")]
-        Bare(super::BareTableReference),
-        #[prost(message, tag = "2")]
-        Partial(super::PartialTableReference),
-        #[prost(message, tag = "3")]
-        Full(super::FullTableReference),
-    }
-}
-/// PhysicalPlanNode is a nested type
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalPlanNode {
-    #[prost(
-        oneof = "physical_plan_node::PhysicalPlanType",
-        tags = "1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21"
-    )]
-    pub physical_plan_type: ::core::option::Option<physical_plan_node::PhysicalPlanType>,
-}
-/// Nested message and enum types in `PhysicalPlanNode`.
-pub mod physical_plan_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum PhysicalPlanType {
-        #[prost(message, tag = "1")]
-        ParquetScan(super::ParquetScanExecNode),
-        #[prost(message, tag = "2")]
-        CsvScan(super::CsvScanExecNode),
-        #[prost(message, tag = "3")]
-        Empty(super::EmptyExecNode),
-        #[prost(message, tag = "4")]
-        Projection(::prost::alloc::boxed::Box<super::ProjectionExecNode>),
-        #[prost(message, tag = "6")]
-        GlobalLimit(::prost::alloc::boxed::Box<super::GlobalLimitExecNode>),
-        #[prost(message, tag = "7")]
-        LocalLimit(::prost::alloc::boxed::Box<super::LocalLimitExecNode>),
-        #[prost(message, tag = "8")]
-        Aggregate(::prost::alloc::boxed::Box<super::AggregateExecNode>),
-        #[prost(message, tag = "9")]
-        HashJoin(::prost::alloc::boxed::Box<super::HashJoinExecNode>),
-        #[prost(message, tag = "10")]
-        Sort(::prost::alloc::boxed::Box<super::SortExecNode>),
-        #[prost(message, tag = "11")]
-        CoalesceBatches(::prost::alloc::boxed::Box<super::CoalesceBatchesExecNode>),
-        #[prost(message, tag = "12")]
-        Filter(::prost::alloc::boxed::Box<super::FilterExecNode>),
-        #[prost(message, tag = "13")]
-        Merge(::prost::alloc::boxed::Box<super::CoalescePartitionsExecNode>),
-        #[prost(message, tag = "14")]
-        Repartition(::prost::alloc::boxed::Box<super::RepartitionExecNode>),
-        #[prost(message, tag = "15")]
-        Window(::prost::alloc::boxed::Box<super::WindowAggExecNode>),
-        #[prost(message, tag = "16")]
-        CrossJoin(::prost::alloc::boxed::Box<super::CrossJoinExecNode>),
-        #[prost(message, tag = "17")]
-        AvroScan(super::AvroScanExecNode),
-        #[prost(message, tag = "18")]
-        Extension(super::PhysicalExtensionNode),
-        #[prost(message, tag = "19")]
-        Union(super::UnionExecNode),
-        #[prost(message, tag = "20")]
-        Explain(super::ExplainExecNode),
-        #[prost(message, tag = "21")]
-        SortPreservingMerge(
-            ::prost::alloc::boxed::Box<super::SortPreservingMergeExecNode>,
-        ),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalExtensionNode {
-    #[prost(bytes = "vec", tag = "1")]
-    pub node: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, repeated, tag = "2")]
-    pub inputs: ::prost::alloc::vec::Vec<PhysicalPlanNode>,
-}
-/// physical expressions
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalExprNode {
-    #[prost(
-        oneof = "physical_expr_node::ExprType",
-        tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19"
-    )]
-    pub expr_type: ::core::option::Option<physical_expr_node::ExprType>,
-}
-/// Nested message and enum types in `PhysicalExprNode`.
-pub mod physical_expr_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum ExprType {
-        /// column references
-        #[prost(message, tag = "1")]
-        Column(super::PhysicalColumn),
-        #[prost(message, tag = "2")]
-        Literal(super::ScalarValue),
-        /// binary expressions
-        #[prost(message, tag = "3")]
-        BinaryExpr(::prost::alloc::boxed::Box<super::PhysicalBinaryExprNode>),
-        /// aggregate expressions
-        #[prost(message, tag = "4")]
-        AggregateExpr(super::PhysicalAggregateExprNode),
-        /// null checks
-        #[prost(message, tag = "5")]
-        IsNullExpr(::prost::alloc::boxed::Box<super::PhysicalIsNull>),
-        #[prost(message, tag = "6")]
-        IsNotNullExpr(::prost::alloc::boxed::Box<super::PhysicalIsNotNull>),
-        #[prost(message, tag = "7")]
-        NotExpr(::prost::alloc::boxed::Box<super::PhysicalNot>),
-        #[prost(message, tag = "8")]
-        Case(::prost::alloc::boxed::Box<super::PhysicalCaseNode>),
-        #[prost(message, tag = "9")]
-        Cast(::prost::alloc::boxed::Box<super::PhysicalCastNode>),
-        #[prost(message, tag = "10")]
-        Sort(::prost::alloc::boxed::Box<super::PhysicalSortExprNode>),
-        #[prost(message, tag = "11")]
-        Negative(::prost::alloc::boxed::Box<super::PhysicalNegativeNode>),
-        #[prost(message, tag = "12")]
-        InList(::prost::alloc::boxed::Box<super::PhysicalInListNode>),
-        #[prost(message, tag = "13")]
-        ScalarFunction(super::PhysicalScalarFunctionNode),
-        #[prost(message, tag = "14")]
-        TryCast(::prost::alloc::boxed::Box<super::PhysicalTryCastNode>),
-        /// window expressions
-        #[prost(message, tag = "15")]
-        WindowExpr(::prost::alloc::boxed::Box<super::PhysicalWindowExprNode>),
-        #[prost(message, tag = "16")]
-        ScalarUdf(super::PhysicalScalarUdfNode),
-        #[prost(message, tag = "17")]
-        DateTimeIntervalExpr(
-            ::prost::alloc::boxed::Box<super::PhysicalDateTimeIntervalExprNode>,
-        ),
-        #[prost(message, tag = "18")]
-        LikeExpr(::prost::alloc::boxed::Box<super::PhysicalLikeExprNode>),
-        #[prost(message, tag = "19")]
-        GetIndexedFieldExpr(
-            ::prost::alloc::boxed::Box<super::PhysicalGetIndexedFieldExprNode>,
-        ),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalScalarUdfNode {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "2")]
-    pub args: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(message, optional, tag = "4")]
-    pub return_type: ::core::option::Option<ArrowType>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalAggregateExprNode {
-    #[prost(message, repeated, tag = "2")]
-    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(message, repeated, tag = "5")]
-    pub ordering_req: ::prost::alloc::vec::Vec<PhysicalSortExprNode>,
-    #[prost(bool, tag = "3")]
-    pub distinct: bool,
-    #[prost(oneof = "physical_aggregate_expr_node::AggregateFunction", tags = "1, 4")]
-    pub aggregate_function: ::core::option::Option<
-        physical_aggregate_expr_node::AggregateFunction,
-    >,
-}
-/// Nested message and enum types in `PhysicalAggregateExprNode`.
-pub mod physical_aggregate_expr_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum AggregateFunction {
-        #[prost(enumeration = "super::AggregateFunction", tag = "1")]
-        AggrFunction(i32),
-        #[prost(string, tag = "4")]
-        UserDefinedAggrFunction(::prost::alloc::string::String),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalWindowExprNode {
-    #[prost(message, optional, boxed, tag = "4")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(oneof = "physical_window_expr_node::WindowFunction", tags = "1, 2")]
-    pub window_function: ::core::option::Option<
-        physical_window_expr_node::WindowFunction,
-    >,
-}
-/// Nested message and enum types in `PhysicalWindowExprNode`.
-pub mod physical_window_expr_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum WindowFunction {
-        #[prost(enumeration = "super::AggregateFunction", tag = "1")]
-        AggrFunction(i32),
-        /// udaf = 3
-        #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")]
-        BuiltInFunction(i32),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalIsNull {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalIsNotNull {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalNot {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalAliasNode {
-    #[prost(message, optional, tag = "1")]
-    pub expr: ::core::option::Option<PhysicalExprNode>,
-    #[prost(string, tag = "2")]
-    pub alias: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalBinaryExprNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub l: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub r: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(string, tag = "3")]
-    pub op: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalDateTimeIntervalExprNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub l: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub r: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(string, tag = "3")]
-    pub op: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalLikeExprNode {
-    #[prost(bool, tag = "1")]
-    pub negated: bool,
-    #[prost(bool, tag = "2")]
-    pub case_insensitive: bool,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, optional, boxed, tag = "4")]
-    pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalSortExprNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(bool, tag = "2")]
-    pub asc: bool,
-    #[prost(bool, tag = "3")]
-    pub nulls_first: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalWhenThen {
-    #[prost(message, optional, tag = "1")]
-    pub when_expr: ::core::option::Option<PhysicalExprNode>,
-    #[prost(message, optional, tag = "2")]
-    pub then_expr: ::core::option::Option<PhysicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalInListNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub list: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(bool, tag = "3")]
-    pub negated: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalCaseNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub when_then_expr: ::prost::alloc::vec::Vec<PhysicalWhenThen>,
-    #[prost(message, optional, boxed, tag = "3")]
-    pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalScalarFunctionNode {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(enumeration = "ScalarFunction", tag = "2")]
-    pub fun: i32,
-    #[prost(message, repeated, tag = "3")]
-    pub args: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(message, optional, tag = "4")]
-    pub return_type: ::core::option::Option<ArrowType>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalTryCastNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub arrow_type: ::core::option::Option<ArrowType>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalCastNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub arrow_type: ::core::option::Option<ArrowType>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalNegativeNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub expr: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FilterExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub expr: ::core::option::Option<PhysicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FileGroup {
-    #[prost(message, repeated, tag = "1")]
-    pub files: ::prost::alloc::vec::Vec<PartitionedFile>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ScanLimit {
-    /// wrap into a message to make it optional
-    #[prost(uint32, tag = "1")]
-    pub limit: u32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalSortExprNodeCollection {
-    #[prost(message, repeated, tag = "1")]
-    pub physical_sort_expr_nodes: ::prost::alloc::vec::Vec<PhysicalSortExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FileScanExecConf {
-    #[prost(message, repeated, tag = "1")]
-    pub file_groups: ::prost::alloc::vec::Vec<FileGroup>,
-    #[prost(message, optional, tag = "2")]
-    pub schema: ::core::option::Option<Schema>,
-    #[prost(uint32, repeated, tag = "4")]
-    pub projection: ::prost::alloc::vec::Vec<u32>,
-    #[prost(message, optional, tag = "5")]
-    pub limit: ::core::option::Option<ScanLimit>,
-    #[prost(message, optional, tag = "6")]
-    pub statistics: ::core::option::Option<Statistics>,
-    #[prost(string, repeated, tag = "7")]
-    pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(string, tag = "8")]
-    pub object_store_url: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag = "9")]
-    pub output_ordering: ::prost::alloc::vec::Vec<PhysicalSortExprNodeCollection>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ParquetScanExecNode {
-    #[prost(message, optional, tag = "1")]
-    pub base_conf: ::core::option::Option<FileScanExecConf>,
-    #[prost(message, optional, tag = "3")]
-    pub predicate: ::core::option::Option<PhysicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CsvScanExecNode {
-    #[prost(message, optional, tag = "1")]
-    pub base_conf: ::core::option::Option<FileScanExecConf>,
-    #[prost(bool, tag = "2")]
-    pub has_header: bool,
-    #[prost(string, tag = "3")]
-    pub delimiter: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AvroScanExecNode {
-    #[prost(message, optional, tag = "1")]
-    pub base_conf: ::core::option::Option<FileScanExecConf>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct HashJoinExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub left: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub right: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, repeated, tag = "3")]
-    pub on: ::prost::alloc::vec::Vec<JoinOn>,
-    #[prost(enumeration = "JoinType", tag = "4")]
-    pub join_type: i32,
-    #[prost(enumeration = "PartitionMode", tag = "6")]
-    pub partition_mode: i32,
-    #[prost(bool, tag = "7")]
-    pub null_equals_null: bool,
-    #[prost(message, optional, tag = "8")]
-    pub filter: ::core::option::Option<JoinFilter>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct UnionExecNode {
-    #[prost(message, repeated, tag = "1")]
-    pub inputs: ::prost::alloc::vec::Vec<PhysicalPlanNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ExplainExecNode {
-    #[prost(message, optional, tag = "1")]
-    pub schema: ::core::option::Option<Schema>,
-    #[prost(message, repeated, tag = "2")]
-    pub stringified_plans: ::prost::alloc::vec::Vec<StringifiedPlan>,
-    #[prost(bool, tag = "3")]
-    pub verbose: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CrossJoinExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub left: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, optional, boxed, tag = "2")]
-    pub right: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalColumn {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(uint32, tag = "2")]
-    pub index: u32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct JoinOn {
-    #[prost(message, optional, tag = "1")]
-    pub left: ::core::option::Option<PhysicalColumn>,
-    #[prost(message, optional, tag = "2")]
-    pub right: ::core::option::Option<PhysicalColumn>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EmptyExecNode {
-    #[prost(bool, tag = "1")]
-    pub produce_one_row: bool,
-    #[prost(message, optional, tag = "2")]
-    pub schema: ::core::option::Option<Schema>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ProjectionExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(string, repeated, tag = "3")]
-    pub expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct WindowAggExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub window_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(string, repeated, tag = "3")]
-    pub window_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(message, optional, tag = "4")]
-    pub input_schema: ::core::option::Option<Schema>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MaybeFilter {
-    #[prost(message, optional, tag = "1")]
-    pub expr: ::core::option::Option<PhysicalExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct MaybePhysicalSortExprs {
-    #[prost(message, repeated, tag = "1")]
-    pub sort_expr: ::prost::alloc::vec::Vec<PhysicalSortExprNode>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AggregateExecNode {
-    #[prost(message, repeated, tag = "1")]
-    pub group_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(message, repeated, tag = "2")]
-    pub aggr_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(enumeration = "AggregateMode", tag = "3")]
-    pub mode: i32,
-    #[prost(message, optional, boxed, tag = "4")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(string, repeated, tag = "5")]
-    pub group_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(string, repeated, tag = "6")]
-    pub aggr_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    /// we need the input schema to the partial aggregate to pass to the final aggregate
-    #[prost(message, optional, tag = "7")]
-    pub input_schema: ::core::option::Option<Schema>,
-    #[prost(message, repeated, tag = "8")]
-    pub null_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(bool, repeated, tag = "9")]
-    pub groups: ::prost::alloc::vec::Vec<bool>,
-    #[prost(message, repeated, tag = "10")]
-    pub filter_expr: ::prost::alloc::vec::Vec<MaybeFilter>,
-    #[prost(message, repeated, tag = "11")]
-    pub order_by_expr: ::prost::alloc::vec::Vec<MaybePhysicalSortExprs>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GlobalLimitExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    /// The number of rows to skip before fetch
-    #[prost(uint32, tag = "2")]
-    pub skip: u32,
-    /// Maximum number of rows to fetch; negative means no limit
-    #[prost(int64, tag = "3")]
-    pub fetch: i64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct LocalLimitExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(uint32, tag = "2")]
-    pub fetch: u32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SortExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    /// Maximum number of highest/lowest rows to fetch; negative means no limit
-    #[prost(int64, tag = "3")]
-    pub fetch: i64,
-    #[prost(bool, tag = "4")]
-    pub preserve_partitioning: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct SortPreservingMergeExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(message, repeated, tag = "2")]
-    pub expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    /// Maximum number of highest/lowest rows to fetch; negative means no limit
-    #[prost(int64, tag = "3")]
-    pub fetch: i64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CoalesceBatchesExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(uint32, tag = "2")]
-    pub target_batch_size: u32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CoalescePartitionsExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalHashRepartition {
-    #[prost(message, repeated, tag = "1")]
-    pub hash_expr: ::prost::alloc::vec::Vec<PhysicalExprNode>,
-    #[prost(uint64, tag = "2")]
-    pub partition_count: u64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct RepartitionExecNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub input: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalPlanNode>>,
-    #[prost(oneof = "repartition_exec_node::PartitionMethod", tags = "2, 3, 4")]
-    pub partition_method: ::core::option::Option<repartition_exec_node::PartitionMethod>,
-}
-/// Nested message and enum types in `RepartitionExecNode`.
-pub mod repartition_exec_node {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum PartitionMethod {
-        #[prost(uint64, tag = "2")]
-        RoundRobin(u64),
-        #[prost(message, tag = "3")]
-        Hash(super::PhysicalHashRepartition),
-        #[prost(uint64, tag = "4")]
-        Unknown(u64),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct JoinFilter {
-    #[prost(message, optional, tag = "1")]
-    pub expression: ::core::option::Option<PhysicalExprNode>,
-    #[prost(message, repeated, tag = "2")]
-    pub column_indices: ::prost::alloc::vec::Vec<ColumnIndex>,
-    #[prost(message, optional, tag = "3")]
-    pub schema: ::core::option::Option<Schema>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ColumnIndex {
-    #[prost(uint32, tag = "1")]
-    pub index: u32,
-    #[prost(enumeration = "JoinSide", tag = "2")]
-    pub side: i32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PartitionedFile {
-    #[prost(string, tag = "1")]
-    pub path: ::prost::alloc::string::String,
-    #[prost(uint64, tag = "2")]
-    pub size: u64,
-    #[prost(uint64, tag = "3")]
-    pub last_modified_ns: u64,
-    #[prost(message, repeated, tag = "4")]
-    pub partition_values: ::prost::alloc::vec::Vec<ScalarValue>,
-    #[prost(message, optional, tag = "5")]
-    pub range: ::core::option::Option<FileRange>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct FileRange {
-    #[prost(int64, tag = "1")]
-    pub start: i64,
-    #[prost(int64, tag = "2")]
-    pub end: i64,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PartitionStats {
-    #[prost(int64, tag = "1")]
-    pub num_rows: i64,
-    #[prost(int64, tag = "2")]
-    pub num_batches: i64,
-    #[prost(int64, tag = "3")]
-    pub num_bytes: i64,
-    #[prost(message, repeated, tag = "4")]
-    pub column_stats: ::prost::alloc::vec::Vec<ColumnStats>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Statistics {
-    #[prost(int64, tag = "1")]
-    pub num_rows: i64,
-    #[prost(int64, tag = "2")]
-    pub total_byte_size: i64,
-    #[prost(message, repeated, tag = "3")]
-    pub column_stats: ::prost::alloc::vec::Vec<ColumnStats>,
-    #[prost(bool, tag = "4")]
-    pub is_exact: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ColumnStats {
-    #[prost(message, optional, tag = "1")]
-    pub min_value: ::core::option::Option<ScalarValue>,
-    #[prost(message, optional, tag = "2")]
-    pub max_value: ::core::option::Option<ScalarValue>,
-    #[prost(uint32, tag = "3")]
-    pub null_count: u32,
-    #[prost(uint32, tag = "4")]
-    pub distinct_count: u32,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct PhysicalGetIndexedFieldExprNode {
-    #[prost(message, optional, boxed, tag = "1")]
-    pub arg: ::core::option::Option<::prost::alloc::boxed::Box<PhysicalExprNode>>,
-    #[prost(message, optional, tag = "2")]
-    pub key: ::core::option::Option<ScalarValue>,
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum JoinType {
-    Inner = 0,
-    Left = 1,
-    Right = 2,
-    Full = 3,
-    Leftsemi = 4,
-    Leftanti = 5,
-    Rightsemi = 6,
-    Rightanti = 7,
-}
-impl JoinType {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            JoinType::Inner => "INNER",
-            JoinType::Left => "LEFT",
-            JoinType::Right => "RIGHT",
-            JoinType::Full => "FULL",
-            JoinType::Leftsemi => "LEFTSEMI",
-            JoinType::Leftanti => "LEFTANTI",
-            JoinType::Rightsemi => "RIGHTSEMI",
-            JoinType::Rightanti => "RIGHTANTI",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "INNER" => Some(Self::Inner),
-            "LEFT" => Some(Self::Left),
-            "RIGHT" => Some(Self::Right),
-            "FULL" => Some(Self::Full),
-            "LEFTSEMI" => Some(Self::Leftsemi),
-            "LEFTANTI" => Some(Self::Leftanti),
-            "RIGHTSEMI" => Some(Self::Rightsemi),
-            "RIGHTANTI" => Some(Self::Rightanti),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum JoinConstraint {
-    On = 0,
-    Using = 1,
-}
-impl JoinConstraint {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            JoinConstraint::On => "ON",
-            JoinConstraint::Using => "USING",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "ON" => Some(Self::On),
-            "USING" => Some(Self::Using),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum ScalarFunction {
-    Abs = 0,
-    Acos = 1,
-    Asin = 2,
-    Atan = 3,
-    Ascii = 4,
-    Ceil = 5,
-    Cos = 6,
-    Digest = 7,
-    Exp = 8,
-    Floor = 9,
-    Ln = 10,
-    Log = 11,
-    Log10 = 12,
-    Log2 = 13,
-    Round = 14,
-    Signum = 15,
-    Sin = 16,
-    Sqrt = 17,
-    Tan = 18,
-    Trunc = 19,
-    Array = 20,
-    RegexpMatch = 21,
-    BitLength = 22,
-    Btrim = 23,
-    CharacterLength = 24,
-    Chr = 25,
-    Concat = 26,
-    ConcatWithSeparator = 27,
-    DatePart = 28,
-    DateTrunc = 29,
-    InitCap = 30,
-    Left = 31,
-    Lpad = 32,
-    Lower = 33,
-    Ltrim = 34,
-    Md5 = 35,
-    NullIf = 36,
-    OctetLength = 37,
-    Random = 38,
-    RegexpReplace = 39,
-    Repeat = 40,
-    Replace = 41,
-    Reverse = 42,
-    Right = 43,
-    Rpad = 44,
-    Rtrim = 45,
-    Sha224 = 46,
-    Sha256 = 47,
-    Sha384 = 48,
-    Sha512 = 49,
-    SplitPart = 50,
-    StartsWith = 51,
-    Strpos = 52,
-    Substr = 53,
-    ToHex = 54,
-    ToTimestamp = 55,
-    ToTimestampMillis = 56,
-    ToTimestampMicros = 57,
-    ToTimestampSeconds = 58,
-    Now = 59,
-    Translate = 60,
-    Trim = 61,
-    Upper = 62,
-    Coalesce = 63,
-    Power = 64,
-    StructFun = 65,
-    FromUnixtime = 66,
-    Atan2 = 67,
-    DateBin = 68,
-    ArrowTypeof = 69,
-    CurrentDate = 70,
-    CurrentTime = 71,
-    Uuid = 72,
-    Cbrt = 73,
-    Acosh = 74,
-    Asinh = 75,
-    Atanh = 76,
-    Sinh = 77,
-    Cosh = 78,
-    Tanh = 79,
-    Pi = 80,
-    Degrees = 81,
-    Radians = 82,
-    Factorial = 83,
-    Lcm = 84,
-    Gcd = 85,
-    ArrayAppend = 86,
-    ArrayConcat = 87,
-    ArrayDims = 88,
-    ArrayFill = 89,
-    ArrayLength = 90,
-    ArrayNdims = 91,
-    ArrayPosition = 92,
-    ArrayPositions = 93,
-    ArrayPrepend = 94,
-    ArrayRemove = 95,
-    ArrayReplace = 96,
-    ArrayToString = 97,
-    Cardinality = 98,
-    TrimArray = 99,
-    ArrayContains = 100,
-}
-impl ScalarFunction {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            ScalarFunction::Abs => "Abs",
-            ScalarFunction::Acos => "Acos",
-            ScalarFunction::Asin => "Asin",
-            ScalarFunction::Atan => "Atan",
-            ScalarFunction::Ascii => "Ascii",
-            ScalarFunction::Ceil => "Ceil",
-            ScalarFunction::Cos => "Cos",
-            ScalarFunction::Digest => "Digest",
-            ScalarFunction::Exp => "Exp",
-            ScalarFunction::Floor => "Floor",
-            ScalarFunction::Ln => "Ln",
-            ScalarFunction::Log => "Log",
-            ScalarFunction::Log10 => "Log10",
-            ScalarFunction::Log2 => "Log2",
-            ScalarFunction::Round => "Round",
-            ScalarFunction::Signum => "Signum",
-            ScalarFunction::Sin => "Sin",
-            ScalarFunction::Sqrt => "Sqrt",
-            ScalarFunction::Tan => "Tan",
-            ScalarFunction::Trunc => "Trunc",
-            ScalarFunction::Array => "Array",
-            ScalarFunction::RegexpMatch => "RegexpMatch",
-            ScalarFunction::BitLength => "BitLength",
-            ScalarFunction::Btrim => "Btrim",
-            ScalarFunction::CharacterLength => "CharacterLength",
-            ScalarFunction::Chr => "Chr",
-            ScalarFunction::Concat => "Concat",
-            ScalarFunction::ConcatWithSeparator => "ConcatWithSeparator",
-            ScalarFunction::DatePart => "DatePart",
-            ScalarFunction::DateTrunc => "DateTrunc",
-            ScalarFunction::InitCap => "InitCap",
-            ScalarFunction::Left => "Left",
-            ScalarFunction::Lpad => "Lpad",
-            ScalarFunction::Lower => "Lower",
-            ScalarFunction::Ltrim => "Ltrim",
-            ScalarFunction::Md5 => "MD5",
-            ScalarFunction::NullIf => "NullIf",
-            ScalarFunction::OctetLength => "OctetLength",
-            ScalarFunction::Random => "Random",
-            ScalarFunction::RegexpReplace => "RegexpReplace",
-            ScalarFunction::Repeat => "Repeat",
-            ScalarFunction::Replace => "Replace",
-            ScalarFunction::Reverse => "Reverse",
-            ScalarFunction::Right => "Right",
-            ScalarFunction::Rpad => "Rpad",
-            ScalarFunction::Rtrim => "Rtrim",
-            ScalarFunction::Sha224 => "SHA224",
-            ScalarFunction::Sha256 => "SHA256",
-            ScalarFunction::Sha384 => "SHA384",
-            ScalarFunction::Sha512 => "SHA512",
-            ScalarFunction::SplitPart => "SplitPart",
-            ScalarFunction::StartsWith => "StartsWith",
-            ScalarFunction::Strpos => "Strpos",
-            ScalarFunction::Substr => "Substr",
-            ScalarFunction::ToHex => "ToHex",
-            ScalarFunction::ToTimestamp => "ToTimestamp",
-            ScalarFunction::ToTimestampMillis => "ToTimestampMillis",
-            ScalarFunction::ToTimestampMicros => "ToTimestampMicros",
-            ScalarFunction::ToTimestampSeconds => "ToTimestampSeconds",
-            ScalarFunction::Now => "Now",
-            ScalarFunction::Translate => "Translate",
-            ScalarFunction::Trim => "Trim",
-            ScalarFunction::Upper => "Upper",
-            ScalarFunction::Coalesce => "Coalesce",
-            ScalarFunction::Power => "Power",
-            ScalarFunction::StructFun => "StructFun",
-            ScalarFunction::FromUnixtime => "FromUnixtime",
-            ScalarFunction::Atan2 => "Atan2",
-            ScalarFunction::DateBin => "DateBin",
-            ScalarFunction::ArrowTypeof => "ArrowTypeof",
-            ScalarFunction::CurrentDate => "CurrentDate",
-            ScalarFunction::CurrentTime => "CurrentTime",
-            ScalarFunction::Uuid => "Uuid",
-            ScalarFunction::Cbrt => "Cbrt",
-            ScalarFunction::Acosh => "Acosh",
-            ScalarFunction::Asinh => "Asinh",
-            ScalarFunction::Atanh => "Atanh",
-            ScalarFunction::Sinh => "Sinh",
-            ScalarFunction::Cosh => "Cosh",
-            ScalarFunction::Tanh => "Tanh",
-            ScalarFunction::Pi => "Pi",
-            ScalarFunction::Degrees => "Degrees",
-            ScalarFunction::Radians => "Radians",
-            ScalarFunction::Factorial => "Factorial",
-            ScalarFunction::Lcm => "Lcm",
-            ScalarFunction::Gcd => "Gcd",
-            ScalarFunction::ArrayAppend => "ArrayAppend",
-            ScalarFunction::ArrayConcat => "ArrayConcat",
-            ScalarFunction::ArrayDims => "ArrayDims",
-            ScalarFunction::ArrayFill => "ArrayFill",
-            ScalarFunction::ArrayLength => "ArrayLength",
-            ScalarFunction::ArrayNdims => "ArrayNdims",
-            ScalarFunction::ArrayPosition => "ArrayPosition",
-            ScalarFunction::ArrayPositions => "ArrayPositions",
-            ScalarFunction::ArrayPrepend => "ArrayPrepend",
-            ScalarFunction::ArrayRemove => "ArrayRemove",
-            ScalarFunction::ArrayReplace => "ArrayReplace",
-            ScalarFunction::ArrayToString => "ArrayToString",
-            ScalarFunction::Cardinality => "Cardinality",
-            ScalarFunction::TrimArray => "TrimArray",
-            ScalarFunction::ArrayContains => "ArrayContains",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "Abs" => Some(Self::Abs),
-            "Acos" => Some(Self::Acos),
-            "Asin" => Some(Self::Asin),
-            "Atan" => Some(Self::Atan),
-            "Ascii" => Some(Self::Ascii),
-            "Ceil" => Some(Self::Ceil),
-            "Cos" => Some(Self::Cos),
-            "Digest" => Some(Self::Digest),
-            "Exp" => Some(Self::Exp),
-            "Floor" => Some(Self::Floor),
-            "Ln" => Some(Self::Ln),
-            "Log" => Some(Self::Log),
-            "Log10" => Some(Self::Log10),
-            "Log2" => Some(Self::Log2),
-            "Round" => Some(Self::Round),
-            "Signum" => Some(Self::Signum),
-            "Sin" => Some(Self::Sin),
-            "Sqrt" => Some(Self::Sqrt),
-            "Tan" => Some(Self::Tan),
-            "Trunc" => Some(Self::Trunc),
-            "Array" => Some(Self::Array),
-            "RegexpMatch" => Some(Self::RegexpMatch),
-            "BitLength" => Some(Self::BitLength),
-            "Btrim" => Some(Self::Btrim),
-            "CharacterLength" => Some(Self::CharacterLength),
-            "Chr" => Some(Self::Chr),
-            "Concat" => Some(Self::Concat),
-            "ConcatWithSeparator" => Some(Self::ConcatWithSeparator),
-            "DatePart" => Some(Self::DatePart),
-            "DateTrunc" => Some(Self::DateTrunc),
-            "InitCap" => Some(Self::InitCap),
-            "Left" => Some(Self::Left),
-            "Lpad" => Some(Self::Lpad),
-            "Lower" => Some(Self::Lower),
-            "Ltrim" => Some(Self::Ltrim),
-            "MD5" => Some(Self::Md5),
-            "NullIf" => Some(Self::NullIf),
-            "OctetLength" => Some(Self::OctetLength),
-            "Random" => Some(Self::Random),
-            "RegexpReplace" => Some(Self::RegexpReplace),
-            "Repeat" => Some(Self::Repeat),
-            "Replace" => Some(Self::Replace),
-            "Reverse" => Some(Self::Reverse),
-            "Right" => Some(Self::Right),
-            "Rpad" => Some(Self::Rpad),
-            "Rtrim" => Some(Self::Rtrim),
-            "SHA224" => Some(Self::Sha224),
-            "SHA256" => Some(Self::Sha256),
-            "SHA384" => Some(Self::Sha384),
-            "SHA512" => Some(Self::Sha512),
-            "SplitPart" => Some(Self::SplitPart),
-            "StartsWith" => Some(Self::StartsWith),
-            "Strpos" => Some(Self::Strpos),
-            "Substr" => Some(Self::Substr),
-            "ToHex" => Some(Self::ToHex),
-            "ToTimestamp" => Some(Self::ToTimestamp),
-            "ToTimestampMillis" => Some(Self::ToTimestampMillis),
-            "ToTimestampMicros" => Some(Self::ToTimestampMicros),
-            "ToTimestampSeconds" => Some(Self::ToTimestampSeconds),
-            "Now" => Some(Self::Now),
-            "Translate" => Some(Self::Translate),
-            "Trim" => Some(Self::Trim),
-            "Upper" => Some(Self::Upper),
-            "Coalesce" => Some(Self::Coalesce),
-            "Power" => Some(Self::Power),
-            "StructFun" => Some(Self::StructFun),
-            "FromUnixtime" => Some(Self::FromUnixtime),
-            "Atan2" => Some(Self::Atan2),
-            "DateBin" => Some(Self::DateBin),
-            "ArrowTypeof" => Some(Self::ArrowTypeof),
-            "CurrentDate" => Some(Self::CurrentDate),
-            "CurrentTime" => Some(Self::CurrentTime),
-            "Uuid" => Some(Self::Uuid),
-            "Cbrt" => Some(Self::Cbrt),
-            "Acosh" => Some(Self::Acosh),
-            "Asinh" => Some(Self::Asinh),
-            "Atanh" => Some(Self::Atanh),
-            "Sinh" => Some(Self::Sinh),
-            "Cosh" => Some(Self::Cosh),
-            "Tanh" => Some(Self::Tanh),
-            "Pi" => Some(Self::Pi),
-            "Degrees" => Some(Self::Degrees),
-            "Radians" => Some(Self::Radians),
-            "Factorial" => Some(Self::Factorial),
-            "Lcm" => Some(Self::Lcm),
-            "Gcd" => Some(Self::Gcd),
-            "ArrayAppend" => Some(Self::ArrayAppend),
-            "ArrayConcat" => Some(Self::ArrayConcat),
-            "ArrayDims" => Some(Self::ArrayDims),
-            "ArrayFill" => Some(Self::ArrayFill),
-            "ArrayLength" => Some(Self::ArrayLength),
-            "ArrayNdims" => Some(Self::ArrayNdims),
-            "ArrayPosition" => Some(Self::ArrayPosition),
-            "ArrayPositions" => Some(Self::ArrayPositions),
-            "ArrayPrepend" => Some(Self::ArrayPrepend),
-            "ArrayRemove" => Some(Self::ArrayRemove),
-            "ArrayReplace" => Some(Self::ArrayReplace),
-            "ArrayToString" => Some(Self::ArrayToString),
-            "Cardinality" => Some(Self::Cardinality),
-            "TrimArray" => Some(Self::TrimArray),
-            "ArrayContains" => Some(Self::ArrayContains),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum AggregateFunction {
-    Min = 0,
-    Max = 1,
-    Sum = 2,
-    Avg = 3,
-    Count = 4,
-    ApproxDistinct = 5,
-    ArrayAgg = 6,
-    Variance = 7,
-    VariancePop = 8,
-    Covariance = 9,
-    CovariancePop = 10,
-    Stddev = 11,
-    StddevPop = 12,
-    Correlation = 13,
-    ApproxPercentileCont = 14,
-    ApproxMedian = 15,
-    ApproxPercentileContWithWeight = 16,
-    Grouping = 17,
-    Median = 18,
-    BitAnd = 19,
-    BitOr = 20,
-    BitXor = 21,
-    BoolAnd = 22,
-    BoolOr = 23,
-    /// When a function with the same name exists among built-in window functions,
-    /// we append "_AGG" to obey name scoping rules.
-    FirstValueAgg = 24,
-    LastValueAgg = 25,
-}
-impl AggregateFunction {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            AggregateFunction::Min => "MIN",
-            AggregateFunction::Max => "MAX",
-            AggregateFunction::Sum => "SUM",
-            AggregateFunction::Avg => "AVG",
-            AggregateFunction::Count => "COUNT",
-            AggregateFunction::ApproxDistinct => "APPROX_DISTINCT",
-            AggregateFunction::ArrayAgg => "ARRAY_AGG",
-            AggregateFunction::Variance => "VARIANCE",
-            AggregateFunction::VariancePop => "VARIANCE_POP",
-            AggregateFunction::Covariance => "COVARIANCE",
-            AggregateFunction::CovariancePop => "COVARIANCE_POP",
-            AggregateFunction::Stddev => "STDDEV",
-            AggregateFunction::StddevPop => "STDDEV_POP",
-            AggregateFunction::Correlation => "CORRELATION",
-            AggregateFunction::ApproxPercentileCont => "APPROX_PERCENTILE_CONT",
-            AggregateFunction::ApproxMedian => "APPROX_MEDIAN",
-            AggregateFunction::ApproxPercentileContWithWeight => {
-                "APPROX_PERCENTILE_CONT_WITH_WEIGHT"
-            }
-            AggregateFunction::Grouping => "GROUPING",
-            AggregateFunction::Median => "MEDIAN",
-            AggregateFunction::BitAnd => "BIT_AND",
-            AggregateFunction::BitOr => "BIT_OR",
-            AggregateFunction::BitXor => "BIT_XOR",
-            AggregateFunction::BoolAnd => "BOOL_AND",
-            AggregateFunction::BoolOr => "BOOL_OR",
-            AggregateFunction::FirstValueAgg => "FIRST_VALUE_AGG",
-            AggregateFunction::LastValueAgg => "LAST_VALUE_AGG",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "MIN" => Some(Self::Min),
-            "MAX" => Some(Self::Max),
-            "SUM" => Some(Self::Sum),
-            "AVG" => Some(Self::Avg),
-            "COUNT" => Some(Self::Count),
-            "APPROX_DISTINCT" => Some(Self::ApproxDistinct),
-            "ARRAY_AGG" => Some(Self::ArrayAgg),
-            "VARIANCE" => Some(Self::Variance),
-            "VARIANCE_POP" => Some(Self::VariancePop),
-            "COVARIANCE" => Some(Self::Covariance),
-            "COVARIANCE_POP" => Some(Self::CovariancePop),
-            "STDDEV" => Some(Self::Stddev),
-            "STDDEV_POP" => Some(Self::StddevPop),
-            "CORRELATION" => Some(Self::Correlation),
-            "APPROX_PERCENTILE_CONT" => Some(Self::ApproxPercentileCont),
-            "APPROX_MEDIAN" => Some(Self::ApproxMedian),
-            "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => {
-                Some(Self::ApproxPercentileContWithWeight)
-            }
-            "GROUPING" => Some(Self::Grouping),
-            "MEDIAN" => Some(Self::Median),
-            "BIT_AND" => Some(Self::BitAnd),
-            "BIT_OR" => Some(Self::BitOr),
-            "BIT_XOR" => Some(Self::BitXor),
-            "BOOL_AND" => Some(Self::BoolAnd),
-            "BOOL_OR" => Some(Self::BoolOr),
-            "FIRST_VALUE_AGG" => Some(Self::FirstValueAgg),
-            "LAST_VALUE_AGG" => Some(Self::LastValueAgg),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum BuiltInWindowFunction {
-    RowNumber = 0,
-    Rank = 1,
-    DenseRank = 2,
-    PercentRank = 3,
-    CumeDist = 4,
-    Ntile = 5,
-    Lag = 6,
-    Lead = 7,
-    FirstValue = 8,
-    LastValue = 9,
-    NthValue = 10,
-}
-impl BuiltInWindowFunction {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            BuiltInWindowFunction::RowNumber => "ROW_NUMBER",
-            BuiltInWindowFunction::Rank => "RANK",
-            BuiltInWindowFunction::DenseRank => "DENSE_RANK",
-            BuiltInWindowFunction::PercentRank => "PERCENT_RANK",
-            BuiltInWindowFunction::CumeDist => "CUME_DIST",
-            BuiltInWindowFunction::Ntile => "NTILE",
-            BuiltInWindowFunction::Lag => "LAG",
-            BuiltInWindowFunction::Lead => "LEAD",
-            BuiltInWindowFunction::FirstValue => "FIRST_VALUE",
-            BuiltInWindowFunction::LastValue => "LAST_VALUE",
-            BuiltInWindowFunction::NthValue => "NTH_VALUE",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "ROW_NUMBER" => Some(Self::RowNumber),
-            "RANK" => Some(Self::Rank),
-            "DENSE_RANK" => Some(Self::DenseRank),
-            "PERCENT_RANK" => Some(Self::PercentRank),
-            "CUME_DIST" => Some(Self::CumeDist),
-            "NTILE" => Some(Self::Ntile),
-            "LAG" => Some(Self::Lag),
-            "LEAD" => Some(Self::Lead),
-            "FIRST_VALUE" => Some(Self::FirstValue),
-            "LAST_VALUE" => Some(Self::LastValue),
-            "NTH_VALUE" => Some(Self::NthValue),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum WindowFrameUnits {
-    Rows = 0,
-    Range = 1,
-    Groups = 2,
-}
-impl WindowFrameUnits {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            WindowFrameUnits::Rows => "ROWS",
-            WindowFrameUnits::Range => "RANGE",
-            WindowFrameUnits::Groups => "GROUPS",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "ROWS" => Some(Self::Rows),
-            "RANGE" => Some(Self::Range),
-            "GROUPS" => Some(Self::Groups),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum WindowFrameBoundType {
-    CurrentRow = 0,
-    Preceding = 1,
-    Following = 2,
-}
-impl WindowFrameBoundType {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            WindowFrameBoundType::CurrentRow => "CURRENT_ROW",
-            WindowFrameBoundType::Preceding => "PRECEDING",
-            WindowFrameBoundType::Following => "FOLLOWING",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "CURRENT_ROW" => Some(Self::CurrentRow),
-            "PRECEDING" => Some(Self::Preceding),
-            "FOLLOWING" => Some(Self::Following),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum DateUnit {
-    Day = 0,
-    DateMillisecond = 1,
-}
-impl DateUnit {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            DateUnit::Day => "Day",
-            DateUnit::DateMillisecond => "DateMillisecond",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "Day" => Some(Self::Day),
-            "DateMillisecond" => Some(Self::DateMillisecond),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum TimeUnit {
-    Second = 0,
-    Millisecond = 1,
-    Microsecond = 2,
-    Nanosecond = 3,
-}
-impl TimeUnit {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            TimeUnit::Second => "Second",
-            TimeUnit::Millisecond => "Millisecond",
-            TimeUnit::Microsecond => "Microsecond",
-            TimeUnit::Nanosecond => "Nanosecond",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "Second" => Some(Self::Second),
-            "Millisecond" => Some(Self::Millisecond),
-            "Microsecond" => Some(Self::Microsecond),
-            "Nanosecond" => Some(Self::Nanosecond),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum IntervalUnit {
-    YearMonth = 0,
-    DayTime = 1,
-    MonthDayNano = 2,
-}
-impl IntervalUnit {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            IntervalUnit::YearMonth => "YearMonth",
-            IntervalUnit::DayTime => "DayTime",
-            IntervalUnit::MonthDayNano => "MonthDayNano",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "YearMonth" => Some(Self::YearMonth),
-            "DayTime" => Some(Self::DayTime),
-            "MonthDayNano" => Some(Self::MonthDayNano),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum UnionMode {
-    Sparse = 0,
-    Dense = 1,
-}
-impl UnionMode {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            UnionMode::Sparse => "sparse",
-            UnionMode::Dense => "dense",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "sparse" => Some(Self::Sparse),
-            "dense" => Some(Self::Dense),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum PartitionMode {
-    CollectLeft = 0,
-    Partitioned = 1,
-    Auto = 2,
-}
-impl PartitionMode {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            PartitionMode::CollectLeft => "COLLECT_LEFT",
-            PartitionMode::Partitioned => "PARTITIONED",
-            PartitionMode::Auto => "AUTO",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "COLLECT_LEFT" => Some(Self::CollectLeft),
-            "PARTITIONED" => Some(Self::Partitioned),
-            "AUTO" => Some(Self::Auto),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum AggregateMode {
-    Partial = 0,
-    Final = 1,
-    FinalPartitioned = 2,
-    Single = 3,
-}
-impl AggregateMode {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            AggregateMode::Partial => "PARTIAL",
-            AggregateMode::Final => "FINAL",
-            AggregateMode::FinalPartitioned => "FINAL_PARTITIONED",
-            AggregateMode::Single => "SINGLE",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "PARTIAL" => Some(Self::Partial),
-            "FINAL" => Some(Self::Final),
-            "FINAL_PARTITIONED" => Some(Self::FinalPartitioned),
-            "SINGLE" => Some(Self::Single),
-            _ => None,
-        }
-    }
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum JoinSide {
-    LeftSide = 0,
-    RightSide = 1,
-}
-impl JoinSide {
-    /// String value of the enum field names used in the ProtoBuf definition.
-    ///
-    /// The values are not transformed in any way and thus are considered stable
-    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-    pub fn as_str_name(&self) -> &'static str {
-        match self {
-            JoinSide::LeftSide => "LEFT_SIDE",
-            JoinSide::RightSide => "RIGHT_SIDE",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "LEFT_SIDE" => Some(Self::LeftSide),
-            "RIGHT_SIDE" => Some(Self::RightSide),
-            _ => None,
-        }
-    }
-}
diff --git a/datafusion/proto/src/datafusion.serde.rs b/datafusion/proto/src/datafusion.serde.rs
deleted file mode 100644
index ab8ddf4f292f8..0000000000000
--- a/datafusion/proto/src/datafusion.serde.rs
+++ /dev/null
@@ -1,22857 +0,0 @@
-impl serde::Serialize for AggregateExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.group_expr.is_empty() {
-            len += 1;
-        }
-        if !self.aggr_expr.is_empty() {
-            len += 1;
-        }
-        if self.mode != 0 {
-            len += 1;
-        }
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.group_expr_name.is_empty() {
-            len += 1;
-        }
-        if !self.aggr_expr_name.is_empty() {
-            len += 1;
-        }
-        if self.input_schema.is_some() {
-            len += 1;
-        }
-        if !self.null_expr.is_empty() {
-            len += 1;
-        }
-        if !self.groups.is_empty() {
-            len += 1;
-        }
-        if !self.filter_expr.is_empty() {
-            len += 1;
-        }
-        if !self.order_by_expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExecNode", len)?;
-        if !self.group_expr.is_empty() {
-            struct_ser.serialize_field("groupExpr", &self.group_expr)?;
-        }
-        if !self.aggr_expr.is_empty() {
-            struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?;
-        }
-        if self.mode != 0 {
-            let v = AggregateMode::from_i32(self.mode)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?;
-            struct_ser.serialize_field("mode", &v)?;
-        }
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.group_expr_name.is_empty() {
-            struct_ser.serialize_field("groupExprName", &self.group_expr_name)?;
-        }
-        if !self.aggr_expr_name.is_empty() {
-            struct_ser.serialize_field("aggrExprName", &self.aggr_expr_name)?;
-        }
-        if let Some(v) = self.input_schema.as_ref() {
-            struct_ser.serialize_field("inputSchema", v)?;
-        }
-        if !self.null_expr.is_empty() {
-            struct_ser.serialize_field("nullExpr", &self.null_expr)?;
-        }
-        if !self.groups.is_empty() {
-            struct_ser.serialize_field("groups", &self.groups)?;
-        }
-        if !self.filter_expr.is_empty() {
-            struct_ser.serialize_field("filterExpr", &self.filter_expr)?;
-        }
-        if !self.order_by_expr.is_empty() {
-            struct_ser.serialize_field("orderByExpr", &self.order_by_expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AggregateExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "group_expr",
-            "groupExpr",
-            "aggr_expr",
-            "aggrExpr",
-            "mode",
-            "input",
-            "group_expr_name",
-            "groupExprName",
-            "aggr_expr_name",
-            "aggrExprName",
-            "input_schema",
-            "inputSchema",
-            "null_expr",
-            "nullExpr",
-            "groups",
-            "filter_expr",
-            "filterExpr",
-            "order_by_expr",
-            "orderByExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            GroupExpr,
-            AggrExpr,
-            Mode,
-            Input,
-            GroupExprName,
-            AggrExprName,
-            InputSchema,
-            NullExpr,
-            Groups,
-            FilterExpr,
-            OrderByExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr),
-                            "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr),
-                            "mode" => Ok(GeneratedField::Mode),
-                            "input" => Ok(GeneratedField::Input),
-                            "groupExprName" | "group_expr_name" => Ok(GeneratedField::GroupExprName),
-                            "aggrExprName" | "aggr_expr_name" => Ok(GeneratedField::AggrExprName),
-                            "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
-                            "nullExpr" | "null_expr" => Ok(GeneratedField::NullExpr),
-                            "groups" => Ok(GeneratedField::Groups),
-                            "filterExpr" | "filter_expr" => Ok(GeneratedField::FilterExpr),
-                            "orderByExpr" | "order_by_expr" => Ok(GeneratedField::OrderByExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AggregateExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AggregateExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut group_expr__ = None;
-                let mut aggr_expr__ = None;
-                let mut mode__ = None;
-                let mut input__ = None;
-                let mut group_expr_name__ = None;
-                let mut aggr_expr_name__ = None;
-                let mut input_schema__ = None;
-                let mut null_expr__ = None;
-                let mut groups__ = None;
-                let mut filter_expr__ = None;
-                let mut order_by_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::GroupExpr => {
-                            if group_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("groupExpr"));
-                            }
-                            group_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::AggrExpr => {
-                            if aggr_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggrExpr"));
-                            }
-                            aggr_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Mode => {
-                            if mode__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("mode"));
-                            }
-                            mode__ = Some(map.next_value::<AggregateMode>()? as i32);
-                        }
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::GroupExprName => {
-                            if group_expr_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("groupExprName"));
-                            }
-                            group_expr_name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::AggrExprName => {
-                            if aggr_expr_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggrExprName"));
-                            }
-                            aggr_expr_name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::InputSchema => {
-                            if input_schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inputSchema"));
-                            }
-                            input_schema__ = map.next_value()?;
-                        }
-                        GeneratedField::NullExpr => {
-                            if null_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullExpr"));
-                            }
-                            null_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Groups => {
-                            if groups__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("groups"));
-                            }
-                            groups__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::FilterExpr => {
-                            if filter_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filterExpr"));
-                            }
-                            filter_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::OrderByExpr => {
-                            if order_by_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("orderByExpr"));
-                            }
-                            order_by_expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(AggregateExecNode {
-                    group_expr: group_expr__.unwrap_or_default(),
-                    aggr_expr: aggr_expr__.unwrap_or_default(),
-                    mode: mode__.unwrap_or_default(),
-                    input: input__,
-                    group_expr_name: group_expr_name__.unwrap_or_default(),
-                    aggr_expr_name: aggr_expr_name__.unwrap_or_default(),
-                    input_schema: input_schema__,
-                    null_expr: null_expr__.unwrap_or_default(),
-                    groups: groups__.unwrap_or_default(),
-                    filter_expr: filter_expr__.unwrap_or_default(),
-                    order_by_expr: order_by_expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AggregateExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AggregateExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.aggr_function != 0 {
-            len += 1;
-        }
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        if self.distinct {
-            len += 1;
-        }
-        if self.filter.is_some() {
-            len += 1;
-        }
-        if !self.order_by.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExprNode", len)?;
-        if self.aggr_function != 0 {
-            let v = AggregateFunction::from_i32(self.aggr_function)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.aggr_function)))?;
-            struct_ser.serialize_field("aggrFunction", &v)?;
-        }
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        if self.distinct {
-            struct_ser.serialize_field("distinct", &self.distinct)?;
-        }
-        if let Some(v) = self.filter.as_ref() {
-            struct_ser.serialize_field("filter", v)?;
-        }
-        if !self.order_by.is_empty() {
-            struct_ser.serialize_field("orderBy", &self.order_by)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AggregateExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "aggr_function",
-            "aggrFunction",
-            "expr",
-            "distinct",
-            "filter",
-            "order_by",
-            "orderBy",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            AggrFunction,
-            Expr,
-            Distinct,
-            Filter,
-            OrderBy,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "distinct" => Ok(GeneratedField::Distinct),
-                            "filter" => Ok(GeneratedField::Filter),
-                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AggregateExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AggregateExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut aggr_function__ = None;
-                let mut expr__ = None;
-                let mut distinct__ = None;
-                let mut filter__ = None;
-                let mut order_by__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::AggrFunction => {
-                            if aggr_function__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
-                            }
-                            aggr_function__ = Some(map.next_value::<AggregateFunction>()? as i32);
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Distinct => {
-                            if distinct__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("distinct"));
-                            }
-                            distinct__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Filter => {
-                            if filter__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filter"));
-                            }
-                            filter__ = map.next_value()?;
-                        }
-                        GeneratedField::OrderBy => {
-                            if order_by__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("orderBy"));
-                            }
-                            order_by__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(AggregateExprNode {
-                    aggr_function: aggr_function__.unwrap_or_default(),
-                    expr: expr__.unwrap_or_default(),
-                    distinct: distinct__.unwrap_or_default(),
-                    filter: filter__,
-                    order_by: order_by__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AggregateExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AggregateFunction {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Min => "MIN",
-            Self::Max => "MAX",
-            Self::Sum => "SUM",
-            Self::Avg => "AVG",
-            Self::Count => "COUNT",
-            Self::ApproxDistinct => "APPROX_DISTINCT",
-            Self::ArrayAgg => "ARRAY_AGG",
-            Self::Variance => "VARIANCE",
-            Self::VariancePop => "VARIANCE_POP",
-            Self::Covariance => "COVARIANCE",
-            Self::CovariancePop => "COVARIANCE_POP",
-            Self::Stddev => "STDDEV",
-            Self::StddevPop => "STDDEV_POP",
-            Self::Correlation => "CORRELATION",
-            Self::ApproxPercentileCont => "APPROX_PERCENTILE_CONT",
-            Self::ApproxMedian => "APPROX_MEDIAN",
-            Self::ApproxPercentileContWithWeight => "APPROX_PERCENTILE_CONT_WITH_WEIGHT",
-            Self::Grouping => "GROUPING",
-            Self::Median => "MEDIAN",
-            Self::BitAnd => "BIT_AND",
-            Self::BitOr => "BIT_OR",
-            Self::BitXor => "BIT_XOR",
-            Self::BoolAnd => "BOOL_AND",
-            Self::BoolOr => "BOOL_OR",
-            Self::FirstValueAgg => "FIRST_VALUE_AGG",
-            Self::LastValueAgg => "LAST_VALUE_AGG",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for AggregateFunction {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "MIN",
-            "MAX",
-            "SUM",
-            "AVG",
-            "COUNT",
-            "APPROX_DISTINCT",
-            "ARRAY_AGG",
-            "VARIANCE",
-            "VARIANCE_POP",
-            "COVARIANCE",
-            "COVARIANCE_POP",
-            "STDDEV",
-            "STDDEV_POP",
-            "CORRELATION",
-            "APPROX_PERCENTILE_CONT",
-            "APPROX_MEDIAN",
-            "APPROX_PERCENTILE_CONT_WITH_WEIGHT",
-            "GROUPING",
-            "MEDIAN",
-            "BIT_AND",
-            "BIT_OR",
-            "BIT_XOR",
-            "BOOL_AND",
-            "BOOL_OR",
-            "FIRST_VALUE_AGG",
-            "LAST_VALUE_AGG",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AggregateFunction;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(AggregateFunction::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(AggregateFunction::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "MIN" => Ok(AggregateFunction::Min),
-                    "MAX" => Ok(AggregateFunction::Max),
-                    "SUM" => Ok(AggregateFunction::Sum),
-                    "AVG" => Ok(AggregateFunction::Avg),
-                    "COUNT" => Ok(AggregateFunction::Count),
-                    "APPROX_DISTINCT" => Ok(AggregateFunction::ApproxDistinct),
-                    "ARRAY_AGG" => Ok(AggregateFunction::ArrayAgg),
-                    "VARIANCE" => Ok(AggregateFunction::Variance),
-                    "VARIANCE_POP" => Ok(AggregateFunction::VariancePop),
-                    "COVARIANCE" => Ok(AggregateFunction::Covariance),
-                    "COVARIANCE_POP" => Ok(AggregateFunction::CovariancePop),
-                    "STDDEV" => Ok(AggregateFunction::Stddev),
-                    "STDDEV_POP" => Ok(AggregateFunction::StddevPop),
-                    "CORRELATION" => Ok(AggregateFunction::Correlation),
-                    "APPROX_PERCENTILE_CONT" => Ok(AggregateFunction::ApproxPercentileCont),
-                    "APPROX_MEDIAN" => Ok(AggregateFunction::ApproxMedian),
-                    "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => Ok(AggregateFunction::ApproxPercentileContWithWeight),
-                    "GROUPING" => Ok(AggregateFunction::Grouping),
-                    "MEDIAN" => Ok(AggregateFunction::Median),
-                    "BIT_AND" => Ok(AggregateFunction::BitAnd),
-                    "BIT_OR" => Ok(AggregateFunction::BitOr),
-                    "BIT_XOR" => Ok(AggregateFunction::BitXor),
-                    "BOOL_AND" => Ok(AggregateFunction::BoolAnd),
-                    "BOOL_OR" => Ok(AggregateFunction::BoolOr),
-                    "FIRST_VALUE_AGG" => Ok(AggregateFunction::FirstValueAgg),
-                    "LAST_VALUE_AGG" => Ok(AggregateFunction::LastValueAgg),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AggregateMode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Partial => "PARTIAL",
-            Self::Final => "FINAL",
-            Self::FinalPartitioned => "FINAL_PARTITIONED",
-            Self::Single => "SINGLE",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for AggregateMode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "PARTIAL",
-            "FINAL",
-            "FINAL_PARTITIONED",
-            "SINGLE",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AggregateMode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(AggregateMode::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(AggregateMode::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "PARTIAL" => Ok(AggregateMode::Partial),
-                    "FINAL" => Ok(AggregateMode::Final),
-                    "FINAL_PARTITIONED" => Ok(AggregateMode::FinalPartitioned),
-                    "SINGLE" => Ok(AggregateMode::Single),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AggregateNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.group_expr.is_empty() {
-            len += 1;
-        }
-        if !self.aggr_expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.group_expr.is_empty() {
-            struct_ser.serialize_field("groupExpr", &self.group_expr)?;
-        }
-        if !self.aggr_expr.is_empty() {
-            struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AggregateNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "group_expr",
-            "groupExpr",
-            "aggr_expr",
-            "aggrExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            GroupExpr,
-            AggrExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr),
-                            "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AggregateNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AggregateNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut group_expr__ = None;
-                let mut aggr_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::GroupExpr => {
-                            if group_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("groupExpr"));
-                            }
-                            group_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::AggrExpr => {
-                            if aggr_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggrExpr"));
-                            }
-                            aggr_expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(AggregateNode {
-                    input: input__,
-                    group_expr: group_expr__.unwrap_or_default(),
-                    aggr_expr: aggr_expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AggregateNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AggregateUdfExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.fun_name.is_empty() {
-            len += 1;
-        }
-        if !self.args.is_empty() {
-            len += 1;
-        }
-        if self.filter.is_some() {
-            len += 1;
-        }
-        if !self.order_by.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AggregateUDFExprNode", len)?;
-        if !self.fun_name.is_empty() {
-            struct_ser.serialize_field("funName", &self.fun_name)?;
-        }
-        if !self.args.is_empty() {
-            struct_ser.serialize_field("args", &self.args)?;
-        }
-        if let Some(v) = self.filter.as_ref() {
-            struct_ser.serialize_field("filter", v)?;
-        }
-        if !self.order_by.is_empty() {
-            struct_ser.serialize_field("orderBy", &self.order_by)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AggregateUdfExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "fun_name",
-            "funName",
-            "args",
-            "filter",
-            "order_by",
-            "orderBy",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            FunName,
-            Args,
-            Filter,
-            OrderBy,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "funName" | "fun_name" => Ok(GeneratedField::FunName),
-                            "args" => Ok(GeneratedField::Args),
-                            "filter" => Ok(GeneratedField::Filter),
-                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AggregateUdfExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AggregateUDFExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AggregateUdfExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut fun_name__ = None;
-                let mut args__ = None;
-                let mut filter__ = None;
-                let mut order_by__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::FunName => {
-                            if fun_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("funName"));
-                            }
-                            fun_name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Args => {
-                            if args__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("args"));
-                            }
-                            args__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Filter => {
-                            if filter__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filter"));
-                            }
-                            filter__ = map.next_value()?;
-                        }
-                        GeneratedField::OrderBy => {
-                            if order_by__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("orderBy"));
-                            }
-                            order_by__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(AggregateUdfExprNode {
-                    fun_name: fun_name__.unwrap_or_default(),
-                    args: args__.unwrap_or_default(),
-                    filter: filter__,
-                    order_by: order_by__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AggregateUDFExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AliasNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if !self.alias.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AliasNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if !self.alias.is_empty() {
-            struct_ser.serialize_field("alias", &self.alias)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AliasNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "alias",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            Alias,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "alias" => Ok(GeneratedField::Alias),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AliasNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AliasNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AliasNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut alias__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Alias => {
-                            if alias__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("alias"));
-                            }
-                            alias__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(AliasNode {
-                    expr: expr__,
-                    alias: alias__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AliasNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AnalyzeNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.verbose {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AnalyzeNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if self.verbose {
-            struct_ser.serialize_field("verbose", &self.verbose)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AnalyzeNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "verbose",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Verbose,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "verbose" => Ok(GeneratedField::Verbose),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AnalyzeNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AnalyzeNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AnalyzeNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut verbose__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Verbose => {
-                            if verbose__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("verbose"));
-                            }
-                            verbose__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(AnalyzeNode {
-                    input: input__,
-                    verbose: verbose__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AnalyzeNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AnalyzedLogicalPlanType {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.analyzer_name.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AnalyzedLogicalPlanType", len)?;
-        if !self.analyzer_name.is_empty() {
-            struct_ser.serialize_field("analyzerName", &self.analyzer_name)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AnalyzedLogicalPlanType {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "analyzer_name",
-            "analyzerName",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            AnalyzerName,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "analyzerName" | "analyzer_name" => Ok(GeneratedField::AnalyzerName),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AnalyzedLogicalPlanType;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AnalyzedLogicalPlanType")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AnalyzedLogicalPlanType, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut analyzer_name__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::AnalyzerName => {
-                            if analyzer_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("analyzerName"));
-                            }
-                            analyzer_name__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(AnalyzedLogicalPlanType {
-                    analyzer_name: analyzer_name__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AnalyzedLogicalPlanType", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ArrowType {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.arrow_type_enum.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ArrowType", len)?;
-        if let Some(v) = self.arrow_type_enum.as_ref() {
-            match v {
-                arrow_type::ArrowTypeEnum::None(v) => {
-                    struct_ser.serialize_field("NONE", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Bool(v) => {
-                    struct_ser.serialize_field("BOOL", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Uint8(v) => {
-                    struct_ser.serialize_field("UINT8", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Int8(v) => {
-                    struct_ser.serialize_field("INT8", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Uint16(v) => {
-                    struct_ser.serialize_field("UINT16", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Int16(v) => {
-                    struct_ser.serialize_field("INT16", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Uint32(v) => {
-                    struct_ser.serialize_field("UINT32", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Int32(v) => {
-                    struct_ser.serialize_field("INT32", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Uint64(v) => {
-                    struct_ser.serialize_field("UINT64", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Int64(v) => {
-                    struct_ser.serialize_field("INT64", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Float16(v) => {
-                    struct_ser.serialize_field("FLOAT16", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Float32(v) => {
-                    struct_ser.serialize_field("FLOAT32", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Float64(v) => {
-                    struct_ser.serialize_field("FLOAT64", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Utf8(v) => {
-                    struct_ser.serialize_field("UTF8", v)?;
-                }
-                arrow_type::ArrowTypeEnum::LargeUtf8(v) => {
-                    struct_ser.serialize_field("LARGEUTF8", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Binary(v) => {
-                    struct_ser.serialize_field("BINARY", v)?;
-                }
-                arrow_type::ArrowTypeEnum::FixedSizeBinary(v) => {
-                    struct_ser.serialize_field("FIXEDSIZEBINARY", v)?;
-                }
-                arrow_type::ArrowTypeEnum::LargeBinary(v) => {
-                    struct_ser.serialize_field("LARGEBINARY", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Date32(v) => {
-                    struct_ser.serialize_field("DATE32", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Date64(v) => {
-                    struct_ser.serialize_field("DATE64", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Duration(v) => {
-                    let v = TimeUnit::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("DURATION", &v)?;
-                }
-                arrow_type::ArrowTypeEnum::Timestamp(v) => {
-                    struct_ser.serialize_field("TIMESTAMP", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Time32(v) => {
-                    let v = TimeUnit::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("TIME32", &v)?;
-                }
-                arrow_type::ArrowTypeEnum::Time64(v) => {
-                    let v = TimeUnit::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("TIME64", &v)?;
-                }
-                arrow_type::ArrowTypeEnum::Interval(v) => {
-                    let v = IntervalUnit::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("INTERVAL", &v)?;
-                }
-                arrow_type::ArrowTypeEnum::Decimal(v) => {
-                    struct_ser.serialize_field("DECIMAL", v)?;
-                }
-                arrow_type::ArrowTypeEnum::List(v) => {
-                    struct_ser.serialize_field("LIST", v)?;
-                }
-                arrow_type::ArrowTypeEnum::LargeList(v) => {
-                    struct_ser.serialize_field("LARGELIST", v)?;
-                }
-                arrow_type::ArrowTypeEnum::FixedSizeList(v) => {
-                    struct_ser.serialize_field("FIXEDSIZELIST", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Struct(v) => {
-                    struct_ser.serialize_field("STRUCT", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Union(v) => {
-                    struct_ser.serialize_field("UNION", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Dictionary(v) => {
-                    struct_ser.serialize_field("DICTIONARY", v)?;
-                }
-                arrow_type::ArrowTypeEnum::Map(v) => {
-                    struct_ser.serialize_field("MAP", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ArrowType {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "NONE",
-            "BOOL",
-            "UINT8",
-            "INT8",
-            "UINT16",
-            "INT16",
-            "UINT32",
-            "INT32",
-            "UINT64",
-            "INT64",
-            "FLOAT16",
-            "FLOAT32",
-            "FLOAT64",
-            "UTF8",
-            "LARGE_UTF8",
-            "LARGEUTF8",
-            "BINARY",
-            "FIXED_SIZE_BINARY",
-            "FIXEDSIZEBINARY",
-            "LARGE_BINARY",
-            "LARGEBINARY",
-            "DATE32",
-            "DATE64",
-            "DURATION",
-            "TIMESTAMP",
-            "TIME32",
-            "TIME64",
-            "INTERVAL",
-            "DECIMAL",
-            "LIST",
-            "LARGE_LIST",
-            "LARGELIST",
-            "FIXED_SIZE_LIST",
-            "FIXEDSIZELIST",
-            "STRUCT",
-            "UNION",
-            "DICTIONARY",
-            "MAP",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            None,
-            Bool,
-            Uint8,
-            Int8,
-            Uint16,
-            Int16,
-            Uint32,
-            Int32,
-            Uint64,
-            Int64,
-            Float16,
-            Float32,
-            Float64,
-            Utf8,
-            LargeUtf8,
-            Binary,
-            FixedSizeBinary,
-            LargeBinary,
-            Date32,
-            Date64,
-            Duration,
-            Timestamp,
-            Time32,
-            Time64,
-            Interval,
-            Decimal,
-            List,
-            LargeList,
-            FixedSizeList,
-            Struct,
-            Union,
-            Dictionary,
-            Map,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "NONE" => Ok(GeneratedField::None),
-                            "BOOL" => Ok(GeneratedField::Bool),
-                            "UINT8" => Ok(GeneratedField::Uint8),
-                            "INT8" => Ok(GeneratedField::Int8),
-                            "UINT16" => Ok(GeneratedField::Uint16),
-                            "INT16" => Ok(GeneratedField::Int16),
-                            "UINT32" => Ok(GeneratedField::Uint32),
-                            "INT32" => Ok(GeneratedField::Int32),
-                            "UINT64" => Ok(GeneratedField::Uint64),
-                            "INT64" => Ok(GeneratedField::Int64),
-                            "FLOAT16" => Ok(GeneratedField::Float16),
-                            "FLOAT32" => Ok(GeneratedField::Float32),
-                            "FLOAT64" => Ok(GeneratedField::Float64),
-                            "UTF8" => Ok(GeneratedField::Utf8),
-                            "LARGEUTF8" | "LARGE_UTF8" => Ok(GeneratedField::LargeUtf8),
-                            "BINARY" => Ok(GeneratedField::Binary),
-                            "FIXEDSIZEBINARY" | "FIXED_SIZE_BINARY" => Ok(GeneratedField::FixedSizeBinary),
-                            "LARGEBINARY" | "LARGE_BINARY" => Ok(GeneratedField::LargeBinary),
-                            "DATE32" => Ok(GeneratedField::Date32),
-                            "DATE64" => Ok(GeneratedField::Date64),
-                            "DURATION" => Ok(GeneratedField::Duration),
-                            "TIMESTAMP" => Ok(GeneratedField::Timestamp),
-                            "TIME32" => Ok(GeneratedField::Time32),
-                            "TIME64" => Ok(GeneratedField::Time64),
-                            "INTERVAL" => Ok(GeneratedField::Interval),
-                            "DECIMAL" => Ok(GeneratedField::Decimal),
-                            "LIST" => Ok(GeneratedField::List),
-                            "LARGELIST" | "LARGE_LIST" => Ok(GeneratedField::LargeList),
-                            "FIXEDSIZELIST" | "FIXED_SIZE_LIST" => Ok(GeneratedField::FixedSizeList),
-                            "STRUCT" => Ok(GeneratedField::Struct),
-                            "UNION" => Ok(GeneratedField::Union),
-                            "DICTIONARY" => Ok(GeneratedField::Dictionary),
-                            "MAP" => Ok(GeneratedField::Map),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ArrowType;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ArrowType")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ArrowType, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut arrow_type_enum__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::None => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("NONE"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::None)
-;
-                        }
-                        GeneratedField::Bool => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("BOOL"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Bool)
-;
-                        }
-                        GeneratedField::Uint8 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("UINT8"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint8)
-;
-                        }
-                        GeneratedField::Int8 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("INT8"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int8)
-;
-                        }
-                        GeneratedField::Uint16 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("UINT16"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint16)
-;
-                        }
-                        GeneratedField::Int16 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("INT16"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int16)
-;
-                        }
-                        GeneratedField::Uint32 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("UINT32"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint32)
-;
-                        }
-                        GeneratedField::Int32 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("INT32"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int32)
-;
-                        }
-                        GeneratedField::Uint64 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("UINT64"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint64)
-;
-                        }
-                        GeneratedField::Int64 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("INT64"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int64)
-;
-                        }
-                        GeneratedField::Float16 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FLOAT16"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float16)
-;
-                        }
-                        GeneratedField::Float32 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FLOAT32"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float32)
-;
-                        }
-                        GeneratedField::Float64 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FLOAT64"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float64)
-;
-                        }
-                        GeneratedField::Utf8 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("UTF8"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Utf8)
-;
-                        }
-                        GeneratedField::LargeUtf8 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("LARGEUTF8"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeUtf8)
-;
-                        }
-                        GeneratedField::Binary => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("BINARY"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Binary)
-;
-                        }
-                        GeneratedField::FixedSizeBinary => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FIXEDSIZEBINARY"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| arrow_type::ArrowTypeEnum::FixedSizeBinary(x.0));
-                        }
-                        GeneratedField::LargeBinary => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("LARGEBINARY"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeBinary)
-;
-                        }
-                        GeneratedField::Date32 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("DATE32"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date32)
-;
-                        }
-                        GeneratedField::Date64 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("DATE64"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date64)
-;
-                        }
-                        GeneratedField::Duration => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("DURATION"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Duration(x as i32));
-                        }
-                        GeneratedField::Timestamp => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("TIMESTAMP"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Timestamp)
-;
-                        }
-                        GeneratedField::Time32 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("TIME32"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Time32(x as i32));
-                        }
-                        GeneratedField::Time64 => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("TIME64"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Time64(x as i32));
-                        }
-                        GeneratedField::Interval => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("INTERVAL"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<IntervalUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Interval(x as i32));
-                        }
-                        GeneratedField::Decimal => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("DECIMAL"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Decimal)
-;
-                        }
-                        GeneratedField::List => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("LIST"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::List)
-;
-                        }
-                        GeneratedField::LargeList => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("LARGELIST"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeList)
-;
-                        }
-                        GeneratedField::FixedSizeList => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FIXEDSIZELIST"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::FixedSizeList)
-;
-                        }
-                        GeneratedField::Struct => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("STRUCT"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Struct)
-;
-                        }
-                        GeneratedField::Union => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("UNION"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Union)
-;
-                        }
-                        GeneratedField::Dictionary => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("DICTIONARY"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Dictionary)
-;
-                        }
-                        GeneratedField::Map => {
-                            if arrow_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("MAP"));
-                            }
-                            arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Map)
-;
-                        }
-                    }
-                }
-                Ok(ArrowType {
-                    arrow_type_enum: arrow_type_enum__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ArrowType", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AvroFormat {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let len = 0;
-        let struct_ser = serializer.serialize_struct("datafusion.AvroFormat", len)?;
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AvroFormat {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                            Err(serde::de::Error::unknown_field(value, FIELDS))
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AvroFormat;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AvroFormat")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AvroFormat, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
-                }
-                Ok(AvroFormat {
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AvroFormat", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for AvroScanExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.base_conf.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.AvroScanExecNode", len)?;
-        if let Some(v) = self.base_conf.as_ref() {
-            struct_ser.serialize_field("baseConf", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for AvroScanExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "base_conf",
-            "baseConf",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            BaseConf,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = AvroScanExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.AvroScanExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<AvroScanExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut base_conf__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::BaseConf => {
-                            if base_conf__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("baseConf"));
-                            }
-                            base_conf__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(AvroScanExecNode {
-                    base_conf: base_conf__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.AvroScanExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for BareTableReference {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.table.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.BareTableReference", len)?;
-        if !self.table.is_empty() {
-            struct_ser.serialize_field("table", &self.table)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for BareTableReference {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "table",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Table,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "table" => Ok(GeneratedField::Table),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = BareTableReference;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.BareTableReference")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<BareTableReference, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut table__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Table => {
-                            if table__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("table"));
-                            }
-                            table__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(BareTableReference {
-                    table: table__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.BareTableReference", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for BetweenNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.negated {
-            len += 1;
-        }
-        if self.low.is_some() {
-            len += 1;
-        }
-        if self.high.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.BetweenNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if self.negated {
-            struct_ser.serialize_field("negated", &self.negated)?;
-        }
-        if let Some(v) = self.low.as_ref() {
-            struct_ser.serialize_field("low", v)?;
-        }
-        if let Some(v) = self.high.as_ref() {
-            struct_ser.serialize_field("high", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for BetweenNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "negated",
-            "low",
-            "high",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            Negated,
-            Low,
-            High,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "negated" => Ok(GeneratedField::Negated),
-                            "low" => Ok(GeneratedField::Low),
-                            "high" => Ok(GeneratedField::High),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = BetweenNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.BetweenNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<BetweenNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut negated__ = None;
-                let mut low__ = None;
-                let mut high__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Negated => {
-                            if negated__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negated"));
-                            }
-                            negated__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Low => {
-                            if low__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("low"));
-                            }
-                            low__ = map.next_value()?;
-                        }
-                        GeneratedField::High => {
-                            if high__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("high"));
-                            }
-                            high__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(BetweenNode {
-                    expr: expr__,
-                    negated: negated__.unwrap_or_default(),
-                    low: low__,
-                    high: high__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.BetweenNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for BinaryExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.operands.is_empty() {
-            len += 1;
-        }
-        if !self.op.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.BinaryExprNode", len)?;
-        if !self.operands.is_empty() {
-            struct_ser.serialize_field("operands", &self.operands)?;
-        }
-        if !self.op.is_empty() {
-            struct_ser.serialize_field("op", &self.op)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for BinaryExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "operands",
-            "op",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Operands,
-            Op,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "operands" => Ok(GeneratedField::Operands),
-                            "op" => Ok(GeneratedField::Op),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = BinaryExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.BinaryExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<BinaryExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut operands__ = None;
-                let mut op__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Operands => {
-                            if operands__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("operands"));
-                            }
-                            operands__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Op => {
-                            if op__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("op"));
-                            }
-                            op__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(BinaryExprNode {
-                    operands: operands__.unwrap_or_default(),
-                    op: op__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.BinaryExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for BuiltInWindowFunction {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::RowNumber => "ROW_NUMBER",
-            Self::Rank => "RANK",
-            Self::DenseRank => "DENSE_RANK",
-            Self::PercentRank => "PERCENT_RANK",
-            Self::CumeDist => "CUME_DIST",
-            Self::Ntile => "NTILE",
-            Self::Lag => "LAG",
-            Self::Lead => "LEAD",
-            Self::FirstValue => "FIRST_VALUE",
-            Self::LastValue => "LAST_VALUE",
-            Self::NthValue => "NTH_VALUE",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for BuiltInWindowFunction {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "ROW_NUMBER",
-            "RANK",
-            "DENSE_RANK",
-            "PERCENT_RANK",
-            "CUME_DIST",
-            "NTILE",
-            "LAG",
-            "LEAD",
-            "FIRST_VALUE",
-            "LAST_VALUE",
-            "NTH_VALUE",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = BuiltInWindowFunction;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(BuiltInWindowFunction::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(BuiltInWindowFunction::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "ROW_NUMBER" => Ok(BuiltInWindowFunction::RowNumber),
-                    "RANK" => Ok(BuiltInWindowFunction::Rank),
-                    "DENSE_RANK" => Ok(BuiltInWindowFunction::DenseRank),
-                    "PERCENT_RANK" => Ok(BuiltInWindowFunction::PercentRank),
-                    "CUME_DIST" => Ok(BuiltInWindowFunction::CumeDist),
-                    "NTILE" => Ok(BuiltInWindowFunction::Ntile),
-                    "LAG" => Ok(BuiltInWindowFunction::Lag),
-                    "LEAD" => Ok(BuiltInWindowFunction::Lead),
-                    "FIRST_VALUE" => Ok(BuiltInWindowFunction::FirstValue),
-                    "LAST_VALUE" => Ok(BuiltInWindowFunction::LastValue),
-                    "NTH_VALUE" => Ok(BuiltInWindowFunction::NthValue),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CaseNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if !self.when_then_expr.is_empty() {
-            len += 1;
-        }
-        if self.else_expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CaseNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if !self.when_then_expr.is_empty() {
-            struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?;
-        }
-        if let Some(v) = self.else_expr.as_ref() {
-            struct_ser.serialize_field("elseExpr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CaseNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "when_then_expr",
-            "whenThenExpr",
-            "else_expr",
-            "elseExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            WhenThenExpr,
-            ElseExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr),
-                            "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CaseNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CaseNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CaseNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut when_then_expr__ = None;
-                let mut else_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::WhenThenExpr => {
-                            if when_then_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("whenThenExpr"));
-                            }
-                            when_then_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::ElseExpr => {
-                            if else_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("elseExpr"));
-                            }
-                            else_expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(CaseNode {
-                    expr: expr__,
-                    when_then_expr: when_then_expr__.unwrap_or_default(),
-                    else_expr: else_expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CaseNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CastNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.arrow_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CastNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.arrow_type.as_ref() {
-            struct_ser.serialize_field("arrowType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CastNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "arrow_type",
-            "arrowType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            ArrowType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CastNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CastNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CastNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut arrow_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::ArrowType => {
-                            if arrow_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("arrowType"));
-                            }
-                            arrow_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(CastNode {
-                    expr: expr__,
-                    arrow_type: arrow_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CastNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CoalesceBatchesExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.target_batch_size != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CoalesceBatchesExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if self.target_batch_size != 0 {
-            struct_ser.serialize_field("targetBatchSize", &self.target_batch_size)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CoalesceBatchesExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "target_batch_size",
-            "targetBatchSize",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            TargetBatchSize,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "targetBatchSize" | "target_batch_size" => Ok(GeneratedField::TargetBatchSize),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CoalesceBatchesExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CoalesceBatchesExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CoalesceBatchesExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut target_batch_size__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::TargetBatchSize => {
-                            if target_batch_size__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("targetBatchSize"));
-                            }
-                            target_batch_size__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(CoalesceBatchesExecNode {
-                    input: input__,
-                    target_batch_size: target_batch_size__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CoalesceBatchesExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CoalescePartitionsExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CoalescePartitionsExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CoalescePartitionsExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CoalescePartitionsExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CoalescePartitionsExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CoalescePartitionsExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(CoalescePartitionsExecNode {
-                    input: input__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CoalescePartitionsExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Column {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.name.is_empty() {
-            len += 1;
-        }
-        if self.relation.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Column", len)?;
-        if !self.name.is_empty() {
-            struct_ser.serialize_field("name", &self.name)?;
-        }
-        if let Some(v) = self.relation.as_ref() {
-            struct_ser.serialize_field("relation", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Column {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "relation",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            Relation,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "relation" => Ok(GeneratedField::Relation),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Column;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Column")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Column, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut relation__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Relation => {
-                            if relation__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("relation"));
-                            }
-                            relation__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(Column {
-                    name: name__.unwrap_or_default(),
-                    relation: relation__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Column", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ColumnIndex {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.index != 0 {
-            len += 1;
-        }
-        if self.side != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ColumnIndex", len)?;
-        if self.index != 0 {
-            struct_ser.serialize_field("index", &self.index)?;
-        }
-        if self.side != 0 {
-            let v = JoinSide::from_i32(self.side)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.side)))?;
-            struct_ser.serialize_field("side", &v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ColumnIndex {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "index",
-            "side",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Index,
-            Side,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "index" => Ok(GeneratedField::Index),
-                            "side" => Ok(GeneratedField::Side),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ColumnIndex;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ColumnIndex")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ColumnIndex, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut index__ = None;
-                let mut side__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Index => {
-                            if index__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("index"));
-                            }
-                            index__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Side => {
-                            if side__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("side"));
-                            }
-                            side__ = Some(map.next_value::<JoinSide>()? as i32);
-                        }
-                    }
-                }
-                Ok(ColumnIndex {
-                    index: index__.unwrap_or_default(),
-                    side: side__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ColumnIndex", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ColumnRelation {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.relation.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ColumnRelation", len)?;
-        if !self.relation.is_empty() {
-            struct_ser.serialize_field("relation", &self.relation)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ColumnRelation {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "relation",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Relation,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "relation" => Ok(GeneratedField::Relation),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ColumnRelation;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ColumnRelation")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ColumnRelation, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut relation__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Relation => {
-                            if relation__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("relation"));
-                            }
-                            relation__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ColumnRelation {
-                    relation: relation__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ColumnRelation", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ColumnStats {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.min_value.is_some() {
-            len += 1;
-        }
-        if self.max_value.is_some() {
-            len += 1;
-        }
-        if self.null_count != 0 {
-            len += 1;
-        }
-        if self.distinct_count != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ColumnStats", len)?;
-        if let Some(v) = self.min_value.as_ref() {
-            struct_ser.serialize_field("minValue", v)?;
-        }
-        if let Some(v) = self.max_value.as_ref() {
-            struct_ser.serialize_field("maxValue", v)?;
-        }
-        if self.null_count != 0 {
-            struct_ser.serialize_field("nullCount", &self.null_count)?;
-        }
-        if self.distinct_count != 0 {
-            struct_ser.serialize_field("distinctCount", &self.distinct_count)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ColumnStats {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "min_value",
-            "minValue",
-            "max_value",
-            "maxValue",
-            "null_count",
-            "nullCount",
-            "distinct_count",
-            "distinctCount",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            MinValue,
-            MaxValue,
-            NullCount,
-            DistinctCount,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "minValue" | "min_value" => Ok(GeneratedField::MinValue),
-                            "maxValue" | "max_value" => Ok(GeneratedField::MaxValue),
-                            "nullCount" | "null_count" => Ok(GeneratedField::NullCount),
-                            "distinctCount" | "distinct_count" => Ok(GeneratedField::DistinctCount),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ColumnStats;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ColumnStats")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ColumnStats, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut min_value__ = None;
-                let mut max_value__ = None;
-                let mut null_count__ = None;
-                let mut distinct_count__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::MinValue => {
-                            if min_value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("minValue"));
-                            }
-                            min_value__ = map.next_value()?;
-                        }
-                        GeneratedField::MaxValue => {
-                            if max_value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("maxValue"));
-                            }
-                            max_value__ = map.next_value()?;
-                        }
-                        GeneratedField::NullCount => {
-                            if null_count__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullCount"));
-                            }
-                            null_count__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::DistinctCount => {
-                            if distinct_count__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("distinctCount"));
-                            }
-                            distinct_count__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(ColumnStats {
-                    min_value: min_value__,
-                    max_value: max_value__,
-                    null_count: null_count__.unwrap_or_default(),
-                    distinct_count: distinct_count__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ColumnStats", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CreateCatalogNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.catalog_name.is_empty() {
-            len += 1;
-        }
-        if self.if_not_exists {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogNode", len)?;
-        if !self.catalog_name.is_empty() {
-            struct_ser.serialize_field("catalogName", &self.catalog_name)?;
-        }
-        if self.if_not_exists {
-            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CreateCatalogNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "catalog_name",
-            "catalogName",
-            "if_not_exists",
-            "ifNotExists",
-            "schema",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            CatalogName,
-            IfNotExists,
-            Schema,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
-                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
-                            "schema" => Ok(GeneratedField::Schema),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CreateCatalogNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CreateCatalogNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateCatalogNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut catalog_name__ = None;
-                let mut if_not_exists__ = None;
-                let mut schema__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::CatalogName => {
-                            if catalog_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("catalogName"));
-                            }
-                            catalog_name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::IfNotExists => {
-                            if if_not_exists__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
-                            }
-                            if_not_exists__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(CreateCatalogNode {
-                    catalog_name: catalog_name__.unwrap_or_default(),
-                    if_not_exists: if_not_exists__.unwrap_or_default(),
-                    schema: schema__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CreateCatalogNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CreateCatalogSchemaNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.schema_name.is_empty() {
-            len += 1;
-        }
-        if self.if_not_exists {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogSchemaNode", len)?;
-        if !self.schema_name.is_empty() {
-            struct_ser.serialize_field("schemaName", &self.schema_name)?;
-        }
-        if self.if_not_exists {
-            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "schema_name",
-            "schemaName",
-            "if_not_exists",
-            "ifNotExists",
-            "schema",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            SchemaName,
-            IfNotExists,
-            Schema,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
-                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
-                            "schema" => Ok(GeneratedField::Schema),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CreateCatalogSchemaNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CreateCatalogSchemaNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateCatalogSchemaNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut schema_name__ = None;
-                let mut if_not_exists__ = None;
-                let mut schema__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::SchemaName => {
-                            if schema_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schemaName"));
-                            }
-                            schema_name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::IfNotExists => {
-                            if if_not_exists__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
-                            }
-                            if_not_exists__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(CreateCatalogSchemaNode {
-                    schema_name: schema_name__.unwrap_or_default(),
-                    if_not_exists: if_not_exists__.unwrap_or_default(),
-                    schema: schema__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CreateCatalogSchemaNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CreateExternalTableNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.name.is_some() {
-            len += 1;
-        }
-        if !self.location.is_empty() {
-            len += 1;
-        }
-        if !self.file_type.is_empty() {
-            len += 1;
-        }
-        if self.has_header {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        if !self.table_partition_cols.is_empty() {
-            len += 1;
-        }
-        if self.if_not_exists {
-            len += 1;
-        }
-        if !self.delimiter.is_empty() {
-            len += 1;
-        }
-        if !self.definition.is_empty() {
-            len += 1;
-        }
-        if !self.file_compression_type.is_empty() {
-            len += 1;
-        }
-        if !self.order_exprs.is_empty() {
-            len += 1;
-        }
-        if self.unbounded {
-            len += 1;
-        }
-        if !self.options.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CreateExternalTableNode", len)?;
-        if let Some(v) = self.name.as_ref() {
-            struct_ser.serialize_field("name", v)?;
-        }
-        if !self.location.is_empty() {
-            struct_ser.serialize_field("location", &self.location)?;
-        }
-        if !self.file_type.is_empty() {
-            struct_ser.serialize_field("fileType", &self.file_type)?;
-        }
-        if self.has_header {
-            struct_ser.serialize_field("hasHeader", &self.has_header)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        if !self.table_partition_cols.is_empty() {
-            struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?;
-        }
-        if self.if_not_exists {
-            struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?;
-        }
-        if !self.delimiter.is_empty() {
-            struct_ser.serialize_field("delimiter", &self.delimiter)?;
-        }
-        if !self.definition.is_empty() {
-            struct_ser.serialize_field("definition", &self.definition)?;
-        }
-        if !self.file_compression_type.is_empty() {
-            struct_ser.serialize_field("fileCompressionType", &self.file_compression_type)?;
-        }
-        if !self.order_exprs.is_empty() {
-            struct_ser.serialize_field("orderExprs", &self.order_exprs)?;
-        }
-        if self.unbounded {
-            struct_ser.serialize_field("unbounded", &self.unbounded)?;
-        }
-        if !self.options.is_empty() {
-            struct_ser.serialize_field("options", &self.options)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CreateExternalTableNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "location",
-            "file_type",
-            "fileType",
-            "has_header",
-            "hasHeader",
-            "schema",
-            "table_partition_cols",
-            "tablePartitionCols",
-            "if_not_exists",
-            "ifNotExists",
-            "delimiter",
-            "definition",
-            "file_compression_type",
-            "fileCompressionType",
-            "order_exprs",
-            "orderExprs",
-            "unbounded",
-            "options",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            Location,
-            FileType,
-            HasHeader,
-            Schema,
-            TablePartitionCols,
-            IfNotExists,
-            Delimiter,
-            Definition,
-            FileCompressionType,
-            OrderExprs,
-            Unbounded,
-            Options,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "location" => Ok(GeneratedField::Location),
-                            "fileType" | "file_type" => Ok(GeneratedField::FileType),
-                            "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
-                            "schema" => Ok(GeneratedField::Schema),
-                            "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
-                            "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
-                            "delimiter" => Ok(GeneratedField::Delimiter),
-                            "definition" => Ok(GeneratedField::Definition),
-                            "fileCompressionType" | "file_compression_type" => Ok(GeneratedField::FileCompressionType),
-                            "orderExprs" | "order_exprs" => Ok(GeneratedField::OrderExprs),
-                            "unbounded" => Ok(GeneratedField::Unbounded),
-                            "options" => Ok(GeneratedField::Options),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CreateExternalTableNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CreateExternalTableNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateExternalTableNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut location__ = None;
-                let mut file_type__ = None;
-                let mut has_header__ = None;
-                let mut schema__ = None;
-                let mut table_partition_cols__ = None;
-                let mut if_not_exists__ = None;
-                let mut delimiter__ = None;
-                let mut definition__ = None;
-                let mut file_compression_type__ = None;
-                let mut order_exprs__ = None;
-                let mut unbounded__ = None;
-                let mut options__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = map.next_value()?;
-                        }
-                        GeneratedField::Location => {
-                            if location__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("location"));
-                            }
-                            location__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::FileType => {
-                            if file_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fileType"));
-                            }
-                            file_type__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::HasHeader => {
-                            if has_header__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hasHeader"));
-                            }
-                            has_header__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                        GeneratedField::TablePartitionCols => {
-                            if table_partition_cols__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tablePartitionCols"));
-                            }
-                            table_partition_cols__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::IfNotExists => {
-                            if if_not_exists__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("ifNotExists"));
-                            }
-                            if_not_exists__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Delimiter => {
-                            if delimiter__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("delimiter"));
-                            }
-                            delimiter__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Definition => {
-                            if definition__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("definition"));
-                            }
-                            definition__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::FileCompressionType => {
-                            if file_compression_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fileCompressionType"));
-                            }
-                            file_compression_type__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::OrderExprs => {
-                            if order_exprs__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("orderExprs"));
-                            }
-                            order_exprs__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Unbounded => {
-                            if unbounded__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("unbounded"));
-                            }
-                            unbounded__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Options => {
-                            if options__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("options"));
-                            }
-                            options__ = Some(
-                                map.next_value::<std::collections::HashMap<_, _>>()?
-                            );
-                        }
-                    }
-                }
-                Ok(CreateExternalTableNode {
-                    name: name__,
-                    location: location__.unwrap_or_default(),
-                    file_type: file_type__.unwrap_or_default(),
-                    has_header: has_header__.unwrap_or_default(),
-                    schema: schema__,
-                    table_partition_cols: table_partition_cols__.unwrap_or_default(),
-                    if_not_exists: if_not_exists__.unwrap_or_default(),
-                    delimiter: delimiter__.unwrap_or_default(),
-                    definition: definition__.unwrap_or_default(),
-                    file_compression_type: file_compression_type__.unwrap_or_default(),
-                    order_exprs: order_exprs__.unwrap_or_default(),
-                    unbounded: unbounded__.unwrap_or_default(),
-                    options: options__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CreateExternalTableNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CreateViewNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.name.is_some() {
-            len += 1;
-        }
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.or_replace {
-            len += 1;
-        }
-        if !self.definition.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CreateViewNode", len)?;
-        if let Some(v) = self.name.as_ref() {
-            struct_ser.serialize_field("name", v)?;
-        }
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if self.or_replace {
-            struct_ser.serialize_field("orReplace", &self.or_replace)?;
-        }
-        if !self.definition.is_empty() {
-            struct_ser.serialize_field("definition", &self.definition)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CreateViewNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "input",
-            "or_replace",
-            "orReplace",
-            "definition",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            Input,
-            OrReplace,
-            Definition,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "input" => Ok(GeneratedField::Input),
-                            "orReplace" | "or_replace" => Ok(GeneratedField::OrReplace),
-                            "definition" => Ok(GeneratedField::Definition),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CreateViewNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CreateViewNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CreateViewNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut input__ = None;
-                let mut or_replace__ = None;
-                let mut definition__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = map.next_value()?;
-                        }
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::OrReplace => {
-                            if or_replace__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("orReplace"));
-                            }
-                            or_replace__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Definition => {
-                            if definition__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("definition"));
-                            }
-                            definition__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(CreateViewNode {
-                    name: name__,
-                    input: input__,
-                    or_replace: or_replace__.unwrap_or_default(),
-                    definition: definition__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CreateViewNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CrossJoinExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.left.is_some() {
-            len += 1;
-        }
-        if self.right.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinExecNode", len)?;
-        if let Some(v) = self.left.as_ref() {
-            struct_ser.serialize_field("left", v)?;
-        }
-        if let Some(v) = self.right.as_ref() {
-            struct_ser.serialize_field("right", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CrossJoinExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "left",
-            "right",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Left,
-            Right,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "left" => Ok(GeneratedField::Left),
-                            "right" => Ok(GeneratedField::Right),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CrossJoinExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CrossJoinExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CrossJoinExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut left__ = None;
-                let mut right__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Left => {
-                            if left__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("left"));
-                            }
-                            left__ = map.next_value()?;
-                        }
-                        GeneratedField::Right => {
-                            if right__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("right"));
-                            }
-                            right__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(CrossJoinExecNode {
-                    left: left__,
-                    right: right__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CrossJoinExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CrossJoinNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.left.is_some() {
-            len += 1;
-        }
-        if self.right.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinNode", len)?;
-        if let Some(v) = self.left.as_ref() {
-            struct_ser.serialize_field("left", v)?;
-        }
-        if let Some(v) = self.right.as_ref() {
-            struct_ser.serialize_field("right", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CrossJoinNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "left",
-            "right",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Left,
-            Right,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "left" => Ok(GeneratedField::Left),
-                            "right" => Ok(GeneratedField::Right),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CrossJoinNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CrossJoinNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CrossJoinNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut left__ = None;
-                let mut right__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Left => {
-                            if left__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("left"));
-                            }
-                            left__ = map.next_value()?;
-                        }
-                        GeneratedField::Right => {
-                            if right__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("right"));
-                            }
-                            right__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(CrossJoinNode {
-                    left: left__,
-                    right: right__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CrossJoinNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CsvFormat {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.has_header {
-            len += 1;
-        }
-        if !self.delimiter.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CsvFormat", len)?;
-        if self.has_header {
-            struct_ser.serialize_field("hasHeader", &self.has_header)?;
-        }
-        if !self.delimiter.is_empty() {
-            struct_ser.serialize_field("delimiter", &self.delimiter)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CsvFormat {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "has_header",
-            "hasHeader",
-            "delimiter",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            HasHeader,
-            Delimiter,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
-                            "delimiter" => Ok(GeneratedField::Delimiter),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CsvFormat;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CsvFormat")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CsvFormat, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut has_header__ = None;
-                let mut delimiter__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::HasHeader => {
-                            if has_header__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hasHeader"));
-                            }
-                            has_header__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Delimiter => {
-                            if delimiter__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("delimiter"));
-                            }
-                            delimiter__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(CsvFormat {
-                    has_header: has_header__.unwrap_or_default(),
-                    delimiter: delimiter__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CsvFormat", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CsvScanExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.base_conf.is_some() {
-            len += 1;
-        }
-        if self.has_header {
-            len += 1;
-        }
-        if !self.delimiter.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CsvScanExecNode", len)?;
-        if let Some(v) = self.base_conf.as_ref() {
-            struct_ser.serialize_field("baseConf", v)?;
-        }
-        if self.has_header {
-            struct_ser.serialize_field("hasHeader", &self.has_header)?;
-        }
-        if !self.delimiter.is_empty() {
-            struct_ser.serialize_field("delimiter", &self.delimiter)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CsvScanExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "base_conf",
-            "baseConf",
-            "has_header",
-            "hasHeader",
-            "delimiter",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            BaseConf,
-            HasHeader,
-            Delimiter,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf),
-                            "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
-                            "delimiter" => Ok(GeneratedField::Delimiter),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CsvScanExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CsvScanExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CsvScanExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut base_conf__ = None;
-                let mut has_header__ = None;
-                let mut delimiter__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::BaseConf => {
-                            if base_conf__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("baseConf"));
-                            }
-                            base_conf__ = map.next_value()?;
-                        }
-                        GeneratedField::HasHeader => {
-                            if has_header__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hasHeader"));
-                            }
-                            has_header__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Delimiter => {
-                            if delimiter__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("delimiter"));
-                            }
-                            delimiter__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(CsvScanExecNode {
-                    base_conf: base_conf__,
-                    has_header: has_header__.unwrap_or_default(),
-                    delimiter: delimiter__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CsvScanExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CubeNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CubeNode", len)?;
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CubeNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CubeNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CubeNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CubeNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(CubeNode {
-                    expr: expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CubeNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for CustomTableScanNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.table_name.is_some() {
-            len += 1;
-        }
-        if self.projection.is_some() {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        if !self.filters.is_empty() {
-            len += 1;
-        }
-        if !self.custom_table_data.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.CustomTableScanNode", len)?;
-        if let Some(v) = self.table_name.as_ref() {
-            struct_ser.serialize_field("tableName", v)?;
-        }
-        if let Some(v) = self.projection.as_ref() {
-            struct_ser.serialize_field("projection", v)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        if !self.filters.is_empty() {
-            struct_ser.serialize_field("filters", &self.filters)?;
-        }
-        if !self.custom_table_data.is_empty() {
-            struct_ser.serialize_field("customTableData", pbjson::private::base64::encode(&self.custom_table_data).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for CustomTableScanNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "table_name",
-            "tableName",
-            "projection",
-            "schema",
-            "filters",
-            "custom_table_data",
-            "customTableData",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            TableName,
-            Projection,
-            Schema,
-            Filters,
-            CustomTableData,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
-                            "projection" => Ok(GeneratedField::Projection),
-                            "schema" => Ok(GeneratedField::Schema),
-                            "filters" => Ok(GeneratedField::Filters),
-                            "customTableData" | "custom_table_data" => Ok(GeneratedField::CustomTableData),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = CustomTableScanNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.CustomTableScanNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<CustomTableScanNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut table_name__ = None;
-                let mut projection__ = None;
-                let mut schema__ = None;
-                let mut filters__ = None;
-                let mut custom_table_data__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::TableName => {
-                            if table_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tableName"));
-                            }
-                            table_name__ = map.next_value()?;
-                        }
-                        GeneratedField::Projection => {
-                            if projection__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("projection"));
-                            }
-                            projection__ = map.next_value()?;
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                        GeneratedField::Filters => {
-                            if filters__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filters"));
-                            }
-                            filters__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::CustomTableData => {
-                            if custom_table_data__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("customTableData"));
-                            }
-                            custom_table_data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(CustomTableScanNode {
-                    table_name: table_name__,
-                    projection: projection__,
-                    schema: schema__,
-                    filters: filters__.unwrap_or_default(),
-                    custom_table_data: custom_table_data__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.CustomTableScanNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for DateUnit {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Day => "Day",
-            Self::DateMillisecond => "DateMillisecond",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for DateUnit {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "Day",
-            "DateMillisecond",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = DateUnit;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(DateUnit::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(DateUnit::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "Day" => Ok(DateUnit::Day),
-                    "DateMillisecond" => Ok(DateUnit::DateMillisecond),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Decimal {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.precision != 0 {
-            len += 1;
-        }
-        if self.scale != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Decimal", len)?;
-        if self.precision != 0 {
-            struct_ser.serialize_field("precision", &self.precision)?;
-        }
-        if self.scale != 0 {
-            struct_ser.serialize_field("scale", &self.scale)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Decimal {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "precision",
-            "scale",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Precision,
-            Scale,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "precision" => Ok(GeneratedField::Precision),
-                            "scale" => Ok(GeneratedField::Scale),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Decimal;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Decimal")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Decimal, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut precision__ = None;
-                let mut scale__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Precision => {
-                            if precision__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("precision"));
-                            }
-                            precision__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Scale => {
-                            if scale__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("scale"));
-                            }
-                            scale__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(Decimal {
-                    precision: precision__.unwrap_or_default(),
-                    scale: scale__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Decimal", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Decimal128 {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.value.is_empty() {
-            len += 1;
-        }
-        if self.p != 0 {
-            len += 1;
-        }
-        if self.s != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Decimal128", len)?;
-        if !self.value.is_empty() {
-            struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
-        }
-        if self.p != 0 {
-            struct_ser.serialize_field("p", ToString::to_string(&self.p).as_str())?;
-        }
-        if self.s != 0 {
-            struct_ser.serialize_field("s", ToString::to_string(&self.s).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Decimal128 {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "value",
-            "p",
-            "s",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Value,
-            P,
-            S,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "value" => Ok(GeneratedField::Value),
-                            "p" => Ok(GeneratedField::P),
-                            "s" => Ok(GeneratedField::S),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Decimal128;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Decimal128")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Decimal128, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut value__ = None;
-                let mut p__ = None;
-                let mut s__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("value"));
-                            }
-                            value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::P => {
-                            if p__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("p"));
-                            }
-                            p__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::S => {
-                            if s__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("s"));
-                            }
-                            s__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(Decimal128 {
-                    value: value__.unwrap_or_default(),
-                    p: p__.unwrap_or_default(),
-                    s: s__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Decimal128", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for DfField {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.field.is_some() {
-            len += 1;
-        }
-        if self.qualifier.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.DfField", len)?;
-        if let Some(v) = self.field.as_ref() {
-            struct_ser.serialize_field("field", v)?;
-        }
-        if let Some(v) = self.qualifier.as_ref() {
-            struct_ser.serialize_field("qualifier", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for DfField {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "field",
-            "qualifier",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Field,
-            Qualifier,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "field" => Ok(GeneratedField::Field),
-                            "qualifier" => Ok(GeneratedField::Qualifier),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = DfField;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.DfField")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<DfField, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut field__ = None;
-                let mut qualifier__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Field => {
-                            if field__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("field"));
-                            }
-                            field__ = map.next_value()?;
-                        }
-                        GeneratedField::Qualifier => {
-                            if qualifier__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("qualifier"));
-                            }
-                            qualifier__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(DfField {
-                    field: field__,
-                    qualifier: qualifier__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.DfField", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for DfSchema {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.columns.is_empty() {
-            len += 1;
-        }
-        if !self.metadata.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.DfSchema", len)?;
-        if !self.columns.is_empty() {
-            struct_ser.serialize_field("columns", &self.columns)?;
-        }
-        if !self.metadata.is_empty() {
-            struct_ser.serialize_field("metadata", &self.metadata)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for DfSchema {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "columns",
-            "metadata",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Columns,
-            Metadata,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "columns" => Ok(GeneratedField::Columns),
-                            "metadata" => Ok(GeneratedField::Metadata),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = DfSchema;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.DfSchema")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<DfSchema, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut columns__ = None;
-                let mut metadata__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Columns => {
-                            if columns__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("columns"));
-                            }
-                            columns__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Metadata => {
-                            if metadata__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("metadata"));
-                            }
-                            metadata__ = Some(
-                                map.next_value::<std::collections::HashMap<_, _>>()?
-                            );
-                        }
-                    }
-                }
-                Ok(DfSchema {
-                    columns: columns__.unwrap_or_default(),
-                    metadata: metadata__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.DfSchema", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Dictionary {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.key.is_some() {
-            len += 1;
-        }
-        if self.value.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Dictionary", len)?;
-        if let Some(v) = self.key.as_ref() {
-            struct_ser.serialize_field("key", v)?;
-        }
-        if let Some(v) = self.value.as_ref() {
-            struct_ser.serialize_field("value", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Dictionary {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "key",
-            "value",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Key,
-            Value,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "key" => Ok(GeneratedField::Key),
-                            "value" => Ok(GeneratedField::Value),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Dictionary;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Dictionary")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Dictionary, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut key__ = None;
-                let mut value__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Key => {
-                            if key__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("key"));
-                            }
-                            key__ = map.next_value()?;
-                        }
-                        GeneratedField::Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("value"));
-                            }
-                            value__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(Dictionary {
-                    key: key__,
-                    value: value__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Dictionary", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for DistinctNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.DistinctNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for DistinctNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = DistinctNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.DistinctNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<DistinctNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(DistinctNode {
-                    input: input__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.DistinctNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for DropViewNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.name.is_some() {
-            len += 1;
-        }
-        if self.if_exists {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.DropViewNode", len)?;
-        if let Some(v) = self.name.as_ref() {
-            struct_ser.serialize_field("name", v)?;
-        }
-        if self.if_exists {
-            struct_ser.serialize_field("ifExists", &self.if_exists)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for DropViewNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "if_exists",
-            "ifExists",
-            "schema",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            IfExists,
-            Schema,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "ifExists" | "if_exists" => Ok(GeneratedField::IfExists),
-                            "schema" => Ok(GeneratedField::Schema),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = DropViewNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.DropViewNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<DropViewNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut if_exists__ = None;
-                let mut schema__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = map.next_value()?;
-                        }
-                        GeneratedField::IfExists => {
-                            if if_exists__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("ifExists"));
-                            }
-                            if_exists__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(DropViewNode {
-                    name: name__,
-                    if_exists: if_exists__.unwrap_or_default(),
-                    schema: schema__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.DropViewNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for EmptyExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.produce_one_row {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.EmptyExecNode", len)?;
-        if self.produce_one_row {
-            struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for EmptyExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "produce_one_row",
-            "produceOneRow",
-            "schema",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            ProduceOneRow,
-            Schema,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow),
-                            "schema" => Ok(GeneratedField::Schema),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = EmptyExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.EmptyExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<EmptyExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut produce_one_row__ = None;
-                let mut schema__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::ProduceOneRow => {
-                            if produce_one_row__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("produceOneRow"));
-                            }
-                            produce_one_row__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(EmptyExecNode {
-                    produce_one_row: produce_one_row__.unwrap_or_default(),
-                    schema: schema__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.EmptyExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for EmptyMessage {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let len = 0;
-        let struct_ser = serializer.serialize_struct("datafusion.EmptyMessage", len)?;
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for EmptyMessage {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                            Err(serde::de::Error::unknown_field(value, FIELDS))
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = EmptyMessage;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.EmptyMessage")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<EmptyMessage, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
-                }
-                Ok(EmptyMessage {
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.EmptyMessage", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for EmptyRelationNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.produce_one_row {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.EmptyRelationNode", len)?;
-        if self.produce_one_row {
-            struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for EmptyRelationNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "produce_one_row",
-            "produceOneRow",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            ProduceOneRow,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = EmptyRelationNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.EmptyRelationNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<EmptyRelationNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut produce_one_row__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::ProduceOneRow => {
-                            if produce_one_row__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("produceOneRow"));
-                            }
-                            produce_one_row__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(EmptyRelationNode {
-                    produce_one_row: produce_one_row__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.EmptyRelationNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ExplainExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.schema.is_some() {
-            len += 1;
-        }
-        if !self.stringified_plans.is_empty() {
-            len += 1;
-        }
-        if self.verbose {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ExplainExecNode", len)?;
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        if !self.stringified_plans.is_empty() {
-            struct_ser.serialize_field("stringifiedPlans", &self.stringified_plans)?;
-        }
-        if self.verbose {
-            struct_ser.serialize_field("verbose", &self.verbose)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ExplainExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "schema",
-            "stringified_plans",
-            "stringifiedPlans",
-            "verbose",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Schema,
-            StringifiedPlans,
-            Verbose,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "schema" => Ok(GeneratedField::Schema),
-                            "stringifiedPlans" | "stringified_plans" => Ok(GeneratedField::StringifiedPlans),
-                            "verbose" => Ok(GeneratedField::Verbose),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ExplainExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ExplainExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ExplainExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut schema__ = None;
-                let mut stringified_plans__ = None;
-                let mut verbose__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                        GeneratedField::StringifiedPlans => {
-                            if stringified_plans__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("stringifiedPlans"));
-                            }
-                            stringified_plans__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Verbose => {
-                            if verbose__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("verbose"));
-                            }
-                            verbose__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ExplainExecNode {
-                    schema: schema__,
-                    stringified_plans: stringified_plans__.unwrap_or_default(),
-                    verbose: verbose__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ExplainExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ExplainNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.verbose {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ExplainNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if self.verbose {
-            struct_ser.serialize_field("verbose", &self.verbose)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ExplainNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "verbose",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Verbose,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "verbose" => Ok(GeneratedField::Verbose),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ExplainNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ExplainNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ExplainNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut verbose__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Verbose => {
-                            if verbose__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("verbose"));
-                            }
-                            verbose__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ExplainNode {
-                    input: input__,
-                    verbose: verbose__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ExplainNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Field {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.name.is_empty() {
-            len += 1;
-        }
-        if self.arrow_type.is_some() {
-            len += 1;
-        }
-        if self.nullable {
-            len += 1;
-        }
-        if !self.children.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Field", len)?;
-        if !self.name.is_empty() {
-            struct_ser.serialize_field("name", &self.name)?;
-        }
-        if let Some(v) = self.arrow_type.as_ref() {
-            struct_ser.serialize_field("arrowType", v)?;
-        }
-        if self.nullable {
-            struct_ser.serialize_field("nullable", &self.nullable)?;
-        }
-        if !self.children.is_empty() {
-            struct_ser.serialize_field("children", &self.children)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Field {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "arrow_type",
-            "arrowType",
-            "nullable",
-            "children",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            ArrowType,
-            Nullable,
-            Children,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
-                            "nullable" => Ok(GeneratedField::Nullable),
-                            "children" => Ok(GeneratedField::Children),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Field;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Field")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Field, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut arrow_type__ = None;
-                let mut nullable__ = None;
-                let mut children__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::ArrowType => {
-                            if arrow_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("arrowType"));
-                            }
-                            arrow_type__ = map.next_value()?;
-                        }
-                        GeneratedField::Nullable => {
-                            if nullable__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullable"));
-                            }
-                            nullable__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Children => {
-                            if children__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("children"));
-                            }
-                            children__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(Field {
-                    name: name__.unwrap_or_default(),
-                    arrow_type: arrow_type__,
-                    nullable: nullable__.unwrap_or_default(),
-                    children: children__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Field", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for FileGroup {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.files.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.FileGroup", len)?;
-        if !self.files.is_empty() {
-            struct_ser.serialize_field("files", &self.files)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for FileGroup {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "files",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Files,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "files" => Ok(GeneratedField::Files),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = FileGroup;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.FileGroup")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<FileGroup, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut files__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Files => {
-                            if files__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("files"));
-                            }
-                            files__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(FileGroup {
-                    files: files__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.FileGroup", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for FileRange {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.start != 0 {
-            len += 1;
-        }
-        if self.end != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.FileRange", len)?;
-        if self.start != 0 {
-            struct_ser.serialize_field("start", ToString::to_string(&self.start).as_str())?;
-        }
-        if self.end != 0 {
-            struct_ser.serialize_field("end", ToString::to_string(&self.end).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for FileRange {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "start",
-            "end",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Start,
-            End,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "start" => Ok(GeneratedField::Start),
-                            "end" => Ok(GeneratedField::End),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = FileRange;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.FileRange")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<FileRange, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut start__ = None;
-                let mut end__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Start => {
-                            if start__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("start"));
-                            }
-                            start__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::End => {
-                            if end__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("end"));
-                            }
-                            end__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(FileRange {
-                    start: start__.unwrap_or_default(),
-                    end: end__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.FileRange", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for FileScanExecConf {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.file_groups.is_empty() {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        if !self.projection.is_empty() {
-            len += 1;
-        }
-        if self.limit.is_some() {
-            len += 1;
-        }
-        if self.statistics.is_some() {
-            len += 1;
-        }
-        if !self.table_partition_cols.is_empty() {
-            len += 1;
-        }
-        if !self.object_store_url.is_empty() {
-            len += 1;
-        }
-        if !self.output_ordering.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.FileScanExecConf", len)?;
-        if !self.file_groups.is_empty() {
-            struct_ser.serialize_field("fileGroups", &self.file_groups)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        if !self.projection.is_empty() {
-            struct_ser.serialize_field("projection", &self.projection)?;
-        }
-        if let Some(v) = self.limit.as_ref() {
-            struct_ser.serialize_field("limit", v)?;
-        }
-        if let Some(v) = self.statistics.as_ref() {
-            struct_ser.serialize_field("statistics", v)?;
-        }
-        if !self.table_partition_cols.is_empty() {
-            struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?;
-        }
-        if !self.object_store_url.is_empty() {
-            struct_ser.serialize_field("objectStoreUrl", &self.object_store_url)?;
-        }
-        if !self.output_ordering.is_empty() {
-            struct_ser.serialize_field("outputOrdering", &self.output_ordering)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for FileScanExecConf {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "file_groups",
-            "fileGroups",
-            "schema",
-            "projection",
-            "limit",
-            "statistics",
-            "table_partition_cols",
-            "tablePartitionCols",
-            "object_store_url",
-            "objectStoreUrl",
-            "output_ordering",
-            "outputOrdering",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            FileGroups,
-            Schema,
-            Projection,
-            Limit,
-            Statistics,
-            TablePartitionCols,
-            ObjectStoreUrl,
-            OutputOrdering,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "fileGroups" | "file_groups" => Ok(GeneratedField::FileGroups),
-                            "schema" => Ok(GeneratedField::Schema),
-                            "projection" => Ok(GeneratedField::Projection),
-                            "limit" => Ok(GeneratedField::Limit),
-                            "statistics" => Ok(GeneratedField::Statistics),
-                            "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
-                            "objectStoreUrl" | "object_store_url" => Ok(GeneratedField::ObjectStoreUrl),
-                            "outputOrdering" | "output_ordering" => Ok(GeneratedField::OutputOrdering),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = FileScanExecConf;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.FileScanExecConf")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<FileScanExecConf, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut file_groups__ = None;
-                let mut schema__ = None;
-                let mut projection__ = None;
-                let mut limit__ = None;
-                let mut statistics__ = None;
-                let mut table_partition_cols__ = None;
-                let mut object_store_url__ = None;
-                let mut output_ordering__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::FileGroups => {
-                            if file_groups__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fileGroups"));
-                            }
-                            file_groups__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                        GeneratedField::Projection => {
-                            if projection__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("projection"));
-                            }
-                            projection__ = 
-                                Some(map.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
-                                    .into_iter().map(|x| x.0).collect())
-                            ;
-                        }
-                        GeneratedField::Limit => {
-                            if limit__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("limit"));
-                            }
-                            limit__ = map.next_value()?;
-                        }
-                        GeneratedField::Statistics => {
-                            if statistics__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("statistics"));
-                            }
-                            statistics__ = map.next_value()?;
-                        }
-                        GeneratedField::TablePartitionCols => {
-                            if table_partition_cols__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tablePartitionCols"));
-                            }
-                            table_partition_cols__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::ObjectStoreUrl => {
-                            if object_store_url__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("objectStoreUrl"));
-                            }
-                            object_store_url__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::OutputOrdering => {
-                            if output_ordering__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("outputOrdering"));
-                            }
-                            output_ordering__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(FileScanExecConf {
-                    file_groups: file_groups__.unwrap_or_default(),
-                    schema: schema__,
-                    projection: projection__.unwrap_or_default(),
-                    limit: limit__,
-                    statistics: statistics__,
-                    table_partition_cols: table_partition_cols__.unwrap_or_default(),
-                    object_store_url: object_store_url__.unwrap_or_default(),
-                    output_ordering: output_ordering__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.FileScanExecConf", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for FilterExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.FilterExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for FilterExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = FilterExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.FilterExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<FilterExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(FilterExecNode {
-                    input: input__,
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.FilterExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for FixedSizeBinary {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.length != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeBinary", len)?;
-        if self.length != 0 {
-            struct_ser.serialize_field("length", &self.length)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for FixedSizeBinary {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "length",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Length,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "length" => Ok(GeneratedField::Length),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = FixedSizeBinary;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.FixedSizeBinary")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<FixedSizeBinary, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut length__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Length => {
-                            if length__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("length"));
-                            }
-                            length__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(FixedSizeBinary {
-                    length: length__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.FixedSizeBinary", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for FixedSizeList {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.field_type.is_some() {
-            len += 1;
-        }
-        if self.list_size != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeList", len)?;
-        if let Some(v) = self.field_type.as_ref() {
-            struct_ser.serialize_field("fieldType", v)?;
-        }
-        if self.list_size != 0 {
-            struct_ser.serialize_field("listSize", &self.list_size)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for FixedSizeList {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "field_type",
-            "fieldType",
-            "list_size",
-            "listSize",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            FieldType,
-            ListSize,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
-                            "listSize" | "list_size" => Ok(GeneratedField::ListSize),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = FixedSizeList;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.FixedSizeList")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<FixedSizeList, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut field_type__ = None;
-                let mut list_size__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::FieldType => {
-                            if field_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fieldType"));
-                            }
-                            field_type__ = map.next_value()?;
-                        }
-                        GeneratedField::ListSize => {
-                            if list_size__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("listSize"));
-                            }
-                            list_size__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(FixedSizeList {
-                    field_type: field_type__,
-                    list_size: list_size__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.FixedSizeList", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for FullTableReference {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.catalog.is_empty() {
-            len += 1;
-        }
-        if !self.schema.is_empty() {
-            len += 1;
-        }
-        if !self.table.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.FullTableReference", len)?;
-        if !self.catalog.is_empty() {
-            struct_ser.serialize_field("catalog", &self.catalog)?;
-        }
-        if !self.schema.is_empty() {
-            struct_ser.serialize_field("schema", &self.schema)?;
-        }
-        if !self.table.is_empty() {
-            struct_ser.serialize_field("table", &self.table)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for FullTableReference {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "catalog",
-            "schema",
-            "table",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Catalog,
-            Schema,
-            Table,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "catalog" => Ok(GeneratedField::Catalog),
-                            "schema" => Ok(GeneratedField::Schema),
-                            "table" => Ok(GeneratedField::Table),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = FullTableReference;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.FullTableReference")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<FullTableReference, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut catalog__ = None;
-                let mut schema__ = None;
-                let mut table__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Catalog => {
-                            if catalog__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("catalog"));
-                            }
-                            catalog__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Table => {
-                            if table__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("table"));
-                            }
-                            table__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(FullTableReference {
-                    catalog: catalog__.unwrap_or_default(),
-                    schema: schema__.unwrap_or_default(),
-                    table: table__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.FullTableReference", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for GetIndexedField {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.key.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.GetIndexedField", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.key.as_ref() {
-            struct_ser.serialize_field("key", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for GetIndexedField {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "key",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            Key,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "key" => Ok(GeneratedField::Key),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = GetIndexedField;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.GetIndexedField")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<GetIndexedField, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut key__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Key => {
-                            if key__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("key"));
-                            }
-                            key__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(GetIndexedField {
-                    expr: expr__,
-                    key: key__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.GetIndexedField", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for GlobalLimitExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.skip != 0 {
-            len += 1;
-        }
-        if self.fetch != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.GlobalLimitExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if self.skip != 0 {
-            struct_ser.serialize_field("skip", &self.skip)?;
-        }
-        if self.fetch != 0 {
-            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for GlobalLimitExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "skip",
-            "fetch",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Skip,
-            Fetch,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "skip" => Ok(GeneratedField::Skip),
-                            "fetch" => Ok(GeneratedField::Fetch),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = GlobalLimitExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.GlobalLimitExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<GlobalLimitExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut skip__ = None;
-                let mut fetch__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Skip => {
-                            if skip__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("skip"));
-                            }
-                            skip__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Fetch => {
-                            if fetch__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fetch"));
-                            }
-                            fetch__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(GlobalLimitExecNode {
-                    input: input__,
-                    skip: skip__.unwrap_or_default(),
-                    fetch: fetch__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.GlobalLimitExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for GroupingSetNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.GroupingSetNode", len)?;
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for GroupingSetNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = GroupingSetNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.GroupingSetNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<GroupingSetNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(GroupingSetNode {
-                    expr: expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.GroupingSetNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for HashJoinExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.left.is_some() {
-            len += 1;
-        }
-        if self.right.is_some() {
-            len += 1;
-        }
-        if !self.on.is_empty() {
-            len += 1;
-        }
-        if self.join_type != 0 {
-            len += 1;
-        }
-        if self.partition_mode != 0 {
-            len += 1;
-        }
-        if self.null_equals_null {
-            len += 1;
-        }
-        if self.filter.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.HashJoinExecNode", len)?;
-        if let Some(v) = self.left.as_ref() {
-            struct_ser.serialize_field("left", v)?;
-        }
-        if let Some(v) = self.right.as_ref() {
-            struct_ser.serialize_field("right", v)?;
-        }
-        if !self.on.is_empty() {
-            struct_ser.serialize_field("on", &self.on)?;
-        }
-        if self.join_type != 0 {
-            let v = JoinType::from_i32(self.join_type)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
-            struct_ser.serialize_field("joinType", &v)?;
-        }
-        if self.partition_mode != 0 {
-            let v = PartitionMode::from_i32(self.partition_mode)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.partition_mode)))?;
-            struct_ser.serialize_field("partitionMode", &v)?;
-        }
-        if self.null_equals_null {
-            struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?;
-        }
-        if let Some(v) = self.filter.as_ref() {
-            struct_ser.serialize_field("filter", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for HashJoinExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "left",
-            "right",
-            "on",
-            "join_type",
-            "joinType",
-            "partition_mode",
-            "partitionMode",
-            "null_equals_null",
-            "nullEqualsNull",
-            "filter",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Left,
-            Right,
-            On,
-            JoinType,
-            PartitionMode,
-            NullEqualsNull,
-            Filter,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "left" => Ok(GeneratedField::Left),
-                            "right" => Ok(GeneratedField::Right),
-                            "on" => Ok(GeneratedField::On),
-                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
-                            "partitionMode" | "partition_mode" => Ok(GeneratedField::PartitionMode),
-                            "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull),
-                            "filter" => Ok(GeneratedField::Filter),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = HashJoinExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.HashJoinExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<HashJoinExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut left__ = None;
-                let mut right__ = None;
-                let mut on__ = None;
-                let mut join_type__ = None;
-                let mut partition_mode__ = None;
-                let mut null_equals_null__ = None;
-                let mut filter__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Left => {
-                            if left__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("left"));
-                            }
-                            left__ = map.next_value()?;
-                        }
-                        GeneratedField::Right => {
-                            if right__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("right"));
-                            }
-                            right__ = map.next_value()?;
-                        }
-                        GeneratedField::On => {
-                            if on__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("on"));
-                            }
-                            on__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::JoinType => {
-                            if join_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("joinType"));
-                            }
-                            join_type__ = Some(map.next_value::<JoinType>()? as i32);
-                        }
-                        GeneratedField::PartitionMode => {
-                            if partition_mode__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("partitionMode"));
-                            }
-                            partition_mode__ = Some(map.next_value::<PartitionMode>()? as i32);
-                        }
-                        GeneratedField::NullEqualsNull => {
-                            if null_equals_null__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullEqualsNull"));
-                            }
-                            null_equals_null__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Filter => {
-                            if filter__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filter"));
-                            }
-                            filter__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(HashJoinExecNode {
-                    left: left__,
-                    right: right__,
-                    on: on__.unwrap_or_default(),
-                    join_type: join_type__.unwrap_or_default(),
-                    partition_mode: partition_mode__.unwrap_or_default(),
-                    null_equals_null: null_equals_null__.unwrap_or_default(),
-                    filter: filter__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.HashJoinExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for HashRepartition {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.hash_expr.is_empty() {
-            len += 1;
-        }
-        if self.partition_count != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.HashRepartition", len)?;
-        if !self.hash_expr.is_empty() {
-            struct_ser.serialize_field("hashExpr", &self.hash_expr)?;
-        }
-        if self.partition_count != 0 {
-            struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for HashRepartition {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "hash_expr",
-            "hashExpr",
-            "partition_count",
-            "partitionCount",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            HashExpr,
-            PartitionCount,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr),
-                            "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = HashRepartition;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.HashRepartition")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<HashRepartition, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut hash_expr__ = None;
-                let mut partition_count__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::HashExpr => {
-                            if hash_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hashExpr"));
-                            }
-                            hash_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::PartitionCount => {
-                            if partition_count__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("partitionCount"));
-                            }
-                            partition_count__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(HashRepartition {
-                    hash_expr: hash_expr__.unwrap_or_default(),
-                    partition_count: partition_count__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.HashRepartition", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ILikeNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.negated {
-            len += 1;
-        }
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.pattern.is_some() {
-            len += 1;
-        }
-        if !self.escape_char.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ILikeNode", len)?;
-        if self.negated {
-            struct_ser.serialize_field("negated", &self.negated)?;
-        }
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.pattern.as_ref() {
-            struct_ser.serialize_field("pattern", v)?;
-        }
-        if !self.escape_char.is_empty() {
-            struct_ser.serialize_field("escapeChar", &self.escape_char)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ILikeNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "negated",
-            "expr",
-            "pattern",
-            "escape_char",
-            "escapeChar",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Negated,
-            Expr,
-            Pattern,
-            EscapeChar,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "negated" => Ok(GeneratedField::Negated),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "pattern" => Ok(GeneratedField::Pattern),
-                            "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ILikeNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ILikeNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ILikeNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut negated__ = None;
-                let mut expr__ = None;
-                let mut pattern__ = None;
-                let mut escape_char__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Negated => {
-                            if negated__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negated"));
-                            }
-                            negated__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Pattern => {
-                            if pattern__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("pattern"));
-                            }
-                            pattern__ = map.next_value()?;
-                        }
-                        GeneratedField::EscapeChar => {
-                            if escape_char__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("escapeChar"));
-                            }
-                            escape_char__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ILikeNode {
-                    negated: negated__.unwrap_or_default(),
-                    expr: expr__,
-                    pattern: pattern__,
-                    escape_char: escape_char__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ILikeNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for InListNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if !self.list.is_empty() {
-            len += 1;
-        }
-        if self.negated {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.InListNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if !self.list.is_empty() {
-            struct_ser.serialize_field("list", &self.list)?;
-        }
-        if self.negated {
-            struct_ser.serialize_field("negated", &self.negated)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for InListNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "list",
-            "negated",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            List,
-            Negated,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "list" => Ok(GeneratedField::List),
-                            "negated" => Ok(GeneratedField::Negated),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = InListNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.InListNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<InListNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut list__ = None;
-                let mut negated__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::List => {
-                            if list__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("list"));
-                            }
-                            list__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Negated => {
-                            if negated__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negated"));
-                            }
-                            negated__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(InListNode {
-                    expr: expr__,
-                    list: list__.unwrap_or_default(),
-                    negated: negated__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.InListNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IntervalMonthDayNanoValue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.months != 0 {
-            len += 1;
-        }
-        if self.days != 0 {
-            len += 1;
-        }
-        if self.nanos != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IntervalMonthDayNanoValue", len)?;
-        if self.months != 0 {
-            struct_ser.serialize_field("months", &self.months)?;
-        }
-        if self.days != 0 {
-            struct_ser.serialize_field("days", &self.days)?;
-        }
-        if self.nanos != 0 {
-            struct_ser.serialize_field("nanos", ToString::to_string(&self.nanos).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "months",
-            "days",
-            "nanos",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Months,
-            Days,
-            Nanos,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "months" => Ok(GeneratedField::Months),
-                            "days" => Ok(GeneratedField::Days),
-                            "nanos" => Ok(GeneratedField::Nanos),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IntervalMonthDayNanoValue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IntervalMonthDayNanoValue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IntervalMonthDayNanoValue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut months__ = None;
-                let mut days__ = None;
-                let mut nanos__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Months => {
-                            if months__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("months"));
-                            }
-                            months__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Days => {
-                            if days__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("days"));
-                            }
-                            days__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Nanos => {
-                            if nanos__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nanos"));
-                            }
-                            nanos__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(IntervalMonthDayNanoValue {
-                    months: months__.unwrap_or_default(),
-                    days: days__.unwrap_or_default(),
-                    nanos: nanos__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IntervalMonthDayNanoValue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IntervalUnit {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::YearMonth => "YearMonth",
-            Self::DayTime => "DayTime",
-            Self::MonthDayNano => "MonthDayNano",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for IntervalUnit {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "YearMonth",
-            "DayTime",
-            "MonthDayNano",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IntervalUnit;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(IntervalUnit::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(IntervalUnit::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "YearMonth" => Ok(IntervalUnit::YearMonth),
-                    "DayTime" => Ok(IntervalUnit::DayTime),
-                    "MonthDayNano" => Ok(IntervalUnit::MonthDayNano),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsFalse {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsFalse", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsFalse {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsFalse;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsFalse")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsFalse, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsFalse {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsFalse", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsNotFalse {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotFalse", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsNotFalse {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsNotFalse;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsNotFalse")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotFalse, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsNotFalse {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsNotFalse", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsNotNull {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotNull", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsNotNull {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsNotNull;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsNotNull")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotNull, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsNotNull {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsNotNull", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsNotTrue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotTrue", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsNotTrue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsNotTrue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsNotTrue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotTrue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsNotTrue {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsNotTrue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsNotUnknown {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsNotUnknown", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsNotUnknown {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsNotUnknown;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsNotUnknown")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNotUnknown, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsNotUnknown {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsNotUnknown", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsNull {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsNull", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsNull {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsNull;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsNull")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsNull, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsNull {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsNull", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsTrue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsTrue", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsTrue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsTrue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsTrue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsTrue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsTrue {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsTrue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for IsUnknown {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.IsUnknown", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for IsUnknown {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = IsUnknown;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.IsUnknown")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<IsUnknown, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(IsUnknown {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.IsUnknown", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for JoinConstraint {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::On => "ON",
-            Self::Using => "USING",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for JoinConstraint {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "ON",
-            "USING",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = JoinConstraint;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(JoinConstraint::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(JoinConstraint::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "ON" => Ok(JoinConstraint::On),
-                    "USING" => Ok(JoinConstraint::Using),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for JoinFilter {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expression.is_some() {
-            len += 1;
-        }
-        if !self.column_indices.is_empty() {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.JoinFilter", len)?;
-        if let Some(v) = self.expression.as_ref() {
-            struct_ser.serialize_field("expression", v)?;
-        }
-        if !self.column_indices.is_empty() {
-            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for JoinFilter {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expression",
-            "column_indices",
-            "columnIndices",
-            "schema",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expression,
-            ColumnIndices,
-            Schema,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expression" => Ok(GeneratedField::Expression),
-                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
-                            "schema" => Ok(GeneratedField::Schema),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = JoinFilter;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.JoinFilter")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<JoinFilter, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expression__ = None;
-                let mut column_indices__ = None;
-                let mut schema__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expression => {
-                            if expression__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expression"));
-                            }
-                            expression__ = map.next_value()?;
-                        }
-                        GeneratedField::ColumnIndices => {
-                            if column_indices__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("columnIndices"));
-                            }
-                            column_indices__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(JoinFilter {
-                    expression: expression__,
-                    column_indices: column_indices__.unwrap_or_default(),
-                    schema: schema__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.JoinFilter", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for JoinNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.left.is_some() {
-            len += 1;
-        }
-        if self.right.is_some() {
-            len += 1;
-        }
-        if self.join_type != 0 {
-            len += 1;
-        }
-        if self.join_constraint != 0 {
-            len += 1;
-        }
-        if !self.left_join_key.is_empty() {
-            len += 1;
-        }
-        if !self.right_join_key.is_empty() {
-            len += 1;
-        }
-        if self.null_equals_null {
-            len += 1;
-        }
-        if self.filter.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.JoinNode", len)?;
-        if let Some(v) = self.left.as_ref() {
-            struct_ser.serialize_field("left", v)?;
-        }
-        if let Some(v) = self.right.as_ref() {
-            struct_ser.serialize_field("right", v)?;
-        }
-        if self.join_type != 0 {
-            let v = JoinType::from_i32(self.join_type)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
-            struct_ser.serialize_field("joinType", &v)?;
-        }
-        if self.join_constraint != 0 {
-            let v = JoinConstraint::from_i32(self.join_constraint)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_constraint)))?;
-            struct_ser.serialize_field("joinConstraint", &v)?;
-        }
-        if !self.left_join_key.is_empty() {
-            struct_ser.serialize_field("leftJoinKey", &self.left_join_key)?;
-        }
-        if !self.right_join_key.is_empty() {
-            struct_ser.serialize_field("rightJoinKey", &self.right_join_key)?;
-        }
-        if self.null_equals_null {
-            struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?;
-        }
-        if let Some(v) = self.filter.as_ref() {
-            struct_ser.serialize_field("filter", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for JoinNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "left",
-            "right",
-            "join_type",
-            "joinType",
-            "join_constraint",
-            "joinConstraint",
-            "left_join_key",
-            "leftJoinKey",
-            "right_join_key",
-            "rightJoinKey",
-            "null_equals_null",
-            "nullEqualsNull",
-            "filter",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Left,
-            Right,
-            JoinType,
-            JoinConstraint,
-            LeftJoinKey,
-            RightJoinKey,
-            NullEqualsNull,
-            Filter,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "left" => Ok(GeneratedField::Left),
-                            "right" => Ok(GeneratedField::Right),
-                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
-                            "joinConstraint" | "join_constraint" => Ok(GeneratedField::JoinConstraint),
-                            "leftJoinKey" | "left_join_key" => Ok(GeneratedField::LeftJoinKey),
-                            "rightJoinKey" | "right_join_key" => Ok(GeneratedField::RightJoinKey),
-                            "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull),
-                            "filter" => Ok(GeneratedField::Filter),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = JoinNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.JoinNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<JoinNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut left__ = None;
-                let mut right__ = None;
-                let mut join_type__ = None;
-                let mut join_constraint__ = None;
-                let mut left_join_key__ = None;
-                let mut right_join_key__ = None;
-                let mut null_equals_null__ = None;
-                let mut filter__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Left => {
-                            if left__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("left"));
-                            }
-                            left__ = map.next_value()?;
-                        }
-                        GeneratedField::Right => {
-                            if right__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("right"));
-                            }
-                            right__ = map.next_value()?;
-                        }
-                        GeneratedField::JoinType => {
-                            if join_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("joinType"));
-                            }
-                            join_type__ = Some(map.next_value::<JoinType>()? as i32);
-                        }
-                        GeneratedField::JoinConstraint => {
-                            if join_constraint__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("joinConstraint"));
-                            }
-                            join_constraint__ = Some(map.next_value::<JoinConstraint>()? as i32);
-                        }
-                        GeneratedField::LeftJoinKey => {
-                            if left_join_key__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("leftJoinKey"));
-                            }
-                            left_join_key__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::RightJoinKey => {
-                            if right_join_key__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("rightJoinKey"));
-                            }
-                            right_join_key__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::NullEqualsNull => {
-                            if null_equals_null__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullEqualsNull"));
-                            }
-                            null_equals_null__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Filter => {
-                            if filter__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filter"));
-                            }
-                            filter__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(JoinNode {
-                    left: left__,
-                    right: right__,
-                    join_type: join_type__.unwrap_or_default(),
-                    join_constraint: join_constraint__.unwrap_or_default(),
-                    left_join_key: left_join_key__.unwrap_or_default(),
-                    right_join_key: right_join_key__.unwrap_or_default(),
-                    null_equals_null: null_equals_null__.unwrap_or_default(),
-                    filter: filter__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.JoinNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for JoinOn {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.left.is_some() {
-            len += 1;
-        }
-        if self.right.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.JoinOn", len)?;
-        if let Some(v) = self.left.as_ref() {
-            struct_ser.serialize_field("left", v)?;
-        }
-        if let Some(v) = self.right.as_ref() {
-            struct_ser.serialize_field("right", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for JoinOn {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "left",
-            "right",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Left,
-            Right,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "left" => Ok(GeneratedField::Left),
-                            "right" => Ok(GeneratedField::Right),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = JoinOn;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.JoinOn")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<JoinOn, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut left__ = None;
-                let mut right__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Left => {
-                            if left__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("left"));
-                            }
-                            left__ = map.next_value()?;
-                        }
-                        GeneratedField::Right => {
-                            if right__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("right"));
-                            }
-                            right__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(JoinOn {
-                    left: left__,
-                    right: right__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.JoinOn", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for JoinSide {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::LeftSide => "LEFT_SIDE",
-            Self::RightSide => "RIGHT_SIDE",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for JoinSide {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "LEFT_SIDE",
-            "RIGHT_SIDE",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = JoinSide;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(JoinSide::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(JoinSide::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "LEFT_SIDE" => Ok(JoinSide::LeftSide),
-                    "RIGHT_SIDE" => Ok(JoinSide::RightSide),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for JoinType {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Inner => "INNER",
-            Self::Left => "LEFT",
-            Self::Right => "RIGHT",
-            Self::Full => "FULL",
-            Self::Leftsemi => "LEFTSEMI",
-            Self::Leftanti => "LEFTANTI",
-            Self::Rightsemi => "RIGHTSEMI",
-            Self::Rightanti => "RIGHTANTI",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for JoinType {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "INNER",
-            "LEFT",
-            "RIGHT",
-            "FULL",
-            "LEFTSEMI",
-            "LEFTANTI",
-            "RIGHTSEMI",
-            "RIGHTANTI",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = JoinType;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(JoinType::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(JoinType::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "INNER" => Ok(JoinType::Inner),
-                    "LEFT" => Ok(JoinType::Left),
-                    "RIGHT" => Ok(JoinType::Right),
-                    "FULL" => Ok(JoinType::Full),
-                    "LEFTSEMI" => Ok(JoinType::Leftsemi),
-                    "LEFTANTI" => Ok(JoinType::Leftanti),
-                    "RIGHTSEMI" => Ok(JoinType::Rightsemi),
-                    "RIGHTANTI" => Ok(JoinType::Rightanti),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LikeNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.negated {
-            len += 1;
-        }
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.pattern.is_some() {
-            len += 1;
-        }
-        if !self.escape_char.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LikeNode", len)?;
-        if self.negated {
-            struct_ser.serialize_field("negated", &self.negated)?;
-        }
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.pattern.as_ref() {
-            struct_ser.serialize_field("pattern", v)?;
-        }
-        if !self.escape_char.is_empty() {
-            struct_ser.serialize_field("escapeChar", &self.escape_char)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LikeNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "negated",
-            "expr",
-            "pattern",
-            "escape_char",
-            "escapeChar",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Negated,
-            Expr,
-            Pattern,
-            EscapeChar,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "negated" => Ok(GeneratedField::Negated),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "pattern" => Ok(GeneratedField::Pattern),
-                            "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LikeNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LikeNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LikeNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut negated__ = None;
-                let mut expr__ = None;
-                let mut pattern__ = None;
-                let mut escape_char__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Negated => {
-                            if negated__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negated"));
-                            }
-                            negated__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Pattern => {
-                            if pattern__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("pattern"));
-                            }
-                            pattern__ = map.next_value()?;
-                        }
-                        GeneratedField::EscapeChar => {
-                            if escape_char__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("escapeChar"));
-                            }
-                            escape_char__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(LikeNode {
-                    negated: negated__.unwrap_or_default(),
-                    expr: expr__,
-                    pattern: pattern__,
-                    escape_char: escape_char__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LikeNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LimitNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.skip != 0 {
-            len += 1;
-        }
-        if self.fetch != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LimitNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if self.skip != 0 {
-            struct_ser.serialize_field("skip", ToString::to_string(&self.skip).as_str())?;
-        }
-        if self.fetch != 0 {
-            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LimitNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "skip",
-            "fetch",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Skip,
-            Fetch,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "skip" => Ok(GeneratedField::Skip),
-                            "fetch" => Ok(GeneratedField::Fetch),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LimitNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LimitNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LimitNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut skip__ = None;
-                let mut fetch__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Skip => {
-                            if skip__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("skip"));
-                            }
-                            skip__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Fetch => {
-                            if fetch__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fetch"));
-                            }
-                            fetch__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(LimitNode {
-                    input: input__,
-                    skip: skip__.unwrap_or_default(),
-                    fetch: fetch__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LimitNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for List {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.field_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.List", len)?;
-        if let Some(v) = self.field_type.as_ref() {
-            struct_ser.serialize_field("fieldType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for List {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "field_type",
-            "fieldType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            FieldType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = List;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.List")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<List, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut field_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::FieldType => {
-                            if field_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fieldType"));
-                            }
-                            field_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(List {
-                    field_type: field_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.List", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ListingTableScanNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.table_name.is_some() {
-            len += 1;
-        }
-        if !self.paths.is_empty() {
-            len += 1;
-        }
-        if !self.file_extension.is_empty() {
-            len += 1;
-        }
-        if self.projection.is_some() {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        if !self.filters.is_empty() {
-            len += 1;
-        }
-        if !self.table_partition_cols.is_empty() {
-            len += 1;
-        }
-        if self.collect_stat {
-            len += 1;
-        }
-        if self.target_partitions != 0 {
-            len += 1;
-        }
-        if !self.file_sort_order.is_empty() {
-            len += 1;
-        }
-        if self.file_format_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ListingTableScanNode", len)?;
-        if let Some(v) = self.table_name.as_ref() {
-            struct_ser.serialize_field("tableName", v)?;
-        }
-        if !self.paths.is_empty() {
-            struct_ser.serialize_field("paths", &self.paths)?;
-        }
-        if !self.file_extension.is_empty() {
-            struct_ser.serialize_field("fileExtension", &self.file_extension)?;
-        }
-        if let Some(v) = self.projection.as_ref() {
-            struct_ser.serialize_field("projection", v)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        if !self.filters.is_empty() {
-            struct_ser.serialize_field("filters", &self.filters)?;
-        }
-        if !self.table_partition_cols.is_empty() {
-            struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?;
-        }
-        if self.collect_stat {
-            struct_ser.serialize_field("collectStat", &self.collect_stat)?;
-        }
-        if self.target_partitions != 0 {
-            struct_ser.serialize_field("targetPartitions", &self.target_partitions)?;
-        }
-        if !self.file_sort_order.is_empty() {
-            struct_ser.serialize_field("fileSortOrder", &self.file_sort_order)?;
-        }
-        if let Some(v) = self.file_format_type.as_ref() {
-            match v {
-                listing_table_scan_node::FileFormatType::Csv(v) => {
-                    struct_ser.serialize_field("csv", v)?;
-                }
-                listing_table_scan_node::FileFormatType::Parquet(v) => {
-                    struct_ser.serialize_field("parquet", v)?;
-                }
-                listing_table_scan_node::FileFormatType::Avro(v) => {
-                    struct_ser.serialize_field("avro", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ListingTableScanNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "table_name",
-            "tableName",
-            "paths",
-            "file_extension",
-            "fileExtension",
-            "projection",
-            "schema",
-            "filters",
-            "table_partition_cols",
-            "tablePartitionCols",
-            "collect_stat",
-            "collectStat",
-            "target_partitions",
-            "targetPartitions",
-            "file_sort_order",
-            "fileSortOrder",
-            "csv",
-            "parquet",
-            "avro",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            TableName,
-            Paths,
-            FileExtension,
-            Projection,
-            Schema,
-            Filters,
-            TablePartitionCols,
-            CollectStat,
-            TargetPartitions,
-            FileSortOrder,
-            Csv,
-            Parquet,
-            Avro,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
-                            "paths" => Ok(GeneratedField::Paths),
-                            "fileExtension" | "file_extension" => Ok(GeneratedField::FileExtension),
-                            "projection" => Ok(GeneratedField::Projection),
-                            "schema" => Ok(GeneratedField::Schema),
-                            "filters" => Ok(GeneratedField::Filters),
-                            "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
-                            "collectStat" | "collect_stat" => Ok(GeneratedField::CollectStat),
-                            "targetPartitions" | "target_partitions" => Ok(GeneratedField::TargetPartitions),
-                            "fileSortOrder" | "file_sort_order" => Ok(GeneratedField::FileSortOrder),
-                            "csv" => Ok(GeneratedField::Csv),
-                            "parquet" => Ok(GeneratedField::Parquet),
-                            "avro" => Ok(GeneratedField::Avro),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ListingTableScanNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ListingTableScanNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ListingTableScanNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut table_name__ = None;
-                let mut paths__ = None;
-                let mut file_extension__ = None;
-                let mut projection__ = None;
-                let mut schema__ = None;
-                let mut filters__ = None;
-                let mut table_partition_cols__ = None;
-                let mut collect_stat__ = None;
-                let mut target_partitions__ = None;
-                let mut file_sort_order__ = None;
-                let mut file_format_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::TableName => {
-                            if table_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tableName"));
-                            }
-                            table_name__ = map.next_value()?;
-                        }
-                        GeneratedField::Paths => {
-                            if paths__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("paths"));
-                            }
-                            paths__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::FileExtension => {
-                            if file_extension__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fileExtension"));
-                            }
-                            file_extension__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Projection => {
-                            if projection__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("projection"));
-                            }
-                            projection__ = map.next_value()?;
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                        GeneratedField::Filters => {
-                            if filters__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filters"));
-                            }
-                            filters__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::TablePartitionCols => {
-                            if table_partition_cols__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tablePartitionCols"));
-                            }
-                            table_partition_cols__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::CollectStat => {
-                            if collect_stat__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("collectStat"));
-                            }
-                            collect_stat__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::TargetPartitions => {
-                            if target_partitions__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("targetPartitions"));
-                            }
-                            target_partitions__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::FileSortOrder => {
-                            if file_sort_order__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fileSortOrder"));
-                            }
-                            file_sort_order__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Csv => {
-                            if file_format_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("csv"));
-                            }
-                            file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Csv)
-;
-                        }
-                        GeneratedField::Parquet => {
-                            if file_format_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("parquet"));
-                            }
-                            file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Parquet)
-;
-                        }
-                        GeneratedField::Avro => {
-                            if file_format_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("avro"));
-                            }
-                            file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Avro)
-;
-                        }
-                    }
-                }
-                Ok(ListingTableScanNode {
-                    table_name: table_name__,
-                    paths: paths__.unwrap_or_default(),
-                    file_extension: file_extension__.unwrap_or_default(),
-                    projection: projection__,
-                    schema: schema__,
-                    filters: filters__.unwrap_or_default(),
-                    table_partition_cols: table_partition_cols__.unwrap_or_default(),
-                    collect_stat: collect_stat__.unwrap_or_default(),
-                    target_partitions: target_partitions__.unwrap_or_default(),
-                    file_sort_order: file_sort_order__.unwrap_or_default(),
-                    file_format_type: file_format_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ListingTableScanNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LocalLimitExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.fetch != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LocalLimitExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if self.fetch != 0 {
-            struct_ser.serialize_field("fetch", &self.fetch)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LocalLimitExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "fetch",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Fetch,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "fetch" => Ok(GeneratedField::Fetch),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LocalLimitExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LocalLimitExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LocalLimitExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut fetch__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Fetch => {
-                            if fetch__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fetch"));
-                            }
-                            fetch__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(LocalLimitExecNode {
-                    input: input__,
-                    fetch: fetch__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LocalLimitExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LogicalExprList {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprList", len)?;
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LogicalExprList {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LogicalExprList;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LogicalExprList")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExprList, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(LogicalExprList {
-                    expr: expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LogicalExprList", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LogicalExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNode", len)?;
-        if let Some(v) = self.expr_type.as_ref() {
-            match v {
-                logical_expr_node::ExprType::Column(v) => {
-                    struct_ser.serialize_field("column", v)?;
-                }
-                logical_expr_node::ExprType::Alias(v) => {
-                    struct_ser.serialize_field("alias", v)?;
-                }
-                logical_expr_node::ExprType::Literal(v) => {
-                    struct_ser.serialize_field("literal", v)?;
-                }
-                logical_expr_node::ExprType::BinaryExpr(v) => {
-                    struct_ser.serialize_field("binaryExpr", v)?;
-                }
-                logical_expr_node::ExprType::AggregateExpr(v) => {
-                    struct_ser.serialize_field("aggregateExpr", v)?;
-                }
-                logical_expr_node::ExprType::IsNullExpr(v) => {
-                    struct_ser.serialize_field("isNullExpr", v)?;
-                }
-                logical_expr_node::ExprType::IsNotNullExpr(v) => {
-                    struct_ser.serialize_field("isNotNullExpr", v)?;
-                }
-                logical_expr_node::ExprType::NotExpr(v) => {
-                    struct_ser.serialize_field("notExpr", v)?;
-                }
-                logical_expr_node::ExprType::Between(v) => {
-                    struct_ser.serialize_field("between", v)?;
-                }
-                logical_expr_node::ExprType::Case(v) => {
-                    struct_ser.serialize_field("case", v)?;
-                }
-                logical_expr_node::ExprType::Cast(v) => {
-                    struct_ser.serialize_field("cast", v)?;
-                }
-                logical_expr_node::ExprType::Sort(v) => {
-                    struct_ser.serialize_field("sort", v)?;
-                }
-                logical_expr_node::ExprType::Negative(v) => {
-                    struct_ser.serialize_field("negative", v)?;
-                }
-                logical_expr_node::ExprType::InList(v) => {
-                    struct_ser.serialize_field("inList", v)?;
-                }
-                logical_expr_node::ExprType::Wildcard(v) => {
-                    struct_ser.serialize_field("wildcard", v)?;
-                }
-                logical_expr_node::ExprType::ScalarFunction(v) => {
-                    struct_ser.serialize_field("scalarFunction", v)?;
-                }
-                logical_expr_node::ExprType::TryCast(v) => {
-                    struct_ser.serialize_field("tryCast", v)?;
-                }
-                logical_expr_node::ExprType::WindowExpr(v) => {
-                    struct_ser.serialize_field("windowExpr", v)?;
-                }
-                logical_expr_node::ExprType::AggregateUdfExpr(v) => {
-                    struct_ser.serialize_field("aggregateUdfExpr", v)?;
-                }
-                logical_expr_node::ExprType::ScalarUdfExpr(v) => {
-                    struct_ser.serialize_field("scalarUdfExpr", v)?;
-                }
-                logical_expr_node::ExprType::GetIndexedField(v) => {
-                    struct_ser.serialize_field("getIndexedField", v)?;
-                }
-                logical_expr_node::ExprType::GroupingSet(v) => {
-                    struct_ser.serialize_field("groupingSet", v)?;
-                }
-                logical_expr_node::ExprType::Cube(v) => {
-                    struct_ser.serialize_field("cube", v)?;
-                }
-                logical_expr_node::ExprType::Rollup(v) => {
-                    struct_ser.serialize_field("rollup", v)?;
-                }
-                logical_expr_node::ExprType::IsTrue(v) => {
-                    struct_ser.serialize_field("isTrue", v)?;
-                }
-                logical_expr_node::ExprType::IsFalse(v) => {
-                    struct_ser.serialize_field("isFalse", v)?;
-                }
-                logical_expr_node::ExprType::IsUnknown(v) => {
-                    struct_ser.serialize_field("isUnknown", v)?;
-                }
-                logical_expr_node::ExprType::IsNotTrue(v) => {
-                    struct_ser.serialize_field("isNotTrue", v)?;
-                }
-                logical_expr_node::ExprType::IsNotFalse(v) => {
-                    struct_ser.serialize_field("isNotFalse", v)?;
-                }
-                logical_expr_node::ExprType::IsNotUnknown(v) => {
-                    struct_ser.serialize_field("isNotUnknown", v)?;
-                }
-                logical_expr_node::ExprType::Like(v) => {
-                    struct_ser.serialize_field("like", v)?;
-                }
-                logical_expr_node::ExprType::Ilike(v) => {
-                    struct_ser.serialize_field("ilike", v)?;
-                }
-                logical_expr_node::ExprType::SimilarTo(v) => {
-                    struct_ser.serialize_field("similarTo", v)?;
-                }
-                logical_expr_node::ExprType::Placeholder(v) => {
-                    struct_ser.serialize_field("placeholder", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LogicalExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "column",
-            "alias",
-            "literal",
-            "binary_expr",
-            "binaryExpr",
-            "aggregate_expr",
-            "aggregateExpr",
-            "is_null_expr",
-            "isNullExpr",
-            "is_not_null_expr",
-            "isNotNullExpr",
-            "not_expr",
-            "notExpr",
-            "between",
-            "case_",
-            "case",
-            "cast",
-            "sort",
-            "negative",
-            "in_list",
-            "inList",
-            "wildcard",
-            "scalar_function",
-            "scalarFunction",
-            "try_cast",
-            "tryCast",
-            "window_expr",
-            "windowExpr",
-            "aggregate_udf_expr",
-            "aggregateUdfExpr",
-            "scalar_udf_expr",
-            "scalarUdfExpr",
-            "get_indexed_field",
-            "getIndexedField",
-            "grouping_set",
-            "groupingSet",
-            "cube",
-            "rollup",
-            "is_true",
-            "isTrue",
-            "is_false",
-            "isFalse",
-            "is_unknown",
-            "isUnknown",
-            "is_not_true",
-            "isNotTrue",
-            "is_not_false",
-            "isNotFalse",
-            "is_not_unknown",
-            "isNotUnknown",
-            "like",
-            "ilike",
-            "similar_to",
-            "similarTo",
-            "placeholder",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Column,
-            Alias,
-            Literal,
-            BinaryExpr,
-            AggregateExpr,
-            IsNullExpr,
-            IsNotNullExpr,
-            NotExpr,
-            Between,
-            Case,
-            Cast,
-            Sort,
-            Negative,
-            InList,
-            Wildcard,
-            ScalarFunction,
-            TryCast,
-            WindowExpr,
-            AggregateUdfExpr,
-            ScalarUdfExpr,
-            GetIndexedField,
-            GroupingSet,
-            Cube,
-            Rollup,
-            IsTrue,
-            IsFalse,
-            IsUnknown,
-            IsNotTrue,
-            IsNotFalse,
-            IsNotUnknown,
-            Like,
-            Ilike,
-            SimilarTo,
-            Placeholder,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "column" => Ok(GeneratedField::Column),
-                            "alias" => Ok(GeneratedField::Alias),
-                            "literal" => Ok(GeneratedField::Literal),
-                            "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr),
-                            "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr),
-                            "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr),
-                            "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr),
-                            "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr),
-                            "between" => Ok(GeneratedField::Between),
-                            "case" | "case_" => Ok(GeneratedField::Case),
-                            "cast" => Ok(GeneratedField::Cast),
-                            "sort" => Ok(GeneratedField::Sort),
-                            "negative" => Ok(GeneratedField::Negative),
-                            "inList" | "in_list" => Ok(GeneratedField::InList),
-                            "wildcard" => Ok(GeneratedField::Wildcard),
-                            "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction),
-                            "tryCast" | "try_cast" => Ok(GeneratedField::TryCast),
-                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
-                            "aggregateUdfExpr" | "aggregate_udf_expr" => Ok(GeneratedField::AggregateUdfExpr),
-                            "scalarUdfExpr" | "scalar_udf_expr" => Ok(GeneratedField::ScalarUdfExpr),
-                            "getIndexedField" | "get_indexed_field" => Ok(GeneratedField::GetIndexedField),
-                            "groupingSet" | "grouping_set" => Ok(GeneratedField::GroupingSet),
-                            "cube" => Ok(GeneratedField::Cube),
-                            "rollup" => Ok(GeneratedField::Rollup),
-                            "isTrue" | "is_true" => Ok(GeneratedField::IsTrue),
-                            "isFalse" | "is_false" => Ok(GeneratedField::IsFalse),
-                            "isUnknown" | "is_unknown" => Ok(GeneratedField::IsUnknown),
-                            "isNotTrue" | "is_not_true" => Ok(GeneratedField::IsNotTrue),
-                            "isNotFalse" | "is_not_false" => Ok(GeneratedField::IsNotFalse),
-                            "isNotUnknown" | "is_not_unknown" => Ok(GeneratedField::IsNotUnknown),
-                            "like" => Ok(GeneratedField::Like),
-                            "ilike" => Ok(GeneratedField::Ilike),
-                            "similarTo" | "similar_to" => Ok(GeneratedField::SimilarTo),
-                            "placeholder" => Ok(GeneratedField::Placeholder),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LogicalExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LogicalExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Column => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("column"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Column)
-;
-                        }
-                        GeneratedField::Alias => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("alias"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Alias)
-;
-                        }
-                        GeneratedField::Literal => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("literal"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Literal)
-;
-                        }
-                        GeneratedField::BinaryExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("binaryExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::BinaryExpr)
-;
-                        }
-                        GeneratedField::AggregateExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggregateExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateExpr)
-;
-                        }
-                        GeneratedField::IsNullExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNullExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNullExpr)
-;
-                        }
-                        GeneratedField::IsNotNullExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNotNullExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotNullExpr)
-;
-                        }
-                        GeneratedField::NotExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("notExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::NotExpr)
-;
-                        }
-                        GeneratedField::Between => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("between"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Between)
-;
-                        }
-                        GeneratedField::Case => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("case"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Case)
-;
-                        }
-                        GeneratedField::Cast => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("cast"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cast)
-;
-                        }
-                        GeneratedField::Sort => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("sort"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Sort)
-;
-                        }
-                        GeneratedField::Negative => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negative"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Negative)
-;
-                        }
-                        GeneratedField::InList => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inList"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::InList)
-;
-                        }
-                        GeneratedField::Wildcard => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("wildcard"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Wildcard);
-                        }
-                        GeneratedField::ScalarFunction => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("scalarFunction"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarFunction)
-;
-                        }
-                        GeneratedField::TryCast => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tryCast"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::TryCast)
-;
-                        }
-                        GeneratedField::WindowExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::WindowExpr)
-;
-                        }
-                        GeneratedField::AggregateUdfExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggregateUdfExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateUdfExpr)
-;
-                        }
-                        GeneratedField::ScalarUdfExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("scalarUdfExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarUdfExpr)
-;
-                        }
-                        GeneratedField::GetIndexedField => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("getIndexedField"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GetIndexedField)
-;
-                        }
-                        GeneratedField::GroupingSet => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("groupingSet"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GroupingSet)
-;
-                        }
-                        GeneratedField::Cube => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("cube"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cube)
-;
-                        }
-                        GeneratedField::Rollup => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("rollup"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Rollup)
-;
-                        }
-                        GeneratedField::IsTrue => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isTrue"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsTrue)
-;
-                        }
-                        GeneratedField::IsFalse => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isFalse"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsFalse)
-;
-                        }
-                        GeneratedField::IsUnknown => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isUnknown"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsUnknown)
-;
-                        }
-                        GeneratedField::IsNotTrue => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNotTrue"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotTrue)
-;
-                        }
-                        GeneratedField::IsNotFalse => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNotFalse"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotFalse)
-;
-                        }
-                        GeneratedField::IsNotUnknown => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNotUnknown"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotUnknown)
-;
-                        }
-                        GeneratedField::Like => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("like"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Like)
-;
-                        }
-                        GeneratedField::Ilike => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("ilike"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Ilike)
-;
-                        }
-                        GeneratedField::SimilarTo => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("similarTo"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::SimilarTo)
-;
-                        }
-                        GeneratedField::Placeholder => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("placeholder"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Placeholder)
-;
-                        }
-                    }
-                }
-                Ok(LogicalExprNode {
-                    expr_type: expr_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LogicalExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LogicalExprNodeCollection {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.logical_expr_nodes.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNodeCollection", len)?;
-        if !self.logical_expr_nodes.is_empty() {
-            struct_ser.serialize_field("logicalExprNodes", &self.logical_expr_nodes)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LogicalExprNodeCollection {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "logical_expr_nodes",
-            "logicalExprNodes",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            LogicalExprNodes,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "logicalExprNodes" | "logical_expr_nodes" => Ok(GeneratedField::LogicalExprNodes),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LogicalExprNodeCollection;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LogicalExprNodeCollection")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExprNodeCollection, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut logical_expr_nodes__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::LogicalExprNodes => {
-                            if logical_expr_nodes__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("logicalExprNodes"));
-                            }
-                            logical_expr_nodes__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(LogicalExprNodeCollection {
-                    logical_expr_nodes: logical_expr_nodes__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LogicalExprNodeCollection", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LogicalExtensionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.node.is_empty() {
-            len += 1;
-        }
-        if !self.inputs.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExtensionNode", len)?;
-        if !self.node.is_empty() {
-            struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?;
-        }
-        if !self.inputs.is_empty() {
-            struct_ser.serialize_field("inputs", &self.inputs)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LogicalExtensionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "node",
-            "inputs",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Node,
-            Inputs,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "node" => Ok(GeneratedField::Node),
-                            "inputs" => Ok(GeneratedField::Inputs),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LogicalExtensionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LogicalExtensionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalExtensionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut node__ = None;
-                let mut inputs__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Node => {
-                            if node__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("node"));
-                            }
-                            node__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Inputs => {
-                            if inputs__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inputs"));
-                            }
-                            inputs__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(LogicalExtensionNode {
-                    node: node__.unwrap_or_default(),
-                    inputs: inputs__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LogicalExtensionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for LogicalPlanNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.logical_plan_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.LogicalPlanNode", len)?;
-        if let Some(v) = self.logical_plan_type.as_ref() {
-            match v {
-                logical_plan_node::LogicalPlanType::ListingScan(v) => {
-                    struct_ser.serialize_field("listingScan", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Projection(v) => {
-                    struct_ser.serialize_field("projection", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Selection(v) => {
-                    struct_ser.serialize_field("selection", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Limit(v) => {
-                    struct_ser.serialize_field("limit", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Aggregate(v) => {
-                    struct_ser.serialize_field("aggregate", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Join(v) => {
-                    struct_ser.serialize_field("join", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Sort(v) => {
-                    struct_ser.serialize_field("sort", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Repartition(v) => {
-                    struct_ser.serialize_field("repartition", v)?;
-                }
-                logical_plan_node::LogicalPlanType::EmptyRelation(v) => {
-                    struct_ser.serialize_field("emptyRelation", v)?;
-                }
-                logical_plan_node::LogicalPlanType::CreateExternalTable(v) => {
-                    struct_ser.serialize_field("createExternalTable", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Explain(v) => {
-                    struct_ser.serialize_field("explain", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Window(v) => {
-                    struct_ser.serialize_field("window", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Analyze(v) => {
-                    struct_ser.serialize_field("analyze", v)?;
-                }
-                logical_plan_node::LogicalPlanType::CrossJoin(v) => {
-                    struct_ser.serialize_field("crossJoin", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Values(v) => {
-                    struct_ser.serialize_field("values", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Extension(v) => {
-                    struct_ser.serialize_field("extension", v)?;
-                }
-                logical_plan_node::LogicalPlanType::CreateCatalogSchema(v) => {
-                    struct_ser.serialize_field("createCatalogSchema", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Union(v) => {
-                    struct_ser.serialize_field("union", v)?;
-                }
-                logical_plan_node::LogicalPlanType::CreateCatalog(v) => {
-                    struct_ser.serialize_field("createCatalog", v)?;
-                }
-                logical_plan_node::LogicalPlanType::SubqueryAlias(v) => {
-                    struct_ser.serialize_field("subqueryAlias", v)?;
-                }
-                logical_plan_node::LogicalPlanType::CreateView(v) => {
-                    struct_ser.serialize_field("createView", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Distinct(v) => {
-                    struct_ser.serialize_field("distinct", v)?;
-                }
-                logical_plan_node::LogicalPlanType::ViewScan(v) => {
-                    struct_ser.serialize_field("viewScan", v)?;
-                }
-                logical_plan_node::LogicalPlanType::CustomScan(v) => {
-                    struct_ser.serialize_field("customScan", v)?;
-                }
-                logical_plan_node::LogicalPlanType::Prepare(v) => {
-                    struct_ser.serialize_field("prepare", v)?;
-                }
-                logical_plan_node::LogicalPlanType::DropView(v) => {
-                    struct_ser.serialize_field("dropView", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for LogicalPlanNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "listing_scan",
-            "listingScan",
-            "projection",
-            "selection",
-            "limit",
-            "aggregate",
-            "join",
-            "sort",
-            "repartition",
-            "empty_relation",
-            "emptyRelation",
-            "create_external_table",
-            "createExternalTable",
-            "explain",
-            "window",
-            "analyze",
-            "cross_join",
-            "crossJoin",
-            "values",
-            "extension",
-            "create_catalog_schema",
-            "createCatalogSchema",
-            "union",
-            "create_catalog",
-            "createCatalog",
-            "subquery_alias",
-            "subqueryAlias",
-            "create_view",
-            "createView",
-            "distinct",
-            "view_scan",
-            "viewScan",
-            "custom_scan",
-            "customScan",
-            "prepare",
-            "drop_view",
-            "dropView",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            ListingScan,
-            Projection,
-            Selection,
-            Limit,
-            Aggregate,
-            Join,
-            Sort,
-            Repartition,
-            EmptyRelation,
-            CreateExternalTable,
-            Explain,
-            Window,
-            Analyze,
-            CrossJoin,
-            Values,
-            Extension,
-            CreateCatalogSchema,
-            Union,
-            CreateCatalog,
-            SubqueryAlias,
-            CreateView,
-            Distinct,
-            ViewScan,
-            CustomScan,
-            Prepare,
-            DropView,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "listingScan" | "listing_scan" => Ok(GeneratedField::ListingScan),
-                            "projection" => Ok(GeneratedField::Projection),
-                            "selection" => Ok(GeneratedField::Selection),
-                            "limit" => Ok(GeneratedField::Limit),
-                            "aggregate" => Ok(GeneratedField::Aggregate),
-                            "join" => Ok(GeneratedField::Join),
-                            "sort" => Ok(GeneratedField::Sort),
-                            "repartition" => Ok(GeneratedField::Repartition),
-                            "emptyRelation" | "empty_relation" => Ok(GeneratedField::EmptyRelation),
-                            "createExternalTable" | "create_external_table" => Ok(GeneratedField::CreateExternalTable),
-                            "explain" => Ok(GeneratedField::Explain),
-                            "window" => Ok(GeneratedField::Window),
-                            "analyze" => Ok(GeneratedField::Analyze),
-                            "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin),
-                            "values" => Ok(GeneratedField::Values),
-                            "extension" => Ok(GeneratedField::Extension),
-                            "createCatalogSchema" | "create_catalog_schema" => Ok(GeneratedField::CreateCatalogSchema),
-                            "union" => Ok(GeneratedField::Union),
-                            "createCatalog" | "create_catalog" => Ok(GeneratedField::CreateCatalog),
-                            "subqueryAlias" | "subquery_alias" => Ok(GeneratedField::SubqueryAlias),
-                            "createView" | "create_view" => Ok(GeneratedField::CreateView),
-                            "distinct" => Ok(GeneratedField::Distinct),
-                            "viewScan" | "view_scan" => Ok(GeneratedField::ViewScan),
-                            "customScan" | "custom_scan" => Ok(GeneratedField::CustomScan),
-                            "prepare" => Ok(GeneratedField::Prepare),
-                            "dropView" | "drop_view" => Ok(GeneratedField::DropView),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = LogicalPlanNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.LogicalPlanNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<LogicalPlanNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut logical_plan_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::ListingScan => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("listingScan"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ListingScan)
-;
-                        }
-                        GeneratedField::Projection => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("projection"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Projection)
-;
-                        }
-                        GeneratedField::Selection => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("selection"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Selection)
-;
-                        }
-                        GeneratedField::Limit => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("limit"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Limit)
-;
-                        }
-                        GeneratedField::Aggregate => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggregate"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Aggregate)
-;
-                        }
-                        GeneratedField::Join => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("join"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Join)
-;
-                        }
-                        GeneratedField::Sort => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("sort"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Sort)
-;
-                        }
-                        GeneratedField::Repartition => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("repartition"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Repartition)
-;
-                        }
-                        GeneratedField::EmptyRelation => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("emptyRelation"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::EmptyRelation)
-;
-                        }
-                        GeneratedField::CreateExternalTable => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("createExternalTable"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateExternalTable)
-;
-                        }
-                        GeneratedField::Explain => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("explain"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Explain)
-;
-                        }
-                        GeneratedField::Window => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("window"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Window)
-;
-                        }
-                        GeneratedField::Analyze => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("analyze"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Analyze)
-;
-                        }
-                        GeneratedField::CrossJoin => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("crossJoin"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CrossJoin)
-;
-                        }
-                        GeneratedField::Values => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("values"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Values)
-;
-                        }
-                        GeneratedField::Extension => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("extension"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Extension)
-;
-                        }
-                        GeneratedField::CreateCatalogSchema => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("createCatalogSchema"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalogSchema)
-;
-                        }
-                        GeneratedField::Union => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("union"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Union)
-;
-                        }
-                        GeneratedField::CreateCatalog => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("createCatalog"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalog)
-;
-                        }
-                        GeneratedField::SubqueryAlias => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("subqueryAlias"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::SubqueryAlias)
-;
-                        }
-                        GeneratedField::CreateView => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("createView"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateView)
-;
-                        }
-                        GeneratedField::Distinct => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("distinct"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Distinct)
-;
-                        }
-                        GeneratedField::ViewScan => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("viewScan"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ViewScan)
-;
-                        }
-                        GeneratedField::CustomScan => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("customScan"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CustomScan)
-;
-                        }
-                        GeneratedField::Prepare => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("prepare"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Prepare)
-;
-                        }
-                        GeneratedField::DropView => {
-                            if logical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("dropView"));
-                            }
-                            logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::DropView)
-;
-                        }
-                    }
-                }
-                Ok(LogicalPlanNode {
-                    logical_plan_type: logical_plan_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.LogicalPlanNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Map {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.field_type.is_some() {
-            len += 1;
-        }
-        if self.keys_sorted {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Map", len)?;
-        if let Some(v) = self.field_type.as_ref() {
-            struct_ser.serialize_field("fieldType", v)?;
-        }
-        if self.keys_sorted {
-            struct_ser.serialize_field("keysSorted", &self.keys_sorted)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Map {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "field_type",
-            "fieldType",
-            "keys_sorted",
-            "keysSorted",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            FieldType,
-            KeysSorted,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
-                            "keysSorted" | "keys_sorted" => Ok(GeneratedField::KeysSorted),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Map;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Map")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Map, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut field_type__ = None;
-                let mut keys_sorted__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::FieldType => {
-                            if field_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fieldType"));
-                            }
-                            field_type__ = map.next_value()?;
-                        }
-                        GeneratedField::KeysSorted => {
-                            if keys_sorted__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("keysSorted"));
-                            }
-                            keys_sorted__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(Map {
-                    field_type: field_type__,
-                    keys_sorted: keys_sorted__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Map", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for MaybeFilter {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.MaybeFilter", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for MaybeFilter {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = MaybeFilter;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.MaybeFilter")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<MaybeFilter, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(MaybeFilter {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.MaybeFilter", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for MaybePhysicalSortExprs {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.sort_expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.MaybePhysicalSortExprs", len)?;
-        if !self.sort_expr.is_empty() {
-            struct_ser.serialize_field("sortExpr", &self.sort_expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for MaybePhysicalSortExprs {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "sort_expr",
-            "sortExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            SortExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "sortExpr" | "sort_expr" => Ok(GeneratedField::SortExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = MaybePhysicalSortExprs;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.MaybePhysicalSortExprs")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<MaybePhysicalSortExprs, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut sort_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::SortExpr => {
-                            if sort_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("sortExpr"));
-                            }
-                            sort_expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(MaybePhysicalSortExprs {
-                    sort_expr: sort_expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.MaybePhysicalSortExprs", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for NegativeNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.NegativeNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for NegativeNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = NegativeNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.NegativeNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<NegativeNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(NegativeNode {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.NegativeNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Not {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Not", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Not {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Not;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Not")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Not, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(Not {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Not", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for OptimizedLogicalPlanType {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.optimizer_name.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedLogicalPlanType", len)?;
-        if !self.optimizer_name.is_empty() {
-            struct_ser.serialize_field("optimizerName", &self.optimizer_name)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "optimizer_name",
-            "optimizerName",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            OptimizerName,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = OptimizedLogicalPlanType;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.OptimizedLogicalPlanType")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<OptimizedLogicalPlanType, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut optimizer_name__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::OptimizerName => {
-                            if optimizer_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("optimizerName"));
-                            }
-                            optimizer_name__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(OptimizedLogicalPlanType {
-                    optimizer_name: optimizer_name__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.OptimizedLogicalPlanType", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for OptimizedPhysicalPlanType {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.optimizer_name.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedPhysicalPlanType", len)?;
-        if !self.optimizer_name.is_empty() {
-            struct_ser.serialize_field("optimizerName", &self.optimizer_name)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "optimizer_name",
-            "optimizerName",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            OptimizerName,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = OptimizedPhysicalPlanType;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.OptimizedPhysicalPlanType")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<OptimizedPhysicalPlanType, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut optimizer_name__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::OptimizerName => {
-                            if optimizer_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("optimizerName"));
-                            }
-                            optimizer_name__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(OptimizedPhysicalPlanType {
-                    optimizer_name: optimizer_name__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.OptimizedPhysicalPlanType", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for OwnedTableReference {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.table_reference_enum.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.OwnedTableReference", len)?;
-        if let Some(v) = self.table_reference_enum.as_ref() {
-            match v {
-                owned_table_reference::TableReferenceEnum::Bare(v) => {
-                    struct_ser.serialize_field("bare", v)?;
-                }
-                owned_table_reference::TableReferenceEnum::Partial(v) => {
-                    struct_ser.serialize_field("partial", v)?;
-                }
-                owned_table_reference::TableReferenceEnum::Full(v) => {
-                    struct_ser.serialize_field("full", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for OwnedTableReference {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "bare",
-            "partial",
-            "full",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Bare,
-            Partial,
-            Full,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "bare" => Ok(GeneratedField::Bare),
-                            "partial" => Ok(GeneratedField::Partial),
-                            "full" => Ok(GeneratedField::Full),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = OwnedTableReference;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.OwnedTableReference")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<OwnedTableReference, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut table_reference_enum__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Bare => {
-                            if table_reference_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("bare"));
-                            }
-                            table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Bare)
-;
-                        }
-                        GeneratedField::Partial => {
-                            if table_reference_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("partial"));
-                            }
-                            table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Partial)
-;
-                        }
-                        GeneratedField::Full => {
-                            if table_reference_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("full"));
-                            }
-                            table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Full)
-;
-                        }
-                    }
-                }
-                Ok(OwnedTableReference {
-                    table_reference_enum: table_reference_enum__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.OwnedTableReference", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ParquetFormat {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let len = 0;
-        let struct_ser = serializer.serialize_struct("datafusion.ParquetFormat", len)?;
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ParquetFormat {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                            Err(serde::de::Error::unknown_field(value, FIELDS))
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ParquetFormat;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ParquetFormat")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ParquetFormat, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
-                }
-                Ok(ParquetFormat {
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ParquetFormat", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ParquetScanExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.base_conf.is_some() {
-            len += 1;
-        }
-        if self.predicate.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ParquetScanExecNode", len)?;
-        if let Some(v) = self.base_conf.as_ref() {
-            struct_ser.serialize_field("baseConf", v)?;
-        }
-        if let Some(v) = self.predicate.as_ref() {
-            struct_ser.serialize_field("predicate", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ParquetScanExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "base_conf",
-            "baseConf",
-            "predicate",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            BaseConf,
-            Predicate,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf),
-                            "predicate" => Ok(GeneratedField::Predicate),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ParquetScanExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ParquetScanExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ParquetScanExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut base_conf__ = None;
-                let mut predicate__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::BaseConf => {
-                            if base_conf__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("baseConf"));
-                            }
-                            base_conf__ = map.next_value()?;
-                        }
-                        GeneratedField::Predicate => {
-                            if predicate__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("predicate"));
-                            }
-                            predicate__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(ParquetScanExecNode {
-                    base_conf: base_conf__,
-                    predicate: predicate__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ParquetScanExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PartialTableReference {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.schema.is_empty() {
-            len += 1;
-        }
-        if !self.table.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PartialTableReference", len)?;
-        if !self.schema.is_empty() {
-            struct_ser.serialize_field("schema", &self.schema)?;
-        }
-        if !self.table.is_empty() {
-            struct_ser.serialize_field("table", &self.table)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PartialTableReference {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "schema",
-            "table",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Schema,
-            Table,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "schema" => Ok(GeneratedField::Schema),
-                            "table" => Ok(GeneratedField::Table),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PartialTableReference;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PartialTableReference")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PartialTableReference, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut schema__ = None;
-                let mut table__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Table => {
-                            if table__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("table"));
-                            }
-                            table__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PartialTableReference {
-                    schema: schema__.unwrap_or_default(),
-                    table: table__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PartialTableReference", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PartitionMode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::CollectLeft => "COLLECT_LEFT",
-            Self::Partitioned => "PARTITIONED",
-            Self::Auto => "AUTO",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for PartitionMode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "COLLECT_LEFT",
-            "PARTITIONED",
-            "AUTO",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PartitionMode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(PartitionMode::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(PartitionMode::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "COLLECT_LEFT" => Ok(PartitionMode::CollectLeft),
-                    "PARTITIONED" => Ok(PartitionMode::Partitioned),
-                    "AUTO" => Ok(PartitionMode::Auto),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PartitionStats {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.num_rows != 0 {
-            len += 1;
-        }
-        if self.num_batches != 0 {
-            len += 1;
-        }
-        if self.num_bytes != 0 {
-            len += 1;
-        }
-        if !self.column_stats.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PartitionStats", len)?;
-        if self.num_rows != 0 {
-            struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?;
-        }
-        if self.num_batches != 0 {
-            struct_ser.serialize_field("numBatches", ToString::to_string(&self.num_batches).as_str())?;
-        }
-        if self.num_bytes != 0 {
-            struct_ser.serialize_field("numBytes", ToString::to_string(&self.num_bytes).as_str())?;
-        }
-        if !self.column_stats.is_empty() {
-            struct_ser.serialize_field("columnStats", &self.column_stats)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PartitionStats {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "num_rows",
-            "numRows",
-            "num_batches",
-            "numBatches",
-            "num_bytes",
-            "numBytes",
-            "column_stats",
-            "columnStats",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            NumRows,
-            NumBatches,
-            NumBytes,
-            ColumnStats,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "numRows" | "num_rows" => Ok(GeneratedField::NumRows),
-                            "numBatches" | "num_batches" => Ok(GeneratedField::NumBatches),
-                            "numBytes" | "num_bytes" => Ok(GeneratedField::NumBytes),
-                            "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PartitionStats;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PartitionStats")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PartitionStats, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut num_rows__ = None;
-                let mut num_batches__ = None;
-                let mut num_bytes__ = None;
-                let mut column_stats__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::NumRows => {
-                            if num_rows__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("numRows"));
-                            }
-                            num_rows__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::NumBatches => {
-                            if num_batches__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("numBatches"));
-                            }
-                            num_batches__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::NumBytes => {
-                            if num_bytes__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("numBytes"));
-                            }
-                            num_bytes__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::ColumnStats => {
-                            if column_stats__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("columnStats"));
-                            }
-                            column_stats__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PartitionStats {
-                    num_rows: num_rows__.unwrap_or_default(),
-                    num_batches: num_batches__.unwrap_or_default(),
-                    num_bytes: num_bytes__.unwrap_or_default(),
-                    column_stats: column_stats__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PartitionStats", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PartitionedFile {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.path.is_empty() {
-            len += 1;
-        }
-        if self.size != 0 {
-            len += 1;
-        }
-        if self.last_modified_ns != 0 {
-            len += 1;
-        }
-        if !self.partition_values.is_empty() {
-            len += 1;
-        }
-        if self.range.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PartitionedFile", len)?;
-        if !self.path.is_empty() {
-            struct_ser.serialize_field("path", &self.path)?;
-        }
-        if self.size != 0 {
-            struct_ser.serialize_field("size", ToString::to_string(&self.size).as_str())?;
-        }
-        if self.last_modified_ns != 0 {
-            struct_ser.serialize_field("lastModifiedNs", ToString::to_string(&self.last_modified_ns).as_str())?;
-        }
-        if !self.partition_values.is_empty() {
-            struct_ser.serialize_field("partitionValues", &self.partition_values)?;
-        }
-        if let Some(v) = self.range.as_ref() {
-            struct_ser.serialize_field("range", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PartitionedFile {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "path",
-            "size",
-            "last_modified_ns",
-            "lastModifiedNs",
-            "partition_values",
-            "partitionValues",
-            "range",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Path,
-            Size,
-            LastModifiedNs,
-            PartitionValues,
-            Range,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "path" => Ok(GeneratedField::Path),
-                            "size" => Ok(GeneratedField::Size),
-                            "lastModifiedNs" | "last_modified_ns" => Ok(GeneratedField::LastModifiedNs),
-                            "partitionValues" | "partition_values" => Ok(GeneratedField::PartitionValues),
-                            "range" => Ok(GeneratedField::Range),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PartitionedFile;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PartitionedFile")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PartitionedFile, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut path__ = None;
-                let mut size__ = None;
-                let mut last_modified_ns__ = None;
-                let mut partition_values__ = None;
-                let mut range__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Path => {
-                            if path__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("path"));
-                            }
-                            path__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Size => {
-                            if size__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("size"));
-                            }
-                            size__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::LastModifiedNs => {
-                            if last_modified_ns__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("lastModifiedNs"));
-                            }
-                            last_modified_ns__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::PartitionValues => {
-                            if partition_values__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("partitionValues"));
-                            }
-                            partition_values__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Range => {
-                            if range__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("range"));
-                            }
-                            range__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PartitionedFile {
-                    path: path__.unwrap_or_default(),
-                    size: size__.unwrap_or_default(),
-                    last_modified_ns: last_modified_ns__.unwrap_or_default(),
-                    partition_values: partition_values__.unwrap_or_default(),
-                    range: range__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PartitionedFile", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalAggregateExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        if !self.ordering_req.is_empty() {
-            len += 1;
-        }
-        if self.distinct {
-            len += 1;
-        }
-        if self.aggregate_function.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAggregateExprNode", len)?;
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        if !self.ordering_req.is_empty() {
-            struct_ser.serialize_field("orderingReq", &self.ordering_req)?;
-        }
-        if self.distinct {
-            struct_ser.serialize_field("distinct", &self.distinct)?;
-        }
-        if let Some(v) = self.aggregate_function.as_ref() {
-            match v {
-                physical_aggregate_expr_node::AggregateFunction::AggrFunction(v) => {
-                    let v = AggregateFunction::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("aggrFunction", &v)?;
-                }
-                physical_aggregate_expr_node::AggregateFunction::UserDefinedAggrFunction(v) => {
-                    struct_ser.serialize_field("userDefinedAggrFunction", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalAggregateExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "ordering_req",
-            "orderingReq",
-            "distinct",
-            "aggr_function",
-            "aggrFunction",
-            "user_defined_aggr_function",
-            "userDefinedAggrFunction",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            OrderingReq,
-            Distinct,
-            AggrFunction,
-            UserDefinedAggrFunction,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "orderingReq" | "ordering_req" => Ok(GeneratedField::OrderingReq),
-                            "distinct" => Ok(GeneratedField::Distinct),
-                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
-                            "userDefinedAggrFunction" | "user_defined_aggr_function" => Ok(GeneratedField::UserDefinedAggrFunction),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalAggregateExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalAggregateExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalAggregateExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut ordering_req__ = None;
-                let mut distinct__ = None;
-                let mut aggregate_function__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::OrderingReq => {
-                            if ordering_req__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("orderingReq"));
-                            }
-                            ordering_req__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Distinct => {
-                            if distinct__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("distinct"));
-                            }
-                            distinct__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::AggrFunction => {
-                            if aggregate_function__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
-                            }
-                            aggregate_function__ = map.next_value::<::std::option::Option<AggregateFunction>>()?.map(|x| physical_aggregate_expr_node::AggregateFunction::AggrFunction(x as i32));
-                        }
-                        GeneratedField::UserDefinedAggrFunction => {
-                            if aggregate_function__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("userDefinedAggrFunction"));
-                            }
-                            aggregate_function__ = map.next_value::<::std::option::Option<_>>()?.map(physical_aggregate_expr_node::AggregateFunction::UserDefinedAggrFunction);
-                        }
-                    }
-                }
-                Ok(PhysicalAggregateExprNode {
-                    expr: expr__.unwrap_or_default(),
-                    ordering_req: ordering_req__.unwrap_or_default(),
-                    distinct: distinct__.unwrap_or_default(),
-                    aggregate_function: aggregate_function__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalAggregateExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalAliasNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if !self.alias.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAliasNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if !self.alias.is_empty() {
-            struct_ser.serialize_field("alias", &self.alias)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalAliasNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "alias",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            Alias,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "alias" => Ok(GeneratedField::Alias),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalAliasNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalAliasNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalAliasNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut alias__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Alias => {
-                            if alias__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("alias"));
-                            }
-                            alias__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PhysicalAliasNode {
-                    expr: expr__,
-                    alias: alias__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalAliasNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalBinaryExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.l.is_some() {
-            len += 1;
-        }
-        if self.r.is_some() {
-            len += 1;
-        }
-        if !self.op.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalBinaryExprNode", len)?;
-        if let Some(v) = self.l.as_ref() {
-            struct_ser.serialize_field("l", v)?;
-        }
-        if let Some(v) = self.r.as_ref() {
-            struct_ser.serialize_field("r", v)?;
-        }
-        if !self.op.is_empty() {
-            struct_ser.serialize_field("op", &self.op)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalBinaryExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "l",
-            "r",
-            "op",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            L,
-            R,
-            Op,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "l" => Ok(GeneratedField::L),
-                            "r" => Ok(GeneratedField::R),
-                            "op" => Ok(GeneratedField::Op),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalBinaryExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalBinaryExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalBinaryExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut l__ = None;
-                let mut r__ = None;
-                let mut op__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::L => {
-                            if l__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("l"));
-                            }
-                            l__ = map.next_value()?;
-                        }
-                        GeneratedField::R => {
-                            if r__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("r"));
-                            }
-                            r__ = map.next_value()?;
-                        }
-                        GeneratedField::Op => {
-                            if op__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("op"));
-                            }
-                            op__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PhysicalBinaryExprNode {
-                    l: l__,
-                    r: r__,
-                    op: op__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalBinaryExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalCaseNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if !self.when_then_expr.is_empty() {
-            len += 1;
-        }
-        if self.else_expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCaseNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if !self.when_then_expr.is_empty() {
-            struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?;
-        }
-        if let Some(v) = self.else_expr.as_ref() {
-            struct_ser.serialize_field("elseExpr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalCaseNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "when_then_expr",
-            "whenThenExpr",
-            "else_expr",
-            "elseExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            WhenThenExpr,
-            ElseExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr),
-                            "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalCaseNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalCaseNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalCaseNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut when_then_expr__ = None;
-                let mut else_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::WhenThenExpr => {
-                            if when_then_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("whenThenExpr"));
-                            }
-                            when_then_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::ElseExpr => {
-                            if else_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("elseExpr"));
-                            }
-                            else_expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalCaseNode {
-                    expr: expr__,
-                    when_then_expr: when_then_expr__.unwrap_or_default(),
-                    else_expr: else_expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalCaseNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalCastNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.arrow_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCastNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.arrow_type.as_ref() {
-            struct_ser.serialize_field("arrowType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalCastNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "arrow_type",
-            "arrowType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            ArrowType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalCastNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalCastNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalCastNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut arrow_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::ArrowType => {
-                            if arrow_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("arrowType"));
-                            }
-                            arrow_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalCastNode {
-                    expr: expr__,
-                    arrow_type: arrow_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalCastNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalColumn {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.name.is_empty() {
-            len += 1;
-        }
-        if self.index != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalColumn", len)?;
-        if !self.name.is_empty() {
-            struct_ser.serialize_field("name", &self.name)?;
-        }
-        if self.index != 0 {
-            struct_ser.serialize_field("index", &self.index)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalColumn {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "index",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            Index,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "index" => Ok(GeneratedField::Index),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalColumn;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalColumn")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalColumn, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut index__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Index => {
-                            if index__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("index"));
-                            }
-                            index__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(PhysicalColumn {
-                    name: name__.unwrap_or_default(),
-                    index: index__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalColumn", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalDateTimeIntervalExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.l.is_some() {
-            len += 1;
-        }
-        if self.r.is_some() {
-            len += 1;
-        }
-        if !self.op.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", len)?;
-        if let Some(v) = self.l.as_ref() {
-            struct_ser.serialize_field("l", v)?;
-        }
-        if let Some(v) = self.r.as_ref() {
-            struct_ser.serialize_field("r", v)?;
-        }
-        if !self.op.is_empty() {
-            struct_ser.serialize_field("op", &self.op)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalDateTimeIntervalExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "l",
-            "r",
-            "op",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            L,
-            R,
-            Op,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "l" => Ok(GeneratedField::L),
-                            "r" => Ok(GeneratedField::R),
-                            "op" => Ok(GeneratedField::Op),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalDateTimeIntervalExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalDateTimeIntervalExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalDateTimeIntervalExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut l__ = None;
-                let mut r__ = None;
-                let mut op__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::L => {
-                            if l__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("l"));
-                            }
-                            l__ = map.next_value()?;
-                        }
-                        GeneratedField::R => {
-                            if r__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("r"));
-                            }
-                            r__ = map.next_value()?;
-                        }
-                        GeneratedField::Op => {
-                            if op__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("op"));
-                            }
-                            op__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PhysicalDateTimeIntervalExprNode {
-                    l: l__,
-                    r: r__,
-                    op: op__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExprNode", len)?;
-        if let Some(v) = self.expr_type.as_ref() {
-            match v {
-                physical_expr_node::ExprType::Column(v) => {
-                    struct_ser.serialize_field("column", v)?;
-                }
-                physical_expr_node::ExprType::Literal(v) => {
-                    struct_ser.serialize_field("literal", v)?;
-                }
-                physical_expr_node::ExprType::BinaryExpr(v) => {
-                    struct_ser.serialize_field("binaryExpr", v)?;
-                }
-                physical_expr_node::ExprType::AggregateExpr(v) => {
-                    struct_ser.serialize_field("aggregateExpr", v)?;
-                }
-                physical_expr_node::ExprType::IsNullExpr(v) => {
-                    struct_ser.serialize_field("isNullExpr", v)?;
-                }
-                physical_expr_node::ExprType::IsNotNullExpr(v) => {
-                    struct_ser.serialize_field("isNotNullExpr", v)?;
-                }
-                physical_expr_node::ExprType::NotExpr(v) => {
-                    struct_ser.serialize_field("notExpr", v)?;
-                }
-                physical_expr_node::ExprType::Case(v) => {
-                    struct_ser.serialize_field("case", v)?;
-                }
-                physical_expr_node::ExprType::Cast(v) => {
-                    struct_ser.serialize_field("cast", v)?;
-                }
-                physical_expr_node::ExprType::Sort(v) => {
-                    struct_ser.serialize_field("sort", v)?;
-                }
-                physical_expr_node::ExprType::Negative(v) => {
-                    struct_ser.serialize_field("negative", v)?;
-                }
-                physical_expr_node::ExprType::InList(v) => {
-                    struct_ser.serialize_field("inList", v)?;
-                }
-                physical_expr_node::ExprType::ScalarFunction(v) => {
-                    struct_ser.serialize_field("scalarFunction", v)?;
-                }
-                physical_expr_node::ExprType::TryCast(v) => {
-                    struct_ser.serialize_field("tryCast", v)?;
-                }
-                physical_expr_node::ExprType::WindowExpr(v) => {
-                    struct_ser.serialize_field("windowExpr", v)?;
-                }
-                physical_expr_node::ExprType::ScalarUdf(v) => {
-                    struct_ser.serialize_field("scalarUdf", v)?;
-                }
-                physical_expr_node::ExprType::DateTimeIntervalExpr(v) => {
-                    struct_ser.serialize_field("dateTimeIntervalExpr", v)?;
-                }
-                physical_expr_node::ExprType::LikeExpr(v) => {
-                    struct_ser.serialize_field("likeExpr", v)?;
-                }
-                physical_expr_node::ExprType::GetIndexedFieldExpr(v) => {
-                    struct_ser.serialize_field("getIndexedFieldExpr", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "column",
-            "literal",
-            "binary_expr",
-            "binaryExpr",
-            "aggregate_expr",
-            "aggregateExpr",
-            "is_null_expr",
-            "isNullExpr",
-            "is_not_null_expr",
-            "isNotNullExpr",
-            "not_expr",
-            "notExpr",
-            "case_",
-            "case",
-            "cast",
-            "sort",
-            "negative",
-            "in_list",
-            "inList",
-            "scalar_function",
-            "scalarFunction",
-            "try_cast",
-            "tryCast",
-            "window_expr",
-            "windowExpr",
-            "scalar_udf",
-            "scalarUdf",
-            "date_time_interval_expr",
-            "dateTimeIntervalExpr",
-            "like_expr",
-            "likeExpr",
-            "get_indexed_field_expr",
-            "getIndexedFieldExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Column,
-            Literal,
-            BinaryExpr,
-            AggregateExpr,
-            IsNullExpr,
-            IsNotNullExpr,
-            NotExpr,
-            Case,
-            Cast,
-            Sort,
-            Negative,
-            InList,
-            ScalarFunction,
-            TryCast,
-            WindowExpr,
-            ScalarUdf,
-            DateTimeIntervalExpr,
-            LikeExpr,
-            GetIndexedFieldExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "column" => Ok(GeneratedField::Column),
-                            "literal" => Ok(GeneratedField::Literal),
-                            "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr),
-                            "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr),
-                            "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr),
-                            "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr),
-                            "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr),
-                            "case" | "case_" => Ok(GeneratedField::Case),
-                            "cast" => Ok(GeneratedField::Cast),
-                            "sort" => Ok(GeneratedField::Sort),
-                            "negative" => Ok(GeneratedField::Negative),
-                            "inList" | "in_list" => Ok(GeneratedField::InList),
-                            "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction),
-                            "tryCast" | "try_cast" => Ok(GeneratedField::TryCast),
-                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
-                            "scalarUdf" | "scalar_udf" => Ok(GeneratedField::ScalarUdf),
-                            "dateTimeIntervalExpr" | "date_time_interval_expr" => Ok(GeneratedField::DateTimeIntervalExpr),
-                            "likeExpr" | "like_expr" => Ok(GeneratedField::LikeExpr),
-                            "getIndexedFieldExpr" | "get_indexed_field_expr" => Ok(GeneratedField::GetIndexedFieldExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Column => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("column"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Column)
-;
-                        }
-                        GeneratedField::Literal => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("literal"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Literal)
-;
-                        }
-                        GeneratedField::BinaryExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("binaryExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::BinaryExpr)
-;
-                        }
-                        GeneratedField::AggregateExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggregateExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::AggregateExpr)
-;
-                        }
-                        GeneratedField::IsNullExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNullExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNullExpr)
-;
-                        }
-                        GeneratedField::IsNotNullExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNotNullExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNotNullExpr)
-;
-                        }
-                        GeneratedField::NotExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("notExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::NotExpr)
-;
-                        }
-                        GeneratedField::Case => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("case"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Case)
-;
-                        }
-                        GeneratedField::Cast => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("cast"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Cast)
-;
-                        }
-                        GeneratedField::Sort => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("sort"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Sort)
-;
-                        }
-                        GeneratedField::Negative => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negative"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Negative)
-;
-                        }
-                        GeneratedField::InList => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inList"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::InList)
-;
-                        }
-                        GeneratedField::ScalarFunction => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("scalarFunction"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarFunction)
-;
-                        }
-                        GeneratedField::TryCast => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tryCast"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::TryCast)
-;
-                        }
-                        GeneratedField::WindowExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::WindowExpr)
-;
-                        }
-                        GeneratedField::ScalarUdf => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("scalarUdf"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarUdf)
-;
-                        }
-                        GeneratedField::DateTimeIntervalExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("dateTimeIntervalExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::DateTimeIntervalExpr)
-;
-                        }
-                        GeneratedField::LikeExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("likeExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::LikeExpr)
-;
-                        }
-                        GeneratedField::GetIndexedFieldExpr => {
-                            if expr_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("getIndexedFieldExpr"));
-                            }
-                            expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::GetIndexedFieldExpr)
-;
-                        }
-                    }
-                }
-                Ok(PhysicalExprNode {
-                    expr_type: expr_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalExtensionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.node.is_empty() {
-            len += 1;
-        }
-        if !self.inputs.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExtensionNode", len)?;
-        if !self.node.is_empty() {
-            struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?;
-        }
-        if !self.inputs.is_empty() {
-            struct_ser.serialize_field("inputs", &self.inputs)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalExtensionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "node",
-            "inputs",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Node,
-            Inputs,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "node" => Ok(GeneratedField::Node),
-                            "inputs" => Ok(GeneratedField::Inputs),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalExtensionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalExtensionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalExtensionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut node__ = None;
-                let mut inputs__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Node => {
-                            if node__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("node"));
-                            }
-                            node__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Inputs => {
-                            if inputs__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inputs"));
-                            }
-                            inputs__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PhysicalExtensionNode {
-                    node: node__.unwrap_or_default(),
-                    inputs: inputs__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalExtensionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalGetIndexedFieldExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.arg.is_some() {
-            len += 1;
-        }
-        if self.key.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalGetIndexedFieldExprNode", len)?;
-        if let Some(v) = self.arg.as_ref() {
-            struct_ser.serialize_field("arg", v)?;
-        }
-        if let Some(v) = self.key.as_ref() {
-            struct_ser.serialize_field("key", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalGetIndexedFieldExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "arg",
-            "key",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Arg,
-            Key,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "arg" => Ok(GeneratedField::Arg),
-                            "key" => Ok(GeneratedField::Key),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalGetIndexedFieldExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalGetIndexedFieldExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalGetIndexedFieldExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut arg__ = None;
-                let mut key__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Arg => {
-                            if arg__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("arg"));
-                            }
-                            arg__ = map.next_value()?;
-                        }
-                        GeneratedField::Key => {
-                            if key__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("key"));
-                            }
-                            key__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalGetIndexedFieldExprNode {
-                    arg: arg__,
-                    key: key__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalGetIndexedFieldExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalHashRepartition {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.hash_expr.is_empty() {
-            len += 1;
-        }
-        if self.partition_count != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalHashRepartition", len)?;
-        if !self.hash_expr.is_empty() {
-            struct_ser.serialize_field("hashExpr", &self.hash_expr)?;
-        }
-        if self.partition_count != 0 {
-            struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalHashRepartition {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "hash_expr",
-            "hashExpr",
-            "partition_count",
-            "partitionCount",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            HashExpr,
-            PartitionCount,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr),
-                            "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalHashRepartition;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalHashRepartition")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalHashRepartition, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut hash_expr__ = None;
-                let mut partition_count__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::HashExpr => {
-                            if hash_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hashExpr"));
-                            }
-                            hash_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::PartitionCount => {
-                            if partition_count__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("partitionCount"));
-                            }
-                            partition_count__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(PhysicalHashRepartition {
-                    hash_expr: hash_expr__.unwrap_or_default(),
-                    partition_count: partition_count__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalHashRepartition", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalInListNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if !self.list.is_empty() {
-            len += 1;
-        }
-        if self.negated {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalInListNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if !self.list.is_empty() {
-            struct_ser.serialize_field("list", &self.list)?;
-        }
-        if self.negated {
-            struct_ser.serialize_field("negated", &self.negated)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalInListNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "list",
-            "negated",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            List,
-            Negated,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "list" => Ok(GeneratedField::List),
-                            "negated" => Ok(GeneratedField::Negated),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalInListNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalInListNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalInListNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut list__ = None;
-                let mut negated__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::List => {
-                            if list__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("list"));
-                            }
-                            list__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Negated => {
-                            if negated__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negated"));
-                            }
-                            negated__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PhysicalInListNode {
-                    expr: expr__,
-                    list: list__.unwrap_or_default(),
-                    negated: negated__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalInListNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalIsNotNull {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNotNull", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalIsNotNull {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalIsNotNull;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalIsNotNull")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalIsNotNull, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalIsNotNull {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalIsNotNull", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalIsNull {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNull", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalIsNull {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalIsNull;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalIsNull")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalIsNull, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalIsNull {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalIsNull", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalLikeExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.negated {
-            len += 1;
-        }
-        if self.case_insensitive {
-            len += 1;
-        }
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.pattern.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalLikeExprNode", len)?;
-        if self.negated {
-            struct_ser.serialize_field("negated", &self.negated)?;
-        }
-        if self.case_insensitive {
-            struct_ser.serialize_field("caseInsensitive", &self.case_insensitive)?;
-        }
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.pattern.as_ref() {
-            struct_ser.serialize_field("pattern", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalLikeExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "negated",
-            "case_insensitive",
-            "caseInsensitive",
-            "expr",
-            "pattern",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Negated,
-            CaseInsensitive,
-            Expr,
-            Pattern,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "negated" => Ok(GeneratedField::Negated),
-                            "caseInsensitive" | "case_insensitive" => Ok(GeneratedField::CaseInsensitive),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "pattern" => Ok(GeneratedField::Pattern),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalLikeExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalLikeExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalLikeExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut negated__ = None;
-                let mut case_insensitive__ = None;
-                let mut expr__ = None;
-                let mut pattern__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Negated => {
-                            if negated__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negated"));
-                            }
-                            negated__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::CaseInsensitive => {
-                            if case_insensitive__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("caseInsensitive"));
-                            }
-                            case_insensitive__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Pattern => {
-                            if pattern__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("pattern"));
-                            }
-                            pattern__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalLikeExprNode {
-                    negated: negated__.unwrap_or_default(),
-                    case_insensitive: case_insensitive__.unwrap_or_default(),
-                    expr: expr__,
-                    pattern: pattern__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalLikeExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalNegativeNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNegativeNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalNegativeNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalNegativeNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalNegativeNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalNegativeNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalNegativeNode {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalNegativeNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalNot {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNot", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalNot {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalNot;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalNot")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalNot, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalNot {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalNot", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalPlanNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.physical_plan_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalPlanNode", len)?;
-        if let Some(v) = self.physical_plan_type.as_ref() {
-            match v {
-                physical_plan_node::PhysicalPlanType::ParquetScan(v) => {
-                    struct_ser.serialize_field("parquetScan", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::CsvScan(v) => {
-                    struct_ser.serialize_field("csvScan", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Empty(v) => {
-                    struct_ser.serialize_field("empty", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Projection(v) => {
-                    struct_ser.serialize_field("projection", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::GlobalLimit(v) => {
-                    struct_ser.serialize_field("globalLimit", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::LocalLimit(v) => {
-                    struct_ser.serialize_field("localLimit", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Aggregate(v) => {
-                    struct_ser.serialize_field("aggregate", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::HashJoin(v) => {
-                    struct_ser.serialize_field("hashJoin", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Sort(v) => {
-                    struct_ser.serialize_field("sort", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::CoalesceBatches(v) => {
-                    struct_ser.serialize_field("coalesceBatches", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Filter(v) => {
-                    struct_ser.serialize_field("filter", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Merge(v) => {
-                    struct_ser.serialize_field("merge", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Repartition(v) => {
-                    struct_ser.serialize_field("repartition", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Window(v) => {
-                    struct_ser.serialize_field("window", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::CrossJoin(v) => {
-                    struct_ser.serialize_field("crossJoin", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::AvroScan(v) => {
-                    struct_ser.serialize_field("avroScan", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Extension(v) => {
-                    struct_ser.serialize_field("extension", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Union(v) => {
-                    struct_ser.serialize_field("union", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::Explain(v) => {
-                    struct_ser.serialize_field("explain", v)?;
-                }
-                physical_plan_node::PhysicalPlanType::SortPreservingMerge(v) => {
-                    struct_ser.serialize_field("sortPreservingMerge", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalPlanNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "parquet_scan",
-            "parquetScan",
-            "csv_scan",
-            "csvScan",
-            "empty",
-            "projection",
-            "global_limit",
-            "globalLimit",
-            "local_limit",
-            "localLimit",
-            "aggregate",
-            "hash_join",
-            "hashJoin",
-            "sort",
-            "coalesce_batches",
-            "coalesceBatches",
-            "filter",
-            "merge",
-            "repartition",
-            "window",
-            "cross_join",
-            "crossJoin",
-            "avro_scan",
-            "avroScan",
-            "extension",
-            "union",
-            "explain",
-            "sort_preserving_merge",
-            "sortPreservingMerge",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            ParquetScan,
-            CsvScan,
-            Empty,
-            Projection,
-            GlobalLimit,
-            LocalLimit,
-            Aggregate,
-            HashJoin,
-            Sort,
-            CoalesceBatches,
-            Filter,
-            Merge,
-            Repartition,
-            Window,
-            CrossJoin,
-            AvroScan,
-            Extension,
-            Union,
-            Explain,
-            SortPreservingMerge,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "parquetScan" | "parquet_scan" => Ok(GeneratedField::ParquetScan),
-                            "csvScan" | "csv_scan" => Ok(GeneratedField::CsvScan),
-                            "empty" => Ok(GeneratedField::Empty),
-                            "projection" => Ok(GeneratedField::Projection),
-                            "globalLimit" | "global_limit" => Ok(GeneratedField::GlobalLimit),
-                            "localLimit" | "local_limit" => Ok(GeneratedField::LocalLimit),
-                            "aggregate" => Ok(GeneratedField::Aggregate),
-                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
-                            "sort" => Ok(GeneratedField::Sort),
-                            "coalesceBatches" | "coalesce_batches" => Ok(GeneratedField::CoalesceBatches),
-                            "filter" => Ok(GeneratedField::Filter),
-                            "merge" => Ok(GeneratedField::Merge),
-                            "repartition" => Ok(GeneratedField::Repartition),
-                            "window" => Ok(GeneratedField::Window),
-                            "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin),
-                            "avroScan" | "avro_scan" => Ok(GeneratedField::AvroScan),
-                            "extension" => Ok(GeneratedField::Extension),
-                            "union" => Ok(GeneratedField::Union),
-                            "explain" => Ok(GeneratedField::Explain),
-                            "sortPreservingMerge" | "sort_preserving_merge" => Ok(GeneratedField::SortPreservingMerge),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalPlanNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalPlanNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalPlanNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut physical_plan_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::ParquetScan => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("parquetScan"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::ParquetScan)
-;
-                        }
-                        GeneratedField::CsvScan => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("csvScan"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CsvScan)
-;
-                        }
-                        GeneratedField::Empty => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("empty"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Empty)
-;
-                        }
-                        GeneratedField::Projection => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("projection"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Projection)
-;
-                        }
-                        GeneratedField::GlobalLimit => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("globalLimit"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::GlobalLimit)
-;
-                        }
-                        GeneratedField::LocalLimit => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("localLimit"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::LocalLimit)
-;
-                        }
-                        GeneratedField::Aggregate => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggregate"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Aggregate)
-;
-                        }
-                        GeneratedField::HashJoin => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hashJoin"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::HashJoin)
-;
-                        }
-                        GeneratedField::Sort => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("sort"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Sort)
-;
-                        }
-                        GeneratedField::CoalesceBatches => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("coalesceBatches"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CoalesceBatches)
-;
-                        }
-                        GeneratedField::Filter => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("filter"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Filter)
-;
-                        }
-                        GeneratedField::Merge => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("merge"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Merge)
-;
-                        }
-                        GeneratedField::Repartition => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("repartition"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Repartition)
-;
-                        }
-                        GeneratedField::Window => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("window"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Window)
-;
-                        }
-                        GeneratedField::CrossJoin => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("crossJoin"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CrossJoin)
-;
-                        }
-                        GeneratedField::AvroScan => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("avroScan"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::AvroScan)
-;
-                        }
-                        GeneratedField::Extension => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("extension"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Extension)
-;
-                        }
-                        GeneratedField::Union => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("union"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Union)
-;
-                        }
-                        GeneratedField::Explain => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("explain"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Explain)
-;
-                        }
-                        GeneratedField::SortPreservingMerge => {
-                            if physical_plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("sortPreservingMerge"));
-                            }
-                            physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::SortPreservingMerge)
-;
-                        }
-                    }
-                }
-                Ok(PhysicalPlanNode {
-                    physical_plan_type: physical_plan_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalPlanNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalScalarFunctionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.name.is_empty() {
-            len += 1;
-        }
-        if self.fun != 0 {
-            len += 1;
-        }
-        if !self.args.is_empty() {
-            len += 1;
-        }
-        if self.return_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarFunctionNode", len)?;
-        if !self.name.is_empty() {
-            struct_ser.serialize_field("name", &self.name)?;
-        }
-        if self.fun != 0 {
-            let v = ScalarFunction::from_i32(self.fun)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?;
-            struct_ser.serialize_field("fun", &v)?;
-        }
-        if !self.args.is_empty() {
-            struct_ser.serialize_field("args", &self.args)?;
-        }
-        if let Some(v) = self.return_type.as_ref() {
-            struct_ser.serialize_field("returnType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalScalarFunctionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "fun",
-            "args",
-            "return_type",
-            "returnType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            Fun,
-            Args,
-            ReturnType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "fun" => Ok(GeneratedField::Fun),
-                            "args" => Ok(GeneratedField::Args),
-                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalScalarFunctionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalScalarFunctionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalScalarFunctionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut fun__ = None;
-                let mut args__ = None;
-                let mut return_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Fun => {
-                            if fun__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fun"));
-                            }
-                            fun__ = Some(map.next_value::<ScalarFunction>()? as i32);
-                        }
-                        GeneratedField::Args => {
-                            if args__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("args"));
-                            }
-                            args__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::ReturnType => {
-                            if return_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("returnType"));
-                            }
-                            return_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalScalarFunctionNode {
-                    name: name__.unwrap_or_default(),
-                    fun: fun__.unwrap_or_default(),
-                    args: args__.unwrap_or_default(),
-                    return_type: return_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalScalarFunctionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalScalarUdfNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.name.is_empty() {
-            len += 1;
-        }
-        if !self.args.is_empty() {
-            len += 1;
-        }
-        if self.return_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarUdfNode", len)?;
-        if !self.name.is_empty() {
-            struct_ser.serialize_field("name", &self.name)?;
-        }
-        if !self.args.is_empty() {
-            struct_ser.serialize_field("args", &self.args)?;
-        }
-        if let Some(v) = self.return_type.as_ref() {
-            struct_ser.serialize_field("returnType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalScalarUdfNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "args",
-            "return_type",
-            "returnType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            Args,
-            ReturnType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "args" => Ok(GeneratedField::Args),
-                            "returnType" | "return_type" => Ok(GeneratedField::ReturnType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalScalarUdfNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalScalarUdfNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalScalarUdfNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut args__ = None;
-                let mut return_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Args => {
-                            if args__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("args"));
-                            }
-                            args__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::ReturnType => {
-                            if return_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("returnType"));
-                            }
-                            return_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalScalarUdfNode {
-                    name: name__.unwrap_or_default(),
-                    args: args__.unwrap_or_default(),
-                    return_type: return_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalScalarUdfNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalSortExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.asc {
-            len += 1;
-        }
-        if self.nulls_first {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalSortExprNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if self.asc {
-            struct_ser.serialize_field("asc", &self.asc)?;
-        }
-        if self.nulls_first {
-            struct_ser.serialize_field("nullsFirst", &self.nulls_first)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalSortExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "asc",
-            "nulls_first",
-            "nullsFirst",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            Asc,
-            NullsFirst,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "asc" => Ok(GeneratedField::Asc),
-                            "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalSortExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalSortExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalSortExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut asc__ = None;
-                let mut nulls_first__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Asc => {
-                            if asc__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("asc"));
-                            }
-                            asc__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::NullsFirst => {
-                            if nulls_first__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullsFirst"));
-                            }
-                            nulls_first__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PhysicalSortExprNode {
-                    expr: expr__,
-                    asc: asc__.unwrap_or_default(),
-                    nulls_first: nulls_first__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalSortExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalSortExprNodeCollection {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.physical_sort_expr_nodes.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalSortExprNodeCollection", len)?;
-        if !self.physical_sort_expr_nodes.is_empty() {
-            struct_ser.serialize_field("physicalSortExprNodes", &self.physical_sort_expr_nodes)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalSortExprNodeCollection {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "physical_sort_expr_nodes",
-            "physicalSortExprNodes",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            PhysicalSortExprNodes,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "physicalSortExprNodes" | "physical_sort_expr_nodes" => Ok(GeneratedField::PhysicalSortExprNodes),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalSortExprNodeCollection;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalSortExprNodeCollection")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalSortExprNodeCollection, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut physical_sort_expr_nodes__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::PhysicalSortExprNodes => {
-                            if physical_sort_expr_nodes__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("physicalSortExprNodes"));
-                            }
-                            physical_sort_expr_nodes__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(PhysicalSortExprNodeCollection {
-                    physical_sort_expr_nodes: physical_sort_expr_nodes__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalSortExprNodeCollection", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalTryCastNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.arrow_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalTryCastNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.arrow_type.as_ref() {
-            struct_ser.serialize_field("arrowType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalTryCastNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "arrow_type",
-            "arrowType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            ArrowType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalTryCastNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalTryCastNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalTryCastNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut arrow_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::ArrowType => {
-                            if arrow_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("arrowType"));
-                            }
-                            arrow_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalTryCastNode {
-                    expr: expr__,
-                    arrow_type: arrow_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalTryCastNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalWhenThen {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.when_expr.is_some() {
-            len += 1;
-        }
-        if self.then_expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWhenThen", len)?;
-        if let Some(v) = self.when_expr.as_ref() {
-            struct_ser.serialize_field("whenExpr", v)?;
-        }
-        if let Some(v) = self.then_expr.as_ref() {
-            struct_ser.serialize_field("thenExpr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalWhenThen {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "when_expr",
-            "whenExpr",
-            "then_expr",
-            "thenExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            WhenExpr,
-            ThenExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr),
-                            "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalWhenThen;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalWhenThen")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalWhenThen, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut when_expr__ = None;
-                let mut then_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::WhenExpr => {
-                            if when_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("whenExpr"));
-                            }
-                            when_expr__ = map.next_value()?;
-                        }
-                        GeneratedField::ThenExpr => {
-                            if then_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("thenExpr"));
-                            }
-                            then_expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PhysicalWhenThen {
-                    when_expr: when_expr__,
-                    then_expr: then_expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalWhenThen", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PhysicalWindowExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.window_function.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWindowExprNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.window_function.as_ref() {
-            match v {
-                physical_window_expr_node::WindowFunction::AggrFunction(v) => {
-                    let v = AggregateFunction::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("aggrFunction", &v)?;
-                }
-                physical_window_expr_node::WindowFunction::BuiltInFunction(v) => {
-                    let v = BuiltInWindowFunction::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("builtInFunction", &v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PhysicalWindowExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "aggr_function",
-            "aggrFunction",
-            "built_in_function",
-            "builtInFunction",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            AggrFunction,
-            BuiltInFunction,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
-                            "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PhysicalWindowExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PhysicalWindowExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PhysicalWindowExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut window_function__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::AggrFunction => {
-                            if window_function__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
-                            }
-                            window_function__ = map.next_value::<::std::option::Option<AggregateFunction>>()?.map(|x| physical_window_expr_node::WindowFunction::AggrFunction(x as i32));
-                        }
-                        GeneratedField::BuiltInFunction => {
-                            if window_function__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("builtInFunction"));
-                            }
-                            window_function__ = map.next_value::<::std::option::Option<BuiltInWindowFunction>>()?.map(|x| physical_window_expr_node::WindowFunction::BuiltInFunction(x as i32));
-                        }
-                    }
-                }
-                Ok(PhysicalWindowExprNode {
-                    expr: expr__,
-                    window_function: window_function__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PhysicalWindowExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PlaceholderNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.id.is_empty() {
-            len += 1;
-        }
-        if self.data_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PlaceholderNode", len)?;
-        if !self.id.is_empty() {
-            struct_ser.serialize_field("id", &self.id)?;
-        }
-        if let Some(v) = self.data_type.as_ref() {
-            struct_ser.serialize_field("dataType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PlaceholderNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "id",
-            "data_type",
-            "dataType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Id,
-            DataType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "id" => Ok(GeneratedField::Id),
-                            "dataType" | "data_type" => Ok(GeneratedField::DataType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PlaceholderNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PlaceholderNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PlaceholderNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut id__ = None;
-                let mut data_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Id => {
-                            if id__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("id"));
-                            }
-                            id__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::DataType => {
-                            if data_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("dataType"));
-                            }
-                            data_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PlaceholderNode {
-                    id: id__.unwrap_or_default(),
-                    data_type: data_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PlaceholderNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PlanType {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.plan_type_enum.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PlanType", len)?;
-        if let Some(v) = self.plan_type_enum.as_ref() {
-            match v {
-                plan_type::PlanTypeEnum::InitialLogicalPlan(v) => {
-                    struct_ser.serialize_field("InitialLogicalPlan", v)?;
-                }
-                plan_type::PlanTypeEnum::AnalyzedLogicalPlan(v) => {
-                    struct_ser.serialize_field("AnalyzedLogicalPlan", v)?;
-                }
-                plan_type::PlanTypeEnum::FinalAnalyzedLogicalPlan(v) => {
-                    struct_ser.serialize_field("FinalAnalyzedLogicalPlan", v)?;
-                }
-                plan_type::PlanTypeEnum::OptimizedLogicalPlan(v) => {
-                    struct_ser.serialize_field("OptimizedLogicalPlan", v)?;
-                }
-                plan_type::PlanTypeEnum::FinalLogicalPlan(v) => {
-                    struct_ser.serialize_field("FinalLogicalPlan", v)?;
-                }
-                plan_type::PlanTypeEnum::InitialPhysicalPlan(v) => {
-                    struct_ser.serialize_field("InitialPhysicalPlan", v)?;
-                }
-                plan_type::PlanTypeEnum::OptimizedPhysicalPlan(v) => {
-                    struct_ser.serialize_field("OptimizedPhysicalPlan", v)?;
-                }
-                plan_type::PlanTypeEnum::FinalPhysicalPlan(v) => {
-                    struct_ser.serialize_field("FinalPhysicalPlan", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PlanType {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "InitialLogicalPlan",
-            "AnalyzedLogicalPlan",
-            "FinalAnalyzedLogicalPlan",
-            "OptimizedLogicalPlan",
-            "FinalLogicalPlan",
-            "InitialPhysicalPlan",
-            "OptimizedPhysicalPlan",
-            "FinalPhysicalPlan",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            InitialLogicalPlan,
-            AnalyzedLogicalPlan,
-            FinalAnalyzedLogicalPlan,
-            OptimizedLogicalPlan,
-            FinalLogicalPlan,
-            InitialPhysicalPlan,
-            OptimizedPhysicalPlan,
-            FinalPhysicalPlan,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "InitialLogicalPlan" => Ok(GeneratedField::InitialLogicalPlan),
-                            "AnalyzedLogicalPlan" => Ok(GeneratedField::AnalyzedLogicalPlan),
-                            "FinalAnalyzedLogicalPlan" => Ok(GeneratedField::FinalAnalyzedLogicalPlan),
-                            "OptimizedLogicalPlan" => Ok(GeneratedField::OptimizedLogicalPlan),
-                            "FinalLogicalPlan" => Ok(GeneratedField::FinalLogicalPlan),
-                            "InitialPhysicalPlan" => Ok(GeneratedField::InitialPhysicalPlan),
-                            "OptimizedPhysicalPlan" => Ok(GeneratedField::OptimizedPhysicalPlan),
-                            "FinalPhysicalPlan" => Ok(GeneratedField::FinalPhysicalPlan),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PlanType;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PlanType")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PlanType, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut plan_type_enum__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::InitialLogicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("InitialLogicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialLogicalPlan)
-;
-                        }
-                        GeneratedField::AnalyzedLogicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("AnalyzedLogicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::AnalyzedLogicalPlan)
-;
-                        }
-                        GeneratedField::FinalAnalyzedLogicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FinalAnalyzedLogicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalAnalyzedLogicalPlan)
-;
-                        }
-                        GeneratedField::OptimizedLogicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("OptimizedLogicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedLogicalPlan)
-;
-                        }
-                        GeneratedField::FinalLogicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FinalLogicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalLogicalPlan)
-;
-                        }
-                        GeneratedField::InitialPhysicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialPhysicalPlan)
-;
-                        }
-                        GeneratedField::OptimizedPhysicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedPhysicalPlan)
-;
-                        }
-                        GeneratedField::FinalPhysicalPlan => {
-                            if plan_type_enum__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan"));
-                            }
-                            plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalPhysicalPlan)
-;
-                        }
-                    }
-                }
-                Ok(PlanType {
-                    plan_type_enum: plan_type_enum__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PlanType", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for PrepareNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.name.is_empty() {
-            len += 1;
-        }
-        if !self.data_types.is_empty() {
-            len += 1;
-        }
-        if self.input.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.PrepareNode", len)?;
-        if !self.name.is_empty() {
-            struct_ser.serialize_field("name", &self.name)?;
-        }
-        if !self.data_types.is_empty() {
-            struct_ser.serialize_field("dataTypes", &self.data_types)?;
-        }
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for PrepareNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "name",
-            "data_types",
-            "dataTypes",
-            "input",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Name,
-            DataTypes,
-            Input,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "name" => Ok(GeneratedField::Name),
-                            "dataTypes" | "data_types" => Ok(GeneratedField::DataTypes),
-                            "input" => Ok(GeneratedField::Input),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = PrepareNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.PrepareNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<PrepareNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut name__ = None;
-                let mut data_types__ = None;
-                let mut input__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Name => {
-                            if name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("name"));
-                            }
-                            name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::DataTypes => {
-                            if data_types__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("dataTypes"));
-                            }
-                            data_types__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(PrepareNode {
-                    name: name__.unwrap_or_default(),
-                    data_types: data_types__.unwrap_or_default(),
-                    input: input__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.PrepareNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ProjectionColumns {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.columns.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionColumns", len)?;
-        if !self.columns.is_empty() {
-            struct_ser.serialize_field("columns", &self.columns)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ProjectionColumns {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "columns",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Columns,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "columns" => Ok(GeneratedField::Columns),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ProjectionColumns;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ProjectionColumns")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ProjectionColumns, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut columns__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Columns => {
-                            if columns__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("columns"));
-                            }
-                            columns__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ProjectionColumns {
-                    columns: columns__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ProjectionColumns", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ProjectionExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        if !self.expr_name.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        if !self.expr_name.is_empty() {
-            struct_ser.serialize_field("exprName", &self.expr_name)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ProjectionExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "expr",
-            "expr_name",
-            "exprName",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Expr,
-            ExprName,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "exprName" | "expr_name" => Ok(GeneratedField::ExprName),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ProjectionExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ProjectionExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ProjectionExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut expr__ = None;
-                let mut expr_name__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::ExprName => {
-                            if expr_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("exprName"));
-                            }
-                            expr_name__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ProjectionExecNode {
-                    input: input__,
-                    expr: expr__.unwrap_or_default(),
-                    expr_name: expr_name__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ProjectionExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ProjectionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        if self.optional_alias.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        if let Some(v) = self.optional_alias.as_ref() {
-            match v {
-                projection_node::OptionalAlias::Alias(v) => {
-                    struct_ser.serialize_field("alias", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ProjectionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "expr",
-            "alias",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Expr,
-            Alias,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "alias" => Ok(GeneratedField::Alias),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ProjectionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ProjectionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ProjectionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut expr__ = None;
-                let mut optional_alias__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Alias => {
-                            if optional_alias__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("alias"));
-                            }
-                            optional_alias__ = map.next_value::<::std::option::Option<_>>()?.map(projection_node::OptionalAlias::Alias);
-                        }
-                    }
-                }
-                Ok(ProjectionNode {
-                    input: input__,
-                    expr: expr__.unwrap_or_default(),
-                    optional_alias: optional_alias__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ProjectionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for RepartitionExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.partition_method.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if let Some(v) = self.partition_method.as_ref() {
-            match v {
-                repartition_exec_node::PartitionMethod::RoundRobin(v) => {
-                    struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?;
-                }
-                repartition_exec_node::PartitionMethod::Hash(v) => {
-                    struct_ser.serialize_field("hash", v)?;
-                }
-                repartition_exec_node::PartitionMethod::Unknown(v) => {
-                    struct_ser.serialize_field("unknown", ToString::to_string(&v).as_str())?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for RepartitionExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "round_robin",
-            "roundRobin",
-            "hash",
-            "unknown",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            RoundRobin,
-            Hash,
-            Unknown,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin),
-                            "hash" => Ok(GeneratedField::Hash),
-                            "unknown" => Ok(GeneratedField::Unknown),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = RepartitionExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.RepartitionExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<RepartitionExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut partition_method__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::RoundRobin => {
-                            if partition_method__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("roundRobin"));
-                            }
-                            partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::RoundRobin(x.0));
-                        }
-                        GeneratedField::Hash => {
-                            if partition_method__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hash"));
-                            }
-                            partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_exec_node::PartitionMethod::Hash)
-;
-                        }
-                        GeneratedField::Unknown => {
-                            if partition_method__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("unknown"));
-                            }
-                            partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::Unknown(x.0));
-                        }
-                    }
-                }
-                Ok(RepartitionExecNode {
-                    input: input__,
-                    partition_method: partition_method__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.RepartitionExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for RepartitionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.partition_method.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if let Some(v) = self.partition_method.as_ref() {
-            match v {
-                repartition_node::PartitionMethod::RoundRobin(v) => {
-                    struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?;
-                }
-                repartition_node::PartitionMethod::Hash(v) => {
-                    struct_ser.serialize_field("hash", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for RepartitionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "round_robin",
-            "roundRobin",
-            "hash",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            RoundRobin,
-            Hash,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin),
-                            "hash" => Ok(GeneratedField::Hash),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = RepartitionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.RepartitionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<RepartitionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut partition_method__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::RoundRobin => {
-                            if partition_method__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("roundRobin"));
-                            }
-                            partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_node::PartitionMethod::RoundRobin(x.0));
-                        }
-                        GeneratedField::Hash => {
-                            if partition_method__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("hash"));
-                            }
-                            partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_node::PartitionMethod::Hash)
-;
-                        }
-                    }
-                }
-                Ok(RepartitionNode {
-                    input: input__,
-                    partition_method: partition_method__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.RepartitionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for RollupNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.RollupNode", len)?;
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for RollupNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = RollupNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.RollupNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<RollupNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(RollupNode {
-                    expr: expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.RollupNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarDictionaryValue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.index_type.is_some() {
-            len += 1;
-        }
-        if self.value.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarDictionaryValue", len)?;
-        if let Some(v) = self.index_type.as_ref() {
-            struct_ser.serialize_field("indexType", v)?;
-        }
-        if let Some(v) = self.value.as_ref() {
-            struct_ser.serialize_field("value", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "index_type",
-            "indexType",
-            "value",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            IndexType,
-            Value,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "indexType" | "index_type" => Ok(GeneratedField::IndexType),
-                            "value" => Ok(GeneratedField::Value),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarDictionaryValue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarDictionaryValue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarDictionaryValue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut index_type__ = None;
-                let mut value__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::IndexType => {
-                            if index_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("indexType"));
-                            }
-                            index_type__ = map.next_value()?;
-                        }
-                        GeneratedField::Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("value"));
-                            }
-                            value__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(ScalarDictionaryValue {
-                    index_type: index_type__,
-                    value: value__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarFixedSizeBinary {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.values.is_empty() {
-            len += 1;
-        }
-        if self.length != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFixedSizeBinary", len)?;
-        if !self.values.is_empty() {
-            struct_ser.serialize_field("values", pbjson::private::base64::encode(&self.values).as_str())?;
-        }
-        if self.length != 0 {
-            struct_ser.serialize_field("length", &self.length)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarFixedSizeBinary {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "values",
-            "length",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Values,
-            Length,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "values" => Ok(GeneratedField::Values),
-                            "length" => Ok(GeneratedField::Length),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarFixedSizeBinary;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarFixedSizeBinary")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarFixedSizeBinary, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut values__ = None;
-                let mut length__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Values => {
-                            if values__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("values"));
-                            }
-                            values__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::Length => {
-                            if length__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("length"));
-                            }
-                            length__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(ScalarFixedSizeBinary {
-                    values: values__.unwrap_or_default(),
-                    length: length__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarFixedSizeBinary", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarFunction {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Abs => "Abs",
-            Self::Acos => "Acos",
-            Self::Asin => "Asin",
-            Self::Atan => "Atan",
-            Self::Ascii => "Ascii",
-            Self::Ceil => "Ceil",
-            Self::Cos => "Cos",
-            Self::Digest => "Digest",
-            Self::Exp => "Exp",
-            Self::Floor => "Floor",
-            Self::Ln => "Ln",
-            Self::Log => "Log",
-            Self::Log10 => "Log10",
-            Self::Log2 => "Log2",
-            Self::Round => "Round",
-            Self::Signum => "Signum",
-            Self::Sin => "Sin",
-            Self::Sqrt => "Sqrt",
-            Self::Tan => "Tan",
-            Self::Trunc => "Trunc",
-            Self::Array => "Array",
-            Self::RegexpMatch => "RegexpMatch",
-            Self::BitLength => "BitLength",
-            Self::Btrim => "Btrim",
-            Self::CharacterLength => "CharacterLength",
-            Self::Chr => "Chr",
-            Self::Concat => "Concat",
-            Self::ConcatWithSeparator => "ConcatWithSeparator",
-            Self::DatePart => "DatePart",
-            Self::DateTrunc => "DateTrunc",
-            Self::InitCap => "InitCap",
-            Self::Left => "Left",
-            Self::Lpad => "Lpad",
-            Self::Lower => "Lower",
-            Self::Ltrim => "Ltrim",
-            Self::Md5 => "MD5",
-            Self::NullIf => "NullIf",
-            Self::OctetLength => "OctetLength",
-            Self::Random => "Random",
-            Self::RegexpReplace => "RegexpReplace",
-            Self::Repeat => "Repeat",
-            Self::Replace => "Replace",
-            Self::Reverse => "Reverse",
-            Self::Right => "Right",
-            Self::Rpad => "Rpad",
-            Self::Rtrim => "Rtrim",
-            Self::Sha224 => "SHA224",
-            Self::Sha256 => "SHA256",
-            Self::Sha384 => "SHA384",
-            Self::Sha512 => "SHA512",
-            Self::SplitPart => "SplitPart",
-            Self::StartsWith => "StartsWith",
-            Self::Strpos => "Strpos",
-            Self::Substr => "Substr",
-            Self::ToHex => "ToHex",
-            Self::ToTimestamp => "ToTimestamp",
-            Self::ToTimestampMillis => "ToTimestampMillis",
-            Self::ToTimestampMicros => "ToTimestampMicros",
-            Self::ToTimestampSeconds => "ToTimestampSeconds",
-            Self::Now => "Now",
-            Self::Translate => "Translate",
-            Self::Trim => "Trim",
-            Self::Upper => "Upper",
-            Self::Coalesce => "Coalesce",
-            Self::Power => "Power",
-            Self::StructFun => "StructFun",
-            Self::FromUnixtime => "FromUnixtime",
-            Self::Atan2 => "Atan2",
-            Self::DateBin => "DateBin",
-            Self::ArrowTypeof => "ArrowTypeof",
-            Self::CurrentDate => "CurrentDate",
-            Self::CurrentTime => "CurrentTime",
-            Self::Uuid => "Uuid",
-            Self::Cbrt => "Cbrt",
-            Self::Acosh => "Acosh",
-            Self::Asinh => "Asinh",
-            Self::Atanh => "Atanh",
-            Self::Sinh => "Sinh",
-            Self::Cosh => "Cosh",
-            Self::Tanh => "Tanh",
-            Self::Pi => "Pi",
-            Self::Degrees => "Degrees",
-            Self::Radians => "Radians",
-            Self::Factorial => "Factorial",
-            Self::Lcm => "Lcm",
-            Self::Gcd => "Gcd",
-            Self::ArrayAppend => "ArrayAppend",
-            Self::ArrayConcat => "ArrayConcat",
-            Self::ArrayDims => "ArrayDims",
-            Self::ArrayFill => "ArrayFill",
-            Self::ArrayLength => "ArrayLength",
-            Self::ArrayNdims => "ArrayNdims",
-            Self::ArrayPosition => "ArrayPosition",
-            Self::ArrayPositions => "ArrayPositions",
-            Self::ArrayPrepend => "ArrayPrepend",
-            Self::ArrayRemove => "ArrayRemove",
-            Self::ArrayReplace => "ArrayReplace",
-            Self::ArrayToString => "ArrayToString",
-            Self::Cardinality => "Cardinality",
-            Self::TrimArray => "TrimArray",
-            Self::ArrayContains => "ArrayContains",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarFunction {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "Abs",
-            "Acos",
-            "Asin",
-            "Atan",
-            "Ascii",
-            "Ceil",
-            "Cos",
-            "Digest",
-            "Exp",
-            "Floor",
-            "Ln",
-            "Log",
-            "Log10",
-            "Log2",
-            "Round",
-            "Signum",
-            "Sin",
-            "Sqrt",
-            "Tan",
-            "Trunc",
-            "Array",
-            "RegexpMatch",
-            "BitLength",
-            "Btrim",
-            "CharacterLength",
-            "Chr",
-            "Concat",
-            "ConcatWithSeparator",
-            "DatePart",
-            "DateTrunc",
-            "InitCap",
-            "Left",
-            "Lpad",
-            "Lower",
-            "Ltrim",
-            "MD5",
-            "NullIf",
-            "OctetLength",
-            "Random",
-            "RegexpReplace",
-            "Repeat",
-            "Replace",
-            "Reverse",
-            "Right",
-            "Rpad",
-            "Rtrim",
-            "SHA224",
-            "SHA256",
-            "SHA384",
-            "SHA512",
-            "SplitPart",
-            "StartsWith",
-            "Strpos",
-            "Substr",
-            "ToHex",
-            "ToTimestamp",
-            "ToTimestampMillis",
-            "ToTimestampMicros",
-            "ToTimestampSeconds",
-            "Now",
-            "Translate",
-            "Trim",
-            "Upper",
-            "Coalesce",
-            "Power",
-            "StructFun",
-            "FromUnixtime",
-            "Atan2",
-            "DateBin",
-            "ArrowTypeof",
-            "CurrentDate",
-            "CurrentTime",
-            "Uuid",
-            "Cbrt",
-            "Acosh",
-            "Asinh",
-            "Atanh",
-            "Sinh",
-            "Cosh",
-            "Tanh",
-            "Pi",
-            "Degrees",
-            "Radians",
-            "Factorial",
-            "Lcm",
-            "Gcd",
-            "ArrayAppend",
-            "ArrayConcat",
-            "ArrayDims",
-            "ArrayFill",
-            "ArrayLength",
-            "ArrayNdims",
-            "ArrayPosition",
-            "ArrayPositions",
-            "ArrayPrepend",
-            "ArrayRemove",
-            "ArrayReplace",
-            "ArrayToString",
-            "Cardinality",
-            "TrimArray",
-            "ArrayContains",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarFunction;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(ScalarFunction::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(ScalarFunction::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "Abs" => Ok(ScalarFunction::Abs),
-                    "Acos" => Ok(ScalarFunction::Acos),
-                    "Asin" => Ok(ScalarFunction::Asin),
-                    "Atan" => Ok(ScalarFunction::Atan),
-                    "Ascii" => Ok(ScalarFunction::Ascii),
-                    "Ceil" => Ok(ScalarFunction::Ceil),
-                    "Cos" => Ok(ScalarFunction::Cos),
-                    "Digest" => Ok(ScalarFunction::Digest),
-                    "Exp" => Ok(ScalarFunction::Exp),
-                    "Floor" => Ok(ScalarFunction::Floor),
-                    "Ln" => Ok(ScalarFunction::Ln),
-                    "Log" => Ok(ScalarFunction::Log),
-                    "Log10" => Ok(ScalarFunction::Log10),
-                    "Log2" => Ok(ScalarFunction::Log2),
-                    "Round" => Ok(ScalarFunction::Round),
-                    "Signum" => Ok(ScalarFunction::Signum),
-                    "Sin" => Ok(ScalarFunction::Sin),
-                    "Sqrt" => Ok(ScalarFunction::Sqrt),
-                    "Tan" => Ok(ScalarFunction::Tan),
-                    "Trunc" => Ok(ScalarFunction::Trunc),
-                    "Array" => Ok(ScalarFunction::Array),
-                    "RegexpMatch" => Ok(ScalarFunction::RegexpMatch),
-                    "BitLength" => Ok(ScalarFunction::BitLength),
-                    "Btrim" => Ok(ScalarFunction::Btrim),
-                    "CharacterLength" => Ok(ScalarFunction::CharacterLength),
-                    "Chr" => Ok(ScalarFunction::Chr),
-                    "Concat" => Ok(ScalarFunction::Concat),
-                    "ConcatWithSeparator" => Ok(ScalarFunction::ConcatWithSeparator),
-                    "DatePart" => Ok(ScalarFunction::DatePart),
-                    "DateTrunc" => Ok(ScalarFunction::DateTrunc),
-                    "InitCap" => Ok(ScalarFunction::InitCap),
-                    "Left" => Ok(ScalarFunction::Left),
-                    "Lpad" => Ok(ScalarFunction::Lpad),
-                    "Lower" => Ok(ScalarFunction::Lower),
-                    "Ltrim" => Ok(ScalarFunction::Ltrim),
-                    "MD5" => Ok(ScalarFunction::Md5),
-                    "NullIf" => Ok(ScalarFunction::NullIf),
-                    "OctetLength" => Ok(ScalarFunction::OctetLength),
-                    "Random" => Ok(ScalarFunction::Random),
-                    "RegexpReplace" => Ok(ScalarFunction::RegexpReplace),
-                    "Repeat" => Ok(ScalarFunction::Repeat),
-                    "Replace" => Ok(ScalarFunction::Replace),
-                    "Reverse" => Ok(ScalarFunction::Reverse),
-                    "Right" => Ok(ScalarFunction::Right),
-                    "Rpad" => Ok(ScalarFunction::Rpad),
-                    "Rtrim" => Ok(ScalarFunction::Rtrim),
-                    "SHA224" => Ok(ScalarFunction::Sha224),
-                    "SHA256" => Ok(ScalarFunction::Sha256),
-                    "SHA384" => Ok(ScalarFunction::Sha384),
-                    "SHA512" => Ok(ScalarFunction::Sha512),
-                    "SplitPart" => Ok(ScalarFunction::SplitPart),
-                    "StartsWith" => Ok(ScalarFunction::StartsWith),
-                    "Strpos" => Ok(ScalarFunction::Strpos),
-                    "Substr" => Ok(ScalarFunction::Substr),
-                    "ToHex" => Ok(ScalarFunction::ToHex),
-                    "ToTimestamp" => Ok(ScalarFunction::ToTimestamp),
-                    "ToTimestampMillis" => Ok(ScalarFunction::ToTimestampMillis),
-                    "ToTimestampMicros" => Ok(ScalarFunction::ToTimestampMicros),
-                    "ToTimestampSeconds" => Ok(ScalarFunction::ToTimestampSeconds),
-                    "Now" => Ok(ScalarFunction::Now),
-                    "Translate" => Ok(ScalarFunction::Translate),
-                    "Trim" => Ok(ScalarFunction::Trim),
-                    "Upper" => Ok(ScalarFunction::Upper),
-                    "Coalesce" => Ok(ScalarFunction::Coalesce),
-                    "Power" => Ok(ScalarFunction::Power),
-                    "StructFun" => Ok(ScalarFunction::StructFun),
-                    "FromUnixtime" => Ok(ScalarFunction::FromUnixtime),
-                    "Atan2" => Ok(ScalarFunction::Atan2),
-                    "DateBin" => Ok(ScalarFunction::DateBin),
-                    "ArrowTypeof" => Ok(ScalarFunction::ArrowTypeof),
-                    "CurrentDate" => Ok(ScalarFunction::CurrentDate),
-                    "CurrentTime" => Ok(ScalarFunction::CurrentTime),
-                    "Uuid" => Ok(ScalarFunction::Uuid),
-                    "Cbrt" => Ok(ScalarFunction::Cbrt),
-                    "Acosh" => Ok(ScalarFunction::Acosh),
-                    "Asinh" => Ok(ScalarFunction::Asinh),
-                    "Atanh" => Ok(ScalarFunction::Atanh),
-                    "Sinh" => Ok(ScalarFunction::Sinh),
-                    "Cosh" => Ok(ScalarFunction::Cosh),
-                    "Tanh" => Ok(ScalarFunction::Tanh),
-                    "Pi" => Ok(ScalarFunction::Pi),
-                    "Degrees" => Ok(ScalarFunction::Degrees),
-                    "Radians" => Ok(ScalarFunction::Radians),
-                    "Factorial" => Ok(ScalarFunction::Factorial),
-                    "Lcm" => Ok(ScalarFunction::Lcm),
-                    "Gcd" => Ok(ScalarFunction::Gcd),
-                    "ArrayAppend" => Ok(ScalarFunction::ArrayAppend),
-                    "ArrayConcat" => Ok(ScalarFunction::ArrayConcat),
-                    "ArrayDims" => Ok(ScalarFunction::ArrayDims),
-                    "ArrayFill" => Ok(ScalarFunction::ArrayFill),
-                    "ArrayLength" => Ok(ScalarFunction::ArrayLength),
-                    "ArrayNdims" => Ok(ScalarFunction::ArrayNdims),
-                    "ArrayPosition" => Ok(ScalarFunction::ArrayPosition),
-                    "ArrayPositions" => Ok(ScalarFunction::ArrayPositions),
-                    "ArrayPrepend" => Ok(ScalarFunction::ArrayPrepend),
-                    "ArrayRemove" => Ok(ScalarFunction::ArrayRemove),
-                    "ArrayReplace" => Ok(ScalarFunction::ArrayReplace),
-                    "ArrayToString" => Ok(ScalarFunction::ArrayToString),
-                    "Cardinality" => Ok(ScalarFunction::Cardinality),
-                    "TrimArray" => Ok(ScalarFunction::TrimArray),
-                    "ArrayContains" => Ok(ScalarFunction::ArrayContains),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarFunctionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.fun != 0 {
-            len += 1;
-        }
-        if !self.args.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFunctionNode", len)?;
-        if self.fun != 0 {
-            let v = ScalarFunction::from_i32(self.fun)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?;
-            struct_ser.serialize_field("fun", &v)?;
-        }
-        if !self.args.is_empty() {
-            struct_ser.serialize_field("args", &self.args)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarFunctionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "fun",
-            "args",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Fun,
-            Args,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "fun" => Ok(GeneratedField::Fun),
-                            "args" => Ok(GeneratedField::Args),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarFunctionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarFunctionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarFunctionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut fun__ = None;
-                let mut args__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Fun => {
-                            if fun__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fun"));
-                            }
-                            fun__ = Some(map.next_value::<ScalarFunction>()? as i32);
-                        }
-                        GeneratedField::Args => {
-                            if args__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("args"));
-                            }
-                            args__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ScalarFunctionNode {
-                    fun: fun__.unwrap_or_default(),
-                    args: args__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarFunctionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarListValue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.is_null {
-            len += 1;
-        }
-        if self.field.is_some() {
-            len += 1;
-        }
-        if !self.values.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarListValue", len)?;
-        if self.is_null {
-            struct_ser.serialize_field("isNull", &self.is_null)?;
-        }
-        if let Some(v) = self.field.as_ref() {
-            struct_ser.serialize_field("field", v)?;
-        }
-        if !self.values.is_empty() {
-            struct_ser.serialize_field("values", &self.values)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarListValue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "is_null",
-            "isNull",
-            "field",
-            "values",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            IsNull,
-            Field,
-            Values,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "isNull" | "is_null" => Ok(GeneratedField::IsNull),
-                            "field" => Ok(GeneratedField::Field),
-                            "values" => Ok(GeneratedField::Values),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarListValue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarListValue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarListValue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut is_null__ = None;
-                let mut field__ = None;
-                let mut values__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::IsNull => {
-                            if is_null__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isNull"));
-                            }
-                            is_null__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Field => {
-                            if field__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("field"));
-                            }
-                            field__ = map.next_value()?;
-                        }
-                        GeneratedField::Values => {
-                            if values__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("values"));
-                            }
-                            values__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ScalarListValue {
-                    is_null: is_null__.unwrap_or_default(),
-                    field: field__,
-                    values: values__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarListValue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarTime32Value {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.value.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime32Value", len)?;
-        if let Some(v) = self.value.as_ref() {
-            match v {
-                scalar_time32_value::Value::Time32SecondValue(v) => {
-                    struct_ser.serialize_field("time32SecondValue", v)?;
-                }
-                scalar_time32_value::Value::Time32MillisecondValue(v) => {
-                    struct_ser.serialize_field("time32MillisecondValue", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarTime32Value {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "time32_second_value",
-            "time32SecondValue",
-            "time32_millisecond_value",
-            "time32MillisecondValue",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Time32SecondValue,
-            Time32MillisecondValue,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "time32SecondValue" | "time32_second_value" => Ok(GeneratedField::Time32SecondValue),
-                            "time32MillisecondValue" | "time32_millisecond_value" => Ok(GeneratedField::Time32MillisecondValue),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarTime32Value;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarTime32Value")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarTime32Value, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut value__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Time32SecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("time32SecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32SecondValue(x.0));
-                        }
-                        GeneratedField::Time32MillisecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("time32MillisecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32MillisecondValue(x.0));
-                        }
-                    }
-                }
-                Ok(ScalarTime32Value {
-                    value: value__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarTime32Value", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarTime64Value {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.value.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime64Value", len)?;
-        if let Some(v) = self.value.as_ref() {
-            match v {
-                scalar_time64_value::Value::Time64MicrosecondValue(v) => {
-                    struct_ser.serialize_field("time64MicrosecondValue", ToString::to_string(&v).as_str())?;
-                }
-                scalar_time64_value::Value::Time64NanosecondValue(v) => {
-                    struct_ser.serialize_field("time64NanosecondValue", ToString::to_string(&v).as_str())?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarTime64Value {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "time64_microsecond_value",
-            "time64MicrosecondValue",
-            "time64_nanosecond_value",
-            "time64NanosecondValue",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Time64MicrosecondValue,
-            Time64NanosecondValue,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "time64MicrosecondValue" | "time64_microsecond_value" => Ok(GeneratedField::Time64MicrosecondValue),
-                            "time64NanosecondValue" | "time64_nanosecond_value" => Ok(GeneratedField::Time64NanosecondValue),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarTime64Value;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarTime64Value")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarTime64Value, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut value__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Time64MicrosecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("time64MicrosecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64MicrosecondValue(x.0));
-                        }
-                        GeneratedField::Time64NanosecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("time64NanosecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64NanosecondValue(x.0));
-                        }
-                    }
-                }
-                Ok(ScalarTime64Value {
-                    value: value__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarTime64Value", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarTimestampValue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.timezone.is_empty() {
-            len += 1;
-        }
-        if self.value.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTimestampValue", len)?;
-        if !self.timezone.is_empty() {
-            struct_ser.serialize_field("timezone", &self.timezone)?;
-        }
-        if let Some(v) = self.value.as_ref() {
-            match v {
-                scalar_timestamp_value::Value::TimeMicrosecondValue(v) => {
-                    struct_ser.serialize_field("timeMicrosecondValue", ToString::to_string(&v).as_str())?;
-                }
-                scalar_timestamp_value::Value::TimeNanosecondValue(v) => {
-                    struct_ser.serialize_field("timeNanosecondValue", ToString::to_string(&v).as_str())?;
-                }
-                scalar_timestamp_value::Value::TimeSecondValue(v) => {
-                    struct_ser.serialize_field("timeSecondValue", ToString::to_string(&v).as_str())?;
-                }
-                scalar_timestamp_value::Value::TimeMillisecondValue(v) => {
-                    struct_ser.serialize_field("timeMillisecondValue", ToString::to_string(&v).as_str())?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarTimestampValue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "timezone",
-            "time_microsecond_value",
-            "timeMicrosecondValue",
-            "time_nanosecond_value",
-            "timeNanosecondValue",
-            "time_second_value",
-            "timeSecondValue",
-            "time_millisecond_value",
-            "timeMillisecondValue",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Timezone,
-            TimeMicrosecondValue,
-            TimeNanosecondValue,
-            TimeSecondValue,
-            TimeMillisecondValue,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "timezone" => Ok(GeneratedField::Timezone),
-                            "timeMicrosecondValue" | "time_microsecond_value" => Ok(GeneratedField::TimeMicrosecondValue),
-                            "timeNanosecondValue" | "time_nanosecond_value" => Ok(GeneratedField::TimeNanosecondValue),
-                            "timeSecondValue" | "time_second_value" => Ok(GeneratedField::TimeSecondValue),
-                            "timeMillisecondValue" | "time_millisecond_value" => Ok(GeneratedField::TimeMillisecondValue),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarTimestampValue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarTimestampValue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarTimestampValue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut timezone__ = None;
-                let mut value__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Timezone => {
-                            if timezone__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timezone"));
-                            }
-                            timezone__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::TimeMicrosecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timeMicrosecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMicrosecondValue(x.0));
-                        }
-                        GeneratedField::TimeNanosecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timeNanosecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeNanosecondValue(x.0));
-                        }
-                        GeneratedField::TimeSecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timeSecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeSecondValue(x.0));
-                        }
-                        GeneratedField::TimeMillisecondValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timeMillisecondValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMillisecondValue(x.0));
-                        }
-                    }
-                }
-                Ok(ScalarTimestampValue {
-                    timezone: timezone__.unwrap_or_default(),
-                    value: value__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarTimestampValue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarUdfExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.fun_name.is_empty() {
-            len += 1;
-        }
-        if !self.args.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarUDFExprNode", len)?;
-        if !self.fun_name.is_empty() {
-            struct_ser.serialize_field("funName", &self.fun_name)?;
-        }
-        if !self.args.is_empty() {
-            struct_ser.serialize_field("args", &self.args)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "fun_name",
-            "funName",
-            "args",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            FunName,
-            Args,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "funName" | "fun_name" => Ok(GeneratedField::FunName),
-                            "args" => Ok(GeneratedField::Args),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarUdfExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarUDFExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarUdfExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut fun_name__ = None;
-                let mut args__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::FunName => {
-                            if fun_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("funName"));
-                            }
-                            fun_name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Args => {
-                            if args__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("args"));
-                            }
-                            args__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ScalarUdfExprNode {
-                    fun_name: fun_name__.unwrap_or_default(),
-                    args: args__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarUDFExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScalarValue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.value.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScalarValue", len)?;
-        if let Some(v) = self.value.as_ref() {
-            match v {
-                scalar_value::Value::NullValue(v) => {
-                    struct_ser.serialize_field("nullValue", v)?;
-                }
-                scalar_value::Value::BoolValue(v) => {
-                    struct_ser.serialize_field("boolValue", v)?;
-                }
-                scalar_value::Value::Utf8Value(v) => {
-                    struct_ser.serialize_field("utf8Value", v)?;
-                }
-                scalar_value::Value::LargeUtf8Value(v) => {
-                    struct_ser.serialize_field("largeUtf8Value", v)?;
-                }
-                scalar_value::Value::Int8Value(v) => {
-                    struct_ser.serialize_field("int8Value", v)?;
-                }
-                scalar_value::Value::Int16Value(v) => {
-                    struct_ser.serialize_field("int16Value", v)?;
-                }
-                scalar_value::Value::Int32Value(v) => {
-                    struct_ser.serialize_field("int32Value", v)?;
-                }
-                scalar_value::Value::Int64Value(v) => {
-                    struct_ser.serialize_field("int64Value", ToString::to_string(&v).as_str())?;
-                }
-                scalar_value::Value::Uint8Value(v) => {
-                    struct_ser.serialize_field("uint8Value", v)?;
-                }
-                scalar_value::Value::Uint16Value(v) => {
-                    struct_ser.serialize_field("uint16Value", v)?;
-                }
-                scalar_value::Value::Uint32Value(v) => {
-                    struct_ser.serialize_field("uint32Value", v)?;
-                }
-                scalar_value::Value::Uint64Value(v) => {
-                    struct_ser.serialize_field("uint64Value", ToString::to_string(&v).as_str())?;
-                }
-                scalar_value::Value::Float32Value(v) => {
-                    struct_ser.serialize_field("float32Value", v)?;
-                }
-                scalar_value::Value::Float64Value(v) => {
-                    struct_ser.serialize_field("float64Value", v)?;
-                }
-                scalar_value::Value::Date32Value(v) => {
-                    struct_ser.serialize_field("date32Value", v)?;
-                }
-                scalar_value::Value::Time32Value(v) => {
-                    struct_ser.serialize_field("time32Value", v)?;
-                }
-                scalar_value::Value::ListValue(v) => {
-                    struct_ser.serialize_field("listValue", v)?;
-                }
-                scalar_value::Value::Decimal128Value(v) => {
-                    struct_ser.serialize_field("decimal128Value", v)?;
-                }
-                scalar_value::Value::Date64Value(v) => {
-                    struct_ser.serialize_field("date64Value", ToString::to_string(&v).as_str())?;
-                }
-                scalar_value::Value::IntervalYearmonthValue(v) => {
-                    struct_ser.serialize_field("intervalYearmonthValue", v)?;
-                }
-                scalar_value::Value::IntervalDaytimeValue(v) => {
-                    struct_ser.serialize_field("intervalDaytimeValue", ToString::to_string(&v).as_str())?;
-                }
-                scalar_value::Value::TimestampValue(v) => {
-                    struct_ser.serialize_field("timestampValue", v)?;
-                }
-                scalar_value::Value::DictionaryValue(v) => {
-                    struct_ser.serialize_field("dictionaryValue", v)?;
-                }
-                scalar_value::Value::BinaryValue(v) => {
-                    struct_ser.serialize_field("binaryValue", pbjson::private::base64::encode(&v).as_str())?;
-                }
-                scalar_value::Value::LargeBinaryValue(v) => {
-                    struct_ser.serialize_field("largeBinaryValue", pbjson::private::base64::encode(&v).as_str())?;
-                }
-                scalar_value::Value::Time64Value(v) => {
-                    struct_ser.serialize_field("time64Value", v)?;
-                }
-                scalar_value::Value::IntervalMonthDayNano(v) => {
-                    struct_ser.serialize_field("intervalMonthDayNano", v)?;
-                }
-                scalar_value::Value::StructValue(v) => {
-                    struct_ser.serialize_field("structValue", v)?;
-                }
-                scalar_value::Value::FixedSizeBinaryValue(v) => {
-                    struct_ser.serialize_field("fixedSizeBinaryValue", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScalarValue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "null_value",
-            "nullValue",
-            "bool_value",
-            "boolValue",
-            "utf8_value",
-            "utf8Value",
-            "large_utf8_value",
-            "largeUtf8Value",
-            "int8_value",
-            "int8Value",
-            "int16_value",
-            "int16Value",
-            "int32_value",
-            "int32Value",
-            "int64_value",
-            "int64Value",
-            "uint8_value",
-            "uint8Value",
-            "uint16_value",
-            "uint16Value",
-            "uint32_value",
-            "uint32Value",
-            "uint64_value",
-            "uint64Value",
-            "float32_value",
-            "float32Value",
-            "float64_value",
-            "float64Value",
-            "date_32_value",
-            "date32Value",
-            "time32_value",
-            "time32Value",
-            "list_value",
-            "listValue",
-            "decimal128_value",
-            "decimal128Value",
-            "date_64_value",
-            "date64Value",
-            "interval_yearmonth_value",
-            "intervalYearmonthValue",
-            "interval_daytime_value",
-            "intervalDaytimeValue",
-            "timestamp_value",
-            "timestampValue",
-            "dictionary_value",
-            "dictionaryValue",
-            "binary_value",
-            "binaryValue",
-            "large_binary_value",
-            "largeBinaryValue",
-            "time64_value",
-            "time64Value",
-            "interval_month_day_nano",
-            "intervalMonthDayNano",
-            "struct_value",
-            "structValue",
-            "fixed_size_binary_value",
-            "fixedSizeBinaryValue",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            NullValue,
-            BoolValue,
-            Utf8Value,
-            LargeUtf8Value,
-            Int8Value,
-            Int16Value,
-            Int32Value,
-            Int64Value,
-            Uint8Value,
-            Uint16Value,
-            Uint32Value,
-            Uint64Value,
-            Float32Value,
-            Float64Value,
-            Date32Value,
-            Time32Value,
-            ListValue,
-            Decimal128Value,
-            Date64Value,
-            IntervalYearmonthValue,
-            IntervalDaytimeValue,
-            TimestampValue,
-            DictionaryValue,
-            BinaryValue,
-            LargeBinaryValue,
-            Time64Value,
-            IntervalMonthDayNano,
-            StructValue,
-            FixedSizeBinaryValue,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "nullValue" | "null_value" => Ok(GeneratedField::NullValue),
-                            "boolValue" | "bool_value" => Ok(GeneratedField::BoolValue),
-                            "utf8Value" | "utf8_value" => Ok(GeneratedField::Utf8Value),
-                            "largeUtf8Value" | "large_utf8_value" => Ok(GeneratedField::LargeUtf8Value),
-                            "int8Value" | "int8_value" => Ok(GeneratedField::Int8Value),
-                            "int16Value" | "int16_value" => Ok(GeneratedField::Int16Value),
-                            "int32Value" | "int32_value" => Ok(GeneratedField::Int32Value),
-                            "int64Value" | "int64_value" => Ok(GeneratedField::Int64Value),
-                            "uint8Value" | "uint8_value" => Ok(GeneratedField::Uint8Value),
-                            "uint16Value" | "uint16_value" => Ok(GeneratedField::Uint16Value),
-                            "uint32Value" | "uint32_value" => Ok(GeneratedField::Uint32Value),
-                            "uint64Value" | "uint64_value" => Ok(GeneratedField::Uint64Value),
-                            "float32Value" | "float32_value" => Ok(GeneratedField::Float32Value),
-                            "float64Value" | "float64_value" => Ok(GeneratedField::Float64Value),
-                            "date32Value" | "date_32_value" => Ok(GeneratedField::Date32Value),
-                            "time32Value" | "time32_value" => Ok(GeneratedField::Time32Value),
-                            "listValue" | "list_value" => Ok(GeneratedField::ListValue),
-                            "decimal128Value" | "decimal128_value" => Ok(GeneratedField::Decimal128Value),
-                            "date64Value" | "date_64_value" => Ok(GeneratedField::Date64Value),
-                            "intervalYearmonthValue" | "interval_yearmonth_value" => Ok(GeneratedField::IntervalYearmonthValue),
-                            "intervalDaytimeValue" | "interval_daytime_value" => Ok(GeneratedField::IntervalDaytimeValue),
-                            "timestampValue" | "timestamp_value" => Ok(GeneratedField::TimestampValue),
-                            "dictionaryValue" | "dictionary_value" => Ok(GeneratedField::DictionaryValue),
-                            "binaryValue" | "binary_value" => Ok(GeneratedField::BinaryValue),
-                            "largeBinaryValue" | "large_binary_value" => Ok(GeneratedField::LargeBinaryValue),
-                            "time64Value" | "time64_value" => Ok(GeneratedField::Time64Value),
-                            "intervalMonthDayNano" | "interval_month_day_nano" => Ok(GeneratedField::IntervalMonthDayNano),
-                            "structValue" | "struct_value" => Ok(GeneratedField::StructValue),
-                            "fixedSizeBinaryValue" | "fixed_size_binary_value" => Ok(GeneratedField::FixedSizeBinaryValue),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScalarValue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScalarValue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarValue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut value__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::NullValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::NullValue)
-;
-                        }
-                        GeneratedField::BoolValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("boolValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::BoolValue);
-                        }
-                        GeneratedField::Utf8Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("utf8Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Utf8Value);
-                        }
-                        GeneratedField::LargeUtf8Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("largeUtf8Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::LargeUtf8Value);
-                        }
-                        GeneratedField::Int8Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("int8Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int8Value(x.0));
-                        }
-                        GeneratedField::Int16Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("int16Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int16Value(x.0));
-                        }
-                        GeneratedField::Int32Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("int32Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int32Value(x.0));
-                        }
-                        GeneratedField::Int64Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("int64Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int64Value(x.0));
-                        }
-                        GeneratedField::Uint8Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("uint8Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint8Value(x.0));
-                        }
-                        GeneratedField::Uint16Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("uint16Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint16Value(x.0));
-                        }
-                        GeneratedField::Uint32Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("uint32Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint32Value(x.0));
-                        }
-                        GeneratedField::Uint64Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("uint64Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint64Value(x.0));
-                        }
-                        GeneratedField::Float32Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("float32Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float32Value(x.0));
-                        }
-                        GeneratedField::Float64Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("float64Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float64Value(x.0));
-                        }
-                        GeneratedField::Date32Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("date32Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date32Value(x.0));
-                        }
-                        GeneratedField::Time32Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("time32Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time32Value)
-;
-                        }
-                        GeneratedField::ListValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("listValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::ListValue)
-;
-                        }
-                        GeneratedField::Decimal128Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("decimal128Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Decimal128Value)
-;
-                        }
-                        GeneratedField::Date64Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("date64Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date64Value(x.0));
-                        }
-                        GeneratedField::IntervalYearmonthValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("intervalYearmonthValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalYearmonthValue(x.0));
-                        }
-                        GeneratedField::IntervalDaytimeValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("intervalDaytimeValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalDaytimeValue(x.0));
-                        }
-                        GeneratedField::TimestampValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timestampValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::TimestampValue)
-;
-                        }
-                        GeneratedField::DictionaryValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("dictionaryValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::DictionaryValue)
-;
-                        }
-                        GeneratedField::BinaryValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("binaryValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::BinaryValue(x.0));
-                        }
-                        GeneratedField::LargeBinaryValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("largeBinaryValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::LargeBinaryValue(x.0));
-                        }
-                        GeneratedField::Time64Value => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("time64Value"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time64Value)
-;
-                        }
-                        GeneratedField::IntervalMonthDayNano => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("intervalMonthDayNano"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::IntervalMonthDayNano)
-;
-                        }
-                        GeneratedField::StructValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("structValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::StructValue)
-;
-                        }
-                        GeneratedField::FixedSizeBinaryValue => {
-                            if value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fixedSizeBinaryValue"));
-                            }
-                            value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::FixedSizeBinaryValue)
-;
-                        }
-                    }
-                }
-                Ok(ScalarValue {
-                    value: value__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScalarValue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ScanLimit {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.limit != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ScanLimit", len)?;
-        if self.limit != 0 {
-            struct_ser.serialize_field("limit", &self.limit)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ScanLimit {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "limit",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Limit,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "limit" => Ok(GeneratedField::Limit),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ScanLimit;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ScanLimit")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ScanLimit, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut limit__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Limit => {
-                            if limit__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("limit"));
-                            }
-                            limit__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(ScanLimit {
-                    limit: limit__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ScanLimit", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Schema {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.columns.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Schema", len)?;
-        if !self.columns.is_empty() {
-            struct_ser.serialize_field("columns", &self.columns)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Schema {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "columns",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Columns,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "columns" => Ok(GeneratedField::Columns),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Schema;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Schema")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Schema, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut columns__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Columns => {
-                            if columns__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("columns"));
-                            }
-                            columns__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(Schema {
-                    columns: columns__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Schema", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SelectionExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SelectionExecNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SelectionExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SelectionExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SelectionExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SelectionExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(SelectionExecNode {
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SelectionExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SelectionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SelectionNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SelectionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "expr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Expr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "expr" => Ok(GeneratedField::Expr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SelectionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SelectionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SelectionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(SelectionNode {
-                    input: input__,
-                    expr: expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SimilarToNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.negated {
-            len += 1;
-        }
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.pattern.is_some() {
-            len += 1;
-        }
-        if !self.escape_char.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?;
-        if self.negated {
-            struct_ser.serialize_field("negated", &self.negated)?;
-        }
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.pattern.as_ref() {
-            struct_ser.serialize_field("pattern", v)?;
-        }
-        if !self.escape_char.is_empty() {
-            struct_ser.serialize_field("escapeChar", &self.escape_char)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SimilarToNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "negated",
-            "expr",
-            "pattern",
-            "escape_char",
-            "escapeChar",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Negated,
-            Expr,
-            Pattern,
-            EscapeChar,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "negated" => Ok(GeneratedField::Negated),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "pattern" => Ok(GeneratedField::Pattern),
-                            "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SimilarToNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SimilarToNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SimilarToNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut negated__ = None;
-                let mut expr__ = None;
-                let mut pattern__ = None;
-                let mut escape_char__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Negated => {
-                            if negated__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("negated"));
-                            }
-                            negated__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Pattern => {
-                            if pattern__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("pattern"));
-                            }
-                            pattern__ = map.next_value()?;
-                        }
-                        GeneratedField::EscapeChar => {
-                            if escape_char__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("escapeChar"));
-                            }
-                            escape_char__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(SimilarToNode {
-                    negated: negated__.unwrap_or_default(),
-                    expr: expr__,
-                    pattern: pattern__,
-                    escape_char: escape_char__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SimilarToNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SortExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        if self.fetch != 0 {
-            len += 1;
-        }
-        if self.preserve_partitioning {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SortExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        if self.fetch != 0 {
-            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
-        }
-        if self.preserve_partitioning {
-            struct_ser.serialize_field("preservePartitioning", &self.preserve_partitioning)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SortExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "expr",
-            "fetch",
-            "preserve_partitioning",
-            "preservePartitioning",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Expr,
-            Fetch,
-            PreservePartitioning,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "fetch" => Ok(GeneratedField::Fetch),
-                            "preservePartitioning" | "preserve_partitioning" => Ok(GeneratedField::PreservePartitioning),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SortExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SortExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut expr__ = None;
-                let mut fetch__ = None;
-                let mut preserve_partitioning__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Fetch => {
-                            if fetch__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fetch"));
-                            }
-                            fetch__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::PreservePartitioning => {
-                            if preserve_partitioning__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("preservePartitioning"));
-                            }
-                            preserve_partitioning__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(SortExecNode {
-                    input: input__,
-                    expr: expr__.unwrap_or_default(),
-                    fetch: fetch__.unwrap_or_default(),
-                    preserve_partitioning: preserve_partitioning__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SortExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SortExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.asc {
-            len += 1;
-        }
-        if self.nulls_first {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SortExprNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if self.asc {
-            struct_ser.serialize_field("asc", &self.asc)?;
-        }
-        if self.nulls_first {
-            struct_ser.serialize_field("nullsFirst", &self.nulls_first)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SortExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "asc",
-            "nulls_first",
-            "nullsFirst",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            Asc,
-            NullsFirst,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "asc" => Ok(GeneratedField::Asc),
-                            "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SortExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SortExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut asc__ = None;
-                let mut nulls_first__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::Asc => {
-                            if asc__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("asc"));
-                            }
-                            asc__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::NullsFirst => {
-                            if nulls_first__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nullsFirst"));
-                            }
-                            nulls_first__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(SortExprNode {
-                    expr: expr__,
-                    asc: asc__.unwrap_or_default(),
-                    nulls_first: nulls_first__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SortExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SortNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        if self.fetch != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SortNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        if self.fetch != 0 {
-            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SortNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "expr",
-            "fetch",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Expr,
-            Fetch,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "fetch" => Ok(GeneratedField::Fetch),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SortNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SortNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut expr__ = None;
-                let mut fetch__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Fetch => {
-                            if fetch__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fetch"));
-                            }
-                            fetch__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(SortNode {
-                    input: input__,
-                    expr: expr__.unwrap_or_default(),
-                    fetch: fetch__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SortNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SortPreservingMergeExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.expr.is_empty() {
-            len += 1;
-        }
-        if self.fetch != 0 {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SortPreservingMergeExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.expr.is_empty() {
-            struct_ser.serialize_field("expr", &self.expr)?;
-        }
-        if self.fetch != 0 {
-            struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "expr",
-            "fetch",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Expr,
-            Fetch,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "expr" => Ok(GeneratedField::Expr),
-                            "fetch" => Ok(GeneratedField::Fetch),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SortPreservingMergeExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SortPreservingMergeExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SortPreservingMergeExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut expr__ = None;
-                let mut fetch__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Fetch => {
-                            if fetch__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fetch"));
-                            }
-                            fetch__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                    }
-                }
-                Ok(SortPreservingMergeExecNode {
-                    input: input__,
-                    expr: expr__.unwrap_or_default(),
-                    fetch: fetch__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SortPreservingMergeExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Statistics {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.num_rows != 0 {
-            len += 1;
-        }
-        if self.total_byte_size != 0 {
-            len += 1;
-        }
-        if !self.column_stats.is_empty() {
-            len += 1;
-        }
-        if self.is_exact {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Statistics", len)?;
-        if self.num_rows != 0 {
-            struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?;
-        }
-        if self.total_byte_size != 0 {
-            struct_ser.serialize_field("totalByteSize", ToString::to_string(&self.total_byte_size).as_str())?;
-        }
-        if !self.column_stats.is_empty() {
-            struct_ser.serialize_field("columnStats", &self.column_stats)?;
-        }
-        if self.is_exact {
-            struct_ser.serialize_field("isExact", &self.is_exact)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Statistics {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "num_rows",
-            "numRows",
-            "total_byte_size",
-            "totalByteSize",
-            "column_stats",
-            "columnStats",
-            "is_exact",
-            "isExact",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            NumRows,
-            TotalByteSize,
-            ColumnStats,
-            IsExact,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "numRows" | "num_rows" => Ok(GeneratedField::NumRows),
-                            "totalByteSize" | "total_byte_size" => Ok(GeneratedField::TotalByteSize),
-                            "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats),
-                            "isExact" | "is_exact" => Ok(GeneratedField::IsExact),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Statistics;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Statistics")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Statistics, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut num_rows__ = None;
-                let mut total_byte_size__ = None;
-                let mut column_stats__ = None;
-                let mut is_exact__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::NumRows => {
-                            if num_rows__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("numRows"));
-                            }
-                            num_rows__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::TotalByteSize => {
-                            if total_byte_size__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("totalByteSize"));
-                            }
-                            total_byte_size__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::ColumnStats => {
-                            if column_stats__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("columnStats"));
-                            }
-                            column_stats__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::IsExact => {
-                            if is_exact__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("isExact"));
-                            }
-                            is_exact__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(Statistics {
-                    num_rows: num_rows__.unwrap_or_default(),
-                    total_byte_size: total_byte_size__.unwrap_or_default(),
-                    column_stats: column_stats__.unwrap_or_default(),
-                    is_exact: is_exact__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Statistics", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for StringifiedPlan {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.plan_type.is_some() {
-            len += 1;
-        }
-        if !self.plan.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.StringifiedPlan", len)?;
-        if let Some(v) = self.plan_type.as_ref() {
-            struct_ser.serialize_field("planType", v)?;
-        }
-        if !self.plan.is_empty() {
-            struct_ser.serialize_field("plan", &self.plan)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for StringifiedPlan {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "plan_type",
-            "planType",
-            "plan",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            PlanType,
-            Plan,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "planType" | "plan_type" => Ok(GeneratedField::PlanType),
-                            "plan" => Ok(GeneratedField::Plan),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = StringifiedPlan;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.StringifiedPlan")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<StringifiedPlan, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut plan_type__ = None;
-                let mut plan__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::PlanType => {
-                            if plan_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("planType"));
-                            }
-                            plan_type__ = map.next_value()?;
-                        }
-                        GeneratedField::Plan => {
-                            if plan__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("plan"));
-                            }
-                            plan__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(StringifiedPlan {
-                    plan_type: plan_type__,
-                    plan: plan__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.StringifiedPlan", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Struct {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.sub_field_types.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Struct", len)?;
-        if !self.sub_field_types.is_empty() {
-            struct_ser.serialize_field("subFieldTypes", &self.sub_field_types)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Struct {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "sub_field_types",
-            "subFieldTypes",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            SubFieldTypes,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "subFieldTypes" | "sub_field_types" => Ok(GeneratedField::SubFieldTypes),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Struct;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Struct")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Struct, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut sub_field_types__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::SubFieldTypes => {
-                            if sub_field_types__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("subFieldTypes"));
-                            }
-                            sub_field_types__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(Struct {
-                    sub_field_types: sub_field_types__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Struct", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for StructValue {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.field_values.is_empty() {
-            len += 1;
-        }
-        if !self.fields.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.StructValue", len)?;
-        if !self.field_values.is_empty() {
-            struct_ser.serialize_field("fieldValues", &self.field_values)?;
-        }
-        if !self.fields.is_empty() {
-            struct_ser.serialize_field("fields", &self.fields)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for StructValue {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "field_values",
-            "fieldValues",
-            "fields",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            FieldValues,
-            Fields,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "fieldValues" | "field_values" => Ok(GeneratedField::FieldValues),
-                            "fields" => Ok(GeneratedField::Fields),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = StructValue;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.StructValue")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<StructValue, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut field_values__ = None;
-                let mut fields__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::FieldValues => {
-                            if field_values__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fieldValues"));
-                            }
-                            field_values__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::Fields => {
-                            if fields__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("fields"));
-                            }
-                            fields__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(StructValue {
-                    field_values: field_values__.unwrap_or_default(),
-                    fields: fields__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.StructValue", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for SubqueryAliasNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.alias.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.SubqueryAliasNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if let Some(v) = self.alias.as_ref() {
-            struct_ser.serialize_field("alias", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for SubqueryAliasNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "alias",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            Alias,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "alias" => Ok(GeneratedField::Alias),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = SubqueryAliasNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.SubqueryAliasNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<SubqueryAliasNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut alias__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Alias => {
-                            if alias__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("alias"));
-                            }
-                            alias__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(SubqueryAliasNode {
-                    input: input__,
-                    alias: alias__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.SubqueryAliasNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for TimeUnit {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Second => "Second",
-            Self::Millisecond => "Millisecond",
-            Self::Microsecond => "Microsecond",
-            Self::Nanosecond => "Nanosecond",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for TimeUnit {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "Second",
-            "Millisecond",
-            "Microsecond",
-            "Nanosecond",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = TimeUnit;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(TimeUnit::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(TimeUnit::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "Second" => Ok(TimeUnit::Second),
-                    "Millisecond" => Ok(TimeUnit::Millisecond),
-                    "Microsecond" => Ok(TimeUnit::Microsecond),
-                    "Nanosecond" => Ok(TimeUnit::Nanosecond),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Timestamp {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.time_unit != 0 {
-            len += 1;
-        }
-        if !self.timezone.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Timestamp", len)?;
-        if self.time_unit != 0 {
-            let v = TimeUnit::from_i32(self.time_unit)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.time_unit)))?;
-            struct_ser.serialize_field("timeUnit", &v)?;
-        }
-        if !self.timezone.is_empty() {
-            struct_ser.serialize_field("timezone", &self.timezone)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Timestamp {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "time_unit",
-            "timeUnit",
-            "timezone",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            TimeUnit,
-            Timezone,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "timeUnit" | "time_unit" => Ok(GeneratedField::TimeUnit),
-                            "timezone" => Ok(GeneratedField::Timezone),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Timestamp;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Timestamp")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Timestamp, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut time_unit__ = None;
-                let mut timezone__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::TimeUnit => {
-                            if time_unit__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timeUnit"));
-                            }
-                            time_unit__ = Some(map.next_value::<TimeUnit>()? as i32);
-                        }
-                        GeneratedField::Timezone => {
-                            if timezone__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("timezone"));
-                            }
-                            timezone__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(Timestamp {
-                    time_unit: time_unit__.unwrap_or_default(),
-                    timezone: timezone__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Timestamp", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for TryCastNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if self.arrow_type.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.TryCastNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if let Some(v) = self.arrow_type.as_ref() {
-            struct_ser.serialize_field("arrowType", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for TryCastNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "arrow_type",
-            "arrowType",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            ArrowType,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = TryCastNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.TryCastNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<TryCastNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut arrow_type__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::ArrowType => {
-                            if arrow_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("arrowType"));
-                            }
-                            arrow_type__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(TryCastNode {
-                    expr: expr__,
-                    arrow_type: arrow_type__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.TryCastNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for Union {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.union_types.is_empty() {
-            len += 1;
-        }
-        if self.union_mode != 0 {
-            len += 1;
-        }
-        if !self.type_ids.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.Union", len)?;
-        if !self.union_types.is_empty() {
-            struct_ser.serialize_field("unionTypes", &self.union_types)?;
-        }
-        if self.union_mode != 0 {
-            let v = UnionMode::from_i32(self.union_mode)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.union_mode)))?;
-            struct_ser.serialize_field("unionMode", &v)?;
-        }
-        if !self.type_ids.is_empty() {
-            struct_ser.serialize_field("typeIds", &self.type_ids)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for Union {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "union_types",
-            "unionTypes",
-            "union_mode",
-            "unionMode",
-            "type_ids",
-            "typeIds",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            UnionTypes,
-            UnionMode,
-            TypeIds,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "unionTypes" | "union_types" => Ok(GeneratedField::UnionTypes),
-                            "unionMode" | "union_mode" => Ok(GeneratedField::UnionMode),
-                            "typeIds" | "type_ids" => Ok(GeneratedField::TypeIds),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = Union;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.Union")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<Union, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut union_types__ = None;
-                let mut union_mode__ = None;
-                let mut type_ids__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::UnionTypes => {
-                            if union_types__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("unionTypes"));
-                            }
-                            union_types__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::UnionMode => {
-                            if union_mode__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("unionMode"));
-                            }
-                            union_mode__ = Some(map.next_value::<UnionMode>()? as i32);
-                        }
-                        GeneratedField::TypeIds => {
-                            if type_ids__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("typeIds"));
-                            }
-                            type_ids__ = 
-                                Some(map.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
-                                    .into_iter().map(|x| x.0).collect())
-                            ;
-                        }
-                    }
-                }
-                Ok(Union {
-                    union_types: union_types__.unwrap_or_default(),
-                    union_mode: union_mode__.unwrap_or_default(),
-                    type_ids: type_ids__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.Union", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for UnionExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.inputs.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.UnionExecNode", len)?;
-        if !self.inputs.is_empty() {
-            struct_ser.serialize_field("inputs", &self.inputs)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for UnionExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "inputs",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Inputs,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "inputs" => Ok(GeneratedField::Inputs),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = UnionExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.UnionExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<UnionExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut inputs__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Inputs => {
-                            if inputs__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inputs"));
-                            }
-                            inputs__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(UnionExecNode {
-                    inputs: inputs__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.UnionExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for UnionMode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Sparse => "sparse",
-            Self::Dense => "dense",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for UnionMode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "sparse",
-            "dense",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = UnionMode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(UnionMode::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(UnionMode::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "sparse" => Ok(UnionMode::Sparse),
-                    "dense" => Ok(UnionMode::Dense),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for UnionNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if !self.inputs.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.UnionNode", len)?;
-        if !self.inputs.is_empty() {
-            struct_ser.serialize_field("inputs", &self.inputs)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for UnionNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "inputs",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Inputs,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "inputs" => Ok(GeneratedField::Inputs),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = UnionNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.UnionNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<UnionNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut inputs__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Inputs => {
-                            if inputs__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inputs"));
-                            }
-                            inputs__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(UnionNode {
-                    inputs: inputs__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.UnionNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ValuesNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.n_cols != 0 {
-            len += 1;
-        }
-        if !self.values_list.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ValuesNode", len)?;
-        if self.n_cols != 0 {
-            struct_ser.serialize_field("nCols", ToString::to_string(&self.n_cols).as_str())?;
-        }
-        if !self.values_list.is_empty() {
-            struct_ser.serialize_field("valuesList", &self.values_list)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ValuesNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "n_cols",
-            "nCols",
-            "values_list",
-            "valuesList",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            NCols,
-            ValuesList,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "nCols" | "n_cols" => Ok(GeneratedField::NCols),
-                            "valuesList" | "values_list" => Ok(GeneratedField::ValuesList),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ValuesNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ValuesNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ValuesNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut n_cols__ = None;
-                let mut values_list__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::NCols => {
-                            if n_cols__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("nCols"));
-                            }
-                            n_cols__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
-                            ;
-                        }
-                        GeneratedField::ValuesList => {
-                            if values_list__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("valuesList"));
-                            }
-                            values_list__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ValuesNode {
-                    n_cols: n_cols__.unwrap_or_default(),
-                    values_list: values_list__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ValuesNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for ViewTableScanNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.table_name.is_some() {
-            len += 1;
-        }
-        if self.input.is_some() {
-            len += 1;
-        }
-        if self.schema.is_some() {
-            len += 1;
-        }
-        if self.projection.is_some() {
-            len += 1;
-        }
-        if !self.definition.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.ViewTableScanNode", len)?;
-        if let Some(v) = self.table_name.as_ref() {
-            struct_ser.serialize_field("tableName", v)?;
-        }
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if let Some(v) = self.schema.as_ref() {
-            struct_ser.serialize_field("schema", v)?;
-        }
-        if let Some(v) = self.projection.as_ref() {
-            struct_ser.serialize_field("projection", v)?;
-        }
-        if !self.definition.is_empty() {
-            struct_ser.serialize_field("definition", &self.definition)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for ViewTableScanNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "table_name",
-            "tableName",
-            "input",
-            "schema",
-            "projection",
-            "definition",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            TableName,
-            Input,
-            Schema,
-            Projection,
-            Definition,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
-                            "input" => Ok(GeneratedField::Input),
-                            "schema" => Ok(GeneratedField::Schema),
-                            "projection" => Ok(GeneratedField::Projection),
-                            "definition" => Ok(GeneratedField::Definition),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = ViewTableScanNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.ViewTableScanNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<ViewTableScanNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut table_name__ = None;
-                let mut input__ = None;
-                let mut schema__ = None;
-                let mut projection__ = None;
-                let mut definition__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::TableName => {
-                            if table_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("tableName"));
-                            }
-                            table_name__ = map.next_value()?;
-                        }
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::Schema => {
-                            if schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("schema"));
-                            }
-                            schema__ = map.next_value()?;
-                        }
-                        GeneratedField::Projection => {
-                            if projection__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("projection"));
-                            }
-                            projection__ = map.next_value()?;
-                        }
-                        GeneratedField::Definition => {
-                            if definition__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("definition"));
-                            }
-                            definition__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(ViewTableScanNode {
-                    table_name: table_name__,
-                    input: input__,
-                    schema: schema__,
-                    projection: projection__,
-                    definition: definition__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.ViewTableScanNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WhenThen {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.when_expr.is_some() {
-            len += 1;
-        }
-        if self.then_expr.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.WhenThen", len)?;
-        if let Some(v) = self.when_expr.as_ref() {
-            struct_ser.serialize_field("whenExpr", v)?;
-        }
-        if let Some(v) = self.then_expr.as_ref() {
-            struct_ser.serialize_field("thenExpr", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for WhenThen {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "when_expr",
-            "whenExpr",
-            "then_expr",
-            "thenExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            WhenExpr,
-            ThenExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr),
-                            "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WhenThen;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.WhenThen")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<WhenThen, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut when_expr__ = None;
-                let mut then_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::WhenExpr => {
-                            if when_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("whenExpr"));
-                            }
-                            when_expr__ = map.next_value()?;
-                        }
-                        GeneratedField::ThenExpr => {
-                            if then_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("thenExpr"));
-                            }
-                            then_expr__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(WhenThen {
-                    when_expr: when_expr__,
-                    then_expr: then_expr__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.WhenThen", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WindowAggExecNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.window_expr.is_empty() {
-            len += 1;
-        }
-        if !self.window_expr_name.is_empty() {
-            len += 1;
-        }
-        if self.input_schema.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.WindowAggExecNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.window_expr.is_empty() {
-            struct_ser.serialize_field("windowExpr", &self.window_expr)?;
-        }
-        if !self.window_expr_name.is_empty() {
-            struct_ser.serialize_field("windowExprName", &self.window_expr_name)?;
-        }
-        if let Some(v) = self.input_schema.as_ref() {
-            struct_ser.serialize_field("inputSchema", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for WindowAggExecNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "window_expr",
-            "windowExpr",
-            "window_expr_name",
-            "windowExprName",
-            "input_schema",
-            "inputSchema",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            WindowExpr,
-            WindowExprName,
-            InputSchema,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
-                            "windowExprName" | "window_expr_name" => Ok(GeneratedField::WindowExprName),
-                            "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WindowAggExecNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.WindowAggExecNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowAggExecNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut window_expr__ = None;
-                let mut window_expr_name__ = None;
-                let mut input_schema__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::WindowExpr => {
-                            if window_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowExpr"));
-                            }
-                            window_expr__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::WindowExprName => {
-                            if window_expr_name__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowExprName"));
-                            }
-                            window_expr_name__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::InputSchema => {
-                            if input_schema__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("inputSchema"));
-                            }
-                            input_schema__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(WindowAggExecNode {
-                    input: input__,
-                    window_expr: window_expr__.unwrap_or_default(),
-                    window_expr_name: window_expr_name__.unwrap_or_default(),
-                    input_schema: input_schema__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.WindowAggExecNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WindowExprNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.expr.is_some() {
-            len += 1;
-        }
-        if !self.partition_by.is_empty() {
-            len += 1;
-        }
-        if !self.order_by.is_empty() {
-            len += 1;
-        }
-        if self.window_frame.is_some() {
-            len += 1;
-        }
-        if self.window_function.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.WindowExprNode", len)?;
-        if let Some(v) = self.expr.as_ref() {
-            struct_ser.serialize_field("expr", v)?;
-        }
-        if !self.partition_by.is_empty() {
-            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
-        }
-        if !self.order_by.is_empty() {
-            struct_ser.serialize_field("orderBy", &self.order_by)?;
-        }
-        if let Some(v) = self.window_frame.as_ref() {
-            struct_ser.serialize_field("windowFrame", v)?;
-        }
-        if let Some(v) = self.window_function.as_ref() {
-            match v {
-                window_expr_node::WindowFunction::AggrFunction(v) => {
-                    let v = AggregateFunction::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("aggrFunction", &v)?;
-                }
-                window_expr_node::WindowFunction::BuiltInFunction(v) => {
-                    let v = BuiltInWindowFunction::from_i32(*v)
-                        .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
-                    struct_ser.serialize_field("builtInFunction", &v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for WindowExprNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "expr",
-            "partition_by",
-            "partitionBy",
-            "order_by",
-            "orderBy",
-            "window_frame",
-            "windowFrame",
-            "aggr_function",
-            "aggrFunction",
-            "built_in_function",
-            "builtInFunction",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Expr,
-            PartitionBy,
-            OrderBy,
-            WindowFrame,
-            AggrFunction,
-            BuiltInFunction,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "expr" => Ok(GeneratedField::Expr),
-                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
-                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
-                            "windowFrame" | "window_frame" => Ok(GeneratedField::WindowFrame),
-                            "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
-                            "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WindowExprNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.WindowExprNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowExprNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut expr__ = None;
-                let mut partition_by__ = None;
-                let mut order_by__ = None;
-                let mut window_frame__ = None;
-                let mut window_function__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Expr => {
-                            if expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("expr"));
-                            }
-                            expr__ = map.next_value()?;
-                        }
-                        GeneratedField::PartitionBy => {
-                            if partition_by__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("partitionBy"));
-                            }
-                            partition_by__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::OrderBy => {
-                            if order_by__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("orderBy"));
-                            }
-                            order_by__ = Some(map.next_value()?);
-                        }
-                        GeneratedField::WindowFrame => {
-                            if window_frame__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowFrame"));
-                            }
-                            window_frame__ = map.next_value()?;
-                        }
-                        GeneratedField::AggrFunction => {
-                            if window_function__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("aggrFunction"));
-                            }
-                            window_function__ = map.next_value::<::std::option::Option<AggregateFunction>>()?.map(|x| window_expr_node::WindowFunction::AggrFunction(x as i32));
-                        }
-                        GeneratedField::BuiltInFunction => {
-                            if window_function__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("builtInFunction"));
-                            }
-                            window_function__ = map.next_value::<::std::option::Option<BuiltInWindowFunction>>()?.map(|x| window_expr_node::WindowFunction::BuiltInFunction(x as i32));
-                        }
-                    }
-                }
-                Ok(WindowExprNode {
-                    expr: expr__,
-                    partition_by: partition_by__.unwrap_or_default(),
-                    order_by: order_by__.unwrap_or_default(),
-                    window_frame: window_frame__,
-                    window_function: window_function__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.WindowExprNode", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WindowFrame {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.window_frame_units != 0 {
-            len += 1;
-        }
-        if self.start_bound.is_some() {
-            len += 1;
-        }
-        if self.end_bound.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrame", len)?;
-        if self.window_frame_units != 0 {
-            let v = WindowFrameUnits::from_i32(self.window_frame_units)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_units)))?;
-            struct_ser.serialize_field("windowFrameUnits", &v)?;
-        }
-        if let Some(v) = self.start_bound.as_ref() {
-            struct_ser.serialize_field("startBound", v)?;
-        }
-        if let Some(v) = self.end_bound.as_ref() {
-            match v {
-                window_frame::EndBound::Bound(v) => {
-                    struct_ser.serialize_field("bound", v)?;
-                }
-            }
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for WindowFrame {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "window_frame_units",
-            "windowFrameUnits",
-            "start_bound",
-            "startBound",
-            "bound",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            WindowFrameUnits,
-            StartBound,
-            Bound,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "windowFrameUnits" | "window_frame_units" => Ok(GeneratedField::WindowFrameUnits),
-                            "startBound" | "start_bound" => Ok(GeneratedField::StartBound),
-                            "bound" => Ok(GeneratedField::Bound),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WindowFrame;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.WindowFrame")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowFrame, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut window_frame_units__ = None;
-                let mut start_bound__ = None;
-                let mut end_bound__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::WindowFrameUnits => {
-                            if window_frame_units__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowFrameUnits"));
-                            }
-                            window_frame_units__ = Some(map.next_value::<WindowFrameUnits>()? as i32);
-                        }
-                        GeneratedField::StartBound => {
-                            if start_bound__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("startBound"));
-                            }
-                            start_bound__ = map.next_value()?;
-                        }
-                        GeneratedField::Bound => {
-                            if end_bound__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("bound"));
-                            }
-                            end_bound__ = map.next_value::<::std::option::Option<_>>()?.map(window_frame::EndBound::Bound)
-;
-                        }
-                    }
-                }
-                Ok(WindowFrame {
-                    window_frame_units: window_frame_units__.unwrap_or_default(),
-                    start_bound: start_bound__,
-                    end_bound: end_bound__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.WindowFrame", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WindowFrameBound {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.window_frame_bound_type != 0 {
-            len += 1;
-        }
-        if self.bound_value.is_some() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrameBound", len)?;
-        if self.window_frame_bound_type != 0 {
-            let v = WindowFrameBoundType::from_i32(self.window_frame_bound_type)
-                .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_bound_type)))?;
-            struct_ser.serialize_field("windowFrameBoundType", &v)?;
-        }
-        if let Some(v) = self.bound_value.as_ref() {
-            struct_ser.serialize_field("boundValue", v)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for WindowFrameBound {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "window_frame_bound_type",
-            "windowFrameBoundType",
-            "bound_value",
-            "boundValue",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            WindowFrameBoundType,
-            BoundValue,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "windowFrameBoundType" | "window_frame_bound_type" => Ok(GeneratedField::WindowFrameBoundType),
-                            "boundValue" | "bound_value" => Ok(GeneratedField::BoundValue),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WindowFrameBound;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.WindowFrameBound")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowFrameBound, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut window_frame_bound_type__ = None;
-                let mut bound_value__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::WindowFrameBoundType => {
-                            if window_frame_bound_type__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowFrameBoundType"));
-                            }
-                            window_frame_bound_type__ = Some(map.next_value::<WindowFrameBoundType>()? as i32);
-                        }
-                        GeneratedField::BoundValue => {
-                            if bound_value__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("boundValue"));
-                            }
-                            bound_value__ = map.next_value()?;
-                        }
-                    }
-                }
-                Ok(WindowFrameBound {
-                    window_frame_bound_type: window_frame_bound_type__.unwrap_or_default(),
-                    bound_value: bound_value__,
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.WindowFrameBound", FIELDS, GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WindowFrameBoundType {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::CurrentRow => "CURRENT_ROW",
-            Self::Preceding => "PRECEDING",
-            Self::Following => "FOLLOWING",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for WindowFrameBoundType {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "CURRENT_ROW",
-            "PRECEDING",
-            "FOLLOWING",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WindowFrameBoundType;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(WindowFrameBoundType::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(WindowFrameBoundType::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "CURRENT_ROW" => Ok(WindowFrameBoundType::CurrentRow),
-                    "PRECEDING" => Ok(WindowFrameBoundType::Preceding),
-                    "FOLLOWING" => Ok(WindowFrameBoundType::Following),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WindowFrameUnits {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let variant = match self {
-            Self::Rows => "ROWS",
-            Self::Range => "RANGE",
-            Self::Groups => "GROUPS",
-        };
-        serializer.serialize_str(variant)
-    }
-}
-impl<'de> serde::Deserialize<'de> for WindowFrameUnits {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "ROWS",
-            "RANGE",
-            "GROUPS",
-        ];
-
-        struct GeneratedVisitor;
-
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WindowFrameUnits;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(formatter, "expected one of: {:?}", &FIELDS)
-            }
-
-            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(WindowFrameUnits::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
-                    })
-            }
-
-            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                use std::convert::TryFrom;
-                i32::try_from(v)
-                    .ok()
-                    .and_then(WindowFrameUnits::from_i32)
-                    .ok_or_else(|| {
-                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
-                    })
-            }
-
-            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                match value {
-                    "ROWS" => Ok(WindowFrameUnits::Rows),
-                    "RANGE" => Ok(WindowFrameUnits::Range),
-                    "GROUPS" => Ok(WindowFrameUnits::Groups),
-                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
-                }
-            }
-        }
-        deserializer.deserialize_any(GeneratedVisitor)
-    }
-}
-impl serde::Serialize for WindowNode {
-    #[allow(deprecated)]
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        use serde::ser::SerializeStruct;
-        let mut len = 0;
-        if self.input.is_some() {
-            len += 1;
-        }
-        if !self.window_expr.is_empty() {
-            len += 1;
-        }
-        let mut struct_ser = serializer.serialize_struct("datafusion.WindowNode", len)?;
-        if let Some(v) = self.input.as_ref() {
-            struct_ser.serialize_field("input", v)?;
-        }
-        if !self.window_expr.is_empty() {
-            struct_ser.serialize_field("windowExpr", &self.window_expr)?;
-        }
-        struct_ser.end()
-    }
-}
-impl<'de> serde::Deserialize<'de> for WindowNode {
-    #[allow(deprecated)]
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        const FIELDS: &[&str] = &[
-            "input",
-            "window_expr",
-            "windowExpr",
-        ];
-
-        #[allow(clippy::enum_variant_names)]
-        enum GeneratedField {
-            Input,
-            WindowExpr,
-        }
-        impl<'de> serde::Deserialize<'de> for GeneratedField {
-            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                struct GeneratedVisitor;
-
-                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-                    type Value = GeneratedField;
-
-                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                        write!(formatter, "expected one of: {:?}", &FIELDS)
-                    }
-
-                    #[allow(unused_variables)]
-                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
-                    where
-                        E: serde::de::Error,
-                    {
-                        match value {
-                            "input" => Ok(GeneratedField::Input),
-                            "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
-                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-                deserializer.deserialize_identifier(GeneratedVisitor)
-            }
-        }
-        struct GeneratedVisitor;
-        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
-            type Value = WindowNode;
-
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("struct datafusion.WindowNode")
-            }
-
-            fn visit_map<V>(self, mut map: V) -> std::result::Result<WindowNode, V::Error>
-                where
-                    V: serde::de::MapAccess<'de>,
-            {
-                let mut input__ = None;
-                let mut window_expr__ = None;
-                while let Some(k) = map.next_key()? {
-                    match k {
-                        GeneratedField::Input => {
-                            if input__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("input"));
-                            }
-                            input__ = map.next_value()?;
-                        }
-                        GeneratedField::WindowExpr => {
-                            if window_expr__.is_some() {
-                                return Err(serde::de::Error::duplicate_field("windowExpr"));
-                            }
-                            window_expr__ = Some(map.next_value()?);
-                        }
-                    }
-                }
-                Ok(WindowNode {
-                    input: input__,
-                    window_expr: window_expr__.unwrap_or_default(),
-                })
-            }
-        }
-        deserializer.deserialize_struct("datafusion.WindowNode", FIELDS, GeneratedVisitor)
-    }
-}

From b10c910a19c6bdff7966c69492f8f715cffacb3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 16:31:34 +0200
Subject: [PATCH 03/15] fmt

---
 .../core/src/physical_optimizer/sort_enforcement.rs |  5 +++--
 datafusion/core/src/physical_plan/sorts/merge.rs    | 11 +++++++----
 .../physical_plan/sorts/sort_preserving_merge.rs    | 13 ++++++-------
 datafusion/proto/src/physical_plan/mod.rs           |  2 +-
 4 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/datafusion/core/src/physical_optimizer/sort_enforcement.rs b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
index f10401877f65b..b0c67db1f9e82 100644
--- a/datafusion/core/src/physical_optimizer/sort_enforcement.rs
+++ b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
@@ -423,7 +423,8 @@ fn parallelize_sorts(
         let sort_exprs = get_sort_exprs(&plan)?;
         add_sort_above(&mut prev_layer, sort_exprs.to_vec())?;
         let sort_fetch = get_sort_fetch(&plan)?;
-        let spm = SortPreservingMergeExec::new(sort_exprs.to_vec(), prev_layer).with_fetch(sort_fetch);
+        let spm = SortPreservingMergeExec::new(sort_exprs.to_vec(), prev_layer)
+            .with_fetch(sort_fetch);
         return Ok(Transformed::Yes(PlanWithCorrespondingCoalescePartitions {
             plan: Arc::new(spm),
             coalesce_onwards: vec![None],
@@ -802,7 +803,7 @@ fn get_sort_exprs(sort_any: &Arc<dyn ExecutionPlan>) -> Result<&[PhysicalSortExp
     }
 }
 
-/// gets 
+/// gets
 fn get_sort_fetch(sort_any: &Arc<dyn ExecutionPlan>) -> Result<Option<usize>> {
     if let Some(sort_exec) = sort_any.as_any().downcast_ref::<SortExec>() {
         Ok(sort_exec.fetch())
diff --git a/datafusion/core/src/physical_plan/sorts/merge.rs b/datafusion/core/src/physical_plan/sorts/merge.rs
index f5472dc57f660..abb763d24190d 100644
--- a/datafusion/core/src/physical_plan/sorts/merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/merge.rs
@@ -80,7 +80,7 @@ pub(crate) fn streaming_merge(
         schema,
         metrics,
         batch_size,
-        fetch
+        fetch,
     )))
 }
 
@@ -241,17 +241,20 @@ impl<C: Cursor> SortPreservingMergeStream<C> {
                 self.in_progress.push_row(stream_idx);
 
                 // stop sorting if fetch has been reached
-                if self.fetch.map(|fetch| self.produced + self.in_progress.len() >= fetch).unwrap_or(false) {
+                if self
+                    .fetch
+                    .map(|fetch| self.produced + self.in_progress.len() >= fetch)
+                    .unwrap_or(false)
+                {
                     self.aborted = true;
                 }
-                if self.in_progress.len() < self.batch_size  {
+                if self.in_progress.len() < self.batch_size {
                     continue;
                 }
             }
 
             self.produced += self.in_progress.len();
 
-
             return Poll::Ready(self.in_progress.build_record_batch().transpose());
         }
     }
diff --git a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
index 724ec1de3c8eb..b55d1cae6dd88 100644
--- a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
@@ -72,7 +72,7 @@ pub struct SortPreservingMergeExec {
     /// Execution metrics
     metrics: ExecutionPlanMetricsSet,
     /// Optional number of rows to fetch
-    fetch: Option<usize>
+    fetch: Option<usize>,
 }
 
 impl SortPreservingMergeExec {
@@ -85,7 +85,7 @@ impl SortPreservingMergeExec {
             fetch: None,
         }
     }
-    /// Sets the number of rows to fetch 
+    /// Sets the number of rows to fetch
     pub fn with_fetch(mut self, fetch: Option<usize>) -> Self {
         self.fetch = fetch;
         self
@@ -105,7 +105,6 @@ impl SortPreservingMergeExec {
     pub fn fetch(&self) -> Option<usize> {
         self.fetch
     }
-    
 }
 
 impl ExecutionPlan for SortPreservingMergeExec {
@@ -151,10 +150,10 @@ impl ExecutionPlan for SortPreservingMergeExec {
         self: Arc<Self>,
         children: Vec<Arc<dyn ExecutionPlan>>,
     ) -> Result<Arc<dyn ExecutionPlan>> {
-        Ok(Arc::new(SortPreservingMergeExec::new(
-            self.expr.clone(),
-            children[0].clone(),
-        ).with_fetch(self.fetch)))
+        Ok(Arc::new(
+            SortPreservingMergeExec::new(self.expr.clone(), children[0].clone())
+                .with_fetch(self.fetch),
+        ))
     }
 
     fn execute(
diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs
index ba1e9e0b0916a..805afd4158643 100644
--- a/datafusion/proto/src/physical_plan/mod.rs
+++ b/datafusion/proto/src/physical_plan/mod.rs
@@ -1144,7 +1144,7 @@ impl AsExecutionPlan for PhysicalPlanNode {
                     Box::new(protobuf::SortPreservingMergeExecNode {
                         input: Some(Box::new(input)),
                         expr,
-                        fetch: exec.fetch().map(|f|f as i64).unwrap_or(-1)
+                        fetch: exec.fetch().map(|f| f as i64).unwrap_or(-1),
                     }),
                 )),
             })

From 1da1f42e6938e25fa7a9328dfcc26a62b66f11fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 16:34:10 +0200
Subject: [PATCH 04/15] Deserialize

---
 datafusion/proto/src/physical_plan/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs
index 805afd4158643..d6603e6756320 100644
--- a/datafusion/proto/src/physical_plan/mod.rs
+++ b/datafusion/proto/src/physical_plan/mod.rs
@@ -692,7 +692,8 @@ impl AsExecutionPlan for PhysicalPlanNode {
                         }
                     })
                     .collect::<Result<Vec<_>, _>>()?;
-                Ok(Arc::new(SortPreservingMergeExec::new(exprs, input)))
+                let fetch = if sort.fetch == -1 {None} else {Some(sort.fetch as usize)};
+                Ok(Arc::new(SortPreservingMergeExec::new(exprs, input).with_fetch(fetch)))
             }
             PhysicalPlanType::Extension(extension) => {
                 let inputs: Vec<Arc<dyn ExecutionPlan>> = extension

From 878d7a40b5334e74fc3d4374f8d57ffd87bbb545 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 16:38:15 +0200
Subject: [PATCH 05/15] Fmt

---
 datafusion/proto/src/physical_plan/mod.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs
index d6603e6756320..70196b684a1cd 100644
--- a/datafusion/proto/src/physical_plan/mod.rs
+++ b/datafusion/proto/src/physical_plan/mod.rs
@@ -692,8 +692,14 @@ impl AsExecutionPlan for PhysicalPlanNode {
                         }
                     })
                     .collect::<Result<Vec<_>, _>>()?;
-                let fetch = if sort.fetch == -1 {None} else {Some(sort.fetch as usize)};
-                Ok(Arc::new(SortPreservingMergeExec::new(exprs, input).with_fetch(fetch)))
+                let fetch = if sort.fetch == -1 {
+                    None
+                } else {
+                    Some(sort.fetch as usize)
+                };
+                Ok(Arc::new(
+                    SortPreservingMergeExec::new(exprs, input).with_fetch(fetch),
+                ))
             }
             PhysicalPlanType::Extension(extension) => {
                 let inputs: Vec<Arc<dyn ExecutionPlan>> = extension

From 38f38deca5fe449b6b31748fd7f9407f91aff51e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 16:54:32 +0200
Subject: [PATCH 06/15] Fix test

---
 .../core/src/physical_plan/sorts/sort_preserving_merge.rs       | 2 +-
 datafusion/core/tests/sql/explain_analyze.rs                    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
index b55d1cae6dd88..c8521e531da25 100644
--- a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
@@ -225,7 +225,7 @@ impl ExecutionPlan for SortPreservingMergeExec {
                 let expr: Vec<String> = self.expr.iter().map(|e| e.to_string()).collect();
                 write!(f, "SortPreservingMergeExec: [{}]", expr.join(","))?;
                 if let Some(fetch) = self.fetch {
-                    write!(f, "fetch={fetch}")?;
+                    write!(f, ", fetch={fetch}")?;
                 };
 
                 Ok(())
diff --git a/datafusion/core/tests/sql/explain_analyze.rs b/datafusion/core/tests/sql/explain_analyze.rs
index 01bdb629ee840..e0130cb09c8c0 100644
--- a/datafusion/core/tests/sql/explain_analyze.rs
+++ b/datafusion/core/tests/sql/explain_analyze.rs
@@ -599,7 +599,7 @@ async fn test_physical_plan_display_indent() {
     let physical_plan = dataframe.create_physical_plan().await.unwrap();
     let expected = vec![
         "GlobalLimitExec: skip=0, fetch=10",
-        "  SortPreservingMergeExec: [the_min@2 DESC]",
+        "  SortPreservingMergeExec: [the_min@2 DESC], fetch=10",
         "    SortExec: fetch=10, expr=[the_min@2 DESC]",
         "      ProjectionExec: expr=[c1@0 as c1, MAX(aggregate_test_100.c12)@1 as MAX(aggregate_test_100.c12), MIN(aggregate_test_100.c12)@2 as the_min]",
         "        AggregateExec: mode=FinalPartitioned, gby=[c1@0 as c1], aggr=[MAX(aggregate_test_100.c12), MIN(aggregate_test_100.c12)]",

From fd1f2a7a19486b3081a41ea19db19b0cac680c9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 17:24:44 +0200
Subject: [PATCH 07/15] Fix test

---
 datafusion/core/tests/sqllogictests/test_files/union.slt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datafusion/core/tests/sqllogictests/test_files/union.slt b/datafusion/core/tests/sqllogictests/test_files/union.slt
index 94c9eef89324c..2b3022ddd1a35 100644
--- a/datafusion/core/tests/sqllogictests/test_files/union.slt
+++ b/datafusion/core/tests/sqllogictests/test_files/union.slt
@@ -308,7 +308,7 @@ Limit: skip=0, fetch=5
 --------TableScan: aggregate_test_100 projection=[c1, c3]
 physical_plan
 GlobalLimitExec: skip=0, fetch=5
---SortPreservingMergeExec: [c9@1 DESC]
+--SortPreservingMergeExec: [c9@1 DESC], fetch=5
 ----UnionExec
 ------SortExec: expr=[c9@1 DESC]
 --------ProjectionExec: expr=[c1@0 as c1, CAST(c9@1 AS Int64) as c9]

From 8f3605f7d5bcd74ec5482bc9bfd0d0dfd9827a1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Fri, 30 Jun 2023 20:48:42 +0200
Subject: [PATCH 08/15] Fix test

---
 datafusion/core/src/physical_plan/sorts/merge.rs          | 3 +--
 datafusion/core/tests/sqllogictests/test_files/window.slt | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/datafusion/core/src/physical_plan/sorts/merge.rs b/datafusion/core/src/physical_plan/sorts/merge.rs
index abb763d24190d..3d9a7a97dc870 100644
--- a/datafusion/core/src/physical_plan/sorts/merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/merge.rs
@@ -247,8 +247,7 @@ impl<C: Cursor> SortPreservingMergeStream<C> {
                     .unwrap_or(false)
                 {
                     self.aborted = true;
-                }
-                if self.in_progress.len() < self.batch_size {
+                } else if self.in_progress.len() < self.batch_size {
                     continue;
                 }
             }
diff --git a/datafusion/core/tests/sqllogictests/test_files/window.slt b/datafusion/core/tests/sqllogictests/test_files/window.slt
index 08d1a5616e8a2..d77df127a80a2 100644
--- a/datafusion/core/tests/sqllogictests/test_files/window.slt
+++ b/datafusion/core/tests/sqllogictests/test_files/window.slt
@@ -1792,7 +1792,7 @@ Limit: skip=0, fetch=5
 ------------TableScan: aggregate_test_100 projection=[c2, c3, c9]
 physical_plan
 GlobalLimitExec: skip=0, fetch=5
---SortPreservingMergeExec: [c3@0 ASC NULLS LAST]
+--SortPreservingMergeExec: [c3@0 ASC NULLS LAST], fetch=5
 ----ProjectionExec: expr=[c3@0 as c3, SUM(aggregate_test_100.c9) ORDER BY [aggregate_test_100.c3 DESC NULLS FIRST, aggregate_test_100.c9 DESC NULLS FIRST, aggregate_test_100.c2 ASC NULLS LAST] RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW@2 as sum1, SUM(aggregate_test_100.c9) PARTITION BY [aggregate_test_100.c3] ORDER BY [aggregate_test_100.c9 DESC NULLS FIRST] RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW@3 as sum2]
 ------BoundedWindowAggExec: wdw=[SUM(aggregate_test_100.c9): Ok(Field { name: "SUM(aggregate_test_100.c9)", data_type: UInt64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: {} }), frame: WindowFrame { units: Range, start_bound: Preceding(UInt64(NULL)), end_bound: CurrentRow }], mode=[Sorted]
 --------SortExec: expr=[c3@0 ASC NULLS LAST,c9@1 DESC]

From 14461620a7ef5f6288b373e0ab83228194007497 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Sat, 1 Jul 2023 12:57:54 +0200
Subject: [PATCH 09/15] Fix plan output

---
 .../core/tests/sqllogictests/test_files/tpch/q10.slt.part       | 2 +-
 .../core/tests/sqllogictests/test_files/tpch/q11.slt.part       | 2 +-
 .../core/tests/sqllogictests/test_files/tpch/q13.slt.part       | 2 +-
 .../core/tests/sqllogictests/test_files/tpch/q16.slt.part       | 2 +-
 datafusion/core/tests/sqllogictests/test_files/tpch/q2.slt.part | 2 +-
 datafusion/core/tests/sqllogictests/test_files/tpch/q3.slt.part | 2 +-
 datafusion/core/tests/sqllogictests/test_files/tpch/q9.slt.part | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/datafusion/core/tests/sqllogictests/test_files/tpch/q10.slt.part b/datafusion/core/tests/sqllogictests/test_files/tpch/q10.slt.part
index d2e06d5ff6d99..6c662c1091b94 100644
--- a/datafusion/core/tests/sqllogictests/test_files/tpch/q10.slt.part
+++ b/datafusion/core/tests/sqllogictests/test_files/tpch/q10.slt.part
@@ -71,7 +71,7 @@ Limit: skip=0, fetch=10
 ------------TableScan: nation projection=[n_nationkey, n_name]
 physical_plan
 GlobalLimitExec: skip=0, fetch=10
---SortPreservingMergeExec: [revenue@2 DESC]
+--SortPreservingMergeExec: [revenue@2 DESC], fetch=10
 ----SortExec: fetch=10, expr=[revenue@2 DESC]
 ------ProjectionExec: expr=[c_custkey@0 as c_custkey, c_name@1 as c_name, SUM(lineitem.l_extendedprice * Int64(1) - lineitem.l_discount)@7 as revenue, c_acctbal@2 as c_acctbal, n_name@4 as n_name, c_address@5 as c_address, c_phone@3 as c_phone, c_comment@6 as c_comment]
 --------AggregateExec: mode=FinalPartitioned, gby=[c_custkey@0 as c_custkey, c_name@1 as c_name, c_acctbal@2 as c_acctbal, c_phone@3 as c_phone, n_name@4 as n_name, c_address@5 as c_address, c_comment@6 as c_comment], aggr=[SUM(lineitem.l_extendedprice * Int64(1) - lineitem.l_discount)]
diff --git a/datafusion/core/tests/sqllogictests/test_files/tpch/q11.slt.part b/datafusion/core/tests/sqllogictests/test_files/tpch/q11.slt.part
index af29708c679cb..0c16fe1ab98d2 100644
--- a/datafusion/core/tests/sqllogictests/test_files/tpch/q11.slt.part
+++ b/datafusion/core/tests/sqllogictests/test_files/tpch/q11.slt.part
@@ -75,7 +75,7 @@ Limit: skip=0, fetch=10
 ----------------------TableScan: nation projection=[n_nationkey, n_name], partial_filters=[nation.n_name = Utf8("GERMANY")]
 physical_plan
 GlobalLimitExec: skip=0, fetch=10
---SortPreservingMergeExec: [value@1 DESC]
+--SortPreservingMergeExec: [value@1 DESC], fetch=10
 ----SortExec: fetch=10, expr=[value@1 DESC]
 ------ProjectionExec: expr=[ps_partkey@0 as ps_partkey, SUM(partsupp.ps_supplycost * partsupp.ps_availqty)@1 as value]
 --------NestedLoopJoinExec: join_type=Inner, filter=CAST(SUM(partsupp.ps_supplycost * partsupp.ps_availqty)@0 AS Decimal128(38, 15)) > SUM(partsupp.ps_supplycost * partsupp.ps_availqty) * Float64(0.0001)@1
diff --git a/datafusion/core/tests/sqllogictests/test_files/tpch/q13.slt.part b/datafusion/core/tests/sqllogictests/test_files/tpch/q13.slt.part
index 7e5be142712a9..8ac9576a12483 100644
--- a/datafusion/core/tests/sqllogictests/test_files/tpch/q13.slt.part
+++ b/datafusion/core/tests/sqllogictests/test_files/tpch/q13.slt.part
@@ -56,7 +56,7 @@ Limit: skip=0, fetch=10
 ------------------------TableScan: orders projection=[o_orderkey, o_custkey, o_comment], partial_filters=[orders.o_comment NOT LIKE Utf8("%special%requests%")]
 physical_plan
 GlobalLimitExec: skip=0, fetch=10
---SortPreservingMergeExec: [custdist@1 DESC,c_count@0 DESC]
+--SortPreservingMergeExec: [custdist@1 DESC,c_count@0 DESC], fetch=10
 ----SortExec: fetch=10, expr=[custdist@1 DESC,c_count@0 DESC]
 ------ProjectionExec: expr=[c_count@0 as c_count, COUNT(UInt8(1))@1 as custdist]
 --------AggregateExec: mode=FinalPartitioned, gby=[c_count@0 as c_count], aggr=[COUNT(UInt8(1))]
diff --git a/datafusion/core/tests/sqllogictests/test_files/tpch/q16.slt.part b/datafusion/core/tests/sqllogictests/test_files/tpch/q16.slt.part
index 677db0329c21f..58796e93a893a 100644
--- a/datafusion/core/tests/sqllogictests/test_files/tpch/q16.slt.part
+++ b/datafusion/core/tests/sqllogictests/test_files/tpch/q16.slt.part
@@ -67,7 +67,7 @@ Limit: skip=0, fetch=10
 ------------------TableScan: supplier projection=[s_suppkey, s_comment], partial_filters=[supplier.s_comment LIKE Utf8("%Customer%Complaints%")]
 physical_plan
 GlobalLimitExec: skip=0, fetch=10
---SortPreservingMergeExec: [supplier_cnt@3 DESC,p_brand@0 ASC NULLS LAST,p_type@1 ASC NULLS LAST,p_size@2 ASC NULLS LAST]
+--SortPreservingMergeExec: [supplier_cnt@3 DESC,p_brand@0 ASC NULLS LAST,p_type@1 ASC NULLS LAST,p_size@2 ASC NULLS LAST], fetch=10
 ----SortExec: fetch=10, expr=[supplier_cnt@3 DESC,p_brand@0 ASC NULLS LAST,p_type@1 ASC NULLS LAST,p_size@2 ASC NULLS LAST]
 ------ProjectionExec: expr=[group_alias_0@0 as part.p_brand, group_alias_1@1 as part.p_type, group_alias_2@2 as part.p_size, COUNT(alias1)@3 as supplier_cnt]
 --------AggregateExec: mode=FinalPartitioned, gby=[group_alias_0@0 as group_alias_0, group_alias_1@1 as group_alias_1, group_alias_2@2 as group_alias_2], aggr=[COUNT(alias1)]
diff --git a/datafusion/core/tests/sqllogictests/test_files/tpch/q2.slt.part b/datafusion/core/tests/sqllogictests/test_files/tpch/q2.slt.part
index 4ad1ed729337f..18cd261b76637 100644
--- a/datafusion/core/tests/sqllogictests/test_files/tpch/q2.slt.part
+++ b/datafusion/core/tests/sqllogictests/test_files/tpch/q2.slt.part
@@ -101,7 +101,7 @@ Limit: skip=0, fetch=10
 ----------------------TableScan: region projection=[r_regionkey, r_name], partial_filters=[region.r_name = Utf8("EUROPE")]
 physical_plan
 GlobalLimitExec: skip=0, fetch=10
---SortPreservingMergeExec: [s_acctbal@0 DESC,n_name@2 ASC NULLS LAST,s_name@1 ASC NULLS LAST,p_partkey@3 ASC NULLS LAST]
+--SortPreservingMergeExec: [s_acctbal@0 DESC,n_name@2 ASC NULLS LAST,s_name@1 ASC NULLS LAST,p_partkey@3 ASC NULLS LAST], fetch=10
 ----SortExec: fetch=10, expr=[s_acctbal@0 DESC,n_name@2 ASC NULLS LAST,s_name@1 ASC NULLS LAST,p_partkey@3 ASC NULLS LAST]
 ------ProjectionExec: expr=[s_acctbal@5 as s_acctbal, s_name@2 as s_name, n_name@8 as n_name, p_partkey@0 as p_partkey, p_mfgr@1 as p_mfgr, s_address@3 as s_address, s_phone@4 as s_phone, s_comment@6 as s_comment]
 --------CoalesceBatchesExec: target_batch_size=8192
diff --git a/datafusion/core/tests/sqllogictests/test_files/tpch/q3.slt.part b/datafusion/core/tests/sqllogictests/test_files/tpch/q3.slt.part
index dc3b150877a86..f8c13856812a4 100644
--- a/datafusion/core/tests/sqllogictests/test_files/tpch/q3.slt.part
+++ b/datafusion/core/tests/sqllogictests/test_files/tpch/q3.slt.part
@@ -60,7 +60,7 @@ Limit: skip=0, fetch=10
 ----------------TableScan: lineitem projection=[l_orderkey, l_extendedprice, l_discount, l_shipdate], partial_filters=[lineitem.l_shipdate > Date32("9204")]
 physical_plan
 GlobalLimitExec: skip=0, fetch=10
---SortPreservingMergeExec: [revenue@1 DESC,o_orderdate@2 ASC NULLS LAST]
+--SortPreservingMergeExec: [revenue@1 DESC,o_orderdate@2 ASC NULLS LAST], fetch=10
 ----SortExec: fetch=10, expr=[revenue@1 DESC,o_orderdate@2 ASC NULLS LAST]
 ------ProjectionExec: expr=[l_orderkey@0 as l_orderkey, SUM(lineitem.l_extendedprice * Int64(1) - lineitem.l_discount)@3 as revenue, o_orderdate@1 as o_orderdate, o_shippriority@2 as o_shippriority]
 --------AggregateExec: mode=FinalPartitioned, gby=[l_orderkey@0 as l_orderkey, o_orderdate@1 as o_orderdate, o_shippriority@2 as o_shippriority], aggr=[SUM(lineitem.l_extendedprice * Int64(1) - lineitem.l_discount)]
diff --git a/datafusion/core/tests/sqllogictests/test_files/tpch/q9.slt.part b/datafusion/core/tests/sqllogictests/test_files/tpch/q9.slt.part
index 756b2e2c7cc33..45a4be6466e46 100644
--- a/datafusion/core/tests/sqllogictests/test_files/tpch/q9.slt.part
+++ b/datafusion/core/tests/sqllogictests/test_files/tpch/q9.slt.part
@@ -77,7 +77,7 @@ Limit: skip=0, fetch=10
 --------------TableScan: nation projection=[n_nationkey, n_name]
 physical_plan
 GlobalLimitExec: skip=0, fetch=10
---SortPreservingMergeExec: [nation@0 ASC NULLS LAST,o_year@1 DESC]
+--SortPreservingMergeExec: [nation@0 ASC NULLS LAST,o_year@1 DESC], fetch=10
 ----SortExec: fetch=10, expr=[nation@0 ASC NULLS LAST,o_year@1 DESC]
 ------ProjectionExec: expr=[nation@0 as nation, o_year@1 as o_year, SUM(profit.amount)@2 as sum_profit]
 --------AggregateExec: mode=FinalPartitioned, gby=[nation@0 as nation, o_year@1 as o_year], aggr=[SUM(profit.amount)]

From 193d0ac3a0345ef46dec64e11643fd49ce2c78d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Sat, 1 Jul 2023 20:41:34 +0200
Subject: [PATCH 10/15] Doc

---
 datafusion/core/src/physical_optimizer/sort_enforcement.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/datafusion/core/src/physical_optimizer/sort_enforcement.rs b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
index b0c67db1f9e82..990e3d9c17cc2 100644
--- a/datafusion/core/src/physical_optimizer/sort_enforcement.rs
+++ b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
@@ -787,7 +787,7 @@ fn remove_corresponding_sort_from_sub_plan(
     Ok(updated_plan)
 }
 
-/// Retrieves a fetch from a `SortExec` when possible
+/// Converts an [ExecutionPlan] trait object to a [PhysicalSortExpr] slice when possible.
 fn get_sort_exprs(sort_any: &Arc<dyn ExecutionPlan>) -> Result<&[PhysicalSortExpr]> {
     if let Some(sort_exec) = sort_any.as_any().downcast_ref::<SortExec>() {
         Ok(sort_exec.expr())
@@ -803,7 +803,7 @@ fn get_sort_exprs(sort_any: &Arc<dyn ExecutionPlan>) -> Result<&[PhysicalSortExp
     }
 }
 
-/// gets
+/// Retrieves a fetch from a `SortExec` or `SortPreservingMergeExec` when possible
 fn get_sort_fetch(sort_any: &Arc<dyn ExecutionPlan>) -> Result<Option<usize>> {
     if let Some(sort_exec) = sort_any.as_any().downcast_ref::<SortExec>() {
         Ok(sort_exec.fetch())

From 99170b942d91fb419d22faaadd72616bf59a0b87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <danielheres@gmail.com>
Date: Sun, 2 Jul 2023 16:42:39 +0200
Subject: [PATCH 11/15] Update
 datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs

Co-authored-by: Andrew Lamb <andrew@nerdnetworks.org>
---
 .../core/src/physical_plan/sorts/sort_preserving_merge.rs       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
index c8521e531da25..397d254162c72 100644
--- a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
@@ -71,7 +71,7 @@ pub struct SortPreservingMergeExec {
     expr: Vec<PhysicalSortExpr>,
     /// Execution metrics
     metrics: ExecutionPlanMetricsSet,
-    /// Optional number of rows to fetch
+    /// Optional number of rows to fetch. Stops producing rows after this fetch
     fetch: Option<usize>,
 }
 

From acaae3e1a19d011467734abea064d8d823cf0ee2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Sun, 2 Jul 2023 20:30:57 +0200
Subject: [PATCH 12/15] Extract into method

---
 datafusion/core/src/physical_plan/sorts/merge.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/datafusion/core/src/physical_plan/sorts/merge.rs b/datafusion/core/src/physical_plan/sorts/merge.rs
index 3d9a7a97dc870..8041b5c2d77b3 100644
--- a/datafusion/core/src/physical_plan/sorts/merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/merge.rs
@@ -241,11 +241,7 @@ impl<C: Cursor> SortPreservingMergeStream<C> {
                 self.in_progress.push_row(stream_idx);
 
                 // stop sorting if fetch has been reached
-                if self
-                    .fetch
-                    .map(|fetch| self.produced + self.in_progress.len() >= fetch)
-                    .unwrap_or(false)
-                {
+                if self.fetch_reached() {
                     self.aborted = true;
                 } else if self.in_progress.len() < self.batch_size {
                     continue;
@@ -258,6 +254,12 @@ impl<C: Cursor> SortPreservingMergeStream<C> {
         }
     }
 
+    fn fetch_reached(&mut self) -> bool {
+        self.fetch
+            .map(|fetch| self.produced + self.in_progress.len() >= fetch)
+            .unwrap_or(false)
+    }
+
     fn advance(&mut self, stream_idx: usize) -> bool {
         let slot = &mut self.cursors[stream_idx];
         match slot.as_mut() {

From 43d04e0afab7510d502b283d87ed1471b1bc6998 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <daniel.heres@coralogix.com>
Date: Sun, 2 Jul 2023 20:51:15 +0200
Subject: [PATCH 13/15] Remove from sort enforcement

---
 .../physical_optimizer/sort_enforcement.rs    | 20 +------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/datafusion/core/src/physical_optimizer/sort_enforcement.rs b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
index 990e3d9c17cc2..719c152841b79 100644
--- a/datafusion/core/src/physical_optimizer/sort_enforcement.rs
+++ b/datafusion/core/src/physical_optimizer/sort_enforcement.rs
@@ -422,9 +422,7 @@ fn parallelize_sorts(
         update_child_to_remove_coalesce(&mut prev_layer, &mut coalesce_onwards[0])?;
         let sort_exprs = get_sort_exprs(&plan)?;
         add_sort_above(&mut prev_layer, sort_exprs.to_vec())?;
-        let sort_fetch = get_sort_fetch(&plan)?;
-        let spm = SortPreservingMergeExec::new(sort_exprs.to_vec(), prev_layer)
-            .with_fetch(sort_fetch);
+        let spm = SortPreservingMergeExec::new(sort_exprs.to_vec(), prev_layer);
         return Ok(Transformed::Yes(PlanWithCorrespondingCoalescePartitions {
             plan: Arc::new(spm),
             coalesce_onwards: vec![None],
@@ -803,22 +801,6 @@ fn get_sort_exprs(sort_any: &Arc<dyn ExecutionPlan>) -> Result<&[PhysicalSortExp
     }
 }
 
-/// Retrieves a fetch from a `SortExec` or `SortPreservingMergeExec` when possible
-fn get_sort_fetch(sort_any: &Arc<dyn ExecutionPlan>) -> Result<Option<usize>> {
-    if let Some(sort_exec) = sort_any.as_any().downcast_ref::<SortExec>() {
-        Ok(sort_exec.fetch())
-    } else if let Some(sort_preserving_merge_exec) =
-        sort_any.as_any().downcast_ref::<SortPreservingMergeExec>()
-    {
-        Ok(sort_preserving_merge_exec.fetch())
-    } else {
-        Err(DataFusionError::Plan(
-            "Given ExecutionPlan is not a SortExec or a SortPreservingMergeExec"
-                .to_string(),
-        ))
-    }
-}
-
 /// Compares physical ordering (output ordering of input executor) with
 /// `partitionby_exprs` and `orderby_keys`
 /// to decide whether existing ordering is sufficient to run current window executor.

From ed39a279ea7b8ba7684e879efdfbdc3369b6003c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <danielheres@gmail.com>
Date: Mon, 3 Jul 2023 10:18:26 +0200
Subject: [PATCH 14/15] Update datafusion/core/src/physical_plan/sorts/merge.rs

Co-authored-by: Mustafa Akur <106137913+mustafasrepo@users.noreply.github.com>
---
 datafusion/core/src/physical_plan/sorts/merge.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datafusion/core/src/physical_plan/sorts/merge.rs b/datafusion/core/src/physical_plan/sorts/merge.rs
index 8041b5c2d77b3..e191c044b9040 100644
--- a/datafusion/core/src/physical_plan/sorts/merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/merge.rs
@@ -147,7 +147,7 @@ struct SortPreservingMergeStream<C> {
     /// Optional number of rows to fetch
     fetch: Option<usize>,
 
-    /// number of rows produces
+    /// number of rows produced
     produced: usize,
 }
 

From 19f027f8a52dfb4e8e41fb3f8df3ce0236e9797f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dani=C3=ABl=20Heres?= <danielheres@gmail.com>
Date: Mon, 3 Jul 2023 10:18:36 +0200
Subject: [PATCH 15/15] Update datafusion/proto/src/physical_plan/mod.rs

Co-authored-by: Mustafa Akur <106137913+mustafasrepo@users.noreply.github.com>
---
 datafusion/proto/src/physical_plan/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs
index 70196b684a1cd..7bbbe135680bc 100644
--- a/datafusion/proto/src/physical_plan/mod.rs
+++ b/datafusion/proto/src/physical_plan/mod.rs
@@ -692,7 +692,7 @@ impl AsExecutionPlan for PhysicalPlanNode {
                         }
                     })
                     .collect::<Result<Vec<_>, _>>()?;
-                let fetch = if sort.fetch == -1 {
+                let fetch = if sort.fetch < 0 {
                     None
                 } else {
                     Some(sort.fetch as usize)