You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by tu...@apache.org on 2022/10/27 11:25:25 UTC
[arrow-datafusion] branch master updated: Update protos (#3979)
This is an automated email from the ASF dual-hosted git repository.
tustvold pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-datafusion.git
The following commit(s) were added to refs/heads/master by this push:
new c50573939 Update protos (#3979)
c50573939 is described below
commit c50573939d21de40e591c04915d41f7c46a51d0d
Author: Raphael Taylor-Davies <17...@users.noreply.github.com>
AuthorDate: Fri Oct 28 00:25:19 2022 +1300
Update protos (#3979)
---
datafusion/proto/src/generated/pbjson.rs | 1249 +++++++++++++++++++-----------
datafusion/proto/src/generated/prost.rs | 27 +-
2 files changed, 793 insertions(+), 483 deletions(-)
diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs
index 6250c1a0c..e6b095b84 100644
--- a/datafusion/proto/src/generated/pbjson.rs
+++ b/datafusion/proto/src/generated/pbjson.rs
@@ -43,6 +43,7 @@ impl<'de> serde::Deserialize<'de> for AggregateExprNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "aggr_function",
"aggrFunction",
"expr",
"distinct",
@@ -76,7 +77,7 @@ impl<'de> serde::Deserialize<'de> for AggregateExprNode {
E: serde::de::Error,
{
match value {
- "aggrFunction" => Ok(GeneratedField::AggrFunction),
+ "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
"expr" => Ok(GeneratedField::Expr),
"distinct" => Ok(GeneratedField::Distinct),
"filter" => Ok(GeneratedField::Filter),
@@ -127,7 +128,7 @@ impl<'de> serde::Deserialize<'de> for AggregateExprNode {
if filter__.is_some() {
return Err(serde::de::Error::duplicate_field("filter"));
}
- filter__ = Some(map.next_value()?);
+ filter__ = map.next_value()?;
}
}
}
@@ -304,7 +305,9 @@ impl<'de> serde::Deserialize<'de> for AggregateNode {
{
const FIELDS: &[&str] = &[
"input",
+ "group_expr",
"groupExpr",
+ "aggr_expr",
"aggrExpr",
];
@@ -335,8 +338,8 @@ impl<'de> serde::Deserialize<'de> for AggregateNode {
{
match value {
"input" => Ok(GeneratedField::Input),
- "groupExpr" => Ok(GeneratedField::GroupExpr),
- "aggrExpr" => Ok(GeneratedField::AggrExpr),
+ "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr),
+ "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -365,7 +368,7 @@ impl<'de> serde::Deserialize<'de> for AggregateNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::GroupExpr => {
if group_expr__.is_some() {
@@ -428,6 +431,7 @@ impl<'de> serde::Deserialize<'de> for AggregateUdfExprNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "fun_name",
"funName",
"args",
"filter",
@@ -459,7 +463,7 @@ impl<'de> serde::Deserialize<'de> for AggregateUdfExprNode {
E: serde::de::Error,
{
match value {
- "funName" => Ok(GeneratedField::FunName),
+ "funName" | "fun_name" => Ok(GeneratedField::FunName),
"args" => Ok(GeneratedField::Args),
"filter" => Ok(GeneratedField::Filter),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
@@ -502,7 +506,7 @@ impl<'de> serde::Deserialize<'de> for AggregateUdfExprNode {
if filter__.is_some() {
return Err(serde::de::Error::duplicate_field("filter"));
}
- filter__ = Some(map.next_value()?);
+ filter__ = map.next_value()?;
}
}
}
@@ -605,7 +609,7 @@ impl<'de> serde::Deserialize<'de> for AliasNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::Alias => {
if alias__.is_some() {
@@ -713,7 +717,7 @@ impl<'de> serde::Deserialize<'de> for AnalyzeNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Verbose => {
if verbose__.is_some() {
@@ -876,9 +880,12 @@ impl<'de> serde::Deserialize<'de> for ArrowType {
"FLOAT32",
"FLOAT64",
"UTF8",
+ "LARGE_UTF8",
"LARGEUTF8",
"BINARY",
+ "FIXED_SIZE_BINARY",
"FIXEDSIZEBINARY",
+ "LARGE_BINARY",
"LARGEBINARY",
"DATE32",
"DATE64",
@@ -889,7 +896,9 @@ impl<'de> serde::Deserialize<'de> for ArrowType {
"INTERVAL",
"DECIMAL",
"LIST",
+ "LARGE_LIST",
"LARGELIST",
+ "FIXED_SIZE_LIST",
"FIXEDSIZELIST",
"STRUCT",
"UNION",
@@ -965,10 +974,10 @@ impl<'de> serde::Deserialize<'de> for ArrowType {
"FLOAT32" => Ok(GeneratedField::Float32),
"FLOAT64" => Ok(GeneratedField::Float64),
"UTF8" => Ok(GeneratedField::Utf8),
- "LARGEUTF8" => Ok(GeneratedField::LargeUtf8),
+ "LARGEUTF8" | "LARGE_UTF8" => Ok(GeneratedField::LargeUtf8),
"BINARY" => Ok(GeneratedField::Binary),
- "FIXEDSIZEBINARY" => Ok(GeneratedField::FixedSizeBinary),
- "LARGEBINARY" => Ok(GeneratedField::LargeBinary),
+ "FIXEDSIZEBINARY" | "FIXED_SIZE_BINARY" => Ok(GeneratedField::FixedSizeBinary),
+ "LARGEBINARY" | "LARGE_BINARY" => Ok(GeneratedField::LargeBinary),
"DATE32" => Ok(GeneratedField::Date32),
"DATE64" => Ok(GeneratedField::Date64),
"DURATION" => Ok(GeneratedField::Duration),
@@ -978,8 +987,8 @@ impl<'de> serde::Deserialize<'de> for ArrowType {
"INTERVAL" => Ok(GeneratedField::Interval),
"DECIMAL" => Ok(GeneratedField::Decimal),
"LIST" => Ok(GeneratedField::List),
- "LARGELIST" => Ok(GeneratedField::LargeList),
- "FIXEDSIZELIST" => Ok(GeneratedField::FixedSizeList),
+ "LARGELIST" | "LARGE_LIST" => Ok(GeneratedField::LargeList),
+ "FIXEDSIZELIST" | "FIXED_SIZE_LIST" => Ok(GeneratedField::FixedSizeList),
"STRUCT" => Ok(GeneratedField::Struct),
"UNION" => Ok(GeneratedField::Union),
"DICTIONARY" => Ok(GeneratedField::Dictionary),
@@ -1009,195 +1018,220 @@ impl<'de> serde::Deserialize<'de> for ArrowType {
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()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::None)
+;
}
GeneratedField::Bool => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("BOOL"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Bool(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Bool)
+;
}
GeneratedField::Uint8 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("UINT8"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint8(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint8)
+;
}
GeneratedField::Int8 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("INT8"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int8(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int8)
+;
}
GeneratedField::Uint16 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("UINT16"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint16(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint16)
+;
}
GeneratedField::Int16 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("INT16"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int16(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int16)
+;
}
GeneratedField::Uint32 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("UINT32"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint32(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint32)
+;
}
GeneratedField::Int32 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("INT32"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int32(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int32)
+;
}
GeneratedField::Uint64 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("UINT64"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Uint64(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint64)
+;
}
GeneratedField::Int64 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("INT64"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Int64(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int64)
+;
}
GeneratedField::Float16 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("FLOAT16"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float16(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float16)
+;
}
GeneratedField::Float32 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("FLOAT32"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float32(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float32)
+;
}
GeneratedField::Float64 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("FLOAT64"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Float64(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float64)
+;
}
GeneratedField::Utf8 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("UTF8"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Utf8(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Utf8)
+;
}
GeneratedField::LargeUtf8 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("LARGEUTF8"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeUtf8(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeUtf8)
+;
}
GeneratedField::Binary => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("BINARY"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Binary(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Binary)
+;
}
GeneratedField::FixedSizeBinary => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("FIXEDSIZEBINARY"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::FixedSizeBinary(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| arrow_type::ArrowTypeEnum::FixedSizeBinary(x.0));
}
GeneratedField::LargeBinary => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("LARGEBINARY"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeBinary(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeBinary)
+;
}
GeneratedField::Date32 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("DATE32"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Date32(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date32)
+;
}
GeneratedField::Date64 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("DATE64"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Date64(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date64)
+;
}
GeneratedField::Duration => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("DURATION"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Duration(map.next_value::<TimeUnit>()? as i32));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Duration(x as i32));
}
GeneratedField::Timestamp => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("TIMESTAMP"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Timestamp(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Timestamp)
+;
}
GeneratedField::Time32 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("TIME32"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Time32(map.next_value::<TimeUnit>()? as i32));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Time32(x as i32));
}
GeneratedField::Time64 => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("TIME64"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Time64(map.next_value::<TimeUnit>()? as i32));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<TimeUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Time64(x as i32));
}
GeneratedField::Interval => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("INTERVAL"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Interval(map.next_value::<IntervalUnit>()? as i32));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<IntervalUnit>>()?.map(|x| arrow_type::ArrowTypeEnum::Interval(x as i32));
}
GeneratedField::Decimal => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("DECIMAL"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Decimal(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Decimal)
+;
}
GeneratedField::List => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("LIST"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::List(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::List)
+;
}
GeneratedField::LargeList => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("LARGELIST"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::LargeList(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeList)
+;
}
GeneratedField::FixedSizeList => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("FIXEDSIZELIST"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::FixedSizeList(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::FixedSizeList)
+;
}
GeneratedField::Struct => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("STRUCT"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Struct(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Struct)
+;
}
GeneratedField::Union => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("UNION"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Union(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Union)
+;
}
GeneratedField::Dictionary => {
if arrow_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("DICTIONARY"));
}
- arrow_type_enum__ = Some(arrow_type::ArrowTypeEnum::Dictionary(map.next_value()?));
+ arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Dictionary)
+;
}
}
}
@@ -1389,7 +1423,7 @@ impl<'de> serde::Deserialize<'de> for BetweenNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::Negated => {
if negated__.is_some() {
@@ -1401,13 +1435,13 @@ impl<'de> serde::Deserialize<'de> for BetweenNode {
if low__.is_some() {
return Err(serde::de::Error::duplicate_field("low"));
}
- low__ = Some(map.next_value()?);
+ low__ = map.next_value()?;
}
GeneratedField::High => {
if high__.is_some() {
return Err(serde::de::Error::duplicate_field("high"));
}
- high__ = Some(map.next_value()?);
+ high__ = map.next_value()?;
}
}
}
@@ -1521,13 +1555,13 @@ impl<'de> serde::Deserialize<'de> for BinaryExprNode {
if l__.is_some() {
return Err(serde::de::Error::duplicate_field("l"));
}
- l__ = Some(map.next_value()?);
+ l__ = map.next_value()?;
}
GeneratedField::R => {
if r__.is_some() {
return Err(serde::de::Error::duplicate_field("r"));
}
- r__ = Some(map.next_value()?);
+ r__ = map.next_value()?;
}
GeneratedField::Op => {
if op__.is_some() {
@@ -1685,7 +1719,9 @@ impl<'de> serde::Deserialize<'de> for CaseNode {
{
const FIELDS: &[&str] = &[
"expr",
+ "when_then_expr",
"whenThenExpr",
+ "else_expr",
"elseExpr",
];
@@ -1716,8 +1752,8 @@ impl<'de> serde::Deserialize<'de> for CaseNode {
{
match value {
"expr" => Ok(GeneratedField::Expr),
- "whenThenExpr" => Ok(GeneratedField::WhenThenExpr),
- "elseExpr" => Ok(GeneratedField::ElseExpr),
+ "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr),
+ "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -1746,7 +1782,7 @@ impl<'de> serde::Deserialize<'de> for CaseNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::WhenThenExpr => {
if when_then_expr__.is_some() {
@@ -1758,7 +1794,7 @@ impl<'de> serde::Deserialize<'de> for CaseNode {
if else_expr__.is_some() {
return Err(serde::de::Error::duplicate_field("elseExpr"));
}
- else_expr__ = Some(map.next_value()?);
+ else_expr__ = map.next_value()?;
}
}
}
@@ -1804,6 +1840,7 @@ impl<'de> serde::Deserialize<'de> for CastNode {
{
const FIELDS: &[&str] = &[
"expr",
+ "arrow_type",
"arrowType",
];
@@ -1833,7 +1870,7 @@ impl<'de> serde::Deserialize<'de> for CastNode {
{
match value {
"expr" => Ok(GeneratedField::Expr),
- "arrowType" => Ok(GeneratedField::ArrowType),
+ "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -1861,13 +1898,13 @@ impl<'de> serde::Deserialize<'de> for CastNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::ArrowType => {
if arrow_type__.is_some() {
return Err(serde::de::Error::duplicate_field("arrowType"));
}
- arrow_type__ = Some(map.next_value()?);
+ arrow_type__ = map.next_value()?;
}
}
}
@@ -1975,7 +2012,7 @@ impl<'de> serde::Deserialize<'de> for Column {
if relation__.is_some() {
return Err(serde::de::Error::duplicate_field("relation"));
}
- relation__ = Some(map.next_value()?);
+ relation__ = map.next_value()?;
}
}
}
@@ -2116,7 +2153,9 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "catalog_name",
"catalogName",
+ "if_not_exists",
"ifNotExists",
"schema",
];
@@ -2147,8 +2186,8 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogNode {
E: serde::de::Error,
{
match value {
- "catalogName" => Ok(GeneratedField::CatalogName),
- "ifNotExists" => Ok(GeneratedField::IfNotExists),
+ "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
+ "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
"schema" => Ok(GeneratedField::Schema),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -2190,7 +2229,7 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogNode {
if schema__.is_some() {
return Err(serde::de::Error::duplicate_field("schema"));
}
- schema__ = Some(map.next_value()?);
+ schema__ = map.next_value()?;
}
}
}
@@ -2241,7 +2280,9 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "schema_name",
"schemaName",
+ "if_not_exists",
"ifNotExists",
"schema",
];
@@ -2272,8 +2313,8 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode {
E: serde::de::Error,
{
match value {
- "schemaName" => Ok(GeneratedField::SchemaName),
- "ifNotExists" => Ok(GeneratedField::IfNotExists),
+ "schemaName" | "schema_name" => Ok(GeneratedField::SchemaName),
+ "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
"schema" => Ok(GeneratedField::Schema),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -2315,7 +2356,7 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode {
if schema__.is_some() {
return Err(serde::de::Error::duplicate_field("schema"));
}
- schema__ = Some(map.next_value()?);
+ schema__ = map.next_value()?;
}
}
}
@@ -2410,13 +2451,18 @@ impl<'de> serde::Deserialize<'de> for CreateExternalTableNode {
const FIELDS: &[&str] = &[
"name",
"location",
+ "file_type",
"fileType",
+ "has_header",
"hasHeader",
"schema",
+ "table_partition_cols",
"tablePartitionCols",
+ "if_not_exists",
"ifNotExists",
"delimiter",
"definition",
+ "file_compression_type",
"fileCompressionType",
];
@@ -2455,14 +2501,14 @@ impl<'de> serde::Deserialize<'de> for CreateExternalTableNode {
match value {
"name" => Ok(GeneratedField::Name),
"location" => Ok(GeneratedField::Location),
- "fileType" => Ok(GeneratedField::FileType),
- "hasHeader" => Ok(GeneratedField::HasHeader),
+ "fileType" | "file_type" => Ok(GeneratedField::FileType),
+ "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
"schema" => Ok(GeneratedField::Schema),
- "tablePartitionCols" => Ok(GeneratedField::TablePartitionCols),
- "ifNotExists" => Ok(GeneratedField::IfNotExists),
+ "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
+ "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists),
"delimiter" => Ok(GeneratedField::Delimiter),
"definition" => Ok(GeneratedField::Definition),
- "fileCompressionType" => Ok(GeneratedField::FileCompressionType),
+ "fileCompressionType" | "file_compression_type" => Ok(GeneratedField::FileCompressionType),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -2522,7 +2568,7 @@ impl<'de> serde::Deserialize<'de> for CreateExternalTableNode {
if schema__.is_some() {
return Err(serde::de::Error::duplicate_field("schema"));
}
- schema__ = Some(map.next_value()?);
+ schema__ = map.next_value()?;
}
GeneratedField::TablePartitionCols => {
if table_partition_cols__.is_some() {
@@ -2618,6 +2664,7 @@ impl<'de> serde::Deserialize<'de> for CreateViewNode {
const FIELDS: &[&str] = &[
"name",
"input",
+ "or_replace",
"orReplace",
"definition",
];
@@ -2651,7 +2698,7 @@ impl<'de> serde::Deserialize<'de> for CreateViewNode {
match value {
"name" => Ok(GeneratedField::Name),
"input" => Ok(GeneratedField::Input),
- "orReplace" => Ok(GeneratedField::OrReplace),
+ "orReplace" | "or_replace" => Ok(GeneratedField::OrReplace),
"definition" => Ok(GeneratedField::Definition),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -2688,7 +2735,7 @@ impl<'de> serde::Deserialize<'de> for CreateViewNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::OrReplace => {
if or_replace__.is_some() {
@@ -2804,13 +2851,13 @@ impl<'de> serde::Deserialize<'de> for CrossJoinNode {
if left__.is_some() {
return Err(serde::de::Error::duplicate_field("left"));
}
- left__ = Some(map.next_value()?);
+ left__ = map.next_value()?;
}
GeneratedField::Right => {
if right__.is_some() {
return Err(serde::de::Error::duplicate_field("right"));
}
- right__ = Some(map.next_value()?);
+ right__ = map.next_value()?;
}
}
}
@@ -2854,6 +2901,7 @@ impl<'de> serde::Deserialize<'de> for CsvFormat {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "has_header",
"hasHeader",
"delimiter",
];
@@ -2883,7 +2931,7 @@ impl<'de> serde::Deserialize<'de> for CsvFormat {
E: serde::de::Error,
{
match value {
- "hasHeader" => Ok(GeneratedField::HasHeader),
+ "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader),
"delimiter" => Ok(GeneratedField::Delimiter),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -3071,10 +3119,12 @@ impl<'de> serde::Deserialize<'de> for CustomTableScanNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "table_name",
"tableName",
"projection",
"schema",
"filters",
+ "custom_table_data",
"customTableData",
];
@@ -3106,11 +3156,11 @@ impl<'de> serde::Deserialize<'de> for CustomTableScanNode {
E: serde::de::Error,
{
match value {
- "tableName" => Ok(GeneratedField::TableName),
+ "tableName" | "table_name" => Ok(GeneratedField::TableName),
"projection" => Ok(GeneratedField::Projection),
"schema" => Ok(GeneratedField::Schema),
"filters" => Ok(GeneratedField::Filters),
- "customTableData" => Ok(GeneratedField::CustomTableData),
+ "customTableData" | "custom_table_data" => Ok(GeneratedField::CustomTableData),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -3147,13 +3197,13 @@ impl<'de> serde::Deserialize<'de> for CustomTableScanNode {
if projection__.is_some() {
return Err(serde::de::Error::duplicate_field("projection"));
}
- projection__ = Some(map.next_value()?);
+ projection__ = map.next_value()?;
}
GeneratedField::Schema => {
if schema__.is_some() {
return Err(serde::de::Error::duplicate_field("schema"));
}
- schema__ = Some(map.next_value()?);
+ schema__ = map.next_value()?;
}
GeneratedField::Filters => {
if filters__.is_some() {
@@ -3165,9 +3215,9 @@ impl<'de> serde::Deserialize<'de> for CustomTableScanNode {
if custom_table_data__.is_some() {
return Err(serde::de::Error::duplicate_field("customTableData"));
}
- custom_table_data__ = Some(
- map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0
- );
+ custom_table_data__ =
+ Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -3345,17 +3395,17 @@ impl<'de> serde::Deserialize<'de> for Decimal {
if whole__.is_some() {
return Err(serde::de::Error::duplicate_field("whole"));
}
- whole__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ 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
- );
+ fractional__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -3467,25 +3517,25 @@ impl<'de> serde::Deserialize<'de> for Decimal128 {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
- value__ = Some(
- map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0
- );
+ 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
- );
+ 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
- );
+ s__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -3588,13 +3638,13 @@ impl<'de> serde::Deserialize<'de> for DfField {
if field__.is_some() {
return Err(serde::de::Error::duplicate_field("field"));
}
- field__ = Some(map.next_value()?);
+ field__ = map.next_value()?;
}
GeneratedField::Qualifier => {
if qualifier__.is_some() {
return Err(serde::de::Error::duplicate_field("qualifier"));
}
- qualifier__ = Some(map.next_value()?);
+ qualifier__ = map.next_value()?;
}
}
}
@@ -3806,13 +3856,13 @@ impl<'de> serde::Deserialize<'de> for Dictionary {
if key__.is_some() {
return Err(serde::de::Error::duplicate_field("key"));
}
- key__ = Some(map.next_value()?);
+ key__ = map.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
- value__ = Some(map.next_value()?);
+ value__ = map.next_value()?;
}
}
}
@@ -3904,7 +3954,7 @@ impl<'de> serde::Deserialize<'de> for DistinctNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
}
}
@@ -4012,6 +4062,7 @@ impl<'de> serde::Deserialize<'de> for EmptyRelationNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "produce_one_row",
"produceOneRow",
];
@@ -4039,7 +4090,7 @@ impl<'de> serde::Deserialize<'de> for EmptyRelationNode {
E: serde::de::Error,
{
match value {
- "produceOneRow" => Ok(GeneratedField::ProduceOneRow),
+ "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -4167,7 +4218,7 @@ impl<'de> serde::Deserialize<'de> for ExplainNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Verbose => {
if verbose__.is_some() {
@@ -4230,6 +4281,7 @@ impl<'de> serde::Deserialize<'de> for Field {
{
const FIELDS: &[&str] = &[
"name",
+ "arrow_type",
"arrowType",
"nullable",
"children",
@@ -4263,7 +4315,7 @@ impl<'de> serde::Deserialize<'de> for Field {
{
match value {
"name" => Ok(GeneratedField::Name),
- "arrowType" => Ok(GeneratedField::ArrowType),
+ "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
"nullable" => Ok(GeneratedField::Nullable),
"children" => Ok(GeneratedField::Children),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
@@ -4301,7 +4353,7 @@ impl<'de> serde::Deserialize<'de> for Field {
if arrow_type__.is_some() {
return Err(serde::de::Error::duplicate_field("arrowType"));
}
- arrow_type__ = Some(map.next_value()?);
+ arrow_type__ = map.next_value()?;
}
GeneratedField::Nullable => {
if nullable__.is_some() {
@@ -4407,9 +4459,9 @@ impl<'de> serde::Deserialize<'de> for FixedSizeBinary {
if length__.is_some() {
return Err(serde::de::Error::duplicate_field("length"));
}
- length__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ length__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -4452,7 +4504,9 @@ impl<'de> serde::Deserialize<'de> for FixedSizeList {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "field_type",
"fieldType",
+ "list_size",
"listSize",
];
@@ -4481,8 +4535,8 @@ impl<'de> serde::Deserialize<'de> for FixedSizeList {
E: serde::de::Error,
{
match value {
- "fieldType" => Ok(GeneratedField::FieldType),
- "listSize" => Ok(GeneratedField::ListSize),
+ "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
+ "listSize" | "list_size" => Ok(GeneratedField::ListSize),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -4510,15 +4564,15 @@ impl<'de> serde::Deserialize<'de> for FixedSizeList {
if field_type__.is_some() {
return Err(serde::de::Error::duplicate_field("fieldType"));
}
- field_type__ = Some(map.next_value()?);
+ field_type__ = map.next_value()?;
}
GeneratedField::ListSize => {
if list_size__.is_some() {
return Err(serde::de::Error::duplicate_field("listSize"));
}
- list_size__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ list_size__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -4620,13 +4674,13 @@ impl<'de> serde::Deserialize<'de> for GetIndexedField {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::Key => {
if key__.is_some() {
return Err(serde::de::Error::duplicate_field("key"));
}
- key__ = Some(map.next_value()?);
+ key__ = map.next_value()?;
}
}
}
@@ -4761,7 +4815,9 @@ impl<'de> serde::Deserialize<'de> for HashRepartition {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "hash_expr",
"hashExpr",
+ "partition_count",
"partitionCount",
];
@@ -4790,8 +4846,8 @@ impl<'de> serde::Deserialize<'de> for HashRepartition {
E: serde::de::Error,
{
match value {
- "hashExpr" => Ok(GeneratedField::HashExpr),
- "partitionCount" => Ok(GeneratedField::PartitionCount),
+ "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr),
+ "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -4825,9 +4881,9 @@ impl<'de> serde::Deserialize<'de> for HashRepartition {
if partition_count__.is_some() {
return Err(serde::de::Error::duplicate_field("partitionCount"));
}
- partition_count__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ partition_count__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -4886,6 +4942,7 @@ impl<'de> serde::Deserialize<'de> for ILikeNode {
"negated",
"expr",
"pattern",
+ "escape_char",
"escapeChar",
];
@@ -4919,7 +4976,7 @@ impl<'de> serde::Deserialize<'de> for ILikeNode {
"negated" => Ok(GeneratedField::Negated),
"expr" => Ok(GeneratedField::Expr),
"pattern" => Ok(GeneratedField::Pattern),
- "escapeChar" => Ok(GeneratedField::EscapeChar),
+ "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -4955,13 +5012,13 @@ impl<'de> serde::Deserialize<'de> for ILikeNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::Pattern => {
if pattern__.is_some() {
return Err(serde::de::Error::duplicate_field("pattern"));
}
- pattern__ = Some(map.next_value()?);
+ pattern__ = map.next_value()?;
}
GeneratedField::EscapeChar => {
if escape_char__.is_some() {
@@ -5081,7 +5138,7 @@ impl<'de> serde::Deserialize<'de> for InListNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::List => {
if list__.is_some() {
@@ -5206,25 +5263,25 @@ impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue {
if months__.is_some() {
return Err(serde::de::Error::duplicate_field("months"));
}
- months__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ 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
- );
+ 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
- );
+ nanos__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -5393,7 +5450,7 @@ impl<'de> serde::Deserialize<'de> for IsFalse {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -5484,7 +5541,7 @@ impl<'de> serde::Deserialize<'de> for IsNotFalse {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -5575,7 +5632,7 @@ impl<'de> serde::Deserialize<'de> for IsNotNull {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -5666,7 +5723,7 @@ impl<'de> serde::Deserialize<'de> for IsNotTrue {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -5757,7 +5814,7 @@ impl<'de> serde::Deserialize<'de> for IsNotUnknown {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -5848,7 +5905,7 @@ impl<'de> serde::Deserialize<'de> for IsNull {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -5939,7 +5996,7 @@ impl<'de> serde::Deserialize<'de> for IsTrue {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -6030,7 +6087,7 @@ impl<'de> serde::Deserialize<'de> for IsUnknown {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -6188,10 +6245,15 @@ impl<'de> serde::Deserialize<'de> for JoinNode {
const FIELDS: &[&str] = &[
"left",
"right",
+ "join_type",
"joinType",
+ "join_constraint",
"joinConstraint",
+ "left_join_column",
"leftJoinColumn",
+ "right_join_column",
"rightJoinColumn",
+ "null_equals_null",
"nullEqualsNull",
"filter",
];
@@ -6229,11 +6291,11 @@ impl<'de> serde::Deserialize<'de> for JoinNode {
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),
+ "joinType" | "join_type" => Ok(GeneratedField::JoinType),
+ "joinConstraint" | "join_constraint" => Ok(GeneratedField::JoinConstraint),
+ "leftJoinColumn" | "left_join_column" => Ok(GeneratedField::LeftJoinColumn),
+ "rightJoinColumn" | "right_join_column" => Ok(GeneratedField::RightJoinColumn),
+ "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull),
"filter" => Ok(GeneratedField::Filter),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -6268,13 +6330,13 @@ impl<'de> serde::Deserialize<'de> for JoinNode {
if left__.is_some() {
return Err(serde::de::Error::duplicate_field("left"));
}
- left__ = Some(map.next_value()?);
+ left__ = map.next_value()?;
}
GeneratedField::Right => {
if right__.is_some() {
return Err(serde::de::Error::duplicate_field("right"));
}
- right__ = Some(map.next_value()?);
+ right__ = map.next_value()?;
}
GeneratedField::JoinType => {
if join_type__.is_some() {
@@ -6310,7 +6372,7 @@ impl<'de> serde::Deserialize<'de> for JoinNode {
if filter__.is_some() {
return Err(serde::de::Error::duplicate_field("filter"));
}
- filter__ = Some(map.next_value()?);
+ filter__ = map.next_value()?;
}
}
}
@@ -6460,6 +6522,7 @@ impl<'de> serde::Deserialize<'de> for LikeNode {
"negated",
"expr",
"pattern",
+ "escape_char",
"escapeChar",
];
@@ -6493,7 +6556,7 @@ impl<'de> serde::Deserialize<'de> for LikeNode {
"negated" => Ok(GeneratedField::Negated),
"expr" => Ok(GeneratedField::Expr),
"pattern" => Ok(GeneratedField::Pattern),
- "escapeChar" => Ok(GeneratedField::EscapeChar),
+ "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -6529,13 +6592,13 @@ impl<'de> serde::Deserialize<'de> for LikeNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::Pattern => {
if pattern__.is_some() {
return Err(serde::de::Error::duplicate_field("pattern"));
}
- pattern__ = Some(map.next_value()?);
+ pattern__ = map.next_value()?;
}
GeneratedField::EscapeChar => {
if escape_char__.is_some() {
@@ -6655,23 +6718,23 @@ impl<'de> serde::Deserialize<'de> for LimitNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Skip => {
if skip__.is_some() {
return Err(serde::de::Error::duplicate_field("skip"));
}
- skip__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ 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
- );
+ fetch__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -6710,6 +6773,7 @@ impl<'de> serde::Deserialize<'de> for List {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "field_type",
"fieldType",
];
@@ -6737,7 +6801,7 @@ impl<'de> serde::Deserialize<'de> for List {
E: serde::de::Error,
{
match value {
- "fieldType" => Ok(GeneratedField::FieldType),
+ "fieldType" | "field_type" => Ok(GeneratedField::FieldType),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -6764,7 +6828,7 @@ impl<'de> serde::Deserialize<'de> for List {
if field_type__.is_some() {
return Err(serde::de::Error::duplicate_field("fieldType"));
}
- field_type__ = Some(map.next_value()?);
+ field_type__ = map.next_value()?;
}
}
}
@@ -6865,14 +6929,19 @@ impl<'de> serde::Deserialize<'de> for ListingTableScanNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "table_name",
"tableName",
"paths",
+ "file_extension",
"fileExtension",
"projection",
"schema",
"filters",
+ "table_partition_cols",
"tablePartitionCols",
+ "collect_stat",
"collectStat",
+ "target_partitions",
"targetPartitions",
"csv",
"parquet",
@@ -6914,15 +6983,15 @@ impl<'de> serde::Deserialize<'de> for ListingTableScanNode {
E: serde::de::Error,
{
match value {
- "tableName" => Ok(GeneratedField::TableName),
+ "tableName" | "table_name" => Ok(GeneratedField::TableName),
"paths" => Ok(GeneratedField::Paths),
- "fileExtension" => Ok(GeneratedField::FileExtension),
+ "fileExtension" | "file_extension" => 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),
+ "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols),
+ "collectStat" | "collect_stat" => Ok(GeneratedField::CollectStat),
+ "targetPartitions" | "target_partitions" => Ok(GeneratedField::TargetPartitions),
"csv" => Ok(GeneratedField::Csv),
"parquet" => Ok(GeneratedField::Parquet),
"avro" => Ok(GeneratedField::Avro),
@@ -6979,13 +7048,13 @@ impl<'de> serde::Deserialize<'de> for ListingTableScanNode {
if projection__.is_some() {
return Err(serde::de::Error::duplicate_field("projection"));
}
- projection__ = Some(map.next_value()?);
+ projection__ = map.next_value()?;
}
GeneratedField::Schema => {
if schema__.is_some() {
return Err(serde::de::Error::duplicate_field("schema"));
}
- schema__ = Some(map.next_value()?);
+ schema__ = map.next_value()?;
}
GeneratedField::Filters => {
if filters__.is_some() {
@@ -7009,27 +7078,30 @@ impl<'de> serde::Deserialize<'de> for ListingTableScanNode {
if target_partitions__.is_some() {
return Err(serde::de::Error::duplicate_field("targetPartitions"));
}
- target_partitions__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ 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()?));
+ file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Csv)
+;
}
GeneratedField::Parquet => {
if file_format_type__.is_some() {
return Err(serde::de::Error::duplicate_field("parquet"));
}
- file_format_type__ = Some(listing_table_scan_node::FileFormatType::Parquet(map.next_value()?));
+ file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Parquet)
+;
}
GeneratedField::Avro => {
if file_format_type__.is_some() {
return Err(serde::de::Error::duplicate_field("avro"));
}
- file_format_type__ = Some(listing_table_scan_node::FileFormatType::Avro(map.next_value()?));
+ file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Avro)
+;
}
}
}
@@ -7269,35 +7341,56 @@ impl<'de> serde::Deserialize<'de> for LogicalExprNode {
"column",
"alias",
"literal",
+ "binary_expr",
"binaryExpr",
+ "aggregate_expr",
"aggregateExpr",
+ "is_null_expr",
"isNullExpr",
+ "is_not_null_expr",
"isNotNullExpr",
+ "not_expr",
"notExpr",
"between",
+ "case_",
"case",
"cast",
"sort",
"negative",
+ "in_list",
"inList",
"wildcard",
+ "scalar_function",
"scalarFunction",
+ "try_cast",
"tryCast",
+ "window_expr",
"windowExpr",
+ "aggregate_udf_expr",
"aggregateUdfExpr",
+ "scalar_udf_expr",
"scalarUdfExpr",
+ "get_indexed_field",
"getIndexedField",
+ "grouping_set",
"groupingSet",
"cube",
"rollup",
+ "is_true",
"isTrue",
+ "is_false",
"isFalse",
+ "is_unknown",
"isUnknown",
+ "is_not_true",
"isNotTrue",
+ "is_not_false",
"isNotFalse",
+ "is_not_unknown",
"isNotUnknown",
"like",
"ilike",
+ "similar_to",
"similarTo",
];
@@ -7360,36 +7453,36 @@ impl<'de> serde::Deserialize<'de> for LogicalExprNode {
"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),
+ "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr),
+ "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr),
+ "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr),
+ "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr),
+ "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr),
"between" => Ok(GeneratedField::Between),
- "case" => Ok(GeneratedField::Case),
+ "case" | "case_" => Ok(GeneratedField::Case),
"cast" => Ok(GeneratedField::Cast),
"sort" => Ok(GeneratedField::Sort),
"negative" => Ok(GeneratedField::Negative),
- "inList" => Ok(GeneratedField::InList),
+ "inList" | "in_list" => 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),
+ "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction),
+ "tryCast" | "try_cast" => Ok(GeneratedField::TryCast),
+ "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
+ "aggregateUdfExpr" | "aggregate_udf_expr" => Ok(GeneratedField::AggregateUdfExpr),
+ "scalarUdfExpr" | "scalar_udf_expr" => Ok(GeneratedField::ScalarUdfExpr),
+ "getIndexedField" | "get_indexed_field" => Ok(GeneratedField::GetIndexedField),
+ "groupingSet" | "grouping_set" => Ok(GeneratedField::GroupingSet),
"cube" => Ok(GeneratedField::Cube),
"rollup" => Ok(GeneratedField::Rollup),
- "isTrue" => Ok(GeneratedField::IsTrue),
- "isFalse" => Ok(GeneratedField::IsFalse),
- "isUnknown" => Ok(GeneratedField::IsUnknown),
- "isNotTrue" => Ok(GeneratedField::IsNotTrue),
- "isNotFalse" => Ok(GeneratedField::IsNotFalse),
- "isNotUnknown" => Ok(GeneratedField::IsNotUnknown),
+ "isTrue" | "is_true" => Ok(GeneratedField::IsTrue),
+ "isFalse" | "is_false" => Ok(GeneratedField::IsFalse),
+ "isUnknown" | "is_unknown" => Ok(GeneratedField::IsUnknown),
+ "isNotTrue" | "is_not_true" => Ok(GeneratedField::IsNotTrue),
+ "isNotFalse" | "is_not_false" => Ok(GeneratedField::IsNotFalse),
+ "isNotUnknown" | "is_not_unknown" => Ok(GeneratedField::IsNotUnknown),
"like" => Ok(GeneratedField::Like),
"ilike" => Ok(GeneratedField::Ilike),
- "similarTo" => Ok(GeneratedField::SimilarTo),
+ "similarTo" | "similar_to" => Ok(GeneratedField::SimilarTo),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -7416,199 +7509,231 @@ impl<'de> serde::Deserialize<'de> for LogicalExprNode {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("column"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Column(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Column)
+;
}
GeneratedField::Alias => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("alias"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Alias(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Alias)
+;
}
GeneratedField::Literal => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("literal"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Literal(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Literal)
+;
}
GeneratedField::BinaryExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("binaryExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::BinaryExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::BinaryExpr)
+;
}
GeneratedField::AggregateExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("aggregateExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::AggregateExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateExpr)
+;
}
GeneratedField::IsNullExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isNullExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsNullExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNullExpr)
+;
}
GeneratedField::IsNotNullExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isNotNullExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsNotNullExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotNullExpr)
+;
}
GeneratedField::NotExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("notExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::NotExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::NotExpr)
+;
}
GeneratedField::Between => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("between"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Between(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Between)
+;
}
GeneratedField::Case => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("case"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Case(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Case)
+;
}
GeneratedField::Cast => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("cast"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Cast(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cast)
+;
}
GeneratedField::Sort => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("sort"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Sort(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Sort)
+;
}
GeneratedField::Negative => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("negative"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Negative(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Negative)
+;
}
GeneratedField::InList => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("inList"));
}
- expr_type__ = Some(logical_expr_node::ExprType::InList(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::InList)
+;
}
GeneratedField::Wildcard => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("wildcard"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Wildcard(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Wildcard);
}
GeneratedField::ScalarFunction => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("scalarFunction"));
}
- expr_type__ = Some(logical_expr_node::ExprType::ScalarFunction(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarFunction)
+;
}
GeneratedField::TryCast => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("tryCast"));
}
- expr_type__ = Some(logical_expr_node::ExprType::TryCast(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::TryCast)
+;
}
GeneratedField::WindowExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("windowExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::WindowExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::WindowExpr)
+;
}
GeneratedField::AggregateUdfExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("aggregateUdfExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::AggregateUdfExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateUdfExpr)
+;
}
GeneratedField::ScalarUdfExpr => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("scalarUdfExpr"));
}
- expr_type__ = Some(logical_expr_node::ExprType::ScalarUdfExpr(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarUdfExpr)
+;
}
GeneratedField::GetIndexedField => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("getIndexedField"));
}
- expr_type__ = Some(logical_expr_node::ExprType::GetIndexedField(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GetIndexedField)
+;
}
GeneratedField::GroupingSet => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("groupingSet"));
}
- expr_type__ = Some(logical_expr_node::ExprType::GroupingSet(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GroupingSet)
+;
}
GeneratedField::Cube => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("cube"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Cube(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cube)
+;
}
GeneratedField::Rollup => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("rollup"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Rollup(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Rollup)
+;
}
GeneratedField::IsTrue => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isTrue"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsTrue(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsTrue)
+;
}
GeneratedField::IsFalse => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isFalse"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsFalse(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsFalse)
+;
}
GeneratedField::IsUnknown => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isUnknown"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsUnknown(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsUnknown)
+;
}
GeneratedField::IsNotTrue => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isNotTrue"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsNotTrue(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotTrue)
+;
}
GeneratedField::IsNotFalse => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isNotFalse"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsNotFalse(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotFalse)
+;
}
GeneratedField::IsNotUnknown => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("isNotUnknown"));
}
- expr_type__ = Some(logical_expr_node::ExprType::IsNotUnknown(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotUnknown)
+;
}
GeneratedField::Like => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("like"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Like(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Like)
+;
}
GeneratedField::Ilike => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("ilike"));
}
- expr_type__ = Some(logical_expr_node::ExprType::Ilike(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Ilike)
+;
}
GeneratedField::SimilarTo => {
if expr_type__.is_some() {
return Err(serde::de::Error::duplicate_field("similarTo"));
}
- expr_type__ = Some(logical_expr_node::ExprType::SimilarTo(map.next_value()?));
+ expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::SimilarTo)
+;
}
}
}
@@ -7709,9 +7834,9 @@ impl<'de> serde::Deserialize<'de> for LogicalExtensionNode {
if node__.is_some() {
return Err(serde::de::Error::duplicate_field("node"));
}
- node__ = Some(
- map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0
- );
+ node__ =
+ Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+ ;
}
GeneratedField::Inputs => {
if inputs__.is_some() {
@@ -7828,6 +7953,7 @@ impl<'de> serde::Deserialize<'de> for LogicalPlanNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "listing_scan",
"listingScan",
"projection",
"selection",
@@ -7836,21 +7962,30 @@ impl<'de> serde::Deserialize<'de> for LogicalPlanNode {
"join",
"sort",
"repartition",
+ "empty_relation",
"emptyRelation",
+ "create_external_table",
"createExternalTable",
"explain",
"window",
"analyze",
+ "cross_join",
"crossJoin",
"values",
"extension",
+ "create_catalog_schema",
"createCatalogSchema",
"union",
+ "create_catalog",
"createCatalog",
+ "subquery_alias",
"subqueryAlias",
+ "create_view",
"createView",
"distinct",
+ "view_scan",
"viewScan",
+ "custom_scan",
"customScan",
];
@@ -7901,7 +8036,7 @@ impl<'de> serde::Deserialize<'de> for LogicalPlanNode {
E: serde::de::Error,
{
match value {
- "listingScan" => Ok(GeneratedField::ListingScan),
+ "listingScan" | "listing_scan" => Ok(GeneratedField::ListingScan),
"projection" => Ok(GeneratedField::Projection),
"selection" => Ok(GeneratedField::Selection),
"limit" => Ok(GeneratedField::Limit),
@@ -7909,22 +8044,22 @@ impl<'de> serde::Deserialize<'de> for LogicalPlanNode {
"join" => Ok(GeneratedField::Join),
"sort" => Ok(GeneratedField::Sort),
"repartition" => Ok(GeneratedField::Repartition),
- "emptyRelation" => Ok(GeneratedField::EmptyRelation),
- "createExternalTable" => Ok(GeneratedField::CreateExternalTable),
+ "emptyRelation" | "empty_relation" => Ok(GeneratedField::EmptyRelation),
+ "createExternalTable" | "create_external_table" => Ok(GeneratedField::CreateExternalTable),
"explain" => Ok(GeneratedField::Explain),
"window" => Ok(GeneratedField::Window),
"analyze" => Ok(GeneratedField::Analyze),
- "crossJoin" => Ok(GeneratedField::CrossJoin),
+ "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin),
"values" => Ok(GeneratedField::Values),
"extension" => Ok(GeneratedField::Extension),
- "createCatalogSchema" => Ok(GeneratedField::CreateCatalogSchema),
+ "createCatalogSchema" | "create_catalog_schema" => Ok(GeneratedField::CreateCatalogSchema),
"union" => Ok(GeneratedField::Union),
- "createCatalog" => Ok(GeneratedField::CreateCatalog),
- "subqueryAlias" => Ok(GeneratedField::SubqueryAlias),
- "createView" => Ok(GeneratedField::CreateView),
+ "createCatalog" | "create_catalog" => Ok(GeneratedField::CreateCatalog),
+ "subqueryAlias" | "subquery_alias" => Ok(GeneratedField::SubqueryAlias),
+ "createView" | "create_view" => Ok(GeneratedField::CreateView),
"distinct" => Ok(GeneratedField::Distinct),
- "viewScan" => Ok(GeneratedField::ViewScan),
- "customScan" => Ok(GeneratedField::CustomScan),
+ "viewScan" | "view_scan" => Ok(GeneratedField::ViewScan),
+ "customScan" | "custom_scan" => Ok(GeneratedField::CustomScan),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -7951,145 +8086,169 @@ impl<'de> serde::Deserialize<'de> for LogicalPlanNode {
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()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ListingScan)
+;
}
GeneratedField::Projection => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("projection"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Projection(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Projection)
+;
}
GeneratedField::Selection => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("selection"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Selection(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Selection)
+;
}
GeneratedField::Limit => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("limit"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Limit(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Limit)
+;
}
GeneratedField::Aggregate => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("aggregate"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Aggregate(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Aggregate)
+;
}
GeneratedField::Join => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("join"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Join(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Join)
+;
}
GeneratedField::Sort => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("sort"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Sort(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Sort)
+;
}
GeneratedField::Repartition => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("repartition"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Repartition(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Repartition)
+;
}
GeneratedField::EmptyRelation => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("emptyRelation"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::EmptyRelation(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::EmptyRelation)
+;
}
GeneratedField::CreateExternalTable => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("createExternalTable"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateExternalTable(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateExternalTable)
+;
}
GeneratedField::Explain => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("explain"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Explain(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Explain)
+;
}
GeneratedField::Window => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("window"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Window(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Window)
+;
}
GeneratedField::Analyze => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("analyze"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Analyze(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Analyze)
+;
}
GeneratedField::CrossJoin => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("crossJoin"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CrossJoin(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CrossJoin)
+;
}
GeneratedField::Values => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Values(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Values)
+;
}
GeneratedField::Extension => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("extension"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Extension(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Extension)
+;
}
GeneratedField::CreateCatalogSchema => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("createCatalogSchema"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateCatalogSchema(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalogSchema)
+;
}
GeneratedField::Union => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("union"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Union(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Union)
+;
}
GeneratedField::CreateCatalog => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("createCatalog"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateCatalog(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalog)
+;
}
GeneratedField::SubqueryAlias => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("subqueryAlias"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::SubqueryAlias(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::SubqueryAlias)
+;
}
GeneratedField::CreateView => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("createView"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CreateView(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateView)
+;
}
GeneratedField::Distinct => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("distinct"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::Distinct(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Distinct)
+;
}
GeneratedField::ViewScan => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("viewScan"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::ViewScan(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ViewScan)
+;
}
GeneratedField::CustomScan => {
if logical_plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("customScan"));
}
- logical_plan_type__ = Some(logical_plan_node::LogicalPlanType::CustomScan(map.next_value()?));
+ logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CustomScan)
+;
}
}
}
@@ -8180,7 +8339,7 @@ impl<'de> serde::Deserialize<'de> for NegativeNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -8271,7 +8430,7 @@ impl<'de> serde::Deserialize<'de> for Not {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -8308,6 +8467,7 @@ impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "optimizer_name",
"optimizerName",
];
@@ -8335,7 +8495,7 @@ impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType {
E: serde::de::Error,
{
match value {
- "optimizerName" => Ok(GeneratedField::OptimizerName),
+ "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -8399,6 +8559,7 @@ impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "optimizer_name",
"optimizerName",
];
@@ -8426,7 +8587,7 @@ impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType {
E: serde::de::Error,
{
match value {
- "optimizerName" => Ok(GeneratedField::OptimizerName),
+ "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -8490,6 +8651,7 @@ impl<'de> serde::Deserialize<'de> for ParquetFormat {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "enable_pruning",
"enablePruning",
];
@@ -8517,7 +8679,7 @@ impl<'de> serde::Deserialize<'de> for ParquetFormat {
E: serde::de::Error,
{
match value {
- "enablePruning" => Ok(GeneratedField::EnablePruning),
+ "enablePruning" | "enable_pruning" => Ok(GeneratedField::EnablePruning),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -8669,37 +8831,43 @@ impl<'de> serde::Deserialize<'de> for PlanType {
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()?));
+ plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialLogicalPlan)
+;
}
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()?));
+ plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedLogicalPlan)
+;
}
GeneratedField::FinalLogicalPlan => {
if plan_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("FinalLogicalPlan"));
}
- plan_type_enum__ = Some(plan_type::PlanTypeEnum::FinalLogicalPlan(map.next_value()?));
+ plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalLogicalPlan)
+;
}
GeneratedField::InitialPhysicalPlan => {
if plan_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan"));
}
- plan_type_enum__ = Some(plan_type::PlanTypeEnum::InitialPhysicalPlan(map.next_value()?));
+ plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialPhysicalPlan)
+;
}
GeneratedField::OptimizedPhysicalPlan => {
if plan_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan"));
}
- plan_type_enum__ = Some(plan_type::PlanTypeEnum::OptimizedPhysicalPlan(map.next_value()?));
+ plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedPhysicalPlan)
+;
}
GeneratedField::FinalPhysicalPlan => {
if plan_type_enum__.is_some() {
return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan"));
}
- plan_type_enum__ = Some(plan_type::PlanTypeEnum::FinalPhysicalPlan(map.next_value()?));
+ plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalPhysicalPlan)
+;
}
}
}
@@ -8905,7 +9073,7 @@ impl<'de> serde::Deserialize<'de> for ProjectionNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Expr => {
if expr__.is_some() {
@@ -8917,7 +9085,7 @@ impl<'de> serde::Deserialize<'de> for ProjectionNode {
if optional_alias__.is_some() {
return Err(serde::de::Error::duplicate_field("alias"));
}
- optional_alias__ = Some(projection_node::OptionalAlias::Alias(map.next_value()?));
+ optional_alias__ = map.next_value::<::std::option::Option<_>>()?.map(projection_node::OptionalAlias::Alias);
}
}
}
@@ -8970,6 +9138,7 @@ impl<'de> serde::Deserialize<'de> for RepartitionNode {
{
const FIELDS: &[&str] = &[
"input",
+ "round_robin",
"roundRobin",
"hash",
];
@@ -9001,7 +9170,7 @@ impl<'de> serde::Deserialize<'de> for RepartitionNode {
{
match value {
"input" => Ok(GeneratedField::Input),
- "roundRobin" => Ok(GeneratedField::RoundRobin),
+ "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin),
"hash" => Ok(GeneratedField::Hash),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -9030,21 +9199,20 @@ impl<'de> serde::Deserialize<'de> for RepartitionNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = 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
- ));
+ partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_node::PartitionMethod::RoundRobin(x.0));
}
GeneratedField::Hash => {
if partition_method__.is_some() {
return Err(serde::de::Error::duplicate_field("hash"));
}
- partition_method__ = Some(repartition_node::PartitionMethod::Hash(map.next_value()?));
+ partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_node::PartitionMethod::Hash)
+;
}
}
}
@@ -9179,6 +9347,7 @@ impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "index_type",
"indexType",
"value",
];
@@ -9208,7 +9377,7 @@ impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue {
E: serde::de::Error,
{
match value {
- "indexType" => Ok(GeneratedField::IndexType),
+ "indexType" | "index_type" => Ok(GeneratedField::IndexType),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -9237,13 +9406,13 @@ impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue {
if index_type__.is_some() {
return Err(serde::de::Error::duplicate_field("indexType"));
}
- index_type__ = Some(map.next_value()?);
+ index_type__ = map.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
- value__ = Some(map.next_value()?);
+ value__ = map.next_value()?;
}
}
}
@@ -9256,6 +9425,118 @@ impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue {
deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", FIELDS, GeneratedVisitor)
}
}
+impl serde::Serialize for ScalarFixedSizeBinary {
+ #[allow(deprecated)]
+ fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ use serde::ser::SerializeStruct;
+ let mut len = 0;
+ if !self.values.is_empty() {
+ len += 1;
+ }
+ if self.length != 0 {
+ len += 1;
+ }
+ let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFixedSizeBinary", len)?;
+ if !self.values.is_empty() {
+ struct_ser.serialize_field("values", pbjson::private::base64::encode(&self.values).as_str())?;
+ }
+ if self.length != 0 {
+ struct_ser.serialize_field("length", &self.length)?;
+ }
+ struct_ser.end()
+ }
+}
+impl<'de> serde::Deserialize<'de> for ScalarFixedSizeBinary {
+ #[allow(deprecated)]
+ fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ const FIELDS: &[&str] = &[
+ "values",
+ "length",
+ ];
+
+ #[allow(clippy::enum_variant_names)]
+ enum GeneratedField {
+ Values,
+ Length,
+ }
+ impl<'de> serde::Deserialize<'de> for GeneratedField {
+ fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
+ where
+ D: serde::Deserializer<'de>,
+ {
+ struct GeneratedVisitor;
+
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = GeneratedField;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ write!(formatter, "expected one of: {:?}", &FIELDS)
+ }
+
+ #[allow(unused_variables)]
+ fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
+ where
+ E: serde::de::Error,
+ {
+ match value {
+ "values" => Ok(GeneratedField::Values),
+ "length" => Ok(GeneratedField::Length),
+ _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
+ }
+ }
+ }
+ deserializer.deserialize_identifier(GeneratedVisitor)
+ }
+ }
+ struct GeneratedVisitor;
+ impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
+ type Value = ScalarFixedSizeBinary;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ formatter.write_str("struct datafusion.ScalarFixedSizeBinary")
+ }
+
+ fn visit_map<V>(self, mut map: V) -> std::result::Result<ScalarFixedSizeBinary, V::Error>
+ where
+ V: serde::de::MapAccess<'de>,
+ {
+ let mut values__ = None;
+ let mut length__ = None;
+ while let Some(k) = map.next_key()? {
+ match k {
+ GeneratedField::Values => {
+ if values__.is_some() {
+ return Err(serde::de::Error::duplicate_field("values"));
+ }
+ values__ =
+ Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+ ;
+ }
+ GeneratedField::Length => {
+ if length__.is_some() {
+ return Err(serde::de::Error::duplicate_field("length"));
+ }
+ length__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
+ }
+ }
+ }
+ Ok(ScalarFixedSizeBinary {
+ values: values__.unwrap_or_default(),
+ length: length__.unwrap_or_default(),
+ })
+ }
+ }
+ deserializer.deserialize_struct("datafusion.ScalarFixedSizeBinary", FIELDS, GeneratedVisitor)
+ }
+}
impl serde::Serialize for ScalarFunction {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
@@ -9680,6 +9961,7 @@ impl<'de> serde::Deserialize<'de> for ScalarListValue {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "is_null",
"isNull",
"field",
"values",
@@ -9711,7 +9993,7 @@ impl<'de> serde::Deserialize<'de> for ScalarListValue {
E: serde::de::Error,
{
match value {
- "isNull" => Ok(GeneratedField::IsNull),
+ "isNull" | "is_null" => Ok(GeneratedField::IsNull),
"field" => Ok(GeneratedField::Field),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
@@ -9748,7 +10030,7 @@ impl<'de> serde::Deserialize<'de> for ScalarListValue {
if field__.is_some() {
return Err(serde::de::Error::duplicate_field("field"));
}
- field__ = Some(map.next_value()?);
+ field__ = map.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
@@ -9813,9 +10095,13 @@ impl<'de> serde::Deserialize<'de> for ScalarTimestampValue {
{
const FIELDS: &[&str] = &[
"timezone",
+ "time_microsecond_value",
"timeMicrosecondValue",
+ "time_nanosecond_value",
"timeNanosecondValue",
+ "time_second_value",
"timeSecondValue",
+ "time_millisecond_value",
"timeMillisecondValue",
];
@@ -9848,10 +10134,10 @@ impl<'de> serde::Deserialize<'de> for ScalarTimestampValue {
{
match value {
"timezone" => Ok(GeneratedField::Timezone),
- "timeMicrosecondValue" => Ok(GeneratedField::TimeMicrosecondValue),
- "timeNanosecondValue" => Ok(GeneratedField::TimeNanosecondValue),
- "timeSecondValue" => Ok(GeneratedField::TimeSecondValue),
- "timeMillisecondValue" => Ok(GeneratedField::TimeMillisecondValue),
+ "timeMicrosecondValue" | "time_microsecond_value" => Ok(GeneratedField::TimeMicrosecondValue),
+ "timeNanosecondValue" | "time_nanosecond_value" => Ok(GeneratedField::TimeNanosecondValue),
+ "timeSecondValue" | "time_second_value" => Ok(GeneratedField::TimeSecondValue),
+ "timeMillisecondValue" | "time_millisecond_value" => Ok(GeneratedField::TimeMillisecondValue),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -9885,33 +10171,25 @@ impl<'de> serde::Deserialize<'de> for ScalarTimestampValue {
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
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMicrosecondValue(x.0));
}
GeneratedField::TimeNanosecondValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("timeNanosecondValue"));
}
- value__ = Some(scalar_timestamp_value::Value::TimeNanosecondValue(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeNanosecondValue(x.0));
}
GeneratedField::TimeSecondValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("timeSecondValue"));
}
- value__ = Some(scalar_timestamp_value::Value::TimeSecondValue(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeSecondValue(x.0));
}
GeneratedField::TimeMillisecondValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("timeMillisecondValue"));
}
- value__ = Some(scalar_timestamp_value::Value::TimeMillisecondValue(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMillisecondValue(x.0));
}
}
}
@@ -9955,6 +10233,7 @@ impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "fun_name",
"funName",
"args",
];
@@ -9984,7 +10263,7 @@ impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode {
E: serde::de::Error,
{
match value {
- "funName" => Ok(GeneratedField::FunName),
+ "funName" | "fun_name" => Ok(GeneratedField::FunName),
"args" => Ok(GeneratedField::Args),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -10127,6 +10406,9 @@ impl serde::Serialize for ScalarValue {
scalar_value::Value::StructValue(v) => {
struct_ser.serialize_field("structValue", v)?;
}
+ scalar_value::Value::FixedSizeBinaryValue(v) => {
+ struct_ser.serialize_field("fixedSizeBinaryValue", v)?;
+ }
}
}
struct_ser.end()
@@ -10139,33 +10421,62 @@ impl<'de> serde::Deserialize<'de> for ScalarValue {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "null_value",
"nullValue",
+ "bool_value",
"boolValue",
+ "utf8_value",
"utf8Value",
+ "large_utf8_value",
"largeUtf8Value",
+ "int8_value",
"int8Value",
+ "int16_value",
"int16Value",
+ "int32_value",
"int32Value",
+ "int64_value",
"int64Value",
+ "uint8_value",
"uint8Value",
+ "uint16_value",
"uint16Value",
+ "uint32_value",
"uint32Value",
+ "uint64_value",
"uint64Value",
+ "float32_value",
"float32Value",
+ "float64_value",
"float64Value",
+ "date_32_value",
"date32Value",
+ "list_value",
"listValue",
+ "decimal128_value",
"decimal128Value",
+ "date_64_value",
"date64Value",
+ "interval_yearmonth_value",
"intervalYearmonthValue",
+ "interval_daytime_value",
"intervalDaytimeValue",
+ "timestamp_value",
"timestampValue",
+ "dictionary_value",
"dictionaryValue",
+ "binary_value",
"binaryValue",
+ "large_binary_value",
"largeBinaryValue",
+ "time64_value",
"time64Value",
+ "interval_month_day_nano",
"intervalMonthDayNano",
+ "struct_value",
"structValue",
+ "fixed_size_binary_value",
+ "fixedSizeBinaryValue",
];
#[allow(clippy::enum_variant_names)]
@@ -10197,6 +10508,7 @@ impl<'de> serde::Deserialize<'de> for ScalarValue {
Time64Value,
IntervalMonthDayNano,
StructValue,
+ FixedSizeBinaryValue,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
@@ -10218,33 +10530,34 @@ impl<'de> serde::Deserialize<'de> for ScalarValue {
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),
+ "nullValue" | "null_value" => Ok(GeneratedField::NullValue),
+ "boolValue" | "bool_value" => Ok(GeneratedField::BoolValue),
+ "utf8Value" | "utf8_value" => Ok(GeneratedField::Utf8Value),
+ "largeUtf8Value" | "large_utf8_value" => Ok(GeneratedField::LargeUtf8Value),
+ "int8Value" | "int8_value" => Ok(GeneratedField::Int8Value),
+ "int16Value" | "int16_value" => Ok(GeneratedField::Int16Value),
+ "int32Value" | "int32_value" => Ok(GeneratedField::Int32Value),
+ "int64Value" | "int64_value" => Ok(GeneratedField::Int64Value),
+ "uint8Value" | "uint8_value" => Ok(GeneratedField::Uint8Value),
+ "uint16Value" | "uint16_value" => Ok(GeneratedField::Uint16Value),
+ "uint32Value" | "uint32_value" => Ok(GeneratedField::Uint32Value),
+ "uint64Value" | "uint64_value" => Ok(GeneratedField::Uint64Value),
+ "float32Value" | "float32_value" => Ok(GeneratedField::Float32Value),
+ "float64Value" | "float64_value" => Ok(GeneratedField::Float64Value),
+ "date32Value" | "date_32_value" => Ok(GeneratedField::Date32Value),
+ "listValue" | "list_value" => Ok(GeneratedField::ListValue),
+ "decimal128Value" | "decimal128_value" => Ok(GeneratedField::Decimal128Value),
+ "date64Value" | "date_64_value" => Ok(GeneratedField::Date64Value),
+ "intervalYearmonthValue" | "interval_yearmonth_value" => Ok(GeneratedField::IntervalYearmonthValue),
+ "intervalDaytimeValue" | "interval_daytime_value" => Ok(GeneratedField::IntervalDaytimeValue),
+ "timestampValue" | "timestamp_value" => Ok(GeneratedField::TimestampValue),
+ "dictionaryValue" | "dictionary_value" => Ok(GeneratedField::DictionaryValue),
+ "binaryValue" | "binary_value" => Ok(GeneratedField::BinaryValue),
+ "largeBinaryValue" | "large_binary_value" => Ok(GeneratedField::LargeBinaryValue),
+ "time64Value" | "time64_value" => Ok(GeneratedField::Time64Value),
+ "intervalMonthDayNano" | "interval_month_day_nano" => Ok(GeneratedField::IntervalMonthDayNano),
+ "structValue" | "struct_value" => Ok(GeneratedField::StructValue),
+ "fixedSizeBinaryValue" | "fixed_size_binary_value" => Ok(GeneratedField::FixedSizeBinaryValue),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -10271,197 +10584,177 @@ impl<'de> serde::Deserialize<'de> for ScalarValue {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("nullValue"));
}
- value__ = Some(scalar_value::Value::NullValue(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::NullValue)
+;
}
GeneratedField::BoolValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("boolValue"));
}
- value__ = Some(scalar_value::Value::BoolValue(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::BoolValue);
}
GeneratedField::Utf8Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("utf8Value"));
}
- value__ = Some(scalar_value::Value::Utf8Value(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Utf8Value);
}
GeneratedField::LargeUtf8Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("largeUtf8Value"));
}
- value__ = Some(scalar_value::Value::LargeUtf8Value(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::LargeUtf8Value);
}
GeneratedField::Int8Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("int8Value"));
}
- value__ = Some(scalar_value::Value::Int8Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int8Value(x.0));
}
GeneratedField::Int16Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("int16Value"));
}
- value__ = Some(scalar_value::Value::Int16Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int16Value(x.0));
}
GeneratedField::Int32Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("int32Value"));
}
- value__ = Some(scalar_value::Value::Int32Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int32Value(x.0));
}
GeneratedField::Int64Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("int64Value"));
}
- value__ = Some(scalar_value::Value::Int64Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int64Value(x.0));
}
GeneratedField::Uint8Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("uint8Value"));
}
- value__ = Some(scalar_value::Value::Uint8Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint8Value(x.0));
}
GeneratedField::Uint16Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("uint16Value"));
}
- value__ = Some(scalar_value::Value::Uint16Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint16Value(x.0));
}
GeneratedField::Uint32Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("uint32Value"));
}
- value__ = Some(scalar_value::Value::Uint32Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint32Value(x.0));
}
GeneratedField::Uint64Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("uint64Value"));
}
- value__ = Some(scalar_value::Value::Uint64Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint64Value(x.0));
}
GeneratedField::Float32Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("float32Value"));
}
- value__ = Some(scalar_value::Value::Float32Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float32Value(x.0));
}
GeneratedField::Float64Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("float64Value"));
}
- value__ = Some(scalar_value::Value::Float64Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float64Value(x.0));
}
GeneratedField::Date32Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("date32Value"));
}
- value__ = Some(scalar_value::Value::Date32Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date32Value(x.0));
}
GeneratedField::ListValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("listValue"));
}
- value__ = Some(scalar_value::Value::ListValue(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::ListValue)
+;
}
GeneratedField::Decimal128Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("decimal128Value"));
}
- value__ = Some(scalar_value::Value::Decimal128Value(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Decimal128Value)
+;
}
GeneratedField::Date64Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("date64Value"));
}
- value__ = Some(scalar_value::Value::Date64Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date64Value(x.0));
}
GeneratedField::IntervalYearmonthValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("intervalYearmonthValue"));
}
- value__ = Some(scalar_value::Value::IntervalYearmonthValue(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalYearmonthValue(x.0));
}
GeneratedField::IntervalDaytimeValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("intervalDaytimeValue"));
}
- value__ = Some(scalar_value::Value::IntervalDaytimeValue(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalDaytimeValue(x.0));
}
GeneratedField::TimestampValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("timestampValue"));
}
- value__ = Some(scalar_value::Value::TimestampValue(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::TimestampValue)
+;
}
GeneratedField::DictionaryValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("dictionaryValue"));
}
- value__ = Some(scalar_value::Value::DictionaryValue(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::DictionaryValue)
+;
}
GeneratedField::BinaryValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("binaryValue"));
}
- value__ = Some(scalar_value::Value::BinaryValue(
- map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::BinaryValue(x.0));
}
GeneratedField::LargeBinaryValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("largeBinaryValue"));
}
- value__ = Some(scalar_value::Value::LargeBinaryValue(
- map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::LargeBinaryValue(x.0));
}
GeneratedField::Time64Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("time64Value"));
}
- value__ = Some(scalar_value::Value::Time64Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Time64Value(x.0));
}
GeneratedField::IntervalMonthDayNano => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("intervalMonthDayNano"));
}
- value__ = Some(scalar_value::Value::IntervalMonthDayNano(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::IntervalMonthDayNano)
+;
}
GeneratedField::StructValue => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("structValue"));
}
- value__ = Some(scalar_value::Value::StructValue(map.next_value()?));
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::StructValue)
+;
+ }
+ GeneratedField::FixedSizeBinaryValue => {
+ if value__.is_some() {
+ return Err(serde::de::Error::duplicate_field("fixedSizeBinaryValue"));
+ }
+ value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::FixedSizeBinaryValue)
+;
}
}
}
@@ -10643,7 +10936,7 @@ impl<'de> serde::Deserialize<'de> for SelectionExecNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -10744,13 +11037,13 @@ impl<'de> serde::Deserialize<'de> for SelectionNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Expr => {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
}
}
@@ -10809,6 +11102,7 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
"negated",
"expr",
"pattern",
+ "escape_char",
"escapeChar",
];
@@ -10842,7 +11136,7 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
"negated" => Ok(GeneratedField::Negated),
"expr" => Ok(GeneratedField::Expr),
"pattern" => Ok(GeneratedField::Pattern),
- "escapeChar" => Ok(GeneratedField::EscapeChar),
+ "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -10878,13 +11172,13 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::Pattern => {
if pattern__.is_some() {
return Err(serde::de::Error::duplicate_field("pattern"));
}
- pattern__ = Some(map.next_value()?);
+ pattern__ = map.next_value()?;
}
GeneratedField::EscapeChar => {
if escape_char__.is_some() {
@@ -10944,6 +11238,7 @@ impl<'de> serde::Deserialize<'de> for SortExprNode {
const FIELDS: &[&str] = &[
"expr",
"asc",
+ "nulls_first",
"nullsFirst",
];
@@ -10975,7 +11270,7 @@ impl<'de> serde::Deserialize<'de> for SortExprNode {
match value {
"expr" => Ok(GeneratedField::Expr),
"asc" => Ok(GeneratedField::Asc),
- "nullsFirst" => Ok(GeneratedField::NullsFirst),
+ "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -11004,7 +11299,7 @@ impl<'de> serde::Deserialize<'de> for SortExprNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::Asc => {
if asc__.is_some() {
@@ -11129,7 +11424,7 @@ impl<'de> serde::Deserialize<'de> for SortNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Expr => {
if expr__.is_some() {
@@ -11141,9 +11436,9 @@ impl<'de> serde::Deserialize<'de> for SortNode {
if fetch__.is_some() {
return Err(serde::de::Error::duplicate_field("fetch"));
}
- fetch__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ fetch__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
}
}
@@ -11188,6 +11483,7 @@ impl<'de> serde::Deserialize<'de> for StringifiedPlan {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "plan_type",
"planType",
"plan",
];
@@ -11217,7 +11513,7 @@ impl<'de> serde::Deserialize<'de> for StringifiedPlan {
E: serde::de::Error,
{
match value {
- "planType" => Ok(GeneratedField::PlanType),
+ "planType" | "plan_type" => Ok(GeneratedField::PlanType),
"plan" => Ok(GeneratedField::Plan),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -11246,7 +11542,7 @@ impl<'de> serde::Deserialize<'de> for StringifiedPlan {
if plan_type__.is_some() {
return Err(serde::de::Error::duplicate_field("planType"));
}
- plan_type__ = Some(map.next_value()?);
+ plan_type__ = map.next_value()?;
}
GeneratedField::Plan => {
if plan__.is_some() {
@@ -11290,6 +11586,7 @@ impl<'de> serde::Deserialize<'de> for Struct {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "sub_field_types",
"subFieldTypes",
];
@@ -11317,7 +11614,7 @@ impl<'de> serde::Deserialize<'de> for Struct {
E: serde::de::Error,
{
match value {
- "subFieldTypes" => Ok(GeneratedField::SubFieldTypes),
+ "subFieldTypes" | "sub_field_types" => Ok(GeneratedField::SubFieldTypes),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -11387,6 +11684,7 @@ impl<'de> serde::Deserialize<'de> for StructValue {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "field_values",
"fieldValues",
"fields",
];
@@ -11416,7 +11714,7 @@ impl<'de> serde::Deserialize<'de> for StructValue {
E: serde::de::Error,
{
match value {
- "fieldValues" => Ok(GeneratedField::FieldValues),
+ "fieldValues" | "field_values" => Ok(GeneratedField::FieldValues),
"fields" => Ok(GeneratedField::Fields),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -11553,7 +11851,7 @@ impl<'de> serde::Deserialize<'de> for SubqueryAliasNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Alias => {
if alias__.is_some() {
@@ -11684,6 +11982,7 @@ impl<'de> serde::Deserialize<'de> for Timestamp {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "time_unit",
"timeUnit",
"timezone",
];
@@ -11713,7 +12012,7 @@ impl<'de> serde::Deserialize<'de> for Timestamp {
E: serde::de::Error,
{
match value {
- "timeUnit" => Ok(GeneratedField::TimeUnit),
+ "timeUnit" | "time_unit" => Ok(GeneratedField::TimeUnit),
"timezone" => Ok(GeneratedField::Timezone),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -11793,6 +12092,7 @@ impl<'de> serde::Deserialize<'de> for TryCastNode {
{
const FIELDS: &[&str] = &[
"expr",
+ "arrow_type",
"arrowType",
];
@@ -11822,7 +12122,7 @@ impl<'de> serde::Deserialize<'de> for TryCastNode {
{
match value {
"expr" => Ok(GeneratedField::Expr),
- "arrowType" => Ok(GeneratedField::ArrowType),
+ "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -11850,13 +12150,13 @@ impl<'de> serde::Deserialize<'de> for TryCastNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::ArrowType => {
if arrow_type__.is_some() {
return Err(serde::de::Error::duplicate_field("arrowType"));
}
- arrow_type__ = Some(map.next_value()?);
+ arrow_type__ = map.next_value()?;
}
}
}
@@ -11908,8 +12208,11 @@ impl<'de> serde::Deserialize<'de> for Union {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "union_types",
"unionTypes",
+ "union_mode",
"unionMode",
+ "type_ids",
"typeIds",
];
@@ -11939,9 +12242,9 @@ impl<'de> serde::Deserialize<'de> for Union {
E: serde::de::Error,
{
match value {
- "unionTypes" => Ok(GeneratedField::UnionTypes),
- "unionMode" => Ok(GeneratedField::UnionMode),
- "typeIds" => Ok(GeneratedField::TypeIds),
+ "unionTypes" | "union_types" => Ok(GeneratedField::UnionTypes),
+ "unionMode" | "union_mode" => Ok(GeneratedField::UnionMode),
+ "typeIds" | "type_ids" => Ok(GeneratedField::TypeIds),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -11982,10 +12285,10 @@ impl<'de> serde::Deserialize<'de> for Union {
if type_ids__.is_some() {
return Err(serde::de::Error::duplicate_field("typeIds"));
}
- type_ids__ = Some(
- map.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
- .into_iter().map(|x| x.0).collect()
- );
+ type_ids__ =
+ Some(map.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
+ .into_iter().map(|x| x.0).collect())
+ ;
}
}
}
@@ -12194,7 +12497,9 @@ impl<'de> serde::Deserialize<'de> for ValuesNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "n_cols",
"nCols",
+ "values_list",
"valuesList",
];
@@ -12223,8 +12528,8 @@ impl<'de> serde::Deserialize<'de> for ValuesNode {
E: serde::de::Error,
{
match value {
- "nCols" => Ok(GeneratedField::NCols),
- "valuesList" => Ok(GeneratedField::ValuesList),
+ "nCols" | "n_cols" => Ok(GeneratedField::NCols),
+ "valuesList" | "values_list" => Ok(GeneratedField::ValuesList),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -12252,9 +12557,9 @@ impl<'de> serde::Deserialize<'de> for ValuesNode {
if n_cols__.is_some() {
return Err(serde::de::Error::duplicate_field("nCols"));
}
- n_cols__ = Some(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- );
+ n_cols__ =
+ Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+ ;
}
GeneratedField::ValuesList => {
if values_list__.is_some() {
@@ -12322,6 +12627,7 @@ impl<'de> serde::Deserialize<'de> for ViewTableScanNode {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "table_name",
"tableName",
"input",
"schema",
@@ -12357,7 +12663,7 @@ impl<'de> serde::Deserialize<'de> for ViewTableScanNode {
E: serde::de::Error,
{
match value {
- "tableName" => Ok(GeneratedField::TableName),
+ "tableName" | "table_name" => Ok(GeneratedField::TableName),
"input" => Ok(GeneratedField::Input),
"schema" => Ok(GeneratedField::Schema),
"projection" => Ok(GeneratedField::Projection),
@@ -12398,19 +12704,19 @@ impl<'de> serde::Deserialize<'de> for ViewTableScanNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::Schema => {
if schema__.is_some() {
return Err(serde::de::Error::duplicate_field("schema"));
}
- schema__ = Some(map.next_value()?);
+ schema__ = map.next_value()?;
}
GeneratedField::Projection => {
if projection__.is_some() {
return Err(serde::de::Error::duplicate_field("projection"));
}
- projection__ = Some(map.next_value()?);
+ projection__ = map.next_value()?;
}
GeneratedField::Definition => {
if definition__.is_some() {
@@ -12463,7 +12769,9 @@ impl<'de> serde::Deserialize<'de> for WhenThen {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "when_expr",
"whenExpr",
+ "then_expr",
"thenExpr",
];
@@ -12492,8 +12800,8 @@ impl<'de> serde::Deserialize<'de> for WhenThen {
E: serde::de::Error,
{
match value {
- "whenExpr" => Ok(GeneratedField::WhenExpr),
- "thenExpr" => Ok(GeneratedField::ThenExpr),
+ "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr),
+ "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -12521,13 +12829,13 @@ impl<'de> serde::Deserialize<'de> for WhenThen {
if when_expr__.is_some() {
return Err(serde::de::Error::duplicate_field("whenExpr"));
}
- when_expr__ = Some(map.next_value()?);
+ when_expr__ = map.next_value()?;
}
GeneratedField::ThenExpr => {
if then_expr__.is_some() {
return Err(serde::de::Error::duplicate_field("thenExpr"));
}
- then_expr__ = Some(map.next_value()?);
+ then_expr__ = map.next_value()?;
}
}
}
@@ -12605,9 +12913,13 @@ impl<'de> serde::Deserialize<'de> for WindowExprNode {
{
const FIELDS: &[&str] = &[
"expr",
+ "partition_by",
"partitionBy",
+ "order_by",
"orderBy",
+ "aggr_function",
"aggrFunction",
+ "built_in_function",
"builtInFunction",
"frame",
];
@@ -12642,10 +12954,10 @@ impl<'de> serde::Deserialize<'de> for WindowExprNode {
{
match value {
"expr" => Ok(GeneratedField::Expr),
- "partitionBy" => Ok(GeneratedField::PartitionBy),
- "orderBy" => Ok(GeneratedField::OrderBy),
- "aggrFunction" => Ok(GeneratedField::AggrFunction),
- "builtInFunction" => Ok(GeneratedField::BuiltInFunction),
+ "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
+ "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
+ "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction),
+ "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction),
"frame" => Ok(GeneratedField::Frame),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -12677,7 +12989,7 @@ impl<'de> serde::Deserialize<'de> for WindowExprNode {
if expr__.is_some() {
return Err(serde::de::Error::duplicate_field("expr"));
}
- expr__ = Some(map.next_value()?);
+ expr__ = map.next_value()?;
}
GeneratedField::PartitionBy => {
if partition_by__.is_some() {
@@ -12695,19 +13007,20 @@ impl<'de> serde::Deserialize<'de> for WindowExprNode {
if window_function__.is_some() {
return Err(serde::de::Error::duplicate_field("aggrFunction"));
}
- window_function__ = Some(window_expr_node::WindowFunction::AggrFunction(map.next_value::<AggregateFunction>()? as i32));
+ window_function__ = map.next_value::<::std::option::Option<AggregateFunction>>()?.map(|x| window_expr_node::WindowFunction::AggrFunction(x as i32));
}
GeneratedField::BuiltInFunction => {
if window_function__.is_some() {
return Err(serde::de::Error::duplicate_field("builtInFunction"));
}
- window_function__ = Some(window_expr_node::WindowFunction::BuiltInFunction(map.next_value::<BuiltInWindowFunction>()? as i32));
+ window_function__ = map.next_value::<::std::option::Option<BuiltInWindowFunction>>()?.map(|x| window_expr_node::WindowFunction::BuiltInFunction(x 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()?));
+ window_frame__ = map.next_value::<::std::option::Option<_>>()?.map(window_expr_node::WindowFrame::Frame)
+;
}
}
}
@@ -12766,7 +13079,9 @@ impl<'de> serde::Deserialize<'de> for WindowFrame {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "window_frame_units",
"windowFrameUnits",
+ "start_bound",
"startBound",
"bound",
];
@@ -12797,8 +13112,8 @@ impl<'de> serde::Deserialize<'de> for WindowFrame {
E: serde::de::Error,
{
match value {
- "windowFrameUnits" => Ok(GeneratedField::WindowFrameUnits),
- "startBound" => Ok(GeneratedField::StartBound),
+ "windowFrameUnits" | "window_frame_units" => Ok(GeneratedField::WindowFrameUnits),
+ "startBound" | "start_bound" => Ok(GeneratedField::StartBound),
"bound" => Ok(GeneratedField::Bound),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
@@ -12834,13 +13149,14 @@ impl<'de> serde::Deserialize<'de> for WindowFrame {
if start_bound__.is_some() {
return Err(serde::de::Error::duplicate_field("startBound"));
}
- start_bound__ = Some(map.next_value()?);
+ start_bound__ = 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()?));
+ end_bound__ = map.next_value::<::std::option::Option<_>>()?.map(window_frame::EndBound::Bound)
+;
}
}
}
@@ -12875,11 +13191,7 @@ impl serde::Serialize for WindowFrameBound {
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.serialize_field("boundValue", v)?;
}
struct_ser.end()
}
@@ -12891,14 +13203,16 @@ impl<'de> serde::Deserialize<'de> for WindowFrameBound {
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
+ "window_frame_bound_type",
"windowFrameBoundType",
- "value",
+ "bound_value",
+ "boundValue",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
WindowFrameBoundType,
- Value,
+ BoundValue,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
@@ -12920,8 +13234,8 @@ impl<'de> serde::Deserialize<'de> for WindowFrameBound {
E: serde::de::Error,
{
match value {
- "windowFrameBoundType" => Ok(GeneratedField::WindowFrameBoundType),
- "value" => Ok(GeneratedField::Value),
+ "windowFrameBoundType" | "window_frame_bound_type" => Ok(GeneratedField::WindowFrameBoundType),
+ "boundValue" | "bound_value" => Ok(GeneratedField::BoundValue),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -12951,13 +13265,11 @@ impl<'de> serde::Deserialize<'de> for WindowFrameBound {
}
window_frame_bound_type__ = Some(map.next_value::<WindowFrameBoundType>()? as i32);
}
- GeneratedField::Value => {
+ GeneratedField::BoundValue => {
if bound_value__.is_some() {
- return Err(serde::de::Error::duplicate_field("value"));
+ return Err(serde::de::Error::duplicate_field("boundValue"));
}
- bound_value__ = Some(window_frame_bound::BoundValue::Value(
- map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0
- ));
+ bound_value__ = map.next_value()?;
}
}
}
@@ -13154,6 +13466,7 @@ impl<'de> serde::Deserialize<'de> for WindowNode {
{
const FIELDS: &[&str] = &[
"input",
+ "window_expr",
"windowExpr",
];
@@ -13183,7 +13496,7 @@ impl<'de> serde::Deserialize<'de> for WindowNode {
{
match value {
"input" => Ok(GeneratedField::Input),
- "windowExpr" => Ok(GeneratedField::WindowExpr),
+ "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
@@ -13211,7 +13524,7 @@ impl<'de> serde::Deserialize<'de> for WindowNode {
if input__.is_some() {
return Err(serde::de::Error::duplicate_field("input"));
}
- input__ = Some(map.next_value()?);
+ input__ = map.next_value()?;
}
GeneratedField::WindowExpr => {
if window_expr__.is_some() {
diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs
index eee0732d4..149edf020 100644
--- a/datafusion/proto/src/generated/prost.rs
+++ b/datafusion/proto/src/generated/prost.rs
@@ -748,20 +748,8 @@ pub mod window_frame {
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 <https://github.com/tokio-rs/prost/issues/430> and <https://github.com/tokio-rs/prost/pull/455>)
- /// this syntax is ugly but is binary compatible with the "optional" keyword (see <https://stackoverflow.com/questions/42622015/how-to-define-an-optional-field-in-protobuf-3>)
- #[prost(oneof="window_frame_bound::BoundValue", tags="2")]
- pub bound_value: ::core::option::Option<window_frame_bound::BoundValue>,
-}
-/// 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 <https://github.com/tokio-rs/prost/issues/430> and <https://github.com/tokio-rs/prost/pull/455>)
- /// this syntax is ugly but is binary compatible with the "optional" keyword (see <https://stackoverflow.com/questions/42622015/how-to-define-an-optional-field-in-protobuf-3>)
- #[derive(Clone, PartialEq, ::prost::Oneof)]
- pub enum BoundValue {
- #[prost(uint64, tag="2")]
- Value(u64),
- }
+ #[prost(message, optional, tag="2")]
+ pub bound_value: ::core::option::Option<ScalarValue>,
}
// /////////////////////////////////////////////////////////////////////////////////////////////////
// Arrow Data Types
@@ -896,8 +884,15 @@ pub struct StructValue {
pub fields: ::prost::alloc::vec::Vec<Field>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ScalarFixedSizeBinary {
+ #[prost(bytes="vec", tag="1")]
+ pub values: ::prost::alloc::vec::Vec<u8>,
+ #[prost(int32, tag="2")]
+ pub length: i32,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ScalarValue {
- #[prost(oneof="scalar_value::Value", tags="33, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 20, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32")]
+ #[prost(oneof="scalar_value::Value", tags="33, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 20, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34")]
pub value: ::core::option::Option<scalar_value::Value>,
}
/// Nested message and enum types in `ScalarValue`.
@@ -962,6 +957,8 @@ pub mod scalar_value {
IntervalMonthDayNano(super::IntervalMonthDayNanoValue),
#[prost(message, tag="32")]
StructValue(super::StructValue),
+ #[prost(message, tag="34")]
+ FixedSizeBinaryValue(super::ScalarFixedSizeBinary),
}
}
#[derive(Clone, PartialEq, ::prost::Message)]