diff --git a/benchmarks/Cargo.toml b/benchmarks/Cargo.toml
index d432c454b2c..ac0da91175f 100644
--- a/benchmarks/Cargo.toml
+++ b/benchmarks/Cargo.toml
@@ -33,14 +33,14 @@ simd = ["datafusion/simd"]
 snmalloc = ["snmalloc-rs"]
 
 [dependencies]
-arrow = "26.0.0"
+arrow = "27.0.0"
 datafusion = { path = "../datafusion/core", version = "14.0.0" }
 env_logger = "0.9"
 futures = "0.3"
 mimalloc = { version = "0.1", optional = true, default-features = false }
 num_cpus = "1.13.0"
 object_store = "0.5.0"
-parquet = "26.0.0"
+parquet = "27.0.0"
 parquet-test-utils = { path = "../parquet-test-utils/", version = "0.1.0" }
 rand = "0.8.4"
 serde = { version = "1.0.136", features = ["derive"] }
diff --git a/benchmarks/expected-plans/q6.txt b/benchmarks/expected-plans/q6.txt
index efc17a2724b..463909acbc6 100644
--- a/benchmarks/expected-plans/q6.txt
+++ b/benchmarks/expected-plans/q6.txt
@@ -1,6 +1,4 @@
 Projection: SUM(lineitem.l_extendedprice * lineitem.l_discount) AS revenue
   Aggregate: groupBy=[[]], aggr=[[SUM(lineitem.l_extendedprice * lineitem.l_discount)]]
-    Projection: lineitem.l_extendedprice, lineitem.l_discount
-      Filter: lineitem.l_shipdate >= Date32("8766") AND lineitem.l_shipdate < Date32("9131") AND CAST(lineitem.l_discount AS Decimal128(30, 15))lineitem.l_discount >= Decimal128(Some(49999999999999),30,15) AND CAST(lineitem.l_discount AS Decimal128(30, 15))lineitem.l_discount <= Decimal128(Some(69999999999999),30,15) AND lineitem.l_quantity < Decimal128(Some(2400),15,2)
-        Projection: CAST(lineitem.l_discount AS Decimal128(30, 15)) AS CAST(lineitem.l_discount AS Decimal128(30, 15))lineitem.l_discount, lineitem.l_quantity, lineitem.l_extendedprice, lineitem.l_discount, lineitem.l_shipdate
-          TableScan: lineitem projection=[l_quantity, l_extendedprice, l_discount, l_shipdate]
\ No newline at end of file
+    Filter: lineitem.l_shipdate >= Date32("8766") AND lineitem.l_shipdate < Date32("9131") AND lineitem.l_discount >= Decimal128(Some(5),15,2) AND lineitem.l_discount <= Decimal128(Some(7),15,2) AND lineitem.l_quantity < Decimal128(Some(2400),15,2)
+      TableScan: lineitem projection=[l_quantity, l_extendedprice, l_discount, l_shipdate]
diff --git a/datafusion-cli/Cargo.lock b/datafusion-cli/Cargo.lock
index 9bc0aef84c6..b42c2039054 100644
--- a/datafusion-cli/Cargo.lock
+++ b/datafusion-cli/Cargo.lock
@@ -79,38 +79,35 @@ checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
 
 [[package]]
 name = "arrow"
-version = "26.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24e2bcd431a4aa0ff003fdd2dc21c78cfb42f31459c89d2312c2746fe17a5ac"
+checksum = "b329393dcb0f1d7b11179bb4bdf1ba03e65f0c3aa09a70c7d75a889cb4e2be48"
 dependencies = [
  "ahash 0.8.2",
  "arrow-array",
  "arrow-buffer",
+ "arrow-cast",
+ "arrow-csv",
  "arrow-data",
+ "arrow-ipc",
+ "arrow-json",
  "arrow-schema",
  "arrow-select",
- "bitflags",
  "chrono",
  "comfy-table",
- "csv",
- "flatbuffers",
  "half",
- "hashbrown",
- "indexmap",
- "lazy_static",
- "lexical-core",
+ "hashbrown 0.13.1",
  "multiversion",
  "num",
  "regex",
  "regex-syntax",
- "serde_json",
 ]
 
 [[package]]
 name = "arrow-array"
-version = "26.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9044300874385f19e77cbf90911e239bd23630d8f23bb0f948f9067998a13b7"
+checksum = "05cc1efb944a4309b73fd8035f283724ec767b632fc3048e2da7c87cfcd92b08"
 dependencies = [
  "ahash 0.8.2",
  "arrow-buffer",
@@ -118,25 +115,59 @@ dependencies = [
  "arrow-schema",
  "chrono",
  "half",
- "hashbrown",
+ "hashbrown 0.13.1",
  "num",
 ]
 
 [[package]]
 name = "arrow-buffer"
-version = "26.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78476cbe9e3f808dcecab86afe42d573863c63e149c62e6e379ed2522743e626"
+checksum = "3b1e46f50d5a7adcd14465605a3f07f0f11982a0fcf6a5a3562b94ea53af4546"
 dependencies = [
  "half",
  "num",
 ]
 
+[[package]]
+name = "arrow-cast"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "563ceb60e814e9f89c3a1e20ce13f388af362e7ca9c1e75493e047d82cbcb773"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "chrono",
+ "lexical-core",
+ "num",
+]
+
+[[package]]
+name = "arrow-csv"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2c61a79a865fbb7a209623513824d73ecd5b860b8dcfedb271df664e843e6ae"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "csv",
+ "lazy_static",
+ "lexical-core",
+ "regex",
+]
+
 [[package]]
 name = "arrow-data"
-version = "26.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d916feee158c485dad4f701cba31bc9a90a8db87d9df8e2aa8adc0c20a2bbb9"
+checksum = "e17bc1336039023ba297cccea8fe9dc6c8d03a980414e938274a3a3f21922200"
 dependencies = [
  "arrow-buffer",
  "arrow-schema",
@@ -144,17 +175,49 @@ dependencies = [
  "num",
 ]
 
+[[package]]
+name = "arrow-ipc"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4728d966e9e79d55e27d354fe8bad38b59106143230d80723219457c34de0259"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-schema",
+ "flatbuffers",
+]
+
+[[package]]
+name = "arrow-json"
+version = "27.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290444e50fde2e38e7611b50886ab4329787c792b7563c5541af1236cdbc3a5f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "indexmap",
+ "num",
+ "serde_json",
+]
+
 [[package]]
 name = "arrow-schema"
-version = "26.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f9406eb7834ca6bd8350d1baa515d18b9fcec487eddacfb62f5e19511f7bd37"
+checksum = "c564654550c1e197d07660391e32607fac1ce9ca6748a949c36f372bb715f451"
 
 [[package]]
 name = "arrow-select"
