From d1cff056ece0a86e8fe6ad1fdad5209f4f710c8e Mon Sep 17 00:00:00 2001 From: Raphael Taylor-Davies Date: Tue, 25 Oct 2022 15:55:21 +1300 Subject: [PATCH] Vendor generated protobuf code (#3947) --- .gitattributes | 2 + datafusion/proto/Cargo.toml | 8 +- datafusion/proto/build.rs | 42 +- datafusion/proto/src/generated/.gitignore | 4 - datafusion/proto/src/generated/mod.rs | 8 +- datafusion/proto/src/generated/pbjson.rs | 13209 ++++++++++++++++++++ datafusion/proto/src/generated/prost.rs | 1572 +++ 7 files changed, 14804 insertions(+), 41 deletions(-) create mode 100644 .gitattributes delete mode 100644 datafusion/proto/src/generated/.gitignore create mode 100644 datafusion/proto/src/generated/pbjson.rs create mode 100644 datafusion/proto/src/generated/prost.rs diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000000..7ff0bbb6d959 --- /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/datafusion/proto/Cargo.toml b/datafusion/proto/Cargo.toml index ff2af33b22d8..bfd562cdc9e3 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 3efd71350300..c92d4e269e9b 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; type Result = std::result::Result; 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() @@ -57,27 +61,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(); + let prost = out.join("datafusion.rs"); + let pbjson = out.join("datafusion.serde.rs"); - #[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(); - - #[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 42eb8bcd5521..000000000000 --- 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 bf58e9687d79..e48e96e887cf 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 000000000000..d347f5369391 --- /dev/null +++ b/datafusion/proto/src/generated/pbjson.rs @@ -0,0 +1,13209 @@ +impl serde::Serialize for AggregateExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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::()? 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(self, v: i64) -> std::result::Result + 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(self, v: u64) -> std::result::Result + 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(self, value: &str) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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::()? 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::()? 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::()? 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::()? 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(AvroFormat { + }) + } + } + deserializer.deserialize_struct("datafusion.AvroFormat", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BetweenNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(self, v: i64) -> std::result::Result + 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(self, v: u64) -> std::result::Result + 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(self, value: &str) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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 DateUnit { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(self, v: i64) -> std::result::Result + 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(self, v: u64) -> std::result::Result + 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(self, value: &str) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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::>()? + ); + } + } + } + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(EmptyMessage { + }) + } + } + deserializer.deserialize_struct("datafusion.EmptyMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EmptyRelationNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(self, v: i64) -> std::result::Result + 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(self, v: u64) -> std::result::Result + 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(self, value: &str) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(self, v: i64) -> std::result::Result + 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(self, v: u64) -> std::result::Result + 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(self, value: &str) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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::()? as i32); + } + GeneratedField::JoinConstraint => { + if join_constraint__.is_some() { + return Err(serde::de::Error::duplicate_field("joinConstraint")); + } + join_constraint__ = Some(map.next_value::()? 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(self, v: i64) -> std::result::Result + 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(self, v: u64) -> std::result::Result + 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(self, value: &str) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalPlanNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + 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", + ]; + + #[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, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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), + _ => 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(self, mut map: V) -> std::result::Result + 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()?)); + } + } + } + Ok(LogicalPlanNode { + logical_plan_type: logical_plan_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalPlanNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for NegativeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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 PrimitiveScalarType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Bool => "BOOL", + Self::Uint8 => "UINT8", + Self::Int8 => "INT8", + Self::Uint16 => "UINT16", + Self::Int16 => "INT16", + Self::Uint32 => "UINT32", + Self::Int32 => "INT32", + Self::Uint64 => "UINT64", + Self::Int64 => "INT64", + Self::Float32 => "FLOAT32", + Self::Float64 => "FLOAT64", + Self::Utf8 => "UTF8", + Self::LargeUtf8 => "LARGE_UTF8", + Self::Date32 => "DATE32", + Self::TimestampMicrosecond => "TIMESTAMP_MICROSECOND", + Self::TimestampNanosecond => "TIMESTAMP_NANOSECOND", + Self::Null => "NULL", + Self::Decimal128 => "DECIMAL128", + Self::Date64 => "DATE64", + Self::TimestampSecond => "TIMESTAMP_SECOND", + Self::TimestampMillisecond => "TIMESTAMP_MILLISECOND", + Self::IntervalYearmonth => "INTERVAL_YEARMONTH", + Self::IntervalDaytime => "INTERVAL_DAYTIME", + Self::IntervalMonthdaynano => "INTERVAL_MONTHDAYNANO", + Self::Binary => "BINARY", + Self::LargeBinary => "LARGE_BINARY", + Self::Time64 => "TIME64", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for PrimitiveScalarType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "BOOL", + "UINT8", + "INT8", + "UINT16", + "INT16", + "UINT32", + "INT32", + "UINT64", + "INT64", + "FLOAT32", + "FLOAT64", + "UTF8", + "LARGE_UTF8", + "DATE32", + "TIMESTAMP_MICROSECOND", + "TIMESTAMP_NANOSECOND", + "NULL", + "DECIMAL128", + "DATE64", + "TIMESTAMP_SECOND", + "TIMESTAMP_MILLISECOND", + "INTERVAL_YEARMONTH", + "INTERVAL_DAYTIME", + "INTERVAL_MONTHDAYNANO", + "BINARY", + "LARGE_BINARY", + "TIME64", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PrimitiveScalarType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(PrimitiveScalarType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(PrimitiveScalarType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "BOOL" => Ok(PrimitiveScalarType::Bool), + "UINT8" => Ok(PrimitiveScalarType::Uint8), + "INT8" => Ok(PrimitiveScalarType::Int8), + "UINT16" => Ok(PrimitiveScalarType::Uint16), + "INT16" => Ok(PrimitiveScalarType::Int16), + "UINT32" => Ok(PrimitiveScalarType::Uint32), + "INT32" => Ok(PrimitiveScalarType::Int32), + "UINT64" => Ok(PrimitiveScalarType::Uint64), + "INT64" => Ok(PrimitiveScalarType::Int64), + "FLOAT32" => Ok(PrimitiveScalarType::Float32), + "FLOAT64" => Ok(PrimitiveScalarType::Float64), + "UTF8" => Ok(PrimitiveScalarType::Utf8), + "LARGE_UTF8" => Ok(PrimitiveScalarType::LargeUtf8), + "DATE32" => Ok(PrimitiveScalarType::Date32), + "TIMESTAMP_MICROSECOND" => Ok(PrimitiveScalarType::TimestampMicrosecond), + "TIMESTAMP_NANOSECOND" => Ok(PrimitiveScalarType::TimestampNanosecond), + "NULL" => Ok(PrimitiveScalarType::Null), + "DECIMAL128" => Ok(PrimitiveScalarType::Decimal128), + "DATE64" => Ok(PrimitiveScalarType::Date64), + "TIMESTAMP_SECOND" => Ok(PrimitiveScalarType::TimestampSecond), + "TIMESTAMP_MILLISECOND" => Ok(PrimitiveScalarType::TimestampMillisecond), + "INTERVAL_YEARMONTH" => Ok(PrimitiveScalarType::IntervalYearmonth), + "INTERVAL_DAYTIME" => Ok(PrimitiveScalarType::IntervalDaytime), + "INTERVAL_MONTHDAYNANO" => Ok(PrimitiveScalarType::IntervalMonthdaynano), + "BINARY" => Ok(PrimitiveScalarType::Binary), + "LARGE_BINARY" => Ok(PrimitiveScalarType::LargeBinary), + "TIME64" => Ok(PrimitiveScalarType::Time64), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ProjectionColumns { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(self, v: i64) -> std::result::Result + 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(self, v: u64) -> std::result::Result + 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(self, value: &str) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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::()? 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(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.timezone.is_empty() { + len += 1; + } + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTimestampValue", len)?; + if !self.timezone.is_empty() { + struct_ser.serialize_field("timezone", &self.timezone)?; + } + if let Some(v) = self.value.as_ref() { + match v { + scalar_timestamp_value::Value::TimeMicrosecondValue(v) => { + struct_ser.serialize_field("timeMicrosecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeNanosecondValue(v) => { + struct_ser.serialize_field("timeNanosecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeSecondValue(v) => { + struct_ser.serialize_field("timeSecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeMillisecondValue(v) => { + struct_ser.serialize_field("timeMillisecondValue", ToString::to_string(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarTimestampValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timezone", + "timeMicrosecondValue", + "timeNanosecondValue", + "timeSecondValue", + "timeMillisecondValue", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Timezone, + TimeMicrosecondValue, + TimeNanosecondValue, + TimeSecondValue, + TimeMillisecondValue, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timezone" => Ok(GeneratedField::Timezone), + "timeMicrosecondValue" => Ok(GeneratedField::TimeMicrosecondValue), + "timeNanosecondValue" => Ok(GeneratedField::TimeNanosecondValue), + "timeSecondValue" => Ok(GeneratedField::TimeSecondValue), + "timeMillisecondValue" => Ok(GeneratedField::TimeMillisecondValue), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarTimestampValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarTimestampValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut timezone__ = None; + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Timezone => { + if timezone__.is_some() { + return Err(serde::de::Error::duplicate_field("timezone")); + } + timezone__ = Some(map.next_value()?); + } + GeneratedField::TimeMicrosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeMicrosecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeMicrosecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimeNanosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeNanosecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeNanosecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimeSecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeSecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeSecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimeMillisecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeMillisecondValue")); + } + value__ = Some(scalar_timestamp_value::Value::TimeMillisecondValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + } + } + Ok(ScalarTimestampValue { + timezone: timezone__.unwrap_or_default(), + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarTimestampValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarUdfExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.fun_name.is_empty() { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarUDFExprNode", len)?; + if !self.fun_name.is_empty() { + struct_ser.serialize_field("funName", &self.fun_name)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "funName", + "args", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FunName, + Args, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "funName" => Ok(GeneratedField::FunName), + "args" => Ok(GeneratedField::Args), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarUdfExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarUDFExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut fun_name__ = None; + let mut args__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FunName => { + if fun_name__.is_some() { + return Err(serde::de::Error::duplicate_field("funName")); + } + fun_name__ = Some(map.next_value()?); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map.next_value()?); + } + } + } + Ok(ScalarUdfExprNode { + fun_name: fun_name__.unwrap_or_default(), + args: args__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarUDFExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarValue", len)?; + if let Some(v) = self.value.as_ref() { + match v { + scalar_value::Value::NullValue(v) => { + let v = PrimitiveScalarType::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("nullValue", &v)?; + } + scalar_value::Value::BoolValue(v) => { + struct_ser.serialize_field("boolValue", v)?; + } + scalar_value::Value::Utf8Value(v) => { + struct_ser.serialize_field("utf8Value", v)?; + } + scalar_value::Value::LargeUtf8Value(v) => { + struct_ser.serialize_field("largeUtf8Value", v)?; + } + scalar_value::Value::Int8Value(v) => { + struct_ser.serialize_field("int8Value", v)?; + } + scalar_value::Value::Int16Value(v) => { + struct_ser.serialize_field("int16Value", v)?; + } + scalar_value::Value::Int32Value(v) => { + struct_ser.serialize_field("int32Value", v)?; + } + scalar_value::Value::Int64Value(v) => { + struct_ser.serialize_field("int64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::Uint8Value(v) => { + struct_ser.serialize_field("uint8Value", v)?; + } + scalar_value::Value::Uint16Value(v) => { + struct_ser.serialize_field("uint16Value", v)?; + } + scalar_value::Value::Uint32Value(v) => { + struct_ser.serialize_field("uint32Value", v)?; + } + scalar_value::Value::Uint64Value(v) => { + struct_ser.serialize_field("uint64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::Float32Value(v) => { + struct_ser.serialize_field("float32Value", v)?; + } + scalar_value::Value::Float64Value(v) => { + struct_ser.serialize_field("float64Value", v)?; + } + scalar_value::Value::Date32Value(v) => { + struct_ser.serialize_field("date32Value", v)?; + } + scalar_value::Value::ListValue(v) => { + struct_ser.serialize_field("listValue", v)?; + } + scalar_value::Value::Decimal128Value(v) => { + struct_ser.serialize_field("decimal128Value", v)?; + } + scalar_value::Value::Date64Value(v) => { + struct_ser.serialize_field("date64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::IntervalYearmonthValue(v) => { + struct_ser.serialize_field("intervalYearmonthValue", v)?; + } + scalar_value::Value::IntervalDaytimeValue(v) => { + struct_ser.serialize_field("intervalDaytimeValue", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::TimestampValue(v) => { + struct_ser.serialize_field("timestampValue", v)?; + } + scalar_value::Value::DictionaryValue(v) => { + struct_ser.serialize_field("dictionaryValue", v)?; + } + scalar_value::Value::BinaryValue(v) => { + struct_ser.serialize_field("binaryValue", pbjson::private::base64::encode(&v).as_str())?; + } + scalar_value::Value::LargeBinaryValue(v) => { + struct_ser.serialize_field("largeBinaryValue", pbjson::private::base64::encode(&v).as_str())?; + } + scalar_value::Value::Time64Value(v) => { + struct_ser.serialize_field("time64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::IntervalMonthDayNano(v) => { + struct_ser.serialize_field("intervalMonthDayNano", v)?; + } + scalar_value::Value::StructValue(v) => { + struct_ser.serialize_field("structValue", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "nullValue", + "boolValue", + "utf8Value", + "largeUtf8Value", + "int8Value", + "int16Value", + "int32Value", + "int64Value", + "uint8Value", + "uint16Value", + "uint32Value", + "uint64Value", + "float32Value", + "float64Value", + "date32Value", + "listValue", + "decimal128Value", + "date64Value", + "intervalYearmonthValue", + "intervalDaytimeValue", + "timestampValue", + "dictionaryValue", + "binaryValue", + "largeBinaryValue", + "time64Value", + "intervalMonthDayNano", + "structValue", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + NullValue, + BoolValue, + Utf8Value, + LargeUtf8Value, + Int8Value, + Int16Value, + Int32Value, + Int64Value, + Uint8Value, + Uint16Value, + Uint32Value, + Uint64Value, + Float32Value, + Float64Value, + Date32Value, + ListValue, + Decimal128Value, + Date64Value, + IntervalYearmonthValue, + IntervalDaytimeValue, + TimestampValue, + DictionaryValue, + BinaryValue, + LargeBinaryValue, + Time64Value, + IntervalMonthDayNano, + StructValue, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "nullValue" => Ok(GeneratedField::NullValue), + "boolValue" => Ok(GeneratedField::BoolValue), + "utf8Value" => Ok(GeneratedField::Utf8Value), + "largeUtf8Value" => Ok(GeneratedField::LargeUtf8Value), + "int8Value" => Ok(GeneratedField::Int8Value), + "int16Value" => Ok(GeneratedField::Int16Value), + "int32Value" => Ok(GeneratedField::Int32Value), + "int64Value" => Ok(GeneratedField::Int64Value), + "uint8Value" => Ok(GeneratedField::Uint8Value), + "uint16Value" => Ok(GeneratedField::Uint16Value), + "uint32Value" => Ok(GeneratedField::Uint32Value), + "uint64Value" => Ok(GeneratedField::Uint64Value), + "float32Value" => Ok(GeneratedField::Float32Value), + "float64Value" => Ok(GeneratedField::Float64Value), + "date32Value" => Ok(GeneratedField::Date32Value), + "listValue" => Ok(GeneratedField::ListValue), + "decimal128Value" => Ok(GeneratedField::Decimal128Value), + "date64Value" => Ok(GeneratedField::Date64Value), + "intervalYearmonthValue" => Ok(GeneratedField::IntervalYearmonthValue), + "intervalDaytimeValue" => Ok(GeneratedField::IntervalDaytimeValue), + "timestampValue" => Ok(GeneratedField::TimestampValue), + "dictionaryValue" => Ok(GeneratedField::DictionaryValue), + "binaryValue" => Ok(GeneratedField::BinaryValue), + "largeBinaryValue" => Ok(GeneratedField::LargeBinaryValue), + "time64Value" => Ok(GeneratedField::Time64Value), + "intervalMonthDayNano" => Ok(GeneratedField::IntervalMonthDayNano), + "structValue" => Ok(GeneratedField::StructValue), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::NullValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("nullValue")); + } + value__ = Some(scalar_value::Value::NullValue(map.next_value::()? as i32)); + } + GeneratedField::BoolValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("boolValue")); + } + value__ = Some(scalar_value::Value::BoolValue(map.next_value()?)); + } + GeneratedField::Utf8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("utf8Value")); + } + value__ = Some(scalar_value::Value::Utf8Value(map.next_value()?)); + } + GeneratedField::LargeUtf8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("largeUtf8Value")); + } + value__ = Some(scalar_value::Value::LargeUtf8Value(map.next_value()?)); + } + GeneratedField::Int8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int8Value")); + } + value__ = Some(scalar_value::Value::Int8Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Int16Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int16Value")); + } + value__ = Some(scalar_value::Value::Int16Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Int32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int32Value")); + } + value__ = Some(scalar_value::Value::Int32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Int64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int64Value")); + } + value__ = Some(scalar_value::Value::Int64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint8Value")); + } + value__ = Some(scalar_value::Value::Uint8Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint16Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint16Value")); + } + value__ = Some(scalar_value::Value::Uint16Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint32Value")); + } + value__ = Some(scalar_value::Value::Uint32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Uint64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint64Value")); + } + value__ = Some(scalar_value::Value::Uint64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Float32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("float32Value")); + } + value__ = Some(scalar_value::Value::Float32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Float64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("float64Value")); + } + value__ = Some(scalar_value::Value::Float64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::Date32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("date32Value")); + } + value__ = Some(scalar_value::Value::Date32Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::ListValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("listValue")); + } + value__ = Some(scalar_value::Value::ListValue(map.next_value()?)); + } + GeneratedField::Decimal128Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("decimal128Value")); + } + value__ = Some(scalar_value::Value::Decimal128Value(map.next_value()?)); + } + GeneratedField::Date64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("date64Value")); + } + value__ = Some(scalar_value::Value::Date64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::IntervalYearmonthValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalYearmonthValue")); + } + value__ = Some(scalar_value::Value::IntervalYearmonthValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::IntervalDaytimeValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalDaytimeValue")); + } + value__ = Some(scalar_value::Value::IntervalDaytimeValue( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::TimestampValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timestampValue")); + } + value__ = Some(scalar_value::Value::TimestampValue(map.next_value()?)); + } + GeneratedField::DictionaryValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("dictionaryValue")); + } + value__ = Some(scalar_value::Value::DictionaryValue(map.next_value()?)); + } + GeneratedField::BinaryValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("binaryValue")); + } + value__ = Some(scalar_value::Value::BinaryValue( + map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0 + )); + } + GeneratedField::LargeBinaryValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("largeBinaryValue")); + } + value__ = Some(scalar_value::Value::LargeBinaryValue( + map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0 + )); + } + GeneratedField::Time64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("time64Value")); + } + value__ = Some(scalar_value::Value::Time64Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + GeneratedField::IntervalMonthDayNano => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalMonthDayNano")); + } + value__ = Some(scalar_value::Value::IntervalMonthDayNano(map.next_value()?)); + } + GeneratedField::StructValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("structValue")); + } + value__ = Some(scalar_value::Value::StructValue(map.next_value()?)); + } + } + } + Ok(ScalarValue { + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Schema { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.columns.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Schema", len)?; + if !self.columns.is_empty() { + struct_ser.serialize_field("columns", &self.columns)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Schema { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "columns" => Ok(GeneratedField::Columns), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Schema; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Schema") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut columns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); + } + columns__ = Some(map.next_value()?); + } + } + } + Ok(Schema { + columns: columns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Schema", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SelectionExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SelectionExecNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SelectionExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SelectionExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SelectionExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + 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(SelectionExecNode { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.SelectionExecNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SelectionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SelectionNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SelectionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SelectionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SelectionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(SelectionNode { + input: input__, + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SimilarToNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.negated { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + if self.pattern.is_some() { + len += 1; + } + if !self.escape_char.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?; + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.pattern.as_ref() { + struct_ser.serialize_field("pattern", v)?; + } + if !self.escape_char.is_empty() { + struct_ser.serialize_field("escapeChar", &self.escape_char)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SimilarToNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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 = SimilarToNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SimilarToNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + 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(SimilarToNode { + negated: negated__.unwrap_or_default(), + expr: expr__, + pattern: pattern__, + escape_char: escape_char__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SimilarToNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SortExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.asc { + len += 1; + } + if self.nulls_first { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SortExprNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if self.asc { + struct_ser.serialize_field("asc", &self.asc)?; + } + if self.nulls_first { + struct_ser.serialize_field("nullsFirst", &self.nulls_first)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SortExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "asc", + "nullsFirst", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Asc, + NullsFirst, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "asc" => Ok(GeneratedField::Asc), + "nullsFirst" => Ok(GeneratedField::NullsFirst), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SortExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SortExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut asc__ = None; + let mut nulls_first__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Asc => { + if asc__.is_some() { + return Err(serde::de::Error::duplicate_field("asc")); + } + asc__ = Some(map.next_value()?); + } + GeneratedField::NullsFirst => { + if nulls_first__.is_some() { + return Err(serde::de::Error::duplicate_field("nullsFirst")); + } + nulls_first__ = Some(map.next_value()?); + } + } + } + Ok(SortExprNode { + expr: expr__, + asc: asc__.unwrap_or_default(), + nulls_first: nulls_first__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SortExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SortNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.expr.is_empty() { + len += 1; + } + if self.fetch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SortNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if self.fetch != 0 { + struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SortNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "expr", + "fetch", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Expr, + Fetch, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), + "fetch" => Ok(GeneratedField::Fetch), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SortNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SortNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut expr__ = None; + let mut fetch__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); + } + fetch__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + } + } + Ok(SortNode { + input: input__, + expr: expr__.unwrap_or_default(), + fetch: fetch__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SortNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StringifiedPlan { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.plan_type.is_some() { + len += 1; + } + if !self.plan.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.StringifiedPlan", len)?; + if let Some(v) = self.plan_type.as_ref() { + struct_ser.serialize_field("planType", v)?; + } + if !self.plan.is_empty() { + struct_ser.serialize_field("plan", &self.plan)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StringifiedPlan { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "planType", + "plan", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + PlanType, + Plan, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "planType" => Ok(GeneratedField::PlanType), + "plan" => Ok(GeneratedField::Plan), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StringifiedPlan; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.StringifiedPlan") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut plan_type__ = None; + let mut plan__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::PlanType => { + if plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("planType")); + } + plan_type__ = Some(map.next_value()?); + } + GeneratedField::Plan => { + if plan__.is_some() { + return Err(serde::de::Error::duplicate_field("plan")); + } + plan__ = Some(map.next_value()?); + } + } + } + Ok(StringifiedPlan { + plan_type: plan_type__, + plan: plan__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.StringifiedPlan", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Struct { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.sub_field_types.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Struct", len)?; + if !self.sub_field_types.is_empty() { + struct_ser.serialize_field("subFieldTypes", &self.sub_field_types)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Struct { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "subFieldTypes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + SubFieldTypes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "subFieldTypes" => Ok(GeneratedField::SubFieldTypes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Struct; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Struct") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sub_field_types__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::SubFieldTypes => { + if sub_field_types__.is_some() { + return Err(serde::de::Error::duplicate_field("subFieldTypes")); + } + sub_field_types__ = Some(map.next_value()?); + } + } + } + Ok(Struct { + sub_field_types: sub_field_types__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Struct", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for StructValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.field_values.is_empty() { + len += 1; + } + if !self.fields.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.StructValue", len)?; + if !self.field_values.is_empty() { + struct_ser.serialize_field("fieldValues", &self.field_values)?; + } + if !self.fields.is_empty() { + struct_ser.serialize_field("fields", &self.fields)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for StructValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fieldValues", + "fields", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FieldValues, + Fields, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "fieldValues" => Ok(GeneratedField::FieldValues), + "fields" => Ok(GeneratedField::Fields), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = StructValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.StructValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field_values__ = None; + let mut fields__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FieldValues => { + if field_values__.is_some() { + return Err(serde::de::Error::duplicate_field("fieldValues")); + } + field_values__ = Some(map.next_value()?); + } + GeneratedField::Fields => { + if fields__.is_some() { + return Err(serde::de::Error::duplicate_field("fields")); + } + fields__ = Some(map.next_value()?); + } + } + } + Ok(StructValue { + field_values: field_values__.unwrap_or_default(), + fields: fields__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.StructValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SubqueryAliasNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.alias.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SubqueryAliasNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.alias.is_empty() { + struct_ser.serialize_field("alias", &self.alias)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SubqueryAliasNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "alias", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Alias, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "alias" => Ok(GeneratedField::Alias), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SubqueryAliasNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.SubqueryAliasNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut alias__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Alias => { + if alias__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + alias__ = Some(map.next_value()?); + } + } + } + Ok(SubqueryAliasNode { + input: input__, + alias: alias__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.SubqueryAliasNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TimeUnit { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Second => "Second", + Self::Millisecond => "Millisecond", + Self::Microsecond => "Microsecond", + Self::Nanosecond => "Nanosecond", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for TimeUnit { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "Second", + "Millisecond", + "Microsecond", + "Nanosecond", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TimeUnit; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(TimeUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(TimeUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "Second" => Ok(TimeUnit::Second), + "Millisecond" => Ok(TimeUnit::Millisecond), + "Microsecond" => Ok(TimeUnit::Microsecond), + "Nanosecond" => Ok(TimeUnit::Nanosecond), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for Timestamp { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.time_unit != 0 { + len += 1; + } + if !self.timezone.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Timestamp", len)?; + if self.time_unit != 0 { + let v = TimeUnit::from_i32(self.time_unit) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.time_unit)))?; + struct_ser.serialize_field("timeUnit", &v)?; + } + if !self.timezone.is_empty() { + struct_ser.serialize_field("timezone", &self.timezone)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Timestamp { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timeUnit", + "timezone", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TimeUnit, + Timezone, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timeUnit" => Ok(GeneratedField::TimeUnit), + "timezone" => Ok(GeneratedField::Timezone), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Timestamp; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Timestamp") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut time_unit__ = None; + let mut timezone__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::TimeUnit => { + if time_unit__.is_some() { + return Err(serde::de::Error::duplicate_field("timeUnit")); + } + time_unit__ = Some(map.next_value::()? as i32); + } + GeneratedField::Timezone => { + if timezone__.is_some() { + return Err(serde::de::Error::duplicate_field("timezone")); + } + timezone__ = Some(map.next_value()?); + } + } + } + Ok(Timestamp { + time_unit: time_unit__.unwrap_or_default(), + timezone: timezone__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Timestamp", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TryCastNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.arrow_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.TryCastNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.arrow_type.as_ref() { + struct_ser.serialize_field("arrowType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TryCastNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + 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 = TryCastNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.TryCastNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + 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(TryCastNode { + expr: expr__, + arrow_type: arrow_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.TryCastNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Union { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.union_types.is_empty() { + len += 1; + } + if self.union_mode != 0 { + len += 1; + } + if !self.type_ids.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Union", len)?; + if !self.union_types.is_empty() { + struct_ser.serialize_field("unionTypes", &self.union_types)?; + } + if self.union_mode != 0 { + let v = UnionMode::from_i32(self.union_mode) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.union_mode)))?; + struct_ser.serialize_field("unionMode", &v)?; + } + if !self.type_ids.is_empty() { + struct_ser.serialize_field("typeIds", &self.type_ids)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Union { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "unionTypes", + "unionMode", + "typeIds", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + UnionTypes, + UnionMode, + TypeIds, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "unionTypes" => Ok(GeneratedField::UnionTypes), + "unionMode" => Ok(GeneratedField::UnionMode), + "typeIds" => Ok(GeneratedField::TypeIds), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Union; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Union") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut union_types__ = None; + let mut union_mode__ = None; + let mut type_ids__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::UnionTypes => { + if union_types__.is_some() { + return Err(serde::de::Error::duplicate_field("unionTypes")); + } + union_types__ = Some(map.next_value()?); + } + GeneratedField::UnionMode => { + if union_mode__.is_some() { + return Err(serde::de::Error::duplicate_field("unionMode")); + } + union_mode__ = Some(map.next_value::()? as i32); + } + GeneratedField::TypeIds => { + if type_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("typeIds")); + } + type_ids__ = Some( + map.next_value::>>()? + .into_iter().map(|x| x.0).collect() + ); + } + } + } + Ok(Union { + union_types: union_types__.unwrap_or_default(), + union_mode: union_mode__.unwrap_or_default(), + type_ids: type_ids__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Union", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UnionMode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Sparse => "sparse", + Self::Dense => "dense", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for UnionMode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sparse", + "dense", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnionMode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(UnionMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(UnionMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sparse" => Ok(UnionMode::Sparse), + "dense" => Ok(UnionMode::Dense), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for UnionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.inputs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.UnionNode", len)?; + if !self.inputs.is_empty() { + struct_ser.serialize_field("inputs", &self.inputs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "inputs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Inputs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "inputs" => Ok(GeneratedField::Inputs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.UnionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut inputs__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Inputs => { + if inputs__.is_some() { + return Err(serde::de::Error::duplicate_field("inputs")); + } + inputs__ = Some(map.next_value()?); + } + } + } + Ok(UnionNode { + inputs: inputs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.UnionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ValuesNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.n_cols != 0 { + len += 1; + } + if !self.values_list.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ValuesNode", len)?; + if self.n_cols != 0 { + struct_ser.serialize_field("nCols", ToString::to_string(&self.n_cols).as_str())?; + } + if !self.values_list.is_empty() { + struct_ser.serialize_field("valuesList", &self.values_list)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ValuesNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "nCols", + "valuesList", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + NCols, + ValuesList, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "nCols" => Ok(GeneratedField::NCols), + "valuesList" => Ok(GeneratedField::ValuesList), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ValuesNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ValuesNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut n_cols__ = None; + let mut values_list__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::NCols => { + if n_cols__.is_some() { + return Err(serde::de::Error::duplicate_field("nCols")); + } + n_cols__ = Some( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + ); + } + GeneratedField::ValuesList => { + if values_list__.is_some() { + return Err(serde::de::Error::duplicate_field("valuesList")); + } + values_list__ = Some(map.next_value()?); + } + } + } + Ok(ValuesNode { + n_cols: n_cols__.unwrap_or_default(), + values_list: values_list__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ValuesNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ViewTableScanNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.table_name.is_empty() { + len += 1; + } + if self.input.is_some() { + len += 1; + } + if self.schema.is_some() { + len += 1; + } + if self.projection.is_some() { + len += 1; + } + if !self.definition.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ViewTableScanNode", len)?; + if !self.table_name.is_empty() { + struct_ser.serialize_field("tableName", &self.table_name)?; + } + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if let Some(v) = self.projection.as_ref() { + struct_ser.serialize_field("projection", v)?; + } + if !self.definition.is_empty() { + struct_ser.serialize_field("definition", &self.definition)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ViewTableScanNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "tableName", + "input", + "schema", + "projection", + "definition", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TableName, + Input, + Schema, + Projection, + Definition, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "tableName" => Ok(GeneratedField::TableName), + "input" => Ok(GeneratedField::Input), + "schema" => Ok(GeneratedField::Schema), + "projection" => Ok(GeneratedField::Projection), + "definition" => Ok(GeneratedField::Definition), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ViewTableScanNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ViewTableScanNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut table_name__ = None; + let mut input__ = None; + let mut schema__ = None; + let mut projection__ = None; + let mut definition__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::TableName => { + if table_name__.is_some() { + return Err(serde::de::Error::duplicate_field("tableName")); + } + table_name__ = Some(map.next_value()?); + } + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = Some(map.next_value()?); + } + GeneratedField::Projection => { + if projection__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); + } + projection__ = Some(map.next_value()?); + } + GeneratedField::Definition => { + if definition__.is_some() { + return Err(serde::de::Error::duplicate_field("definition")); + } + definition__ = Some(map.next_value()?); + } + } + } + Ok(ViewTableScanNode { + table_name: table_name__.unwrap_or_default(), + input: input__, + schema: schema__, + projection: projection__, + definition: definition__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ViewTableScanNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WhenThen { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.when_expr.is_some() { + len += 1; + } + if self.then_expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WhenThen", len)?; + if let Some(v) = self.when_expr.as_ref() { + struct_ser.serialize_field("whenExpr", v)?; + } + if let Some(v) = self.then_expr.as_ref() { + struct_ser.serialize_field("thenExpr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WhenThen { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "whenExpr", + "thenExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WhenExpr, + ThenExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "whenExpr" => Ok(GeneratedField::WhenExpr), + "thenExpr" => Ok(GeneratedField::ThenExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WhenThen; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WhenThen") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut when_expr__ = None; + let mut then_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WhenExpr => { + if when_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("whenExpr")); + } + when_expr__ = Some(map.next_value()?); + } + GeneratedField::ThenExpr => { + if then_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("thenExpr")); + } + then_expr__ = Some(map.next_value()?); + } + } + } + Ok(WhenThen { + when_expr: when_expr__, + then_expr: then_expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.WhenThen", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.partition_by.is_empty() { + len += 1; + } + if !self.order_by.is_empty() { + len += 1; + } + if self.window_function.is_some() { + len += 1; + } + if self.window_frame.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowExprNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.partition_by.is_empty() { + struct_ser.serialize_field("partitionBy", &self.partition_by)?; + } + if !self.order_by.is_empty() { + struct_ser.serialize_field("orderBy", &self.order_by)?; + } + if let Some(v) = self.window_function.as_ref() { + match v { + window_expr_node::WindowFunction::AggrFunction(v) => { + let v = AggregateFunction::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("aggrFunction", &v)?; + } + window_expr_node::WindowFunction::BuiltInFunction(v) => { + let v = BuiltInWindowFunction::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("builtInFunction", &v)?; + } + } + } + if let Some(v) = self.window_frame.as_ref() { + match v { + window_expr_node::WindowFrame::Frame(v) => { + struct_ser.serialize_field("frame", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "partitionBy", + "orderBy", + "aggrFunction", + "builtInFunction", + "frame", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + PartitionBy, + OrderBy, + AggrFunction, + BuiltInFunction, + Frame, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "partitionBy" => Ok(GeneratedField::PartitionBy), + "orderBy" => Ok(GeneratedField::OrderBy), + "aggrFunction" => Ok(GeneratedField::AggrFunction), + "builtInFunction" => Ok(GeneratedField::BuiltInFunction), + "frame" => Ok(GeneratedField::Frame), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut partition_by__ = None; + let mut order_by__ = None; + let mut window_function__ = None; + let mut window_frame__ = 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::PartitionBy => { + if partition_by__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionBy")); + } + partition_by__ = Some(map.next_value()?); + } + GeneratedField::OrderBy => { + if order_by__.is_some() { + return Err(serde::de::Error::duplicate_field("orderBy")); + } + order_by__ = Some(map.next_value()?); + } + GeneratedField::AggrFunction => { + if window_function__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrFunction")); + } + window_function__ = Some(window_expr_node::WindowFunction::AggrFunction(map.next_value::()? as i32)); + } + GeneratedField::BuiltInFunction => { + if window_function__.is_some() { + return Err(serde::de::Error::duplicate_field("builtInFunction")); + } + window_function__ = Some(window_expr_node::WindowFunction::BuiltInFunction(map.next_value::()? as i32)); + } + GeneratedField::Frame => { + if window_frame__.is_some() { + return Err(serde::de::Error::duplicate_field("frame")); + } + window_frame__ = Some(window_expr_node::WindowFrame::Frame(map.next_value()?)); + } + } + } + Ok(WindowExprNode { + expr: expr__, + partition_by: partition_by__.unwrap_or_default(), + order_by: order_by__.unwrap_or_default(), + window_function: window_function__, + window_frame: window_frame__, + }) + } + } + deserializer.deserialize_struct("datafusion.WindowExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrame { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.window_frame_units != 0 { + len += 1; + } + if self.start_bound.is_some() { + len += 1; + } + if self.end_bound.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrame", len)?; + if self.window_frame_units != 0 { + let v = WindowFrameUnits::from_i32(self.window_frame_units) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_units)))?; + struct_ser.serialize_field("windowFrameUnits", &v)?; + } + if let Some(v) = self.start_bound.as_ref() { + struct_ser.serialize_field("startBound", v)?; + } + if let Some(v) = self.end_bound.as_ref() { + match v { + window_frame::EndBound::Bound(v) => { + struct_ser.serialize_field("bound", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowFrame { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "windowFrameUnits", + "startBound", + "bound", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WindowFrameUnits, + StartBound, + Bound, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "windowFrameUnits" => Ok(GeneratedField::WindowFrameUnits), + "startBound" => Ok(GeneratedField::StartBound), + "bound" => Ok(GeneratedField::Bound), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowFrame; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowFrame") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut window_frame_units__ = None; + let mut start_bound__ = None; + let mut end_bound__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WindowFrameUnits => { + if window_frame_units__.is_some() { + return Err(serde::de::Error::duplicate_field("windowFrameUnits")); + } + window_frame_units__ = Some(map.next_value::()? as i32); + } + GeneratedField::StartBound => { + if start_bound__.is_some() { + return Err(serde::de::Error::duplicate_field("startBound")); + } + start_bound__ = Some(map.next_value()?); + } + GeneratedField::Bound => { + if end_bound__.is_some() { + return Err(serde::de::Error::duplicate_field("bound")); + } + end_bound__ = Some(window_frame::EndBound::Bound(map.next_value()?)); + } + } + } + Ok(WindowFrame { + window_frame_units: window_frame_units__.unwrap_or_default(), + start_bound: start_bound__, + end_bound: end_bound__, + }) + } + } + deserializer.deserialize_struct("datafusion.WindowFrame", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrameBound { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.window_frame_bound_type != 0 { + len += 1; + } + if self.bound_value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrameBound", len)?; + if self.window_frame_bound_type != 0 { + let v = WindowFrameBoundType::from_i32(self.window_frame_bound_type) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_bound_type)))?; + struct_ser.serialize_field("windowFrameBoundType", &v)?; + } + if let Some(v) = self.bound_value.as_ref() { + match v { + window_frame_bound::BoundValue::Value(v) => { + struct_ser.serialize_field("value", ToString::to_string(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowFrameBound { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "windowFrameBoundType", + "value", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WindowFrameBoundType, + Value, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "windowFrameBoundType" => Ok(GeneratedField::WindowFrameBoundType), + "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 = WindowFrameBound; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowFrameBound") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut window_frame_bound_type__ = None; + let mut bound_value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WindowFrameBoundType => { + if window_frame_bound_type__.is_some() { + return Err(serde::de::Error::duplicate_field("windowFrameBoundType")); + } + window_frame_bound_type__ = Some(map.next_value::()? as i32); + } + GeneratedField::Value => { + if bound_value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + bound_value__ = Some(window_frame_bound::BoundValue::Value( + map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0 + )); + } + } + } + Ok(WindowFrameBound { + window_frame_bound_type: window_frame_bound_type__.unwrap_or_default(), + bound_value: bound_value__, + }) + } + } + deserializer.deserialize_struct("datafusion.WindowFrameBound", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrameBoundType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::CurrentRow => "CURRENT_ROW", + Self::Preceding => "PRECEDING", + Self::Following => "FOLLOWING", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for WindowFrameBoundType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "CURRENT_ROW", + "PRECEDING", + "FOLLOWING", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowFrameBoundType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameBoundType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameBoundType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "CURRENT_ROW" => Ok(WindowFrameBoundType::CurrentRow), + "PRECEDING" => Ok(WindowFrameBoundType::Preceding), + "FOLLOWING" => Ok(WindowFrameBoundType::Following), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for WindowFrameUnits { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Rows => "ROWS", + Self::Range => "RANGE", + Self::Groups => "GROUPS", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for WindowFrameUnits { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ROWS", + "RANGE", + "GROUPS", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowFrameUnits; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameUnits::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(WindowFrameUnits::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ROWS" => Ok(WindowFrameUnits::Rows), + "RANGE" => Ok(WindowFrameUnits::Range), + "GROUPS" => Ok(WindowFrameUnits::Groups), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for WindowNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.window_expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.window_expr.is_empty() { + struct_ser.serialize_field("windowExpr", &self.window_expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "windowExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + WindowExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "windowExpr" => Ok(GeneratedField::WindowExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut window_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = Some(map.next_value()?); + } + GeneratedField::WindowExpr => { + if window_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("windowExpr")); + } + window_expr__ = Some(map.next_value()?); + } + } + } + Ok(WindowNode { + input: input__, + window_expr: window_expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.WindowNode", FIELDS, GeneratedVisitor) + } +} diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs new file mode 100644 index 000000000000..c2a6a107c59a --- /dev/null +++ b/datafusion/proto/src/generated/prost.rs @@ -0,0 +1,1572 @@ +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ColumnRelation { + #[prost(string, tag="1")] + pub relation: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Column { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub relation: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DfField { + #[prost(message, optional, tag="1")] + pub field: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub qualifier: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DfSchema { + #[prost(message, repeated, tag="1")] + pub columns: ::prost::alloc::vec::Vec, + #[prost(map="string, string", tag="2")] + pub metadata: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, +} +/// logical plan +/// LogicalPlan is a nested type +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalPlanNode { + #[prost(oneof="logical_plan_node::LogicalPlanType", tags="1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24")] + pub logical_plan_type: ::core::option::Option, +} +/// Nested message and enum types in `LogicalPlanNode`. +pub mod logical_plan_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum LogicalPlanType { + #[prost(message, tag="1")] + ListingScan(super::ListingTableScanNode), + #[prost(message, tag="3")] + Projection(::prost::alloc::boxed::Box), + #[prost(message, tag="4")] + Selection(::prost::alloc::boxed::Box), + #[prost(message, tag="5")] + Limit(::prost::alloc::boxed::Box), + #[prost(message, tag="6")] + Aggregate(::prost::alloc::boxed::Box), + #[prost(message, tag="7")] + Join(::prost::alloc::boxed::Box), + #[prost(message, tag="8")] + Sort(::prost::alloc::boxed::Box), + #[prost(message, tag="9")] + Repartition(::prost::alloc::boxed::Box), + #[prost(message, tag="10")] + EmptyRelation(super::EmptyRelationNode), + #[prost(message, tag="11")] + CreateExternalTable(super::CreateExternalTableNode), + #[prost(message, tag="12")] + Explain(::prost::alloc::boxed::Box), + #[prost(message, tag="13")] + Window(::prost::alloc::boxed::Box), + #[prost(message, tag="14")] + Analyze(::prost::alloc::boxed::Box), + #[prost(message, tag="15")] + CrossJoin(::prost::alloc::boxed::Box), + #[prost(message, tag="16")] + Values(super::ValuesNode), + #[prost(message, tag="17")] + Extension(super::LogicalExtensionNode), + #[prost(message, tag="18")] + CreateCatalogSchema(super::CreateCatalogSchemaNode), + #[prost(message, tag="19")] + Union(super::UnionNode), + #[prost(message, tag="20")] + CreateCatalog(super::CreateCatalogNode), + #[prost(message, tag="21")] + SubqueryAlias(::prost::alloc::boxed::Box), + #[prost(message, tag="22")] + CreateView(::prost::alloc::boxed::Box), + #[prost(message, tag="23")] + Distinct(::prost::alloc::boxed::Box), + #[prost(message, tag="24")] + ViewScan(::prost::alloc::boxed::Box), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalExtensionNode { + #[prost(bytes="vec", tag="1")] + pub node: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="2")] + pub inputs: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ProjectionColumns { + #[prost(string, repeated, tag="1")] + pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CsvFormat { + #[prost(bool, tag="1")] + pub has_header: bool, + #[prost(string, tag="2")] + pub delimiter: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ParquetFormat { + #[prost(bool, tag="1")] + pub enable_pruning: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AvroFormat { +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListingTableScanNode { + #[prost(string, tag="1")] + pub table_name: ::prost::alloc::string::String, + #[prost(string, repeated, tag="2")] + pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag="3")] + pub file_extension: ::prost::alloc::string::String, + #[prost(message, optional, tag="4")] + pub projection: ::core::option::Option, + #[prost(message, optional, tag="5")] + pub schema: ::core::option::Option, + #[prost(message, repeated, tag="6")] + pub filters: ::prost::alloc::vec::Vec, + #[prost(string, repeated, tag="7")] + pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(bool, tag="8")] + pub collect_stat: bool, + #[prost(uint32, tag="9")] + pub target_partitions: u32, + #[prost(oneof="listing_table_scan_node::FileFormatType", tags="10, 11, 12")] + pub file_format_type: ::core::option::Option, +} +/// Nested message and enum types in `ListingTableScanNode`. +pub mod listing_table_scan_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum FileFormatType { + #[prost(message, tag="10")] + Csv(super::CsvFormat), + #[prost(message, tag="11")] + Parquet(super::ParquetFormat), + #[prost(message, tag="12")] + Avro(super::AvroFormat), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ViewTableScanNode { + #[prost(string, tag="1")] + pub table_name: ::prost::alloc::string::String, + #[prost(message, optional, boxed, tag="2")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag="3")] + pub schema: ::core::option::Option, + #[prost(message, optional, tag="4")] + pub projection: ::core::option::Option, + #[prost(string, tag="5")] + pub definition: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ProjectionNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag="2")] + pub expr: ::prost::alloc::vec::Vec, + #[prost(oneof="projection_node::OptionalAlias", tags="3")] + pub optional_alias: ::core::option::Option, +} +/// Nested message and enum types in `ProjectionNode`. +pub mod projection_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum OptionalAlias { + #[prost(string, tag="3")] + Alias(::prost::alloc::string::String), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SelectionNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag="2")] + pub expr: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SortNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag="2")] + pub expr: ::prost::alloc::vec::Vec, + /// Maximum number of highest/lowest rows to fetch; negative means no limit + #[prost(int64, tag="3")] + pub fetch: i64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RepartitionNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(oneof="repartition_node::PartitionMethod", tags="2, 3")] + pub partition_method: ::core::option::Option, +} +/// Nested message and enum types in `RepartitionNode`. +pub mod repartition_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PartitionMethod { + #[prost(uint64, tag="2")] + RoundRobin(u64), + #[prost(message, tag="3")] + Hash(super::HashRepartition), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HashRepartition { + #[prost(message, repeated, tag="1")] + pub hash_expr: ::prost::alloc::vec::Vec, + #[prost(uint64, tag="2")] + pub partition_count: u64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EmptyRelationNode { + #[prost(bool, tag="1")] + pub produce_one_row: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateExternalTableNode { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub location: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub file_type: ::prost::alloc::string::String, + #[prost(bool, tag="4")] + pub has_header: bool, + #[prost(message, optional, tag="5")] + pub schema: ::core::option::Option, + #[prost(string, repeated, tag="6")] + pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(bool, tag="7")] + pub if_not_exists: bool, + #[prost(string, tag="8")] + pub delimiter: ::prost::alloc::string::String, + #[prost(string, tag="9")] + pub definition: ::prost::alloc::string::String, + #[prost(string, tag="10")] + pub file_compression_type: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateCatalogSchemaNode { + #[prost(string, tag="1")] + pub schema_name: ::prost::alloc::string::String, + #[prost(bool, tag="2")] + pub if_not_exists: bool, + #[prost(message, optional, tag="3")] + pub schema: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateCatalogNode { + #[prost(string, tag="1")] + pub catalog_name: ::prost::alloc::string::String, + #[prost(bool, tag="2")] + pub if_not_exists: bool, + #[prost(message, optional, tag="3")] + pub schema: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateViewNode { + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, boxed, tag="2")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag="3")] + pub or_replace: bool, + #[prost(string, tag="4")] + pub definition: ::prost::alloc::string::String, +} +/// a node containing data for defining values list. unlike in SQL where it's two dimensional, here +/// the list is flattened, and with the field n_cols it can be parsed and partitioned into rows +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ValuesNode { + #[prost(uint64, tag="1")] + pub n_cols: u64, + #[prost(message, repeated, tag="2")] + pub values_list: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AnalyzeNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag="2")] + pub verbose: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExplainNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag="2")] + pub verbose: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AggregateNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag="2")] + pub group_expr: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="3")] + pub aggr_expr: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag="2")] + pub window_expr: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JoinNode { + #[prost(message, optional, boxed, tag="1")] + pub left: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="2")] + pub right: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(enumeration="JoinType", tag="3")] + pub join_type: i32, + #[prost(enumeration="JoinConstraint", tag="4")] + pub join_constraint: i32, + #[prost(message, repeated, tag="5")] + pub left_join_column: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="6")] + pub right_join_column: ::prost::alloc::vec::Vec, + #[prost(bool, tag="7")] + pub null_equals_null: bool, + #[prost(message, optional, tag="8")] + pub filter: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DistinctNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnionNode { + #[prost(message, repeated, tag="1")] + pub inputs: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CrossJoinNode { + #[prost(message, optional, boxed, tag="1")] + pub left: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="2")] + pub right: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LimitNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + /// The number of rows to skip before fetch; non-positive means don't skip any + #[prost(int64, tag="2")] + pub skip: i64, + /// Maximum number of rows to fetch; negative means no limit + #[prost(int64, tag="3")] + pub fetch: i64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SelectionExecNode { + #[prost(message, optional, tag="1")] + pub expr: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubqueryAliasNode { + #[prost(message, optional, boxed, tag="1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag="2")] + pub alias: ::prost::alloc::string::String, +} +/// logical expressions +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalExprNode { + #[prost(oneof="logical_expr_node::ExprType", tags="1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33")] + pub expr_type: ::core::option::Option, +} +/// Nested message and enum types in `LogicalExprNode`. +pub mod logical_expr_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ExprType { + /// column references + #[prost(message, tag="1")] + Column(super::Column), + /// alias + #[prost(message, tag="2")] + Alias(::prost::alloc::boxed::Box), + #[prost(message, tag="3")] + Literal(super::ScalarValue), + /// binary expressions + #[prost(message, tag="4")] + BinaryExpr(::prost::alloc::boxed::Box), + /// aggregate expressions + #[prost(message, tag="5")] + AggregateExpr(::prost::alloc::boxed::Box), + /// null checks + #[prost(message, tag="6")] + IsNullExpr(::prost::alloc::boxed::Box), + #[prost(message, tag="7")] + IsNotNullExpr(::prost::alloc::boxed::Box), + #[prost(message, tag="8")] + NotExpr(::prost::alloc::boxed::Box), + #[prost(message, tag="9")] + Between(::prost::alloc::boxed::Box), + #[prost(message, tag="10")] + Case(::prost::alloc::boxed::Box), + #[prost(message, tag="11")] + Cast(::prost::alloc::boxed::Box), + #[prost(message, tag="12")] + Sort(::prost::alloc::boxed::Box), + #[prost(message, tag="13")] + Negative(::prost::alloc::boxed::Box), + #[prost(message, tag="14")] + InList(::prost::alloc::boxed::Box), + #[prost(bool, tag="15")] + Wildcard(bool), + #[prost(message, tag="16")] + ScalarFunction(super::ScalarFunctionNode), + #[prost(message, tag="17")] + TryCast(::prost::alloc::boxed::Box), + /// window expressions + #[prost(message, tag="18")] + WindowExpr(::prost::alloc::boxed::Box), + /// AggregateUDF expressions + #[prost(message, tag="19")] + AggregateUdfExpr(::prost::alloc::boxed::Box), + /// Scalar UDF expressions + #[prost(message, tag="20")] + ScalarUdfExpr(super::ScalarUdfExprNode), + #[prost(message, tag="21")] + GetIndexedField(::prost::alloc::boxed::Box), + #[prost(message, tag="22")] + GroupingSet(super::GroupingSetNode), + #[prost(message, tag="23")] + Cube(super::CubeNode), + #[prost(message, tag="24")] + Rollup(super::RollupNode), + #[prost(message, tag="25")] + IsTrue(::prost::alloc::boxed::Box), + #[prost(message, tag="26")] + IsFalse(::prost::alloc::boxed::Box), + #[prost(message, tag="27")] + IsUnknown(::prost::alloc::boxed::Box), + #[prost(message, tag="28")] + IsNotTrue(::prost::alloc::boxed::Box), + #[prost(message, tag="29")] + IsNotFalse(::prost::alloc::boxed::Box), + #[prost(message, tag="30")] + IsNotUnknown(::prost::alloc::boxed::Box), + #[prost(message, tag="31")] + Like(::prost::alloc::boxed::Box), + #[prost(message, tag="32")] + Ilike(::prost::alloc::boxed::Box), + #[prost(message, tag="33")] + SimilarTo(::prost::alloc::boxed::Box), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LogicalExprList { + #[prost(message, repeated, tag="1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GroupingSetNode { + #[prost(message, repeated, tag="1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CubeNode { + #[prost(message, repeated, tag="1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RollupNode { + #[prost(message, repeated, tag="1")] + pub expr: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GetIndexedField { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag="2")] + pub key: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNull { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotNull { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsTrue { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsFalse { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsUnknown { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotTrue { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotFalse { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IsNotUnknown { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Not { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AliasNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag="2")] + pub alias: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BinaryExprNode { + #[prost(message, optional, boxed, tag="1")] + pub l: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="2")] + pub r: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag="3")] + pub op: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NegativeNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InListNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag="2")] + pub list: ::prost::alloc::vec::Vec, + #[prost(bool, tag="3")] + pub negated: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarFunctionNode { + #[prost(enumeration="ScalarFunction", tag="1")] + pub fun: i32, + #[prost(message, repeated, tag="2")] + pub args: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AggregateExprNode { + #[prost(enumeration="AggregateFunction", tag="1")] + pub aggr_function: i32, + #[prost(message, repeated, tag="2")] + pub expr: ::prost::alloc::vec::Vec, + #[prost(bool, tag="3")] + pub distinct: bool, + #[prost(message, optional, boxed, tag="4")] + pub filter: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AggregateUdfExprNode { + #[prost(string, tag="1")] + pub fun_name: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub args: ::prost::alloc::vec::Vec, + #[prost(message, optional, boxed, tag="3")] + pub filter: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarUdfExprNode { + #[prost(string, tag="1")] + pub fun_name: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub args: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowExprNode { + #[prost(message, optional, boxed, tag="4")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag="5")] + pub partition_by: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="6")] + pub order_by: ::prost::alloc::vec::Vec, + #[prost(oneof="window_expr_node::WindowFunction", tags="1, 2")] + pub window_function: ::core::option::Option, + /// repeated LogicalExprNode filter = 7; + #[prost(oneof="window_expr_node::WindowFrame", tags="8")] + pub window_frame: ::core::option::Option, +} +/// Nested message and enum types in `WindowExprNode`. +pub mod window_expr_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum WindowFunction { + #[prost(enumeration="super::AggregateFunction", tag="1")] + AggrFunction(i32), + /// udaf = 3 + #[prost(enumeration="super::BuiltInWindowFunction", tag="2")] + BuiltInFunction(i32), + } + /// repeated LogicalExprNode filter = 7; + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum WindowFrame { + #[prost(message, tag="8")] + Frame(super::WindowFrame), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BetweenNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag="2")] + pub negated: bool, + #[prost(message, optional, boxed, tag="3")] + pub low: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="4")] + pub high: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LikeNode { + #[prost(bool, tag="1")] + pub negated: bool, + #[prost(message, optional, boxed, tag="2")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="3")] + pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag="4")] + pub escape_char: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ILikeNode { + #[prost(bool, tag="1")] + pub negated: bool, + #[prost(message, optional, boxed, tag="2")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="3")] + pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag="4")] + pub escape_char: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SimilarToNode { + #[prost(bool, tag="1")] + pub negated: bool, + #[prost(message, optional, boxed, tag="2")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="3")] + pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag="4")] + pub escape_char: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CaseNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag="2")] + pub when_then_expr: ::prost::alloc::vec::Vec, + #[prost(message, optional, boxed, tag="3")] + pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WhenThen { + #[prost(message, optional, tag="1")] + pub when_expr: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub then_expr: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CastNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag="2")] + pub arrow_type: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TryCastNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag="2")] + pub arrow_type: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SortExprNode { + #[prost(message, optional, boxed, tag="1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag="2")] + pub asc: bool, + #[prost(bool, tag="3")] + pub nulls_first: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowFrame { + #[prost(enumeration="WindowFrameUnits", tag="1")] + pub window_frame_units: i32, + #[prost(message, optional, tag="2")] + pub start_bound: ::core::option::Option, + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[prost(oneof="window_frame::EndBound", tags="3")] + pub end_bound: ::core::option::Option, +} +/// Nested message and enum types in `WindowFrame`. +pub mod window_frame { + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum EndBound { + #[prost(message, tag="3")] + Bound(super::WindowFrameBound), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowFrameBound { + #[prost(enumeration="WindowFrameBoundType", tag="1")] + pub window_frame_bound_type: i32, + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[prost(oneof="window_frame_bound::BoundValue", tags="2")] + pub bound_value: ::core::option::Option, +} +/// Nested message and enum types in `WindowFrameBound`. +pub mod window_frame_bound { + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum BoundValue { + #[prost(uint64, tag="2")] + Value(u64), + } +} +// ///////////////////////////////////////////////////////////////////////////////////////////////// +// Arrow Data Types +// ///////////////////////////////////////////////////////////////////////////////////////////////// + +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Schema { + #[prost(message, repeated, tag="1")] + pub columns: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Field { + /// name of the field + #[prost(string, tag="1")] + pub name: ::prost::alloc::string::String, + #[prost(message, optional, boxed, tag="2")] + pub arrow_type: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag="3")] + pub nullable: bool, + /// for complex data types like structs, unions + #[prost(message, repeated, tag="4")] + pub children: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FixedSizeBinary { + #[prost(int32, tag="1")] + pub length: i32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Timestamp { + #[prost(enumeration="TimeUnit", tag="1")] + pub time_unit: i32, + #[prost(string, tag="2")] + pub timezone: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Decimal { + #[prost(uint64, tag="1")] + pub whole: u64, + #[prost(uint64, tag="2")] + pub fractional: u64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct List { + #[prost(message, optional, boxed, tag="1")] + pub field_type: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FixedSizeList { + #[prost(message, optional, boxed, tag="1")] + pub field_type: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(int32, tag="2")] + pub list_size: i32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Dictionary { + #[prost(message, optional, boxed, tag="1")] + pub key: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag="2")] + pub value: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Struct { + #[prost(message, repeated, tag="1")] + pub sub_field_types: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Union { + #[prost(message, repeated, tag="1")] + pub union_types: ::prost::alloc::vec::Vec, + #[prost(enumeration="UnionMode", tag="2")] + pub union_mode: i32, + #[prost(int32, repeated, tag="3")] + pub type_ids: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarListValue { + /// encode null explicitly to distinguish a list with a null value + /// from a list with no values) + #[prost(bool, tag="3")] + pub is_null: bool, + #[prost(message, optional, tag="1")] + pub field: ::core::option::Option, + #[prost(message, repeated, tag="2")] + pub values: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarTimestampValue { + #[prost(string, tag="5")] + pub timezone: ::prost::alloc::string::String, + #[prost(oneof="scalar_timestamp_value::Value", tags="1, 2, 3, 4")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `ScalarTimestampValue`. +pub mod scalar_timestamp_value { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + #[prost(int64, tag="1")] + TimeMicrosecondValue(i64), + #[prost(int64, tag="2")] + TimeNanosecondValue(i64), + #[prost(int64, tag="3")] + TimeSecondValue(i64), + #[prost(int64, tag="4")] + TimeMillisecondValue(i64), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarDictionaryValue { + #[prost(message, optional, tag="1")] + pub index_type: ::core::option::Option, + #[prost(message, optional, boxed, tag="2")] + pub value: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IntervalMonthDayNanoValue { + #[prost(int32, tag="1")] + pub months: i32, + #[prost(int32, tag="2")] + pub days: i32, + #[prost(int64, tag="3")] + pub nanos: i64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StructValue { + /// Note that a null struct value must have one or more fields, so we + /// encode a null StructValue as one witth an empty field_values + /// list. + #[prost(message, repeated, tag="2")] + pub field_values: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="3")] + pub fields: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScalarValue { + #[prost(oneof="scalar_value::Value", tags="19, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 20, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32")] + pub value: ::core::option::Option, +} +/// Nested message and enum types in `ScalarValue`. +pub mod scalar_value { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Value { + /// Null value of any type (type is encoded) + #[prost(enumeration="super::PrimitiveScalarType", tag="19")] + NullValue(i32), + #[prost(bool, tag="1")] + BoolValue(bool), + #[prost(string, tag="2")] + Utf8Value(::prost::alloc::string::String), + #[prost(string, tag="3")] + LargeUtf8Value(::prost::alloc::string::String), + #[prost(int32, tag="4")] + Int8Value(i32), + #[prost(int32, tag="5")] + Int16Value(i32), + #[prost(int32, tag="6")] + Int32Value(i32), + #[prost(int64, tag="7")] + Int64Value(i64), + #[prost(uint32, tag="8")] + Uint8Value(u32), + #[prost(uint32, tag="9")] + Uint16Value(u32), + #[prost(uint32, tag="10")] + Uint32Value(u32), + #[prost(uint64, tag="11")] + Uint64Value(u64), + #[prost(float, tag="12")] + Float32Value(f32), + #[prost(double, tag="13")] + Float64Value(f64), + /// Literal Date32 value always has a unit of day + #[prost(int32, tag="14")] + Date32Value(i32), + /// WAS: ScalarType null_list_value = 18; + #[prost(message, tag="17")] + ListValue(super::ScalarListValue), + #[prost(message, tag="20")] + Decimal128Value(super::Decimal128), + #[prost(int64, tag="21")] + Date64Value(i64), + #[prost(int32, tag="24")] + IntervalYearmonthValue(i32), + #[prost(int64, tag="25")] + IntervalDaytimeValue(i64), + #[prost(message, tag="26")] + TimestampValue(super::ScalarTimestampValue), + #[prost(message, tag="27")] + DictionaryValue(::prost::alloc::boxed::Box), + #[prost(bytes, tag="28")] + BinaryValue(::prost::alloc::vec::Vec), + #[prost(bytes, tag="29")] + LargeBinaryValue(::prost::alloc::vec::Vec), + #[prost(int64, tag="30")] + Time64Value(i64), + #[prost(message, tag="31")] + IntervalMonthDayNano(super::IntervalMonthDayNanoValue), + #[prost(message, tag="32")] + StructValue(super::StructValue), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Decimal128 { + #[prost(bytes="vec", tag="1")] + pub value: ::prost::alloc::vec::Vec, + #[prost(int64, tag="2")] + pub p: i64, + #[prost(int64, tag="3")] + pub s: i64, +} +/// Broke out into multiple message types so that type +/// metadata did not need to be in separate message +/// All types that are of the empty message types contain no additional metadata +/// about the type +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ArrowType { + #[prost(oneof="arrow_type::ArrowTypeEnum", tags="1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 32, 15, 16, 31, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30")] + pub arrow_type_enum: ::core::option::Option, +} +/// Nested message and enum types in `ArrowType`. +pub mod arrow_type { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ArrowTypeEnum { + /// arrow::Type::NA + #[prost(message, tag="1")] + None(super::EmptyMessage), + /// arrow::Type::BOOL + #[prost(message, tag="2")] + Bool(super::EmptyMessage), + /// arrow::Type::UINT8 + #[prost(message, tag="3")] + Uint8(super::EmptyMessage), + /// arrow::Type::INT8 + #[prost(message, tag="4")] + Int8(super::EmptyMessage), + /// represents arrow::Type fields in src/arrow/type.h + #[prost(message, tag="5")] + Uint16(super::EmptyMessage), + #[prost(message, tag="6")] + Int16(super::EmptyMessage), + #[prost(message, tag="7")] + Uint32(super::EmptyMessage), + #[prost(message, tag="8")] + Int32(super::EmptyMessage), + #[prost(message, tag="9")] + Uint64(super::EmptyMessage), + #[prost(message, tag="10")] + Int64(super::EmptyMessage), + #[prost(message, tag="11")] + Float16(super::EmptyMessage), + #[prost(message, tag="12")] + Float32(super::EmptyMessage), + #[prost(message, tag="13")] + Float64(super::EmptyMessage), + #[prost(message, tag="14")] + Utf8(super::EmptyMessage), + #[prost(message, tag="32")] + LargeUtf8(super::EmptyMessage), + #[prost(message, tag="15")] + Binary(super::EmptyMessage), + #[prost(int32, tag="16")] + FixedSizeBinary(i32), + #[prost(message, tag="31")] + LargeBinary(super::EmptyMessage), + #[prost(message, tag="17")] + Date32(super::EmptyMessage), + #[prost(message, tag="18")] + Date64(super::EmptyMessage), + #[prost(enumeration="super::TimeUnit", tag="19")] + Duration(i32), + #[prost(message, tag="20")] + Timestamp(super::Timestamp), + #[prost(enumeration="super::TimeUnit", tag="21")] + Time32(i32), + #[prost(enumeration="super::TimeUnit", tag="22")] + Time64(i32), + #[prost(enumeration="super::IntervalUnit", tag="23")] + Interval(i32), + #[prost(message, tag="24")] + Decimal(super::Decimal), + #[prost(message, tag="25")] + List(::prost::alloc::boxed::Box), + #[prost(message, tag="26")] + LargeList(::prost::alloc::boxed::Box), + #[prost(message, tag="27")] + FixedSizeList(::prost::alloc::boxed::Box), + #[prost(message, tag="28")] + Struct(super::Struct), + #[prost(message, tag="29")] + Union(super::Union), + #[prost(message, tag="30")] + Dictionary(::prost::alloc::boxed::Box), + } +} +/// Useful for representing an empty enum variant in rust +/// E.G. enum example{One, Two(i32)} +/// maps to +/// message example{ +/// oneof{ +/// EmptyMessage One = 1; +/// i32 Two = 2; +/// } +/// } +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EmptyMessage { +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OptimizedLogicalPlanType { + #[prost(string, tag="1")] + pub optimizer_name: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct OptimizedPhysicalPlanType { + #[prost(string, tag="1")] + pub optimizer_name: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PlanType { + #[prost(oneof="plan_type::PlanTypeEnum", tags="1, 2, 3, 4, 5, 6")] + pub plan_type_enum: ::core::option::Option, +} +/// Nested message and enum types in `PlanType`. +pub mod plan_type { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PlanTypeEnum { + #[prost(message, tag="1")] + InitialLogicalPlan(super::EmptyMessage), + #[prost(message, tag="2")] + OptimizedLogicalPlan(super::OptimizedLogicalPlanType), + #[prost(message, tag="3")] + FinalLogicalPlan(super::EmptyMessage), + #[prost(message, tag="4")] + InitialPhysicalPlan(super::EmptyMessage), + #[prost(message, tag="5")] + OptimizedPhysicalPlan(super::OptimizedPhysicalPlanType), + #[prost(message, tag="6")] + FinalPhysicalPlan(super::EmptyMessage), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct StringifiedPlan { + #[prost(message, optional, tag="1")] + pub plan_type: ::core::option::Option, + #[prost(string, tag="2")] + pub plan: ::prost::alloc::string::String, +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum JoinType { + Inner = 0, + Left = 1, + Right = 2, + Full = 3, + Semi = 4, + Anti = 5, +} +impl JoinType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + JoinType::Inner => "INNER", + JoinType::Left => "LEFT", + JoinType::Right => "RIGHT", + JoinType::Full => "FULL", + JoinType::Semi => "SEMI", + JoinType::Anti => "ANTI", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum JoinConstraint { + On = 0, + Using = 1, +} +impl JoinConstraint { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + JoinConstraint::On => "ON", + JoinConstraint::Using => "USING", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ScalarFunction { + Abs = 0, + Acos = 1, + Asin = 2, + Atan = 3, + Ascii = 4, + Ceil = 5, + Cos = 6, + Digest = 7, + Exp = 8, + Floor = 9, + Ln = 10, + Log = 11, + Log10 = 12, + Log2 = 13, + Round = 14, + Signum = 15, + Sin = 16, + Sqrt = 17, + Tan = 18, + Trunc = 19, + Array = 20, + RegexpMatch = 21, + BitLength = 22, + Btrim = 23, + CharacterLength = 24, + Chr = 25, + Concat = 26, + ConcatWithSeparator = 27, + DatePart = 28, + DateTrunc = 29, + InitCap = 30, + Left = 31, + Lpad = 32, + Lower = 33, + Ltrim = 34, + Md5 = 35, + NullIf = 36, + OctetLength = 37, + Random = 38, + RegexpReplace = 39, + Repeat = 40, + Replace = 41, + Reverse = 42, + Right = 43, + Rpad = 44, + Rtrim = 45, + Sha224 = 46, + Sha256 = 47, + Sha384 = 48, + Sha512 = 49, + SplitPart = 50, + StartsWith = 51, + Strpos = 52, + Substr = 53, + ToHex = 54, + ToTimestamp = 55, + ToTimestampMillis = 56, + ToTimestampMicros = 57, + ToTimestampSeconds = 58, + Now = 59, + Translate = 60, + Trim = 61, + Upper = 62, + Coalesce = 63, + Power = 64, + StructFun = 65, + FromUnixtime = 66, + Atan2 = 67, + DateBin = 68, + ArrowTypeof = 69, +} +impl ScalarFunction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ScalarFunction::Abs => "Abs", + ScalarFunction::Acos => "Acos", + ScalarFunction::Asin => "Asin", + ScalarFunction::Atan => "Atan", + ScalarFunction::Ascii => "Ascii", + ScalarFunction::Ceil => "Ceil", + ScalarFunction::Cos => "Cos", + ScalarFunction::Digest => "Digest", + ScalarFunction::Exp => "Exp", + ScalarFunction::Floor => "Floor", + ScalarFunction::Ln => "Ln", + ScalarFunction::Log => "Log", + ScalarFunction::Log10 => "Log10", + ScalarFunction::Log2 => "Log2", + ScalarFunction::Round => "Round", + ScalarFunction::Signum => "Signum", + ScalarFunction::Sin => "Sin", + ScalarFunction::Sqrt => "Sqrt", + ScalarFunction::Tan => "Tan", + ScalarFunction::Trunc => "Trunc", + ScalarFunction::Array => "Array", + ScalarFunction::RegexpMatch => "RegexpMatch", + ScalarFunction::BitLength => "BitLength", + ScalarFunction::Btrim => "Btrim", + ScalarFunction::CharacterLength => "CharacterLength", + ScalarFunction::Chr => "Chr", + ScalarFunction::Concat => "Concat", + ScalarFunction::ConcatWithSeparator => "ConcatWithSeparator", + ScalarFunction::DatePart => "DatePart", + ScalarFunction::DateTrunc => "DateTrunc", + ScalarFunction::InitCap => "InitCap", + ScalarFunction::Left => "Left", + ScalarFunction::Lpad => "Lpad", + ScalarFunction::Lower => "Lower", + ScalarFunction::Ltrim => "Ltrim", + ScalarFunction::Md5 => "MD5", + ScalarFunction::NullIf => "NullIf", + ScalarFunction::OctetLength => "OctetLength", + ScalarFunction::Random => "Random", + ScalarFunction::RegexpReplace => "RegexpReplace", + ScalarFunction::Repeat => "Repeat", + ScalarFunction::Replace => "Replace", + ScalarFunction::Reverse => "Reverse", + ScalarFunction::Right => "Right", + ScalarFunction::Rpad => "Rpad", + ScalarFunction::Rtrim => "Rtrim", + ScalarFunction::Sha224 => "SHA224", + ScalarFunction::Sha256 => "SHA256", + ScalarFunction::Sha384 => "SHA384", + ScalarFunction::Sha512 => "SHA512", + ScalarFunction::SplitPart => "SplitPart", + ScalarFunction::StartsWith => "StartsWith", + ScalarFunction::Strpos => "Strpos", + ScalarFunction::Substr => "Substr", + ScalarFunction::ToHex => "ToHex", + ScalarFunction::ToTimestamp => "ToTimestamp", + ScalarFunction::ToTimestampMillis => "ToTimestampMillis", + ScalarFunction::ToTimestampMicros => "ToTimestampMicros", + ScalarFunction::ToTimestampSeconds => "ToTimestampSeconds", + ScalarFunction::Now => "Now", + ScalarFunction::Translate => "Translate", + ScalarFunction::Trim => "Trim", + ScalarFunction::Upper => "Upper", + ScalarFunction::Coalesce => "Coalesce", + ScalarFunction::Power => "Power", + ScalarFunction::StructFun => "StructFun", + ScalarFunction::FromUnixtime => "FromUnixtime", + ScalarFunction::Atan2 => "Atan2", + ScalarFunction::DateBin => "DateBin", + ScalarFunction::ArrowTypeof => "ArrowTypeof", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AggregateFunction { + Min = 0, + Max = 1, + Sum = 2, + Avg = 3, + Count = 4, + ApproxDistinct = 5, + ArrayAgg = 6, + Variance = 7, + VariancePop = 8, + Covariance = 9, + CovariancePop = 10, + Stddev = 11, + StddevPop = 12, + Correlation = 13, + ApproxPercentileCont = 14, + ApproxMedian = 15, + ApproxPercentileContWithWeight = 16, + Grouping = 17, + Median = 18, +} +impl AggregateFunction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AggregateFunction::Min => "MIN", + AggregateFunction::Max => "MAX", + AggregateFunction::Sum => "SUM", + AggregateFunction::Avg => "AVG", + AggregateFunction::Count => "COUNT", + AggregateFunction::ApproxDistinct => "APPROX_DISTINCT", + AggregateFunction::ArrayAgg => "ARRAY_AGG", + AggregateFunction::Variance => "VARIANCE", + AggregateFunction::VariancePop => "VARIANCE_POP", + AggregateFunction::Covariance => "COVARIANCE", + AggregateFunction::CovariancePop => "COVARIANCE_POP", + AggregateFunction::Stddev => "STDDEV", + AggregateFunction::StddevPop => "STDDEV_POP", + AggregateFunction::Correlation => "CORRELATION", + AggregateFunction::ApproxPercentileCont => "APPROX_PERCENTILE_CONT", + AggregateFunction::ApproxMedian => "APPROX_MEDIAN", + AggregateFunction::ApproxPercentileContWithWeight => "APPROX_PERCENTILE_CONT_WITH_WEIGHT", + AggregateFunction::Grouping => "GROUPING", + AggregateFunction::Median => "MEDIAN", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum BuiltInWindowFunction { + RowNumber = 0, + Rank = 1, + DenseRank = 2, + PercentRank = 3, + CumeDist = 4, + Ntile = 5, + Lag = 6, + Lead = 7, + FirstValue = 8, + LastValue = 9, + NthValue = 10, +} +impl BuiltInWindowFunction { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + BuiltInWindowFunction::RowNumber => "ROW_NUMBER", + BuiltInWindowFunction::Rank => "RANK", + BuiltInWindowFunction::DenseRank => "DENSE_RANK", + BuiltInWindowFunction::PercentRank => "PERCENT_RANK", + BuiltInWindowFunction::CumeDist => "CUME_DIST", + BuiltInWindowFunction::Ntile => "NTILE", + BuiltInWindowFunction::Lag => "LAG", + BuiltInWindowFunction::Lead => "LEAD", + BuiltInWindowFunction::FirstValue => "FIRST_VALUE", + BuiltInWindowFunction::LastValue => "LAST_VALUE", + BuiltInWindowFunction::NthValue => "NTH_VALUE", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum WindowFrameUnits { + Rows = 0, + Range = 1, + Groups = 2, +} +impl WindowFrameUnits { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + WindowFrameUnits::Rows => "ROWS", + WindowFrameUnits::Range => "RANGE", + WindowFrameUnits::Groups => "GROUPS", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum WindowFrameBoundType { + CurrentRow = 0, + Preceding = 1, + Following = 2, +} +impl WindowFrameBoundType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + WindowFrameBoundType::CurrentRow => "CURRENT_ROW", + WindowFrameBoundType::Preceding => "PRECEDING", + WindowFrameBoundType::Following => "FOLLOWING", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum DateUnit { + Day = 0, + DateMillisecond = 1, +} +impl DateUnit { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DateUnit::Day => "Day", + DateUnit::DateMillisecond => "DateMillisecond", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum TimeUnit { + Second = 0, + Millisecond = 1, + Microsecond = 2, + Nanosecond = 3, +} +impl TimeUnit { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + TimeUnit::Second => "Second", + TimeUnit::Millisecond => "Millisecond", + TimeUnit::Microsecond => "Microsecond", + TimeUnit::Nanosecond => "Nanosecond", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum IntervalUnit { + YearMonth = 0, + DayTime = 1, + MonthDayNano = 2, +} +impl IntervalUnit { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + IntervalUnit::YearMonth => "YearMonth", + IntervalUnit::DayTime => "DayTime", + IntervalUnit::MonthDayNano => "MonthDayNano", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum UnionMode { + Sparse = 0, + Dense = 1, +} +impl UnionMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + UnionMode::Sparse => "sparse", + UnionMode::Dense => "dense", + } + } +} +/// Contains all valid datafusion scalar type except for +/// List +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum PrimitiveScalarType { + /// arrow::Type::BOOL + Bool = 0, + /// arrow::Type::UINT8 + Uint8 = 1, + /// arrow::Type::INT8 + Int8 = 2, + /// represents arrow::Type fields in src/arrow/type.h + Uint16 = 3, + Int16 = 4, + Uint32 = 5, + Int32 = 6, + Uint64 = 7, + Int64 = 8, + Float32 = 9, + Float64 = 10, + Utf8 = 11, + LargeUtf8 = 12, + Date32 = 13, + TimestampMicrosecond = 14, + TimestampNanosecond = 15, + Null = 16, + Decimal128 = 17, + Date64 = 20, + TimestampSecond = 21, + TimestampMillisecond = 22, + IntervalYearmonth = 23, + IntervalDaytime = 24, + IntervalMonthdaynano = 28, + Binary = 25, + LargeBinary = 26, + Time64 = 27, +} +impl PrimitiveScalarType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + PrimitiveScalarType::Bool => "BOOL", + PrimitiveScalarType::Uint8 => "UINT8", + PrimitiveScalarType::Int8 => "INT8", + PrimitiveScalarType::Uint16 => "UINT16", + PrimitiveScalarType::Int16 => "INT16", + PrimitiveScalarType::Uint32 => "UINT32", + PrimitiveScalarType::Int32 => "INT32", + PrimitiveScalarType::Uint64 => "UINT64", + PrimitiveScalarType::Int64 => "INT64", + PrimitiveScalarType::Float32 => "FLOAT32", + PrimitiveScalarType::Float64 => "FLOAT64", + PrimitiveScalarType::Utf8 => "UTF8", + PrimitiveScalarType::LargeUtf8 => "LARGE_UTF8", + PrimitiveScalarType::Date32 => "DATE32", + PrimitiveScalarType::TimestampMicrosecond => "TIMESTAMP_MICROSECOND", + PrimitiveScalarType::TimestampNanosecond => "TIMESTAMP_NANOSECOND", + PrimitiveScalarType::Null => "NULL", + PrimitiveScalarType::Decimal128 => "DECIMAL128", + PrimitiveScalarType::Date64 => "DATE64", + PrimitiveScalarType::TimestampSecond => "TIMESTAMP_SECOND", + PrimitiveScalarType::TimestampMillisecond => "TIMESTAMP_MILLISECOND", + PrimitiveScalarType::IntervalYearmonth => "INTERVAL_YEARMONTH", + PrimitiveScalarType::IntervalDaytime => "INTERVAL_DAYTIME", + PrimitiveScalarType::IntervalMonthdaynano => "INTERVAL_MONTHDAYNANO", + PrimitiveScalarType::Binary => "BINARY", + PrimitiveScalarType::LargeBinary => "LARGE_BINARY", + PrimitiveScalarType::Time64 => "TIME64", + } + } +}