You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by tu...@apache.org on 2022/10/27 07:08:45 UTC
[arrow-datafusion] branch master updated: Vendor Generated Protobuf Code (#3947) (#3950)
This is an automated email from the ASF dual-hosted git repository.
tustvold pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git
The following commit(s) were added to refs/heads/master by this push:
new 11c5255ac Vendor Generated Protobuf Code (#3947) (#3950)
11c5255ac is described below
commit 11c5255ac01e12e6b4607fc51bc0f358fb1c245a
Author: Raphael Taylor-Davies <17...@users.noreply.github.com>
AuthorDate: Thu Oct 27 20:08:39 2022 +1300
Vendor Generated Protobuf Code (#3947) (#3950)
* Vendor generated protobuf code (#3947)
* RAT
* Fix build without json
* Review feedback
* Doc tweak
* Fix Arch install instructions
---
.gitattributes | 2 +
.github/workflows/rust.yml | 13 +-
datafusion/proto/Cargo.toml | 8 +-
datafusion/proto/build.rs | 44 +-
datafusion/proto/src/generated/.gitignore | 4 -
datafusion/proto/src/generated/mod.rs | 8 +-
datafusion/proto/src/generated/pbjson.rs | 13232 ++++++++++++++++++++++++++++
datafusion/proto/src/generated/prost.rs | 1512 ++++
dev/release/rat_exclude_files.txt | 2 +
docs/source/contributor-guide/index.md | 22 +
10 files changed, 14793 insertions(+), 54 deletions(-)
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 000000000..7ff0bbb6d
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+datafusion/proto/src/generated/prost.rs linguist-generated
+datafusion/proto/src/generated/pbjson.rs linguist-generated
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index f0fa56089..4c6daf755 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -81,16 +81,6 @@ jobs:
- uses: actions/checkout@v3
with:
submodules: true
- - name: Install protobuf compiler
- shell: bash
- run: |
- mkdir -p $HOME/d/protoc
- cd $HOME/d/protoc
- export PROTO_ZIP="protoc-21.4-linux-x86_64.zip"
- curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v21.4/$PROTO_ZIP
- unzip $PROTO_ZIP
- export PATH=$PATH:$HOME/d/protoc/bin
- protoc --version
- name: Cache Cargo
uses: actions/cache@v3
with:
@@ -124,7 +114,8 @@ jobs:
cargo run --example rewrite_expr
cargo run --example simple_udf
cargo run --example simple_udaf
-
+ - name: Verify Working Directory Clean
+ run: git diff --exit-code
integration-test:
name: "Compare to postgres"
diff --git a/datafusion/proto/Cargo.toml b/datafusion/proto/Cargo.toml
index ff2af33b2..bfd562cdc 100644
--- a/datafusion/proto/Cargo.toml
+++ b/datafusion/proto/Cargo.toml
@@ -28,8 +28,8 @@ keywords = ["arrow", "query", "sql"]
edition = "2021"
rust-version = "1.62"
-[package.metadata.docs.rs]
-rustc-args = ["--cfg", "docsrs"]
+# Exclude proto files so crates.io consumers don't need protoc
+exclude = ["*.proto"]
[lib]
name = "datafusion_proto"
@@ -37,7 +37,7 @@ path = "src/lib.rs"
[features]
default = []
-json = ["pbjson", "pbjson-build", "serde", "serde_json"]
+json = ["pbjson", "serde", "serde_json"]
[dependencies]
arrow = "25.0.0"
@@ -55,5 +55,5 @@ doc-comment = "0.3"
tokio = "1.18"
[build-dependencies]
-pbjson-build = { version = "0.5", optional = true }
+pbjson-build = { version = "0.5" }
prost-build = { version = "0.11.1" }
diff --git a/datafusion/proto/build.rs b/datafusion/proto/build.rs
index 3efd71350..87ee9589c 100644
--- a/datafusion/proto/build.rs
+++ b/datafusion/proto/build.rs
@@ -15,25 +15,29 @@
// specific language governing permissions and limitations
// under the License.
+use std::path::{Path, PathBuf};
+
type Error = Box<dyn std::error::Error>;
type Result<T, E = Error> = std::result::Result<T, E>;
fn main() -> Result<(), String> {
// for use in docker build where file changes can be wonky
println!("cargo:rerun-if-env-changed=FORCE_REBUILD");
- println!("cargo:rerun-if-changed=proto/datafusion.proto");
- build()?;
+ // We don't include the proto files in releases so that downstreams
+ // do not need to have PROTOC included
+ if Path::new("proto/datafusion.proto").exists() {
+ println!("cargo:rerun-if-changed=proto/datafusion.proto");
+ build()?
+ }
Ok(())
}
fn build() -> Result<(), String> {
- use std::io::Write;
-
- let out = std::path::PathBuf::from(
- std::env::var("OUT_DIR").expect("Cannot find OUT_DIR environment variable"),
- );
+ let out: PathBuf = std::env::var("OUT_DIR")
+ .expect("Cannot find OUT_DIR environment variable")
+ .into();
let descriptor_path = out.join("proto_descriptor.bin");
prost_build::Config::new()
@@ -43,11 +47,9 @@ fn build() -> Result<(), String> {
.compile_protos(&["proto/datafusion.proto"], &["proto"])
.map_err(|e| format!("protobuf compilation failed: {}", e))?;
- #[cfg(feature = "json")]
let descriptor_set = std::fs::read(&descriptor_path)
.expect(&*format!("Cannot read {:?}", &descriptor_path));
- #[cfg(feature = "json")]
pbjson_build::Builder::new()
.register_descriptors(&descriptor_set)
.expect(&*format!(
@@ -57,27 +59,11 @@ fn build() -> Result<(), String> {
.build(&[".datafusion"])
.map_err(|e| format!("pbjson compilation failed: {}", e))?;
- // .serde.rs is not a valid package name, so append to datafusion.rs so we can treat it normally
- let proto = std::fs::read_to_string(out.join("datafusion.rs")).unwrap();
-
- #[cfg(feature = "json")]
- let json = std::fs::read_to_string(out.join("datafusion.serde.rs")).unwrap();
-
- #[cfg(feature = "docsrs")]
- let path = out.join("datafusion.rs");
- #[cfg(not(feature = "docsrs"))]
- let path = "src/generated/datafusion.rs";
-
- let mut file = std::fs::OpenOptions::new()
- .write(true)
- .truncate(true)
- .create(true)
- .open(path)
- .unwrap();
- file.write_all(proto.as_str().as_ref()).unwrap();
+ let prost = out.join("datafusion.rs");
+ let pbjson = out.join("datafusion.serde.rs");
- #[cfg(feature = "json")]
- file.write_all(json.as_str().as_ref()).unwrap();
+ std::fs::copy(prost, "src/generated/prost.rs").unwrap();
+ std::fs::copy(pbjson, "src/generated/pbjson.rs").unwrap();
Ok(())
}
diff --git a/datafusion/proto/src/generated/.gitignore b/datafusion/proto/src/generated/.gitignore
deleted file mode 100644
index 42eb8bcd5..000000000
--- a/datafusion/proto/src/generated/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-*
-
-!.gitignore
-!mod.rs
diff --git a/datafusion/proto/src/generated/mod.rs b/datafusion/proto/src/generated/mod.rs
index bf58e9687..e48e96e88 100644
--- a/datafusion/proto/src/generated/mod.rs
+++ b/datafusion/proto/src/generated/mod.rs
@@ -18,13 +18,9 @@
#[allow(clippy::all)]
#[rustfmt::skip]
#[cfg(not(docsrs))]
-pub mod datafusion;
-
-#[cfg(docsrs)]
-#[allow(clippy::all)]
pub mod datafusion {
- include!(concat!(env!("OUT_DIR"), "/datafusion.rs"));
+ include!("prost.rs");
#[cfg(feature = "json")]
- include!(concat!(env!("OUT_DIR"), "/datafusion.serde.rs"));
+ include!("pbjson.rs");
}
diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs
new file mode 100644
index 000000000..6250c1a0c
--- /dev/null
+++ b/datafusion/proto/src/generated/pbjson.rs
@@ -0,0 +1,13232 @@
+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;
+ }
+ 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)?;
+ }
+ 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] = &[
+ "aggrFunction",
+ "expr",
+ "distinct",
+ "filter",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ AggrFunction,
+ Expr,
+ Distinct,
+ 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 {
+ "aggrFunction" => Ok(GeneratedField::AggrFunction),
+ "expr" => Ok(GeneratedField::Expr),
+ "distinct" => Ok(GeneratedField::Distinct),
+ "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 = 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;
+ 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__ = 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__,
+ })
+ }
+ }
+ 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",
+ };
+ 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",
+ ];
+
+ 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),
+ _ => 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",
+ "groupExpr",
+ "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" => Ok(GeneratedField::GroupExpr),
+ "aggrExpr" => 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__ = Some(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;
+ }
+ 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)?;
+ }
+ 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] = &[
+ "funName",
+ "args",
+ "filter",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ FunName,
+ Args,
+ 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 {
+ "funName" => Ok(GeneratedField::FunName),
+ "args" => Ok(GeneratedField::Args),
+ "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 = 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;
+ 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__ = Some(map.next_value()?);
+ }
+ }
+ }
+ Ok(AggregateUdfExprNode {
+ fun_name: fun_name__.unwrap_or_default(),
+ args: args__.unwrap_or_default(),
+ filter: filter__,
+ })
+ }
+ }
+ 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__ = Some(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__ = Some(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 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)?;
+ }
+ }
+ }
+ 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",
+ "LARGEUTF8",
+ "BINARY",
+ "FIXEDSIZEBINARY",
+ "LARGEBINARY",
+ "DATE32",
+ "DATE64",
+ "DURATION",
+ "TIMESTAMP",
+ "TIME32",
+ "TIME64",
+ "INTERVAL",
+ "DECIMAL",
+ "LIST",
+ "LARGELIST",
+ "FIXEDSIZELIST",
+ "STRUCT",
+ "UNION",
+ "DICTIONARY",
+ ];
+
+ #[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,
+ }
+ impl<'de> serde::Deserialize<'de> for GeneratedField {
+ fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct GeneratedVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = GeneratedField;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "expected one 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" => Ok(GeneratedField::LargeUtf8),
+ "BINARY" => Ok(GeneratedField::Binary),
+ "FIXEDSIZEBINARY" => Ok(GeneratedField::FixedSizeBinary),
+ "LARGEBINARY" => 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" => Ok(GeneratedField::LargeList),
+ "FIXEDSIZELIST" => Ok(GeneratedField::FixedSizeList),
+ "STRUCT" => Ok(GeneratedField::Struct),
+ "UNION" => Ok(GeneratedField::Union),
+ "DICTIONARY" => Ok(GeneratedField::Dictionary),
+ _ => 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__ = Some(arrow_type::ArrowTypeEnum::None(map.next_value()?));
+ }
+ GeneratedField::Bool => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("BOOL"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Bool(map.next_value()?));
+ }
+ GeneratedField::Uint8 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("UINT8"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint8(map.next_value()?));
+ }
+ GeneratedField::Int8 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("INT8"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int8(map.next_value()?));
+ }
+ GeneratedField::Uint16 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("UINT16"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint16(map.next_value()?));
+ }
+ GeneratedField::Int16 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("INT16"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int16(map.next_value()?));
+ }
+ GeneratedField::Uint32 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("UINT32"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint32(map.next_value()?));
+ }
+ GeneratedField::Int32 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("INT32"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int32(map.next_value()?));
+ }
+ GeneratedField::Uint64 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("UINT64"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint64(map.next_value()?));
+ }
+ GeneratedField::Int64 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("INT64"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int64(map.next_value()?));
+ }
+ GeneratedField::Float16 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("FLOAT16"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float16(map.next_value()?));
+ }
+ GeneratedField::Float32 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("FLOAT32"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float32(map.next_value()?));
+ }
+ GeneratedField::Float64 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("FLOAT64"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float64(map.next_value()?));
+ }
+ GeneratedField::Utf8 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("UTF8"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Utf8(map.next_value()?));
+ }
+ GeneratedField::LargeUtf8 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("LARGEUTF8"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeUtf8(map.next_value()?));
+ }
+ GeneratedField::Binary => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("BINARY"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Binary(map.next_value()?));
+ }
+ GeneratedField::FixedSizeBinary => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("FIXEDSIZEBINARY"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::FixedSizeBinary(
+ map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
+ ));
+ }
+ GeneratedField::LargeBinary => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("LARGEBINARY"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeBinary(map.next_value()?));
+ }
+ GeneratedField::Date32 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("DATE32"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Date32(map.next_value()?));
+ }
+ GeneratedField::Date64 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("DATE64"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Date64(map.next_value()?));
+ }
+ GeneratedField::Duration => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("DURATION"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Duration(map.next_value::<TimeUnit>()? as i32));
+ }
+ GeneratedField::Timestamp => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("TIMESTAMP"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Timestamp(map.next_value()?));
+ }
+ GeneratedField::Time32 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("TIME32"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Time32(map.next_value::<TimeUnit>()? as i32));
+ }
+ GeneratedField::Time64 => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("TIME64"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Time64(map.next_value::<TimeUnit>()? as i32));
+ }
+ GeneratedField::Interval => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("INTERVAL"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Interval(map.next_value::<IntervalUnit>()? as i32));
+ }
+ GeneratedField::Decimal => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("DECIMAL"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Decimal(map.next_value()?));
+ }
+ GeneratedField::List => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("LIST"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::List(map.next_value()?));
+ }
+ GeneratedField::LargeList => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("LARGELIST"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeList(map.next_value()?));
+ }
+ GeneratedField::FixedSizeList => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("FIXEDSIZELIST"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::FixedSizeList(map.next_value()?));
+ }
+ GeneratedField::Struct => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("STRUCT"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Struct(map.next_value()?));
+ }
+ GeneratedField::Union => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("UNION"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Union(map.next_value()?));
+ }
+ GeneratedField::Dictionary => {
+ if arrow_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("DICTIONARY"));
+ }
+ arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Dictionary(map.next_value()?));
+ }
+ }
+ }
+ 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 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__ = Some(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__ = Some(map.next_value()?);
+ }
+ GeneratedField::High => {
+ if high__.is_some() {
+ return Err(serde::de::Error::duplicate_field("high"));
+ }
+ high__ = Some(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.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.BinaryExprNode", 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 BinaryExprNode {
+ #[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 = 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 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::R => {
+ if r__.is_some() {
+ return Err(serde::de::Error::duplicate_field("r"));
+ }
+ r__ = 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 {
+ l: l__,
+ r: r__,
+ 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",
+ "whenThenExpr",
+ "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" => Ok(GeneratedField::WhenThenExpr),
+ "elseExpr" => 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__ = Some(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__ = Some(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",
+ "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" => 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::ArrowType => {
+ if arrow_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("arrowType"));
+ }
+ arrow_type__ = Some(map.next_value()?);
+ }
+ }
+ }
+ Ok(CastNode {
+ expr: expr__,
+ arrow_type: arrow_type__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.CastNode", 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__ = Some(map.next_value()?);
+ }
+ }
+ }
+ Ok(Column {
+ name: name__.unwrap_or_default(),
+ relation: relation__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.Column", 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 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] = &[
+ "catalogName",
+ "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" => Ok(GeneratedField::CatalogName),
+ "ifNotExists" => 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__ = Some(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] = &[
+ "schemaName",
+ "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" => Ok(GeneratedField::SchemaName),
+ "ifNotExists" => 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__ = Some(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_empty() {
+ 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;
+ }
+ let mut struct_ser = serializer.serialize_struct("datafusion.CreateExternalTableNode", len)?;
+ if !self.name.is_empty() {
+ struct_ser.serialize_field("name", &self.name)?;
+ }
+ 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)?;
+ }
+ 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",
+ "fileType",
+ "hasHeader",
+ "schema",
+ "tablePartitionCols",
+ "ifNotExists",
+ "delimiter",
+ "definition",
+ "fileCompressionType",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ Name,
+ Location,
+ FileType,
+ HasHeader,
+ Schema,
+ TablePartitionCols,
+ IfNotExists,
+ Delimiter,
+ Definition,
+ FileCompressionType,
+ }
+ impl<'de> serde::Deserialize<'de> for GeneratedField {
+ fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct GeneratedVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = GeneratedField;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "expected one 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" => Ok(GeneratedField::FileType),
+ "hasHeader" => Ok(GeneratedField::HasHeader),
+ "schema" => Ok(GeneratedField::Schema),
+ "tablePartitionCols" => Ok(GeneratedField::TablePartitionCols),
+ "ifNotExists" => Ok(GeneratedField::IfNotExists),
+ "delimiter" => Ok(GeneratedField::Delimiter),
+ "definition" => Ok(GeneratedField::Definition),
+ "fileCompressionType" => Ok(GeneratedField::FileCompressionType),
+ _ => 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;
+ 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::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__ = 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::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()?);
+ }
+ }
+ }
+ Ok(CreateExternalTableNode {
+ name: name__.unwrap_or_default(),
+ 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(),
+ })
+ }
+ }
+ 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_empty() {
+ 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 !self.name.is_empty() {
+ struct_ser.serialize_field("name", &self.name)?;
+ }
+ 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",
+ "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" => 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Input => {
+ if input__.is_some() {
+ return Err(serde::de::Error::duplicate_field("input"));
+ }
+ input__ = Some(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__.unwrap_or_default(),
+ 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 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Right => {
+ if right__.is_some() {
+ return Err(serde::de::Error::duplicate_field("right"));
+ }
+ right__ = Some(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] = &[
+ "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" => 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 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_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.custom_table_data.is_empty() {
+ len += 1;
+ }
+ let mut struct_ser = serializer.serialize_struct("datafusion.CustomTableScanNode", len)?;
+ if !self.table_name.is_empty() {
+ struct_ser.serialize_field("tableName", &self.table_name)?;
+ }
+ 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] = &[
+ "tableName",
+ "projection",
+ "schema",
+ "filters",
+ "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" => Ok(GeneratedField::TableName),
+ "projection" => Ok(GeneratedField::Projection),
+ "schema" => Ok(GeneratedField::Schema),
+ "filters" => Ok(GeneratedField::Filters),
+ "customTableData" => 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Projection => {
+ if projection__.is_some() {
+ return Err(serde::de::Error::duplicate_field("projection"));
+ }
+ projection__ = Some(map.next_value()?);
+ }
+ GeneratedField::Schema => {
+ if schema__.is_some() {
+ return Err(serde::de::Error::duplicate_field("schema"));
+ }
+ schema__ = Some(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__.unwrap_or_default(),
+ 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.whole != 0 {
+ len += 1;
+ }
+ if self.fractional != 0 {
+ len += 1;
+ }
+ let mut struct_ser = serializer.serialize_struct("datafusion.Decimal", len)?;
+ if self.whole != 0 {
+ struct_ser.serialize_field("whole", ToString::to_string(&self.whole).as_str())?;
+ }
+ if self.fractional != 0 {
+ struct_ser.serialize_field("fractional", ToString::to_string(&self.fractional).as_str())?;
+ }
+ 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] = &[
+ "whole",
+ "fractional",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ Whole,
+ Fractional,
+ }
+ impl<'de> serde::Deserialize<'de> for GeneratedField {
+ fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct GeneratedVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = GeneratedField;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "expected one of: {:?}", &FIELDS)
+ }
+
+ #[allow(unused_variables)]
+ fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+ where
+ E: serde::de::Error,
+ {
+ match value {
+ "whole" => Ok(GeneratedField::Whole),
+ "fractional" => Ok(GeneratedField::Fractional),
+ _ => 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 whole__ = None;
+ let mut fractional__ = None;
+ while let Some(k) = map.next_key()? {
+ match k {
+ GeneratedField::Whole => {
+ if whole__.is_some() {
+ return Err(serde::de::Error::duplicate_field("whole"));
+ }
+ whole__ = Some(
+ map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
+ );
+ }
+ GeneratedField::Fractional => {
+ if fractional__.is_some() {
+ return Err(serde::de::Error::duplicate_field("fractional"));
+ }
+ fractional__ = Some(
+ map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
+ );
+ }
+ }
+ }
+ Ok(Decimal {
+ whole: whole__.unwrap_or_default(),
+ fractional: fractional__.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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Qualifier => {
+ if qualifier__.is_some() {
+ return Err(serde::de::Error::duplicate_field("qualifier"));
+ }
+ qualifier__ = Some(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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Value => {
+ if value__.is_some() {
+ return Err(serde::de::Error::duplicate_field("value"));
+ }
+ value__ = Some(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__ = Some(map.next_value()?);
+ }
+ }
+ }
+ Ok(DistinctNode {
+ input: input__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.DistinctNode", 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] = &[
+ "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" => 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 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__ = Some(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",
+ "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" => 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__ = Some(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 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] = &[
+ "fieldType",
+ "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" => Ok(GeneratedField::FieldType),
+ "listSize" => 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__ = Some(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 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Key => {
+ if key__.is_some() {
+ return Err(serde::de::Error::duplicate_field("key"));
+ }
+ key__ = Some(map.next_value()?);
+ }
+ }
+ }
+ Ok(GetIndexedField {
+ expr: expr__,
+ key: key__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.GetIndexedField", 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 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] = &[
+ "hashExpr",
+ "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" => Ok(GeneratedField::HashExpr),
+ "partitionCount" => 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",
+ "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" => 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Pattern => {
+ if pattern__.is_some() {
+ return Err(serde::de::Error::duplicate_field("pattern"));
+ }
+ pattern__ = Some(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__ = Some(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__ = Some(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__ = Some(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__ = Some(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__ = Some(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__ = Some(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__ = Some(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__ = Some(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__ = Some(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 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_column.is_empty() {
+ len += 1;
+ }
+ if !self.right_join_column.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_column.is_empty() {
+ struct_ser.serialize_field("leftJoinColumn", &self.left_join_column)?;
+ }
+ if !self.right_join_column.is_empty() {
+ struct_ser.serialize_field("rightJoinColumn", &self.right_join_column)?;
+ }
+ 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",
+ "joinType",
+ "joinConstraint",
+ "leftJoinColumn",
+ "rightJoinColumn",
+ "nullEqualsNull",
+ "filter",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ Left,
+ Right,
+ JoinType,
+ JoinConstraint,
+ LeftJoinColumn,
+ RightJoinColumn,
+ 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" => Ok(GeneratedField::JoinType),
+ "joinConstraint" => Ok(GeneratedField::JoinConstraint),
+ "leftJoinColumn" => Ok(GeneratedField::LeftJoinColumn),
+ "rightJoinColumn" => Ok(GeneratedField::RightJoinColumn),
+ "nullEqualsNull" => 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_column__ = None;
+ let mut right_join_column__ = 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Right => {
+ if right__.is_some() {
+ return Err(serde::de::Error::duplicate_field("right"));
+ }
+ right__ = 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::JoinConstraint => {
+ if join_constraint__.is_some() {
+ return Err(serde::de::Error::duplicate_field("joinConstraint"));
+ }
+ join_constraint__ = Some(map.next_value::<JoinConstraint>()? as i32);
+ }
+ GeneratedField::LeftJoinColumn => {
+ if left_join_column__.is_some() {
+ return Err(serde::de::Error::duplicate_field("leftJoinColumn"));
+ }
+ left_join_column__ = Some(map.next_value()?);
+ }
+ GeneratedField::RightJoinColumn => {
+ if right_join_column__.is_some() {
+ return Err(serde::de::Error::duplicate_field("rightJoinColumn"));
+ }
+ right_join_column__ = 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__ = Some(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_column: left_join_column__.unwrap_or_default(),
+ right_join_column: right_join_column__.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 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::Semi => "SEMI",
+ Self::Anti => "ANTI",
+ };
+ 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",
+ "SEMI",
+ "ANTI",
+ ];
+
+ 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),
+ "SEMI" => Ok(JoinType::Semi),
+ "ANTI" => Ok(JoinType::Anti),
+ _ => 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",
+ "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" => 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Pattern => {
+ if pattern__.is_some() {
+ return Err(serde::de::Error::duplicate_field("pattern"));
+ }
+ pattern__ = Some(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__ = Some(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] = &[
+ "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" => 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__ = Some(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_empty() {
+ 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_format_type.is_some() {
+ len += 1;
+ }
+ let mut struct_ser = serializer.serialize_struct("datafusion.ListingTableScanNode", len)?;
+ if !self.table_name.is_empty() {
+ struct_ser.serialize_field("tableName", &self.table_name)?;
+ }
+ 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 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] = &[
+ "tableName",
+ "paths",
+ "fileExtension",
+ "projection",
+ "schema",
+ "filters",
+ "tablePartitionCols",
+ "collectStat",
+ "targetPartitions",
+ "csv",
+ "parquet",
+ "avro",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ TableName,
+ Paths,
+ FileExtension,
+ Projection,
+ Schema,
+ Filters,
+ TablePartitionCols,
+ CollectStat,
+ TargetPartitions,
+ 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" => Ok(GeneratedField::TableName),
+ "paths" => Ok(GeneratedField::Paths),
+ "fileExtension" => Ok(GeneratedField::FileExtension),
+ "projection" => Ok(GeneratedField::Projection),
+ "schema" => Ok(GeneratedField::Schema),
+ "filters" => Ok(GeneratedField::Filters),
+ "tablePartitionCols" => Ok(GeneratedField::TablePartitionCols),
+ "collectStat" => Ok(GeneratedField::CollectStat),
+ "targetPartitions" => Ok(GeneratedField::TargetPartitions),
+ "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_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__ = Some(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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Schema => {
+ if schema__.is_some() {
+ return Err(serde::de::Error::duplicate_field("schema"));
+ }
+ schema__ = Some(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::Csv => {
+ if file_format_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("csv"));
+ }
+ file_format_type__ = Some(listing_table_scan_node::FileFormatType::Csv(map.next_value()?));
+ }
+ GeneratedField::Parquet => {
+ if file_format_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("parquet"));
+ }
+ file_format_type__ = Some(listing_table_scan_node::FileFormatType::Parquet(map.next_value()?));
+ }
+ GeneratedField::Avro => {
+ if file_format_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("avro"));
+ }
+ file_format_type__ = Some(listing_table_scan_node::FileFormatType::Avro(map.next_value()?));
+ }
+ }
+ }
+ Ok(ListingTableScanNode {
+ table_name: table_name__.unwrap_or_default(),
+ 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_format_type: file_format_type__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.ListingTableScanNode", 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)?;
+ }
+ }
+ }
+ 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",
+ "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",
+ ];
+
+ #[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,
+ }
+ impl<'de> serde::Deserialize<'de> for GeneratedField {
+ fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct GeneratedVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = GeneratedField;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "expected one 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" => Ok(GeneratedField::BinaryExpr),
+ "aggregateExpr" => Ok(GeneratedField::AggregateExpr),
+ "isNullExpr" => Ok(GeneratedField::IsNullExpr),
+ "isNotNullExpr" => Ok(GeneratedField::IsNotNullExpr),
+ "notExpr" => Ok(GeneratedField::NotExpr),
+ "between" => Ok(GeneratedField::Between),
+ "case" => Ok(GeneratedField::Case),
+ "cast" => Ok(GeneratedField::Cast),
+ "sort" => Ok(GeneratedField::Sort),
+ "negative" => Ok(GeneratedField::Negative),
+ "inList" => Ok(GeneratedField::InList),
+ "wildcard" => Ok(GeneratedField::Wildcard),
+ "scalarFunction" => Ok(GeneratedField::ScalarFunction),
+ "tryCast" => Ok(GeneratedField::TryCast),
+ "windowExpr" => Ok(GeneratedField::WindowExpr),
+ "aggregateUdfExpr" => Ok(GeneratedField::AggregateUdfExpr),
+ "scalarUdfExpr" => Ok(GeneratedField::ScalarUdfExpr),
+ "getIndexedField" => Ok(GeneratedField::GetIndexedField),
+ "groupingSet" => Ok(GeneratedField::GroupingSet),
+ "cube" => Ok(GeneratedField::Cube),
+ "rollup" => Ok(GeneratedField::Rollup),
+ "isTrue" => Ok(GeneratedField::IsTrue),
+ "isFalse" => Ok(GeneratedField::IsFalse),
+ "isUnknown" => Ok(GeneratedField::IsUnknown),
+ "isNotTrue" => Ok(GeneratedField::IsNotTrue),
+ "isNotFalse" => Ok(GeneratedField::IsNotFalse),
+ "isNotUnknown" => Ok(GeneratedField::IsNotUnknown),
+ "like" => Ok(GeneratedField::Like),
+ "ilike" => Ok(GeneratedField::Ilike),
+ "similarTo" => Ok(GeneratedField::SimilarTo),
+ _ => 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__ = Some(logical_expr_node::ExprType::Column(map.next_value()?));
+ }
+ GeneratedField::Alias => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("alias"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Alias(map.next_value()?));
+ }
+ GeneratedField::Literal => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("literal"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Literal(map.next_value()?));
+ }
+ GeneratedField::BinaryExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("binaryExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::BinaryExpr(map.next_value()?));
+ }
+ GeneratedField::AggregateExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("aggregateExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::AggregateExpr(map.next_value()?));
+ }
+ GeneratedField::IsNullExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isNullExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsNullExpr(map.next_value()?));
+ }
+ GeneratedField::IsNotNullExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isNotNullExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsNotNullExpr(map.next_value()?));
+ }
+ GeneratedField::NotExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("notExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::NotExpr(map.next_value()?));
+ }
+ GeneratedField::Between => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("between"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Between(map.next_value()?));
+ }
+ GeneratedField::Case => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("case"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Case(map.next_value()?));
+ }
+ GeneratedField::Cast => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("cast"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Cast(map.next_value()?));
+ }
+ GeneratedField::Sort => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("sort"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Sort(map.next_value()?));
+ }
+ GeneratedField::Negative => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("negative"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Negative(map.next_value()?));
+ }
+ GeneratedField::InList => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("inList"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::InList(map.next_value()?));
+ }
+ GeneratedField::Wildcard => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("wildcard"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Wildcard(map.next_value()?));
+ }
+ GeneratedField::ScalarFunction => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("scalarFunction"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::ScalarFunction(map.next_value()?));
+ }
+ GeneratedField::TryCast => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("tryCast"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::TryCast(map.next_value()?));
+ }
+ GeneratedField::WindowExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("windowExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::WindowExpr(map.next_value()?));
+ }
+ GeneratedField::AggregateUdfExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("aggregateUdfExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::AggregateUdfExpr(map.next_value()?));
+ }
+ GeneratedField::ScalarUdfExpr => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("scalarUdfExpr"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::ScalarUdfExpr(map.next_value()?));
+ }
+ GeneratedField::GetIndexedField => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("getIndexedField"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::GetIndexedField(map.next_value()?));
+ }
+ GeneratedField::GroupingSet => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("groupingSet"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::GroupingSet(map.next_value()?));
+ }
+ GeneratedField::Cube => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("cube"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Cube(map.next_value()?));
+ }
+ GeneratedField::Rollup => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("rollup"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Rollup(map.next_value()?));
+ }
+ GeneratedField::IsTrue => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isTrue"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsTrue(map.next_value()?));
+ }
+ GeneratedField::IsFalse => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isFalse"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsFalse(map.next_value()?));
+ }
+ GeneratedField::IsUnknown => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isUnknown"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsUnknown(map.next_value()?));
+ }
+ GeneratedField::IsNotTrue => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isNotTrue"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsNotTrue(map.next_value()?));
+ }
+ GeneratedField::IsNotFalse => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isNotFalse"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsNotFalse(map.next_value()?));
+ }
+ GeneratedField::IsNotUnknown => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("isNotUnknown"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::IsNotUnknown(map.next_value()?));
+ }
+ GeneratedField::Like => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("like"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Like(map.next_value()?));
+ }
+ GeneratedField::Ilike => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("ilike"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::Ilike(map.next_value()?));
+ }
+ GeneratedField::SimilarTo => {
+ if expr_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("similarTo"));
+ }
+ expr_type__ = Some(logical_expr_node::ExprType::SimilarTo(map.next_value()?));
+ }
+ }
+ }
+ Ok(LogicalExprNode {
+ expr_type: expr_type__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.LogicalExprNode", 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)?;
+ }
+ }
+ }
+ 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] = &[
+ "listingScan",
+ "projection",
+ "selection",
+ "limit",
+ "aggregate",
+ "join",
+ "sort",
+ "repartition",
+ "emptyRelation",
+ "createExternalTable",
+ "explain",
+ "window",
+ "analyze",
+ "crossJoin",
+ "values",
+ "extension",
+ "createCatalogSchema",
+ "union",
+ "createCatalog",
+ "subqueryAlias",
+ "createView",
+ "distinct",
+ "viewScan",
+ "customScan",
+ ];
+
+ #[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,
+ }
+ impl<'de> serde::Deserialize<'de> for GeneratedField {
+ fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct GeneratedVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = GeneratedField;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "expected one 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" => 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" => Ok(GeneratedField::EmptyRelation),
+ "createExternalTable" => Ok(GeneratedField::CreateExternalTable),
+ "explain" => Ok(GeneratedField::Explain),
+ "window" => Ok(GeneratedField::Window),
+ "analyze" => Ok(GeneratedField::Analyze),
+ "crossJoin" => Ok(GeneratedField::CrossJoin),
+ "values" => Ok(GeneratedField::Values),
+ "extension" => Ok(GeneratedField::Extension),
+ "createCatalogSchema" => Ok(GeneratedField::CreateCatalogSchema),
+ "union" => Ok(GeneratedField::Union),
+ "createCatalog" => Ok(GeneratedField::CreateCatalog),
+ "subqueryAlias" => Ok(GeneratedField::SubqueryAlias),
+ "createView" => Ok(GeneratedField::CreateView),
+ "distinct" => Ok(GeneratedField::Distinct),
+ "viewScan" => Ok(GeneratedField::ViewScan),
+ "customScan" => Ok(GeneratedField::CustomScan),
+ _ => 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__ = Some(logical_plan_node::LogicalPlanType::ListingScan(map.next_value()?));
+ }
+ GeneratedField::Projection => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("projection"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Projection(map.next_value()?));
+ }
+ GeneratedField::Selection => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("selection"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Selection(map.next_value()?));
+ }
+ GeneratedField::Limit => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("limit"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Limit(map.next_value()?));
+ }
+ GeneratedField::Aggregate => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("aggregate"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Aggregate(map.next_value()?));
+ }
+ GeneratedField::Join => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("join"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Join(map.next_value()?));
+ }
+ GeneratedField::Sort => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("sort"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Sort(map.next_value()?));
+ }
+ GeneratedField::Repartition => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("repartition"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Repartition(map.next_value()?));
+ }
+ GeneratedField::EmptyRelation => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("emptyRelation"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::EmptyRelation(map.next_value()?));
+ }
+ GeneratedField::CreateExternalTable => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("createExternalTable"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateExternalTable(map.next_value()?));
+ }
+ GeneratedField::Explain => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("explain"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Explain(map.next_value()?));
+ }
+ GeneratedField::Window => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("window"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Window(map.next_value()?));
+ }
+ GeneratedField::Analyze => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("analyze"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Analyze(map.next_value()?));
+ }
+ GeneratedField::CrossJoin => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("crossJoin"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CrossJoin(map.next_value()?));
+ }
+ GeneratedField::Values => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("values"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Values(map.next_value()?));
+ }
+ GeneratedField::Extension => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("extension"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Extension(map.next_value()?));
+ }
+ GeneratedField::CreateCatalogSchema => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("createCatalogSchema"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateCatalogSchema(map.next_value()?));
+ }
+ GeneratedField::Union => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("union"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Union(map.next_value()?));
+ }
+ GeneratedField::CreateCatalog => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("createCatalog"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateCatalog(map.next_value()?));
+ }
+ GeneratedField::SubqueryAlias => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("subqueryAlias"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::SubqueryAlias(map.next_value()?));
+ }
+ GeneratedField::CreateView => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("createView"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateView(map.next_value()?));
+ }
+ GeneratedField::Distinct => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("distinct"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Distinct(map.next_value()?));
+ }
+ GeneratedField::ViewScan => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("viewScan"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::ViewScan(map.next_value()?));
+ }
+ GeneratedField::CustomScan => {
+ if logical_plan_type__.is_some() {
+ return Err(serde::de::Error::duplicate_field("customScan"));
+ }
+ logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CustomScan(map.next_value()?));
+ }
+ }
+ }
+ Ok(LogicalPlanNode {
+ logical_plan_type: logical_plan_type__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.LogicalPlanNode", 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__ = Some(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__ = Some(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] = &[
+ "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" => 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] = &[
+ "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" => 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 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 mut len = 0;
+ if self.enable_pruning {
+ len += 1;
+ }
+ let mut struct_ser = serializer.serialize_struct("datafusion.ParquetFormat", len)?;
+ if self.enable_pruning {
+ struct_ser.serialize_field("enablePruning", &self.enable_pruning)?;
+ }
+ 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] = &[
+ "enablePruning",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ EnablePruning,
+ }
+ impl<'de> serde::Deserialize<'de> for GeneratedField {
+ fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct GeneratedVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = GeneratedField;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "expected one of: {:?}", &FIELDS)
+ }
+
+ #[allow(unused_variables)]
+ fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+ where
+ E: serde::de::Error,
+ {
+ match value {
+ "enablePruning" => Ok(GeneratedField::EnablePruning),
+ _ => 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>,
+ {
+ let mut enable_pruning__ = None;
+ while let Some(k) = map.next_key()? {
+ match k {
+ GeneratedField::EnablePruning => {
+ if enable_pruning__.is_some() {
+ return Err(serde::de::Error::duplicate_field("enablePruning"));
+ }
+ enable_pruning__ = Some(map.next_value()?);
+ }
+ }
+ }
+ Ok(ParquetFormat {
+ enable_pruning: enable_pruning__.unwrap_or_default(),
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.ParquetFormat", 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::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",
+ "OptimizedLogicalPlan",
+ "FinalLogicalPlan",
+ "InitialPhysicalPlan",
+ "OptimizedPhysicalPlan",
+ "FinalPhysicalPlan",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ InitialLogicalPlan,
+ 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),
+ "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__ = Some(plan_type::PlanTypeEnum::InitialLogicalPlan(map.next_value()?));
+ }
+ GeneratedField::OptimizedLogicalPlan => {
+ if plan_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("OptimizedLogicalPlan"));
+ }
+ plan_type_enum__ = Some(plan_type::PlanTypeEnum::OptimizedLogicalPlan(map.next_value()?));
+ }
+ GeneratedField::FinalLogicalPlan => {
+ if plan_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("FinalLogicalPlan"));
+ }
+ plan_type_enum__ = Some(plan_type::PlanTypeEnum::FinalLogicalPlan(map.next_value()?));
+ }
+ GeneratedField::InitialPhysicalPlan => {
+ if plan_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan"));
+ }
+ plan_type_enum__ = Some(plan_type::PlanTypeEnum::InitialPhysicalPlan(map.next_value()?));
+ }
+ GeneratedField::OptimizedPhysicalPlan => {
+ if plan_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan"));
+ }
+ plan_type_enum__ = Some(plan_type::PlanTypeEnum::OptimizedPhysicalPlan(map.next_value()?));
+ }
+ GeneratedField::FinalPhysicalPlan => {
+ if plan_type_enum__.is_some() {
+ return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan"));
+ }
+ plan_type_enum__ = Some(plan_type::PlanTypeEnum::FinalPhysicalPlan(map.next_value()?));
+ }
+ }
+ }
+ Ok(PlanType {
+ plan_type_enum: plan_type_enum__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.PlanType", 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 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__ = Some(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__ = Some(projection_node::OptionalAlias::Alias(map.next_value()?));
+ }
+ }
+ }
+ Ok(ProjectionNode {
+ input: input__,
+ expr: expr__.unwrap_or_default(),
+ optional_alias: optional_alias__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.ProjectionNode", 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",
+ "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" => 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::RoundRobin => {
+ if partition_method__.is_some() {
+ return Err(serde::de::Error::duplicate_field("roundRobin"));
+ }
+ partition_method__ = Some(repartition_node::PartitionMethod::RoundRobin(
+ map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
+ ));
+ }
+ GeneratedField::Hash => {
+ if partition_method__.is_some() {
+ return Err(serde::de::Error::duplicate_field("hash"));
+ }
+ partition_method__ = Some(repartition_node::PartitionMethod::Hash(map.next_value()?));
+ }
+ }
+ }
+ 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] = &[
+ "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" => 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__ = Some(map.next_value()?);
+ }
+ GeneratedField::Value => {
+ if value__.is_some() {
+ return Err(serde::de::Error::duplicate_field("value"));
+ }
+ value__ = Some(map.next_value()?);
+ }
+ }
+ }
+ Ok(ScalarDictionaryValue {
+ index_type: index_type__,
+ value: value__,
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", 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",
+ };
+ 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",
+ ];
+
+ 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),
+ _ => 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] = &[
+ "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" => 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__ = Some(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 ScalarTimestampValue {
+ #[allow(deprecated)]
+ fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
... 5018 lines suppressed ...