-version = "26.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6593a01586751c74498495d2f5a01fcd438102b52965c11dd98abf4ebcacef37"
+checksum = "816c229e4489b66a5512d589406fa816b774005b7365cd9b6af8f160806cceb0"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -562,7 +625,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "907076dfda823b0b36d2a1bb5f90c96660a5bbcd7729e10727f07858f22c4edc"
 dependencies = [
  "cfg-if",
- "hashbrown",
+ "hashbrown 0.12.3",
  "lock_api",
  "once_cell",
  "parking_lot_core",
@@ -589,7 +652,7 @@ dependencies = [
  "flate2",
  "futures",
  "glob",
- "hashbrown",
+ "hashbrown 0.12.3",
  "itertools",
  "lazy_static",
  "log",
@@ -659,7 +722,7 @@ dependencies = [
  "datafusion-common",
  "datafusion-expr",
  "datafusion-physical-expr",
- "hashbrown",
+ "hashbrown 0.12.3",
  "log",
 ]
 
@@ -678,7 +741,7 @@ dependencies = [
  "datafusion-expr",
  "datafusion-row",
  "half",
- "hashbrown",
+ "hashbrown 0.12.3",
  "itertools",
  "lazy_static",
  "md-5",
@@ -1043,6 +1106,12 @@ dependencies = [
  "ahash 0.7.6",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ff8ae62cd3a9102e5637afc8452c55acf3844001bd5374e0b0bd7b6616c038"
+
 [[package]]
 name = "heck"
 version = "0.4.0"
@@ -1176,7 +1245,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
 dependencies = [
  "autocfg",
- "hashbrown",
+ "hashbrown 0.12.3",
 ]
 
 [[package]]
@@ -1646,19 +1715,25 @@ dependencies = [
 
 [[package]]
 name = "parquet"
-version = "26.0.0"
+version = "27.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bf8fa7ab6572791325a8595f55dc532dde88b996ae10a5ca8a2db746784ecc4"
+checksum = "54bd654e4ff294122f6d64938f400a433aee755433e6d9cb28b1861781ea1a3b"
 dependencies = [
  "ahash 0.8.2",
- "arrow",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-ipc",
+ "arrow-schema",
+ "arrow-select",
  "base64",
  "brotli",
  "bytes",
  "chrono",
  "flate2",
  "futures",
- "hashbrown",
+ "hashbrown 0.13.1",
  "lz4",
  "num",
  "num-bigint",
diff --git a/datafusion-cli/Cargo.toml b/datafusion-cli/Cargo.toml
index 5a1e4d92626..09e7eba50b0 100644
--- a/datafusion-cli/Cargo.toml
+++ b/datafusion-cli/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.62"
 readme = "README.md"
 
 [dependencies]
-arrow = "26.0.0"
+arrow = "27.0.0"
 clap = { version = "3", features = ["derive", "cargo"] }
 datafusion = { path = "../datafusion/core", version = "14.0.0" }
 dirs = "4.0.0"
diff --git a/datafusion-examples/Cargo.toml b/datafusion-examples/Cargo.toml
index 33cf9dd9592..5f40ed336b2 100644
--- a/datafusion-examples/Cargo.toml
+++ b/datafusion-examples/Cargo.toml
@@ -34,8 +34,8 @@ path = "examples/avro_sql.rs"
 required-features = ["datafusion/avro"]
 
 [dev-dependencies]
-arrow = "26.0.0"
-arrow-flight = "26.0.0"
+arrow = "27.0.0"
+arrow-flight = "27.0.0"
 async-trait = "0.1.41"
 datafusion = { path = "../datafusion/core" }
 datafusion-common = { path = "../datafusion/common" }
diff --git a/datafusion/common/Cargo.toml b/datafusion/common/Cargo.toml
index cbbaf4337cd..69d01b3018a 100644
--- a/datafusion/common/Cargo.toml
+++ b/datafusion/common/Cargo.toml
@@ -40,10 +40,10 @@ pyarrow = ["pyo3", "arrow/pyarrow"]
 
 [dependencies]
 apache-avro = { version = "0.14", default-features = false, features = ["snappy"], optional = true }
-arrow = { version = "26.0.0", default-features = false }
+arrow = { version = "27.0.0", default-features = false }
 chrono = { version = "0.4", default-features = false }
 cranelift-module = { version = "0.89.0", optional = true }
 object_store = { version = "0.5.0", default-features = false, optional = true }
-parquet = { version = "26.0.0", default-features = false, optional = true }
+parquet = { version = "27.0.0", default-features = false, optional = true }
 pyo3 = { version = "0.17.1", optional = true }
 sqlparser = "0.26"
diff --git a/datafusion/core/Cargo.toml b/datafusion/core/Cargo.toml
index 493d8a3c364..efd28ee9c52 100644
--- a/datafusion/core/Cargo.toml
+++ b/datafusion/core/Cargo.toml
@@ -56,7 +56,7 @@ unicode_expressions = ["datafusion-physical-expr/regex_expressions", "datafusion
 [dependencies]
 ahash = { version = "0.8", default-features = false, features = ["runtime-rng"] }
 apache-avro = { version = "0.14", optional = true }
-arrow = { version = "26.0.0", features = ["prettyprint"] }
+arrow = { version = "27.0.0", features = ["prettyprint"] }
 async-compression = { version = "0.3.14", features = ["bzip2", "gzip", "futures-io", "tokio"] }
 async-trait = "0.1.41"
 bytes = "1.1"
@@ -81,7 +81,7 @@ num-traits = { version = "0.2", optional = true }
 num_cpus = "1.13.0"
 object_store = "0.5.0"
 parking_lot = "0.12"
-parquet = { version = "26.0.0", features = ["arrow", "async"] }
+parquet = { version = "27.0.0", features = ["arrow", "async"] }
 paste = "^1.0"
 percent-encoding = "2.2.0"
 pin-project-lite = "^0.2.7"
@@ -98,7 +98,7 @@ url = "2.2"
 uuid = { version = "1.0", features = ["v4"] }
 
 [dev-dependencies]
-arrow = { version = "26.0.0", features = ["prettyprint", "dyn_cmp_dict"] }
+arrow = { version = "27.0.0", features = ["prettyprint", "dyn_cmp_dict"] }
 async-trait = "0.1.53"
 criterion = "0.4"
 csv = "1.1.6"
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 2fe5bc31357..2559f6c58c2 100644
--- a/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
+++ b/datafusion/core/src/physical_plan/sorts/sort_preserving_merge.rs
@@ -356,7 +356,7 @@ impl SortPreservingMergeStream {
                 Ok(SortField::new_with_options(data_type, expr.options))
             })
             .collect::<Result<Vec<_>>>()?;
-        let row_converter = RowConverter::new(sort_fields);
+        let row_converter = RowConverter::new(sort_fields)?;
 
         Ok(Self {
             schema,
diff --git a/datafusion/core/tests/sort_key_cursor.rs b/datafusion/core/tests/sort_key_cursor.rs
index c5e748c97bf..870d47b8260 100644
--- a/datafusion/core/tests/sort_key_cursor.rs
+++ b/datafusion/core/tests/sort_key_cursor.rs
@@ -26,7 +26,7 @@ use datafusion::physical_plan::sorts::{RowIndex, SortKeyCursor};
 
 #[test]
 fn test_single_column() {
-    let mut converter = RowConverter::new(vec![SortField::new(DataType::Int64)]);
+    let mut converter = RowConverter::new(vec![SortField::new(DataType::Int64)]).unwrap();
     let batch1 = int64_batch(vec![Some(1), Some(2), Some(5), Some(6)]);
     let batch2 = int64_batch(vec![Some(3), Some(4), Some(8), Some(9)]);
 
@@ -56,7 +56,7 @@ fn test_single_column() {
 
 #[test]
 fn test_stable_compare() {
-    let mut converter = RowConverter::new(vec![SortField::new(DataType::Int64)]);
+    let mut converter = RowConverter::new(vec![SortField::new(DataType::Int64)]).unwrap();
     // Validate ties are broken by the lower stream idx to ensure stable sort
     let batch1 = int64_batch(vec![Some(3), Some(4)]);
     let batch2 = int64_batch(vec![Some(3)]);
diff --git a/datafusion/expr/Cargo.toml b/datafusion/expr/Cargo.toml
index db4afdc2cfd..6e6fd13d560 100644
--- a/datafusion/expr/Cargo.toml
+++ b/datafusion/expr/Cargo.toml
@@ -36,7 +36,7 @@ path = "src/lib.rs"
 
 [dependencies]
 ahash = { version = "0.8", default-features = false, features = ["runtime-rng"] }
-arrow = { version = "26.0.0", default-features = false }
+arrow = { version = "27.0.0", default-features = false }
 datafusion-common = { path = "../common", version = "14.0.0" }
 log = "^0.4"
 sqlparser = "0.26"
diff --git a/datafusion/jit/Cargo.toml b/datafusion/jit/Cargo.toml
index 31aff38ae8a..e4bd5fc2e47 100644
--- a/datafusion/jit/Cargo.toml
+++ b/datafusion/jit/Cargo.toml
@@ -36,7 +36,7 @@ path = "src/lib.rs"
 jit = []
 
 [dependencies]
-arrow = { version = "26.0.0", default-features = false }
+arrow = { version = "27.0.0", default-features = false }
 cranelift = "0.89.0"
 cranelift-jit = "0.89.0"
 cranelift-module = "0.89.0"
diff --git a/datafusion/optimizer/Cargo.toml b/datafusion/optimizer/Cargo.toml
index 7238d435908..9cde4d1dded 100644
--- a/datafusion/optimizer/Cargo.toml
+++ b/datafusion/optimizer/Cargo.toml
@@ -37,7 +37,7 @@ default = ["unicode_expressions"]
 unicode_expressions = []
 
 [dependencies]
-arrow = { version = "26.0.0", features = ["prettyprint"] }
+arrow = { version = "27.0.0", features = ["prettyprint"] }
 async-trait = "0.1.41"
 chrono = { version = "0.4.23", default-features = false }
 datafusion-common = { path = "../common", version = "14.0.0" }
diff --git a/datafusion/physical-expr/Cargo.toml b/datafusion/physical-expr/Cargo.toml
index 388c52df434..2d2e0032d61 100644
--- a/datafusion/physical-expr/Cargo.toml
+++ b/datafusion/physical-expr/Cargo.toml
@@ -40,9 +40,9 @@ unicode_expressions = ["unicode-segmentation"]
 
 [dependencies]
 ahash = { version = "0.8", default-features = false, features = ["runtime-rng"] }
-arrow = { version = "26.0.0", features = ["prettyprint", "dyn_cmp_dict"] }
-arrow-buffer = "26.0.0"
-arrow-schema = "26.0.0"
+arrow = { version = "27.0.0", features = ["prettyprint", "dyn_cmp_dict"] }
+arrow-buffer = "27.0.0"
+arrow-schema = "27.0.0"
 blake2 = { version = "^0.10.2", optional = true }
 blake3 = { version = "1.0", optional = true }
 chrono = { version = "0.4.23", default-features = false }
@@ -63,7 +63,6 @@ unicode-segmentation = { version = "^1.7.1", optional = true }
 uuid = { version = "^1.2", features = ["v4"] }
 
 [dev-dependencies]
-arrow = { version = "26.0.0", features = ["prettyprint", "dyn_cmp_dict"] }
 criterion = "0.4"
 rand = "0.8"
 
diff --git a/datafusion/physical-expr/src/expressions/cast.rs b/datafusion/physical-expr/src/expressions/cast.rs
index 869c7e8bb1f..d0904da1023 100644
--- a/datafusion/physical-expr/src/expressions/cast.rs
+++ b/datafusion/physical-expr/src/expressions/cast.rs
@@ -572,7 +572,7 @@ mod tests {
                 Some(15000),
                 Some(25000),
                 Some(30000),
-                Some(11234),
+                Some(11235),
                 Some(55000),
             ],
             DEFAULT_DATAFUSION_CAST_OPTIONS
diff --git a/datafusion/physical-expr/src/expressions/try_cast.rs b/datafusion/physical-expr/src/expressions/try_cast.rs
index 299d29ec607..b36243b9177 100644
--- a/datafusion/physical-expr/src/expressions/try_cast.rs
+++ b/datafusion/physical-expr/src/expressions/try_cast.rs
@@ -466,7 +466,7 @@ mod tests {
                 Some(15000),
                 Some(25000),
                 Some(30000),
-                Some(11234),
+                Some(11235),
                 Some(55000),
             ]
         );
diff --git a/datafusion/proto/Cargo.toml b/datafusion/proto/Cargo.toml
index f1d00071006..95c7bf0f6bd 100644
--- a/datafusion/proto/Cargo.toml
+++ b/datafusion/proto/Cargo.toml
@@ -40,7 +40,7 @@ default = []
 json = ["pbjson", "serde", "serde_json"]
 
 [dependencies]
-arrow = "26.0.0"
+arrow = "27.0.0"
 datafusion = { path = "../core", version = "14.0.0" }
 datafusion-common = { path = "../common", version = "14.0.0" }
 datafusion-expr = { path = "../expr", version = "14.0.0" }
@@ -57,4 +57,4 @@ tokio = "1.18"
 [build-dependencies]
 # Pin these dependencies so that the generated output is deterministic
 pbjson-build = { version = "=0.5.1" }
-prost-build = { version = "=0.11.1" }
+prost-build = { version = "=0.11.2" }
diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs
index c84f9a179f7..f34cc5c2a11 100644
--- a/datafusion/proto/src/generated/prost.rs
+++ b/datafusion/proto/src/generated/prost.rs
@@ -1,400 +1,413 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ColumnRelation {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub relation: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Column {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub name: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub relation: ::core::option::Option<ColumnRelation>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DfField {
-    #[prost(message, optional, tag="1")]
+    #[prost(message, optional, tag = "1")]
     pub field: ::core::option::Option<Field>,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub qualifier: ::core::option::Option<ColumnRelation>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DfSchema {
-    #[prost(message, repeated, tag="1")]
+    #[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>,
+    #[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
 #[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")]
+    #[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"
+    )]
     pub logical_plan_type: ::core::option::Option<logical_plan_node::LogicalPlanType>,
 }
 /// Nested message and enum types in `LogicalPlanNode`.
 pub mod logical_plan_node {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum LogicalPlanType {
-        #[prost(message, tag="1")]
+        #[prost(message, tag = "1")]
         ListingScan(super::ListingTableScanNode),
-        #[prost(message, tag="3")]
+        #[prost(message, tag = "3")]
         Projection(::prost::alloc::boxed::Box<super::ProjectionNode>),
-        #[prost(message, tag="4")]
+        #[prost(message, tag = "4")]
         Selection(::prost::alloc::boxed::Box<super::SelectionNode>),
-        #[prost(message, tag="5")]
+        #[prost(message, tag = "5")]
         Limit(::prost::alloc::boxed::Box<super::LimitNode>),
-        #[prost(message, tag="6")]
+        #[prost(message, tag = "6")]
         Aggregate(::prost::alloc::boxed::Box<super::AggregateNode>),
-        #[prost(message, tag="7")]
+        #[prost(message, tag = "7")]
         Join(::prost::alloc::boxed::Box<super::JoinNode>),
-        #[prost(message, tag="8")]
+        #[prost(message, tag = "8")]
         Sort(::prost::alloc::boxed::Box<super::SortNode>),
-        #[prost(message, tag="9")]
+        #[prost(message, tag = "9")]
         Repartition(::prost::alloc::boxed::Box<super::RepartitionNode>),
-        #[prost(message, tag="10")]
+        #[prost(message, tag = "10")]
         EmptyRelation(super::EmptyRelationNode),
-        #[prost(message, tag="11")]
+        #[prost(message, tag = "11")]
         CreateExternalTable(super::CreateExternalTableNode),
-        #[prost(message, tag="12")]
+        #[prost(message, tag = "12")]
         Explain(::prost::alloc::boxed::Box<super::ExplainNode>),
-        #[prost(message, tag="13")]
+        #[prost(message, tag = "13")]
         Window(::prost::alloc::boxed::Box<super::WindowNode>),
-        #[prost(message, tag="14")]
+        #[prost(message, tag = "14")]
         Analyze(::prost::alloc::boxed::Box<super::AnalyzeNode>),
-        #[prost(message, tag="15")]
+        #[prost(message, tag = "15")]
         CrossJoin(::prost::alloc::boxed::Box<super::CrossJoinNode>),
-        #[prost(message, tag="16")]
+        #[prost(message, tag = "16")]
         Values(super::ValuesNode),
-        #[prost(message, tag="17")]
+        #[prost(message, tag = "17")]
         Extension(super::LogicalExtensionNode),
-        #[prost(message, tag="18")]
+        #[prost(message, tag = "18")]
         CreateCatalogSchema(super::CreateCatalogSchemaNode),
-        #[prost(message, tag="19")]
+        #[prost(message, tag = "19")]
         Union(super::UnionNode),
-        #[prost(message, tag="20")]
+        #[prost(message, tag = "20")]
         CreateCatalog(super::CreateCatalogNode),
-        #[prost(message, tag="21")]
+        #[prost(message, tag = "21")]
         SubqueryAlias(::prost::alloc::boxed::Box<super::SubqueryAliasNode>),
-        #[prost(message, tag="22")]
+        #[prost(message, tag = "22")]
         CreateView(::prost::alloc::boxed::Box<super::CreateViewNode>),
-        #[prost(message, tag="23")]
+        #[prost(message, tag = "23")]
         Distinct(::prost::alloc::boxed::Box<super::DistinctNode>),
-        #[prost(message, tag="24")]
+        #[prost(message, tag = "24")]
         ViewScan(::prost::alloc::boxed::Box<super::ViewTableScanNode>),
-        #[prost(message, tag="25")]
+        #[prost(message, tag = "25")]
         CustomScan(super::CustomTableScanNode),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct LogicalExtensionNode {
-    #[prost(bytes="vec", tag="1")]
+    #[prost(bytes = "vec", tag = "1")]
     pub node: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub inputs: ::prost::alloc::vec::Vec<LogicalPlanNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ProjectionColumns {
-    #[prost(string, repeated, tag="1")]
+    #[prost(string, repeated, tag = "1")]
     pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CsvFormat {
-    #[prost(bool, tag="1")]
+    #[prost(bool, tag = "1")]
     pub has_header: bool,
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub delimiter: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ParquetFormat {
-    #[prost(bool, tag="1")]
+    #[prost(bool, tag = "1")]
     pub enable_pruning: bool,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct AvroFormat {
-}
+pub struct AvroFormat {}
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ListingTableScanNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub table_name: ::prost::alloc::string::String,
-    #[prost(string, repeated, tag="2")]
+    #[prost(string, repeated, tag = "2")]
     pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(string, tag="3")]
+    #[prost(string, tag = "3")]
     pub file_extension: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="4")]
+    #[prost(message, optional, tag = "4")]
     pub projection: ::core::option::Option<ProjectionColumns>,
-    #[prost(message, optional, tag="5")]
+    #[prost(message, optional, tag = "5")]
     pub schema: ::core::option::Option<Schema>,
-    #[prost(message, repeated, tag="6")]
+    #[prost(message, repeated, tag = "6")]
     pub filters: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(string, repeated, tag="7")]
+    #[prost(string, repeated, tag = "7")]
     pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(bool, tag="8")]
+    #[prost(bool, tag = "8")]
     pub collect_stat: bool,
-    #[prost(uint32, tag="9")]
+    #[prost(uint32, tag = "9")]
     pub target_partitions: u32,
-    #[prost(message, repeated, tag="13")]
+    #[prost(message, repeated, tag = "13")]
     pub file_sort_order: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(oneof="listing_table_scan_node::FileFormatType", tags="10, 11, 12")]
-    pub file_format_type: ::core::option::Option<listing_table_scan_node::FileFormatType>,
+    #[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 {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum FileFormatType {
-        #[prost(message, tag="10")]
+        #[prost(message, tag = "10")]
         Csv(super::CsvFormat),
-        #[prost(message, tag="11")]
+        #[prost(message, tag = "11")]
         Parquet(super::ParquetFormat),
-        #[prost(message, tag="12")]
+        #[prost(message, tag = "12")]
         Avro(super::AvroFormat),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ViewTableScanNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub table_name: ::prost::alloc::string::String,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, tag="3")]
+    #[prost(message, optional, tag = "3")]
     pub schema: ::core::option::Option<Schema>,
-    #[prost(message, optional, tag="4")]
+    #[prost(message, optional, tag = "4")]
     pub projection: ::core::option::Option<ProjectionColumns>,
-    #[prost(string, tag="5")]
+    #[prost(string, tag = "5")]
     pub definition: ::prost::alloc::string::String,
 }
 /// Logical Plan to Scan a CustomTableProvider registered at runtime
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CustomTableScanNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub table_name: ::prost::alloc::string::String,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub projection: ::core::option::Option<ProjectionColumns>,
-    #[prost(message, optional, tag="3")]
+    #[prost(message, optional, tag = "3")]
     pub schema: ::core::option::Option<Schema>,
-    #[prost(message, repeated, tag="4")]
+    #[prost(message, repeated, tag = "4")]
     pub filters: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(bytes="vec", tag="5")]
+    #[prost(bytes = "vec", tag = "5")]
     pub custom_table_data: ::prost::alloc::vec::Vec<u8>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ProjectionNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(oneof="projection_node::OptionalAlias", tags="3")]
+    #[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 {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum OptionalAlias {
-        #[prost(string, tag="3")]
+        #[prost(string, tag = "3")]
         Alias(::prost::alloc::string::String),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SelectionNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub expr: ::core::option::Option<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SortNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag="2")]
+    #[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")]
+    #[prost(int64, tag = "3")]
     pub fetch: i64,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct RepartitionNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(oneof="repartition_node::PartitionMethod", tags="2, 3")]
+    #[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 {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum PartitionMethod {
-        #[prost(uint64, tag="2")]
+        #[prost(uint64, tag = "2")]
         RoundRobin(u64),
-        #[prost(message, tag="3")]
+        #[prost(message, tag = "3")]
         Hash(super::HashRepartition),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct HashRepartition {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub hash_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(uint64, tag="2")]
+    #[prost(uint64, tag = "2")]
     pub partition_count: u64,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EmptyRelationNode {
-    #[prost(bool, tag="1")]
+    #[prost(bool, tag = "1")]
     pub produce_one_row: bool,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CreateExternalTableNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub name: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub location: ::prost::alloc::string::String,
-    #[prost(string, tag="3")]
+    #[prost(string, tag = "3")]
     pub file_type: ::prost::alloc::string::String,
-    #[prost(bool, tag="4")]
+    #[prost(bool, tag = "4")]
     pub has_header: bool,
-    #[prost(message, optional, tag="5")]
+    #[prost(message, optional, tag = "5")]
     pub schema: ::core::option::Option<DfSchema>,
-    #[prost(string, repeated, tag="6")]
+    #[prost(string, repeated, tag = "6")]
     pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(bool, tag="7")]
+    #[prost(bool, tag = "7")]
     pub if_not_exists: bool,
-    #[prost(string, tag="8")]
+    #[prost(string, tag = "8")]
     pub delimiter: ::prost::alloc::string::String,
-    #[prost(string, tag="9")]
+    #[prost(string, tag = "9")]
     pub definition: ::prost::alloc::string::String,
-    #[prost(string, tag="10")]
+    #[prost(string, tag = "10")]
     pub file_compression_type: ::prost::alloc::string::String,
-    #[prost(map="string, string", tag="11")]
-    pub options: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+    #[prost(map = "string, string", tag = "11")]
+    pub options: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost::alloc::string::String,
+    >,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CreateCatalogSchemaNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub schema_name: ::prost::alloc::string::String,
-    #[prost(bool, tag="2")]
+    #[prost(bool, tag = "2")]
     pub if_not_exists: bool,
-    #[prost(message, optional, tag="3")]
+    #[prost(message, optional, tag = "3")]
     pub schema: ::core::option::Option<DfSchema>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CreateCatalogNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub catalog_name: ::prost::alloc::string::String,
-    #[prost(bool, tag="2")]
+    #[prost(bool, tag = "2")]
     pub if_not_exists: bool,
-    #[prost(message, optional, tag="3")]
+    #[prost(message, optional, tag = "3")]
     pub schema: ::core::option::Option<DfSchema>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CreateViewNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub name: ::prost::alloc::string::String,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(bool, tag="3")]
+    #[prost(bool, tag = "3")]
     pub or_replace: bool,
-    #[prost(string, tag="4")]
+    #[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
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ValuesNode {
-    #[prost(uint64, tag="1")]
+    #[prost(uint64, tag = "1")]
     pub n_cols: u64,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub values_list: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct AnalyzeNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(bool, tag="2")]
+    #[prost(bool, tag = "2")]
     pub verbose: bool,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ExplainNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(bool, tag="2")]
+    #[prost(bool, tag = "2")]
     pub verbose: bool,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct AggregateNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub group_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(message, repeated, tag="3")]
+    #[prost(message, repeated, tag = "3")]
     pub aggr_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WindowNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub window_expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct JoinNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub left: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub right: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(enumeration="JoinType", tag="3")]
+    #[prost(enumeration = "JoinType", tag = "3")]
     pub join_type: i32,
-    #[prost(enumeration="JoinConstraint", tag="4")]
+    #[prost(enumeration = "JoinConstraint", tag = "4")]
     pub join_constraint: i32,
-    #[prost(message, repeated, tag="5")]
+    #[prost(message, repeated, tag = "5")]
     pub left_join_column: ::prost::alloc::vec::Vec<Column>,
-    #[prost(message, repeated, tag="6")]
+    #[prost(message, repeated, tag = "6")]
     pub right_join_column: ::prost::alloc::vec::Vec<Column>,
-    #[prost(bool, tag="7")]
+    #[prost(bool, tag = "7")]
     pub null_equals_null: bool,
-    #[prost(message, optional, tag="8")]
+    #[prost(message, optional, tag = "8")]
     pub filter: ::core::option::Option<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DistinctNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UnionNode {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub inputs: ::prost::alloc::vec::Vec<LogicalPlanNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CrossJoinNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub left: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub right: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct LimitNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[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")]
+    #[prost(int64, tag = "2")]
     pub skip: i64,
     /// Maximum number of rows to fetch; negative means no limit
-    #[prost(int64, tag="3")]
+    #[prost(int64, tag = "3")]
     pub fetch: i64,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SelectionExecNode {
-    #[prost(message, optional, tag="1")]
+    #[prost(message, optional, tag = "1")]
     pub expr: ::core::option::Option<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SubqueryAliasNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub input: ::core::option::Option<::prost::alloc::boxed::Box<LogicalPlanNode>>,
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub alias: ::prost::alloc::string::String,
 }
 /// logical expressions
 #[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")]
+    #[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"
+    )]
     pub expr_type: ::core::option::Option<logical_expr_node::ExprType>,
 }
 /// Nested message and enum types in `LogicalExprNode`.
@@ -402,158 +415,158 @@ pub mod logical_expr_node {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum ExprType {
         /// column references
-        #[prost(message, tag="1")]
+        #[prost(message, tag = "1")]
         Column(super::Column),
         /// alias
-        #[prost(message, tag="2")]
+        #[prost(message, tag = "2")]
         Alias(::prost::alloc::boxed::Box<super::AliasNode>),
-        #[prost(message, tag="3")]
+        #[prost(message, tag = "3")]
         Literal(super::ScalarValue),
         /// binary expressions
-        #[prost(message, tag="4")]
+        #[prost(message, tag = "4")]
         BinaryExpr(super::BinaryExprNode),
         /// aggregate expressions
-        #[prost(message, tag="5")]
+        #[prost(message, tag = "5")]
         AggregateExpr(::prost::alloc::boxed::Box<super::AggregateExprNode>),
         /// null checks
-        #[prost(message, tag="6")]
+        #[prost(message, tag = "6")]
         IsNullExpr(::prost::alloc::boxed::Box<super::IsNull>),
-        #[prost(message, tag="7")]
+        #[prost(message, tag = "7")]
         IsNotNullExpr(::prost::alloc::boxed::Box<super::IsNotNull>),
-        #[prost(message, tag="8")]
+        #[prost(message, tag = "8")]
         NotExpr(::prost::alloc::boxed::Box<super::Not>),
-        #[prost(message, tag="9")]
+        #[prost(message, tag = "9")]
         Between(::prost::alloc::boxed::Box<super::BetweenNode>),
-        #[prost(message, tag="10")]
+        #[prost(message, tag = "10")]
         Case(::prost::alloc::boxed::Box<super::CaseNode>),
-        #[prost(message, tag="11")]
+        #[prost(message, tag = "11")]
         Cast(::prost::alloc::boxed::Box<super::CastNode>),
-        #[prost(message, tag="12")]
+        #[prost(message, tag = "12")]
         Sort(::prost::alloc::boxed::Box<super::SortExprNode>),
-        #[prost(message, tag="13")]
+        #[prost(message, tag = "13")]
         Negative(::prost::alloc::boxed::Box<super::NegativeNode>),
-        #[prost(message, tag="14")]
+        #[prost(message, tag = "14")]
         InList(::prost::alloc::boxed::Box<super::InListNode>),
-        #[prost(bool, tag="15")]
+        #[prost(bool, tag = "15")]
         Wildcard(bool),
-        #[prost(message, tag="16")]
+        #[prost(message, tag = "16")]
         ScalarFunction(super::ScalarFunctionNode),
-        #[prost(message, tag="17")]
+        #[prost(message, tag = "17")]
         TryCast(::prost::alloc::boxed::Box<super::TryCastNode>),
         /// window expressions
-        #[prost(message, tag="18")]
+        #[prost(message, tag = "18")]
         WindowExpr(::prost::alloc::boxed::Box<super::WindowExprNode>),
         /// AggregateUDF expressions
-        #[prost(message, tag="19")]
+        #[prost(message, tag = "19")]
         AggregateUdfExpr(::prost::alloc::boxed::Box<super::AggregateUdfExprNode>),
         /// Scalar UDF expressions
-        #[prost(message, tag="20")]
+        #[prost(message, tag = "20")]
         ScalarUdfExpr(super::ScalarUdfExprNode),
-        #[prost(message, tag="21")]
+        #[prost(message, tag = "21")]
         GetIndexedField(::prost::alloc::boxed::Box<super::GetIndexedField>),
-        #[prost(message, tag="22")]
+        #[prost(message, tag = "22")]
         GroupingSet(super::GroupingSetNode),
-        #[prost(message, tag="23")]
+        #[prost(message, tag = "23")]
         Cube(super::CubeNode),
-        #[prost(message, tag="24")]
+        #[prost(message, tag = "24")]
         Rollup(super::RollupNode),
-        #[prost(message, tag="25")]
+        #[prost(message, tag = "25")]
         IsTrue(::prost::alloc::boxed::Box<super::IsTrue>),
-        #[prost(message, tag="26")]
+        #[prost(message, tag = "26")]
         IsFalse(::prost::alloc::boxed::Box<super::IsFalse>),
-        #[prost(message, tag="27")]
+        #[prost(message, tag = "27")]
         IsUnknown(::prost::alloc::boxed::Box<super::IsUnknown>),
-        #[prost(message, tag="28")]
+        #[prost(message, tag = "28")]
         IsNotTrue(::prost::alloc::boxed::Box<super::IsNotTrue>),
-        #[prost(message, tag="29")]
+        #[prost(message, tag = "29")]
         IsNotFalse(::prost::alloc::boxed::Box<super::IsNotFalse>),
-        #[prost(message, tag="30")]
+        #[prost(message, tag = "30")]
         IsNotUnknown(::prost::alloc::boxed::Box<super::IsNotUnknown>),
-        #[prost(message, tag="31")]
+        #[prost(message, tag = "31")]
         Like(::prost::alloc::boxed::Box<super::LikeNode>),
-        #[prost(message, tag="32")]
+        #[prost(message, tag = "32")]
         Ilike(::prost::alloc::boxed::Box<super::ILikeNode>),
-        #[prost(message, tag="33")]
+        #[prost(message, tag = "33")]
         SimilarTo(::prost::alloc::boxed::Box<super::SimilarToNode>),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct LogicalExprList {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GroupingSetNode {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub expr: ::prost::alloc::vec::Vec<LogicalExprList>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CubeNode {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct RollupNode {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIndexedField {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub key: ::core::option::Option<ScalarValue>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsNull {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsNotNull {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsTrue {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsFalse {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsUnknown {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsNotTrue {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsNotFalse {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IsNotUnknown {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Not {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct AliasNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub alias: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -561,182 +574,182 @@ 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")]
+    #[prost(message, repeated, tag = "1")]
     pub operands: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(string, tag="3")]
+    #[prost(string, tag = "3")]
     pub op: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct NegativeNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct InListNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub list: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(bool, tag="3")]
+    #[prost(bool, tag = "3")]
     pub negated: bool,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ScalarFunctionNode {
-    #[prost(enumeration="ScalarFunction", tag="1")]
+    #[prost(enumeration = "ScalarFunction", tag = "1")]
     pub fun: i32,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct AggregateExprNode {
-    #[prost(enumeration="AggregateFunction", tag="1")]
+    #[prost(enumeration = "AggregateFunction", tag = "1")]
     pub aggr_function: i32,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub expr: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(bool, tag="3")]
+    #[prost(bool, tag = "3")]
     pub distinct: bool,
-    #[prost(message, optional, boxed, tag="4")]
+    #[prost(message, optional, boxed, tag = "4")]
     pub filter: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct AggregateUdfExprNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub fun_name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(message, optional, boxed, tag="3")]
+    #[prost(message, optional, boxed, tag = "3")]
     pub filter: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ScalarUdfExprNode {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub fun_name: ::prost::alloc::string::String,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub args: ::prost::alloc::vec::Vec<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WindowExprNode {
-    #[prost(message, optional, boxed, tag="4")]
+    #[prost(message, optional, boxed, tag = "4")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag="5")]
+    #[prost(message, repeated, tag = "5")]
     pub partition_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(message, repeated, tag="6")]
+    #[prost(message, repeated, tag = "6")]
     pub order_by: ::prost::alloc::vec::Vec<LogicalExprNode>,
-    #[prost(oneof="window_expr_node::WindowFunction", tags="1, 2")]
+    #[prost(oneof = "window_expr_node::WindowFunction", tags = "1, 2")]
     pub window_function: ::core::option::Option<window_expr_node::WindowFunction>,
     /// repeated LogicalExprNode filter = 7;
-    #[prost(oneof="window_expr_node::WindowFrame", tags="8")]
+    #[prost(oneof = "window_expr_node::WindowFrame", tags = "8")]
     pub window_frame: ::core::option::Option<window_expr_node::WindowFrame>,
 }
 /// Nested message and enum types in `WindowExprNode`.
 pub mod window_expr_node {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum WindowFunction {
-        #[prost(enumeration="super::AggregateFunction", tag="1")]
+        #[prost(enumeration = "super::AggregateFunction", tag = "1")]
         AggrFunction(i32),
         /// udaf = 3
-        #[prost(enumeration="super::BuiltInWindowFunction", tag="2")]
+        #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")]
         BuiltInFunction(i32),
     }
     /// repeated LogicalExprNode filter = 7;
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum WindowFrame {
-        #[prost(message, tag="8")]
+        #[prost(message, tag = "8")]
         Frame(super::WindowFrame),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BetweenNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(bool, tag="2")]
+    #[prost(bool, tag = "2")]
     pub negated: bool,
-    #[prost(message, optional, boxed, tag="3")]
+    #[prost(message, optional, boxed, tag = "3")]
     pub low: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag="4")]
+    #[prost(message, optional, boxed, tag = "4")]
     pub high: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct LikeNode {
-    #[prost(bool, tag="1")]
+    #[prost(bool, tag = "1")]
     pub negated: bool,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag="3")]
+    #[prost(message, optional, boxed, tag = "3")]
     pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag="4")]
+    #[prost(string, tag = "4")]
     pub escape_char: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ILikeNode {
-    #[prost(bool, tag="1")]
+    #[prost(bool, tag = "1")]
     pub negated: bool,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag="3")]
+    #[prost(message, optional, boxed, tag = "3")]
     pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag="4")]
+    #[prost(string, tag = "4")]
     pub escape_char: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SimilarToNode {
-    #[prost(bool, tag="1")]
+    #[prost(bool, tag = "1")]
     pub negated: bool,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, boxed, tag="3")]
+    #[prost(message, optional, boxed, tag = "3")]
     pub pattern: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(string, tag="4")]
+    #[prost(string, tag = "4")]
     pub escape_char: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CaseNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub when_then_expr: ::prost::alloc::vec::Vec<WhenThen>,
-    #[prost(message, optional, boxed, tag="3")]
+    #[prost(message, optional, boxed, tag = "3")]
     pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WhenThen {
-    #[prost(message, optional, tag="1")]
+    #[prost(message, optional, tag = "1")]
     pub when_expr: ::core::option::Option<LogicalExprNode>,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub then_expr: ::core::option::Option<LogicalExprNode>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CastNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub arrow_type: ::core::option::Option<ArrowType>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct TryCastNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub arrow_type: ::core::option::Option<ArrowType>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SortExprNode {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub expr: ::core::option::Option<::prost::alloc::boxed::Box<LogicalExprNode>>,
-    #[prost(bool, tag="2")]
+    #[prost(bool, tag = "2")]
     pub asc: bool,
-    #[prost(bool, tag="3")]
+    #[prost(bool, tag = "3")]
     pub nulls_first: bool,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WindowFrame {
-    #[prost(enumeration="WindowFrameUnits", tag="1")]
+    #[prost(enumeration = "WindowFrameUnits", tag = "1")]
     pub window_frame_units: i32,
-    #[prost(message, optional, tag="2")]
+    #[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")]
+    #[prost(oneof = "window_frame::EndBound", tags = "3")]
     pub end_bound: ::core::option::Option<window_frame::EndBound>,
 }
 /// Nested message and enum types in `WindowFrame`.
@@ -745,137 +758,133 @@ pub mod window_frame {
     /// 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>)
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum EndBound {
-        #[prost(message, tag="3")]
+        #[prost(message, tag = "3")]
         Bound(super::WindowFrameBound),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WindowFrameBound {
-    #[prost(enumeration="WindowFrameBoundType", tag="1")]
+    #[prost(enumeration = "WindowFrameBoundType", tag = "1")]
     pub window_frame_bound_type: i32,
-    #[prost(message, optional, tag="2")]
+    #[prost(message, optional, tag = "2")]
     pub bound_value: ::core::option::Option<ScalarValue>,
 }
-// /////////////////////////////////////////////////////////////////////////////////////////////////
-// Arrow Data Types
-// /////////////////////////////////////////////////////////////////////////////////////////////////
-
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Schema {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub columns: ::prost::alloc::vec::Vec<Field>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Field {
     /// name of the field
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub name: ::prost::alloc::string::String,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub arrow_type: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
-    #[prost(bool, tag="3")]
+    #[prost(bool, tag = "3")]
     pub nullable: bool,
     /// for complex data types like structs, unions
-    #[prost(message, repeated, tag="4")]
+    #[prost(message, repeated, tag = "4")]
     pub children: ::prost::alloc::vec::Vec<Field>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FixedSizeBinary {
-    #[prost(int32, tag="1")]
+    #[prost(int32, tag = "1")]
     pub length: i32,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Timestamp {
-    #[prost(enumeration="TimeUnit", tag="1")]
+    #[prost(enumeration = "TimeUnit", tag = "1")]
     pub time_unit: i32,
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub timezone: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Decimal {
-    #[prost(uint64, tag="1")]
+    #[prost(uint64, tag = "1")]
     pub whole: u64,
-    #[prost(uint64, tag="2")]
+    #[prost(uint64, tag = "2")]
     pub fractional: u64,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct List {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FixedSizeList {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub field_type: ::core::option::Option<::prost::alloc::boxed::Box<Field>>,
-    #[prost(int32, tag="2")]
+    #[prost(int32, tag = "2")]
     pub list_size: i32,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Dictionary {
-    #[prost(message, optional, boxed, tag="1")]
+    #[prost(message, optional, boxed, tag = "1")]
     pub key: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub value: ::core::option::Option<::prost::alloc::boxed::Box<ArrowType>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Struct {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub sub_field_types: ::prost::alloc::vec::Vec<Field>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Union {
-    #[prost(message, repeated, tag="1")]
+    #[prost(message, repeated, tag = "1")]
     pub union_types: ::prost::alloc::vec::Vec<Field>,
-    #[prost(enumeration="UnionMode", tag="2")]
+    #[prost(enumeration = "UnionMode", tag = "2")]
     pub union_mode: i32,
-    #[prost(int32, repeated, tag="3")]
+    #[prost(int32, repeated, tag = "3")]
     pub type_ids: ::prost::alloc::vec::Vec<i32>,
 }
 #[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")]
+    #[prost(bool, tag = "3")]
     pub is_null: bool,
-    #[prost(message, optional, tag="1")]
+    #[prost(message, optional, tag = "1")]
     pub field: ::core::option::Option<Field>,
-    #[prost(message, repeated, tag="2")]
+    #[prost(message, repeated, tag = "2")]
     pub values: ::prost::alloc::vec::Vec<ScalarValue>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ScalarTimestampValue {
-    #[prost(string, tag="5")]
+    #[prost(string, tag = "5")]
     pub timezone: ::prost::alloc::string::String,
-    #[prost(oneof="scalar_timestamp_value::Value", tags="1, 2, 3, 4")]
+    #[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 {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum Value {
-        #[prost(int64, tag="1")]
+        #[prost(int64, tag = "1")]
         TimeMicrosecondValue(i64),
-        #[prost(int64, tag="2")]
+        #[prost(int64, tag = "2")]
         TimeNanosecondValue(i64),
-        #[prost(int64, tag="3")]
+        #[prost(int64, tag = "3")]
         TimeSecondValue(i64),
-        #[prost(int64, tag="4")]
+        #[prost(int64, tag = "4")]
         TimeMillisecondValue(i64),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ScalarDictionaryValue {
-    #[prost(message, optional, tag="1")]
+    #[prost(message, optional, tag = "1")]
     pub index_type: ::core::option::Option<ArrowType>,
-    #[prost(message, optional, boxed, tag="2")]
+    #[prost(message, optional, boxed, tag = "2")]
     pub value: ::core::option::Option<::prost::alloc::boxed::Box<ScalarValue>>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct IntervalMonthDayNanoValue {
-    #[prost(int32, tag="1")]
+    #[prost(int32, tag = "1")]
     pub months: i32,
-    #[prost(int32, tag="2")]
+    #[prost(int32, tag = "2")]
     pub days: i32,
-    #[prost(int64, tag="3")]
+    #[prost(int64, tag = "3")]
     pub nanos: i64,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -883,21 +892,24 @@ 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")]
+    #[prost(message, repeated, tag = "2")]
     pub field_values: ::prost::alloc::vec::Vec<ScalarValue>,
-    #[prost(message, repeated, tag="3")]
+    #[prost(message, repeated, tag = "3")]
     pub fields: ::prost::alloc::vec::Vec<Field>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ScalarFixedSizeBinary {
-    #[prost(bytes="vec", tag="1")]
+    #[prost(bytes = "vec", tag = "1")]
     pub values: ::prost::alloc::vec::Vec<u8>,
-    #[prost(int32, tag="2")]
+    #[prost(int32, tag = "2")]
     pub length: i32,
 }
 #[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, 17, 20, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34")]
+    #[prost(
+        oneof = "scalar_value::Value",
+        tags = "33, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 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`.
@@ -906,79 +918,82 @@ pub mod scalar_value {
     pub enum Value {
         /// was PrimitiveScalarType null_value = 19;
         /// Null value of any type
-        #[prost(message, tag="33")]
+        #[prost(message, tag = "33")]
         NullValue(super::ArrowType),
-        #[prost(bool, tag="1")]
+        #[prost(bool, tag = "1")]
         BoolValue(bool),
-        #[prost(string, tag="2")]
+        #[prost(string, tag = "2")]
         Utf8Value(::prost::alloc::string::String),
-        #[prost(string, tag="3")]
+        #[prost(string, tag = "3")]
         LargeUtf8Value(::prost::alloc::string::String),
-        #[prost(int32, tag="4")]
+        #[prost(int32, tag = "4")]
         Int8Value(i32),
-        #[prost(int32, tag="5")]
+        #[prost(int32, tag = "5")]
         Int16Value(i32),
-        #[prost(int32, tag="6")]
+        #[prost(int32, tag = "6")]
         Int32Value(i32),
-        #[prost(int64, tag="7")]
+        #[prost(int64, tag = "7")]
         Int64Value(i64),
-        #[prost(uint32, tag="8")]
+        #[prost(uint32, tag = "8")]
         Uint8Value(u32),
-        #[prost(uint32, tag="9")]
+        #[prost(uint32, tag = "9")]
         Uint16Value(u32),
-        #[prost(uint32, tag="10")]
+        #[prost(uint32, tag = "10")]
         Uint32Value(u32),
-        #[prost(uint64, tag="11")]
+        #[prost(uint64, tag = "11")]
         Uint64Value(u64),
-        #[prost(float, tag="12")]
+        #[prost(float, tag = "12")]
         Float32Value(f32),
-        #[prost(double, tag="13")]
+        #[prost(double, tag = "13")]
         Float64Value(f64),
         /// Literal Date32 value always has a unit of day
-        #[prost(int32, tag="14")]
+        #[prost(int32, tag = "14")]
         Date32Value(i32),
         /// WAS: ScalarType null_list_value = 18;
-        #[prost(message, tag="17")]
+        #[prost(message, tag = "17")]
         ListValue(super::ScalarListValue),
-        #[prost(message, tag="20")]
+        #[prost(message, tag = "20")]
         Decimal128Value(super::Decimal128),
-        #[prost(int64, tag="21")]
+        #[prost(int64, tag = "21")]
         Date64Value(i64),
-        #[prost(int32, tag="24")]
+        #[prost(int32, tag = "24")]
         IntervalYearmonthValue(i32),
-        #[prost(int64, tag="25")]
+        #[prost(int64, tag = "25")]
         IntervalDaytimeValue(i64),
-        #[prost(message, tag="26")]
+        #[prost(message, tag = "26")]
         TimestampValue(super::ScalarTimestampValue),
-        #[prost(message, tag="27")]
+        #[prost(message, tag = "27")]
         DictionaryValue(::prost::alloc::boxed::Box<super::ScalarDictionaryValue>),
-        #[prost(bytes, tag="28")]
+        #[prost(bytes, tag = "28")]
         BinaryValue(::prost::alloc::vec::Vec<u8>),
-        #[prost(bytes, tag="29")]
+        #[prost(bytes, tag = "29")]
         LargeBinaryValue(::prost::alloc::vec::Vec<u8>),
-        #[prost(int64, tag="30")]
+        #[prost(int64, tag = "30")]
         Time64Value(i64),
-        #[prost(message, tag="31")]
+        #[prost(message, tag = "31")]
         IntervalMonthDayNano(super::IntervalMonthDayNanoValue),
-        #[prost(message, tag="32")]
+        #[prost(message, tag = "32")]
         StructValue(super::StructValue),
-        #[prost(message, tag="34")]
+        #[prost(message, tag = "34")]
         FixedSizeBinaryValue(super::ScalarFixedSizeBinary),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Decimal128 {
-    #[prost(bytes="vec", tag="1")]
+    #[prost(bytes = "vec", tag = "1")]
     pub value: ::prost::alloc::vec::Vec<u8>,
-    #[prost(int64, tag="2")]
+    #[prost(int64, tag = "2")]
     pub p: i64,
-    #[prost(int64, tag="3")]
+    #[prost(int64, tag = "3")]
     pub s: i64,
 }
 /// Serialized data type
 #[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")]
+    #[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"
+    )]
     pub arrow_type_enum: ::core::option::Option<arrow_type::ArrowTypeEnum>,
 }
 /// Nested message and enum types in `ArrowType`.
@@ -986,73 +1001,73 @@ pub mod arrow_type {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum ArrowTypeEnum {
         /// arrow::Type::NA
-        #[prost(message, tag="1")]
+        #[prost(message, tag = "1")]
         None(super::EmptyMessage),
         /// arrow::Type::BOOL
-        #[prost(message, tag="2")]
+        #[prost(message, tag = "2")]
         Bool(super::EmptyMessage),
         /// arrow::Type::UINT8
-        #[prost(message, tag="3")]
+        #[prost(message, tag = "3")]
         Uint8(super::EmptyMessage),
         /// arrow::Type::INT8
-        #[prost(message, tag="4")]
+        #[prost(message, tag = "4")]
         Int8(super::EmptyMessage),
         /// represents arrow::Type fields in src/arrow/type.h
-        #[prost(message, tag="5")]
+        #[prost(message, tag = "5")]
         Uint16(super::EmptyMessage),
-        #[prost(message, tag="6")]
+        #[prost(message, tag = "6")]
         Int16(super::EmptyMessage),
-        #[prost(message, tag="7")]
+        #[prost(message, tag = "7")]
         Uint32(super::EmptyMessage),
-        #[prost(message, tag="8")]
+        #[prost(message, tag = "8")]
         Int32(super::EmptyMessage),
-        #[prost(message, tag="9")]
+        #[prost(message, tag = "9")]
         Uint64(super::EmptyMessage),
-        #[prost(message, tag="10")]
+        #[prost(message, tag = "10")]
         Int64(super::EmptyMessage),
-        #[prost(message, tag="11")]
+        #[prost(message, tag = "11")]
         Float16(super::EmptyMessage),
-        #[prost(message, tag="12")]
+        #[prost(message, tag = "12")]
         Float32(super::EmptyMessage),
-        #[prost(message, tag="13")]
+        #[prost(message, tag = "13")]
         Float64(super::EmptyMessage),
-        #[prost(message, tag="14")]
+        #[prost(message, tag = "14")]
         Utf8(super::EmptyMessage),
-        #[prost(message, tag="32")]
+        #[prost(message, tag = "32")]
         LargeUtf8(super::EmptyMessage),
-        #[prost(message, tag="15")]
+        #[prost(message, tag = "15")]
         Binary(super::EmptyMessage),
-        #[prost(int32, tag="16")]
+        #[prost(int32, tag = "16")]
         FixedSizeBinary(i32),
-        #[prost(message, tag="31")]
+        #[prost(message, tag = "31")]
         LargeBinary(super::EmptyMessage),
-        #[prost(message, tag="17")]
+        #[prost(message, tag = "17")]
         Date32(super::EmptyMessage),
-        #[prost(message, tag="18")]
+        #[prost(message, tag = "18")]
         Date64(super::EmptyMessage),
-        #[prost(enumeration="super::TimeUnit", tag="19")]
+        #[prost(enumeration = "super::TimeUnit", tag = "19")]
         Duration(i32),
-        #[prost(message, tag="20")]
+        #[prost(message, tag = "20")]
         Timestamp(super::Timestamp),
-        #[prost(enumeration="super::TimeUnit", tag="21")]
+        #[prost(enumeration = "super::TimeUnit", tag = "21")]
         Time32(i32),
-        #[prost(enumeration="super::TimeUnit", tag="22")]
+        #[prost(enumeration = "super::TimeUnit", tag = "22")]
         Time64(i32),
-        #[prost(enumeration="super::IntervalUnit", tag="23")]
+        #[prost(enumeration = "super::IntervalUnit", tag = "23")]
         Interval(i32),
-        #[prost(message, tag="24")]
+        #[prost(message, tag = "24")]
         Decimal(super::Decimal),
-        #[prost(message, tag="25")]
+        #[prost(message, tag = "25")]
         List(::prost::alloc::boxed::Box<super::List>),
-        #[prost(message, tag="26")]
+        #[prost(message, tag = "26")]
         LargeList(::prost::alloc::boxed::Box<super::List>),
-        #[prost(message, tag="27")]
+        #[prost(message, tag = "27")]
         FixedSizeList(::prost::alloc::boxed::Box<super::FixedSizeList>),
-        #[prost(message, tag="28")]
+        #[prost(message, tag = "28")]
         Struct(super::Struct),
-        #[prost(message, tag="29")]
+        #[prost(message, tag = "29")]
         Union(super::Union),
-        #[prost(message, tag="30")]
+        #[prost(message, tag = "30")]
         Dictionary(::prost::alloc::boxed::Box<super::Dictionary>),
     }
 }
@@ -1066,46 +1081,45 @@ pub mod arrow_type {
 ///    }
 /// }
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct EmptyMessage {
-}
+pub struct EmptyMessage {}
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OptimizedLogicalPlanType {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub optimizer_name: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OptimizedPhysicalPlanType {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub optimizer_name: ::prost::alloc::string::String,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct PlanType {
-    #[prost(oneof="plan_type::PlanTypeEnum", tags="1, 2, 3, 4, 5, 6")]
+    #[prost(oneof = "plan_type::PlanTypeEnum", tags = "1, 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 {
     #[derive(Clone, PartialEq, ::prost::Oneof)]
     pub enum PlanTypeEnum {
-        #[prost(message, tag="1")]
+        #[prost(message, tag = "1")]
         InitialLogicalPlan(super::EmptyMessage),
-        #[prost(message, tag="2")]
+        #[prost(message, tag = "2")]
         OptimizedLogicalPlan(super::OptimizedLogicalPlanType),
-        #[prost(message, tag="3")]
+        #[prost(message, tag = "3")]
         FinalLogicalPlan(super::EmptyMessage),
-        #[prost(message, tag="4")]
+        #[prost(message, tag = "4")]
         InitialPhysicalPlan(super::EmptyMessage),
-        #[prost(message, tag="5")]
+        #[prost(message, tag = "5")]
         OptimizedPhysicalPlan(super::OptimizedPhysicalPlanType),
-        #[prost(message, tag="6")]
+        #[prost(message, tag = "6")]
         FinalPhysicalPlan(super::EmptyMessage),
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct StringifiedPlan {
-    #[prost(message, optional, tag="1")]
+    #[prost(message, optional, tag = "1")]
     pub plan_type: ::core::option::Option<PlanType>,
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub plan: ::prost::alloc::string::String,
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -1362,7 +1376,9 @@ impl AggregateFunction {
             AggregateFunction::Correlation => "CORRELATION",
             AggregateFunction::ApproxPercentileCont => "APPROX_PERCENTILE_CONT",
             AggregateFunction::ApproxMedian => "APPROX_MEDIAN",
-            AggregateFunction::ApproxPercentileContWithWeight => "APPROX_PERCENTILE_CONT_WITH_WEIGHT",
+            AggregateFunction::ApproxPercentileContWithWeight => {
+                "APPROX_PERCENTILE_CONT_WITH_WEIGHT"
+            }
             AggregateFunction::Grouping => "GROUPING",
             AggregateFunction::Median => "MEDIAN",
         }
diff --git a/datafusion/row/Cargo.toml b/datafusion/row/Cargo.toml
index 1e3e7b757ff..a6934cb6f5d 100644
--- a/datafusion/row/Cargo.toml
+++ b/datafusion/row/Cargo.toml
@@ -37,7 +37,7 @@ path = "src/lib.rs"
 jit = ["datafusion-jit"]
 
 [dependencies]
-arrow = "26.0.0"
+arrow = "27.0.0"
 datafusion-common = { path = "../common", version = "14.0.0" }
 datafusion-jit = { path = "../jit", version = "14.0.0", optional = true }
 paste = "^1.0"
diff --git a/datafusion/sql/Cargo.toml b/datafusion/sql/Cargo.toml
index 8939dc8e8ad..2c712ba86ab 100644
--- a/datafusion/sql/Cargo.toml
+++ b/datafusion/sql/Cargo.toml
@@ -37,7 +37,7 @@ default = ["unicode_expressions"]
 unicode_expressions = []
 
 [dependencies]
-arrow = { version = "26.0.0", default-features = false }
+arrow = { version = "27.0.0", default-features = false }
 datafusion-common = { path = "../common", version = "14.0.0" }
 datafusion-expr = { path = "../expr", version = "14.0.0" }
 sqlparser = "0.26"
diff --git a/parquet-test-utils/Cargo.toml b/parquet-test-utils/Cargo.toml
index 5d917490b95..48c7678adbc 100644
--- a/parquet-test-utils/Cargo.toml
+++ b/parquet-test-utils/Cargo.toml
@@ -25,4 +25,4 @@ edition = "2021"
 [dependencies]
 datafusion = { path = "../datafusion/core" }
 object_store = "0.5.0"
-parquet = "26.0.0"
+parquet = "27.0.0"
diff --git a/test-utils/Cargo.toml b/test-utils/Cargo.toml
index ab168961e05..13cdaf03c51 100644
--- a/test-utils/Cargo.toml
+++ b/test-utils/Cargo.toml
@@ -23,7 +23,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-arrow = { version = "26.0.0", features = ["prettyprint"] }
+arrow = { version = "27.0.0", features = ["prettyprint"] }
 datafusion-common = { path = "../datafusion/common", version = "14.0.0" }
 env_logger = "0.9.0"
 rand = "0.8"