From e5a75e3ddf00977abf4a6f27843fb15b94220ff7 Mon Sep 17 00:00:00 2001 From: kikkon Date: Sun, 27 Nov 2022 17:46:58 +0800 Subject: [PATCH 01/10] Move physical plan serde from Ballista to DataFusion Signed-off-by: kikkon --- datafusion/proto/Cargo.toml | 4 +- datafusion/proto/README.md | 30 +- .../{plan_serde.rs => logical_plan_serde.rs} | 0 .../proto/examples/physical_plan_serde.rs | 36 + datafusion/proto/proto/datafusion.proto | 466 + datafusion/proto/src/bytes/mod.rs | 106 +- datafusion/proto/src/common.rs | 21 + datafusion/proto/src/generated/pbjson.rs | 17734 ++++++++++++---- datafusion/proto/src/generated/prost.rs | 770 + datafusion/proto/src/lib.rs | 2 + datafusion/proto/src/logical_plan.rs | 17 - .../proto/src/physical_plan/from_proto.rs | 428 + datafusion/proto/src/physical_plan/mod.rs | 1590 ++ .../proto/src/physical_plan/to_proto.rs | 472 + 14 files changed, 17034 insertions(+), 4642 deletions(-) rename datafusion/proto/examples/{plan_serde.rs => logical_plan_serde.rs} (100%) create mode 100644 datafusion/proto/examples/physical_plan_serde.rs create mode 100644 datafusion/proto/src/common.rs create mode 100644 datafusion/proto/src/physical_plan/from_proto.rs create mode 100644 datafusion/proto/src/physical_plan/mod.rs create mode 100644 datafusion/proto/src/physical_plan/to_proto.rs diff --git a/datafusion/proto/Cargo.toml b/datafusion/proto/Cargo.toml index e3ede179ed6b..df11d9072c7b 100644 --- a/datafusion/proto/Cargo.toml +++ b/datafusion/proto/Cargo.toml @@ -49,7 +49,9 @@ pbjson-types = { version = "0.5", optional = true } prost = "0.11.0" serde = { version = "1.0", optional = true } serde_json = { version = "1.0", optional = true } - +chrono = { version = "0.4", default-features = false } +parking_lot = "0.12" +object_store = "0.5.0" [dev-dependencies] doc-comment = "0.3" tokio = "1.18" diff --git a/datafusion/proto/README.md b/datafusion/proto/README.md index a3878447e042..6995710c40a4 100644 --- a/datafusion/proto/README.md +++ b/datafusion/proto/README.md @@ -46,9 +46,9 @@ fn main() -> Result<()> { } ``` -## Serializing Plans +## Serializing Logical Plans -Based on [examples/plan_serde.rs](examples/plan_serde.rs) +Based on [examples/logical_plan_serde.rs](examples/logical_plan_serde.rs) ```rust use datafusion::prelude::*; @@ -69,4 +69,30 @@ async fn main() -> Result<()> { } ``` +## Serializing Physical Plans + +Based on [examples/physical_plan_serde.rs](examples/physical_plan_serde.rs) + +```rust +use datafusion::prelude::*; +use datafusion_common::Result; +use datafusion_proto::bytes::{physical_plan_from_bytes,physical_plan_to_bytes}; + +#[tokio::main] +async fn main() -> Result<()> { + let ctx = SessionContext::new(); + ctx.register_csv("t1", "testdata/test.csv", CsvReadOptions::default()) + .await + ?; + let logical_plan = ctx.table("t1")?.to_logical_plan()?; + let physical_plan = ctx.create_physical_plan(&logical_plan).await?; + let bytes = physical_plan_to_bytes(physical_plan.clone())?; + let physical_round_trip = physical_plan_from_bytes(&bytes, &ctx)?; + assert_eq!(format!("{:?}", physical_plan), format!("{:?}", physical_round_trip)); + Ok(()) +} + +``` + + [df]: https://crates.io/crates/datafusion diff --git a/datafusion/proto/examples/plan_serde.rs b/datafusion/proto/examples/logical_plan_serde.rs similarity index 100% rename from datafusion/proto/examples/plan_serde.rs rename to datafusion/proto/examples/logical_plan_serde.rs diff --git a/datafusion/proto/examples/physical_plan_serde.rs b/datafusion/proto/examples/physical_plan_serde.rs new file mode 100644 index 000000000000..3fdcff2f0121 --- /dev/null +++ b/datafusion/proto/examples/physical_plan_serde.rs @@ -0,0 +1,36 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +use datafusion::prelude::*; +use datafusion_common::Result; +use datafusion_proto::bytes::{physical_plan_from_bytes, physical_plan_to_bytes}; + +#[tokio::main] +async fn main() -> Result<()> { + let ctx = SessionContext::new(); + ctx.register_csv("t1", "testdata/test.csv", CsvReadOptions::default()) + .await?; + let logical_plan = ctx.table("t1")?.to_logical_plan()?; + let physical_plan = ctx.create_physical_plan(&logical_plan).await?; + let bytes = physical_plan_to_bytes(physical_plan.clone())?; + let physical_round_trip = physical_plan_from_bytes(&bytes, &ctx)?; + assert_eq!( + format!("{:?}", physical_plan), + format!("{:?}", physical_round_trip) + ); + Ok(()) +} diff --git a/datafusion/proto/proto/datafusion.proto b/datafusion/proto/proto/datafusion.proto index 8b2c21f413bf..d416dd28ac03 100644 --- a/datafusion/proto/proto/datafusion.proto +++ b/datafusion/proto/proto/datafusion.proto @@ -916,3 +916,469 @@ message StringifiedPlan { PlanType plan_type = 1; string plan = 2; } + +///////////////////////////////////////////////////////////////////////////////////////////////// + +// PhysicalPlanNode is a nested type +message PhysicalPlanNode { + oneof PhysicalPlanType { + ParquetScanExecNode parquet_scan = 1; + CsvScanExecNode csv_scan = 2; + EmptyExecNode empty = 3; + ProjectionExecNode projection = 4; + GlobalLimitExecNode global_limit = 6; + LocalLimitExecNode local_limit = 7; + AggregateExecNode aggregate = 8; + HashJoinExecNode hash_join = 9; + SortExecNode sort = 10; + CoalesceBatchesExecNode coalesce_batches = 11; + FilterExecNode filter = 12; + CoalescePartitionsExecNode merge = 13; + RepartitionExecNode repartition = 14; + WindowAggExecNode window = 15; + CrossJoinExecNode cross_join = 16; + AvroScanExecNode avro_scan = 17; + PhysicalExtensionNode extension = 18; + UnionExecNode union = 19; + ExplainExecNode explain = 20; + SortPreservingMergeExecNode sort_preserving_merge = 21; + } +} + +message PhysicalExtensionNode { + bytes node = 1; + repeated PhysicalPlanNode inputs = 2; +} + +// physical expressions +message PhysicalExprNode { + oneof ExprType { + // column references + PhysicalColumn column = 1; + + datafusion.ScalarValue literal = 2; + + // binary expressions + PhysicalBinaryExprNode binary_expr = 3; + + // aggregate expressions + PhysicalAggregateExprNode aggregate_expr = 4; + + // null checks + PhysicalIsNull is_null_expr = 5; + PhysicalIsNotNull is_not_null_expr = 6; + PhysicalNot not_expr = 7; + + PhysicalCaseNode case_ = 8; + PhysicalCastNode cast = 9; + PhysicalSortExprNode sort = 10; + PhysicalNegativeNode negative = 11; + PhysicalInListNode in_list = 12; + PhysicalScalarFunctionNode scalar_function = 13; + PhysicalTryCastNode try_cast = 14; + + // window expressions + PhysicalWindowExprNode window_expr = 15; + + PhysicalScalarUdfNode scalar_udf = 16; + + PhysicalDateTimeIntervalExprNode date_time_interval_expr = 17; + } +} + +message PhysicalScalarUdfNode { + string name = 1; + repeated PhysicalExprNode args = 2; + datafusion.ArrowType return_type = 4; +} + +message PhysicalAggregateExprNode { + datafusion.AggregateFunction aggr_function = 1; + repeated PhysicalExprNode expr = 2; + bool distinct = 3; +} + +message PhysicalWindowExprNode { + oneof window_function { + datafusion.AggregateFunction aggr_function = 1; + datafusion.BuiltInWindowFunction built_in_function = 2; + // udaf = 3 + } + PhysicalExprNode expr = 4; +} + +message PhysicalIsNull { + PhysicalExprNode expr = 1; +} + +message PhysicalIsNotNull { + PhysicalExprNode expr = 1; +} + +message PhysicalNot { + PhysicalExprNode expr = 1; +} + +message PhysicalAliasNode { + PhysicalExprNode expr = 1; + string alias = 2; +} + +message PhysicalBinaryExprNode { + PhysicalExprNode l = 1; + PhysicalExprNode r = 2; + string op = 3; +} + +message PhysicalDateTimeIntervalExprNode { + PhysicalExprNode l = 1; + PhysicalExprNode r = 2; + string op = 3; +} + +message PhysicalSortExprNode { + PhysicalExprNode expr = 1; + bool asc = 2; + bool nulls_first = 3; +} + +message PhysicalWhenThen { + PhysicalExprNode when_expr = 1; + PhysicalExprNode then_expr = 2; +} + +message PhysicalInListNode { + PhysicalExprNode expr = 1; + repeated PhysicalExprNode list = 2; + bool negated = 3; +} + +message PhysicalCaseNode { + PhysicalExprNode expr = 1; + repeated PhysicalWhenThen when_then_expr = 2; + PhysicalExprNode else_expr = 3; +} + +message PhysicalScalarFunctionNode { + string name = 1; + datafusion.ScalarFunction fun = 2; + repeated PhysicalExprNode args = 3; + datafusion.ArrowType return_type = 4; +} + +message PhysicalTryCastNode { + PhysicalExprNode expr = 1; + datafusion.ArrowType arrow_type = 2; +} + +message PhysicalCastNode { + PhysicalExprNode expr = 1; + datafusion.ArrowType arrow_type = 2; +} + +message PhysicalNegativeNode { + PhysicalExprNode expr = 1; +} + +message UnresolvedShuffleExecNode { + uint32 stage_id = 1; + datafusion.Schema schema = 2; + uint32 input_partition_count = 3; + uint32 output_partition_count = 4; +} + +message FilterExecNode { + PhysicalPlanNode input = 1; + PhysicalExprNode expr = 2; +} + +message FileGroup { + repeated PartitionedFile files = 1; +} + +message ScanLimit { + // wrap into a message to make it optional + uint32 limit = 1; +} + +message FileScanExecConf { + repeated FileGroup file_groups = 1; + datafusion.Schema schema = 2; + repeated uint32 projection = 4; + ScanLimit limit = 5; + Statistics statistics = 6; + repeated string table_partition_cols = 7; + string object_store_url = 8; +} + +message ParquetScanExecNode { + FileScanExecConf base_conf = 1; + datafusion.LogicalExprNode pruning_predicate = 2; +} + +message CsvScanExecNode { + FileScanExecConf base_conf = 1; + bool has_header = 2; + string delimiter = 3; +} + +message AvroScanExecNode { + FileScanExecConf base_conf = 1; +} + +enum PartitionMode { + COLLECT_LEFT = 0; + PARTITIONED = 1; +} + +message HashJoinExecNode { + PhysicalPlanNode left = 1; + PhysicalPlanNode right = 2; + repeated JoinOn on = 3; + datafusion.JoinType join_type = 4; + PartitionMode partition_mode = 6; + bool null_equals_null = 7; + JoinFilter filter = 8; +} + +message UnionExecNode { + repeated PhysicalPlanNode inputs = 1; +} + +message ExplainExecNode { + datafusion.Schema schema = 1; + repeated datafusion.StringifiedPlan stringified_plans = 2; + bool verbose = 3; +} + +message CrossJoinExecNode { + PhysicalPlanNode left = 1; + PhysicalPlanNode right = 2; +} + +message PhysicalColumn { + string name = 1; + uint32 index = 2; +} + +message JoinOn { + PhysicalColumn left = 1; + PhysicalColumn right = 2; +} + +message EmptyExecNode { + bool produce_one_row = 1; + datafusion.Schema schema = 2; +} + +message ProjectionExecNode { + PhysicalPlanNode input = 1; + repeated PhysicalExprNode expr = 2; + repeated string expr_name = 3; +} + +enum AggregateMode { + PARTIAL = 0; + FINAL = 1; + FINAL_PARTITIONED = 2; +} + +message WindowAggExecNode { + PhysicalPlanNode input = 1; + repeated PhysicalExprNode window_expr = 2; + repeated string window_expr_name = 3; + datafusion.Schema input_schema = 4; +} + +message AggregateExecNode { + repeated PhysicalExprNode group_expr = 1; + repeated PhysicalExprNode aggr_expr = 2; + AggregateMode mode = 3; + PhysicalPlanNode input = 4; + repeated string group_expr_name = 5; + repeated string aggr_expr_name = 6; + // we need the input schema to the partial aggregate to pass to the final aggregate + datafusion.Schema input_schema = 7; + repeated PhysicalExprNode null_expr = 8; + repeated bool groups = 9; +} + +message ShuffleWriterExecNode { + //TODO it seems redundant to provide job and stage id here since we also have them + // in the TaskDefinition that wraps this plan + string job_id = 1; + uint32 stage_id = 2; + PhysicalPlanNode input = 3; + PhysicalHashRepartition output_partitioning = 4; +} + +message GlobalLimitExecNode { + PhysicalPlanNode input = 1; + // The number of rows to skip before fetch + uint32 skip = 2; + // Maximum number of rows to fetch; negative means no limit + int64 fetch = 3; +} + +message LocalLimitExecNode { + PhysicalPlanNode input = 1; + uint32 fetch = 2; +} + +message SortExecNode { + PhysicalPlanNode input = 1; + repeated PhysicalExprNode expr = 2; + // Maximum number of highest/lowest rows to fetch; negative means no limit + int64 fetch = 3; +} + +message SortPreservingMergeExecNode { + PhysicalPlanNode input = 1; + repeated PhysicalExprNode expr = 2; +} + +message CoalesceBatchesExecNode { + PhysicalPlanNode input = 1; + uint32 target_batch_size = 2; +} + +message CoalescePartitionsExecNode { + PhysicalPlanNode input = 1; +} + +message PhysicalHashRepartition { + repeated PhysicalExprNode hash_expr = 1; + uint64 partition_count = 2; +} + +message RepartitionExecNode{ + PhysicalPlanNode input = 1; + oneof partition_method { + uint64 round_robin = 2; + PhysicalHashRepartition hash = 3; + uint64 unknown = 4; + } +} + +message JoinFilter{ + PhysicalExprNode expression = 1; + repeated ColumnIndex column_indices = 2; + datafusion.Schema schema = 3; +} + +message ColumnIndex{ + uint32 index = 1; + JoinSide side = 2; +} + +enum JoinSide{ + LEFT_SIDE = 0; + RIGHT_SIDE = 1; +} + +message PartitionedFile { + string path = 1; + uint64 size = 2; + uint64 last_modified_ns = 3; + repeated ScalarValue partition_values = 4; + FileRange range = 5; +} + +message FileRange { + int64 start = 1; + int64 end = 2; +} + +message PartitionStats { + int64 num_rows = 1; + int64 num_batches = 2; + int64 num_bytes = 3; + repeated ColumnStats column_stats = 4; +} + +message Statistics { + int64 num_rows = 1; + int64 total_byte_size = 2; + repeated ColumnStats column_stats = 3; + bool is_exact = 4; +} + +message ColumnStats { + ScalarValue min_value = 1; + ScalarValue max_value = 2; + uint32 null_count = 3; + uint32 distinct_count = 4; +} + +message PartitionLocation { + // partition_id of the map stage who produces the shuffle. + uint32 map_partition_id = 1; + // partition_id of the shuffle, a composition of(job_id + map_stage_id + partition_id). + PartitionId partition_id = 2; + ExecutorMetadata executor_meta = 3; + PartitionStats partition_stats = 4; + string path = 5; +} + +// Unique identifier for a materialized partition of data +message PartitionId { + string job_id = 1; + uint32 stage_id = 2; + uint32 partition_id = 4; +} + +// Used by scheduler +message ExecutorMetadata { + string id = 1; + string host = 2; + uint32 port = 3; + uint32 grpc_port = 4; + ExecutorSpecification specification = 5; +} + +// Used by grpc +message ExecutorRegistration { + string id = 1; + // "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) + oneof optional_host { + string host = 2; + } + uint32 port = 3; + uint32 grpc_port = 4; + ExecutorSpecification specification = 5; +} + +message ExecutorHeartbeat { + string executor_id = 1; + // Unix epoch-based timestamp in seconds + uint64 timestamp = 2; + repeated ExecutorMetric metrics = 3; + ExecutorStatus status = 4; +} + +message ExecutorSpecification { + repeated ExecutorResource resources = 1; +} + +message ExecutorResource { + // TODO add more resources + oneof resource { + uint32 task_slots = 1; + } +} + +message ExecutorMetric { + // TODO add more metrics + oneof metric { + uint64 available_memory = 1; + } +} + +message ExecutorStatus { + oneof status { + string active = 1; + string dead = 2; + string unknown = 3; + } +} \ No newline at end of file diff --git a/datafusion/proto/src/bytes/mod.rs b/datafusion/proto/src/bytes/mod.rs index 1ffe8ab7a7b3..dd9f1467a28f 100644 --- a/datafusion/proto/src/bytes/mod.rs +++ b/datafusion/proto/src/bytes/mod.rs @@ -17,6 +17,7 @@ //! Serialization / Deserialization to Bytes use crate::logical_plan::{AsLogicalPlan, LogicalExtensionCodec}; +use crate::physical_plan::{AsExecutionPlan, PhysicalExtensionCodec}; use crate::{from_proto::parse_expr, protobuf}; use arrow::datatypes::SchemaRef; use datafusion::datasource::TableProvider; @@ -33,6 +34,7 @@ use std::sync::Arc; // Reexport Bytes which appears in the API use datafusion::execution::registry::FunctionRegistry; +use datafusion::physical_plan::ExecutionPlan; use datafusion::prelude::SessionContext; mod registry; @@ -143,14 +145,14 @@ impl Serializeable for Expr { /// Serialize a LogicalPlan as bytes pub fn logical_plan_to_bytes(plan: &LogicalPlan) -> Result { - let extension_codec = DefaultExtensionCodec {}; + let extension_codec = DefaultLogicalExtensionCodec {}; logical_plan_to_bytes_with_extension_codec(plan, &extension_codec) } /// Serialize a LogicalPlan as json #[cfg(feature = "json")] pub fn logical_plan_to_json(plan: &LogicalPlan) -> Result { - let extension_codec = DefaultExtensionCodec {}; + let extension_codec = DefaultLogicalExtensionCodec {}; let protobuf = protobuf::LogicalPlanNode::try_from_logical_plan(plan, &extension_codec) .map_err(|e| { @@ -179,7 +181,7 @@ pub fn logical_plan_to_bytes_with_extension_codec( pub fn logical_plan_from_json(json: &str, ctx: &SessionContext) -> Result { let back: protobuf::LogicalPlanNode = serde_json::from_str(json) .map_err(|e| DataFusionError::Plan(format!("Error serializing plan: {}", e)))?; - let extension_codec = DefaultExtensionCodec {}; + let extension_codec = DefaultLogicalExtensionCodec {}; back.try_into_logical_plan(ctx, &extension_codec) } @@ -188,7 +190,7 @@ pub fn logical_plan_from_bytes( bytes: &[u8], ctx: &SessionContext, ) -> Result { - let extension_codec = DefaultExtensionCodec {}; + let extension_codec = DefaultLogicalExtensionCodec {}; logical_plan_from_bytes_with_extension_codec(bytes, ctx, &extension_codec) } @@ -204,10 +206,76 @@ pub fn logical_plan_from_bytes_with_extension_codec( protobuf.try_into_logical_plan(ctx, extension_codec) } +/// Serialize a PhysicalPlan as bytes +pub fn physical_plan_to_bytes(plan: Arc) -> Result { + let extension_codec = DefaultPhysicalExtensionCodec {}; + physical_plan_to_bytes_with_extension_codec(plan, &extension_codec) +} + +/// Serialize a PhysicalPlan as json +#[cfg(feature = "json")] +pub fn physical_plan_to_json(plan: Arc) -> Result { + let extension_codec = DefaultLogicalExtensionCodec {}; + let protobuf = + protobuf::LogicalPlanNode::try_from_physical_plan(plan, &extension_codec) + .map_err(|e| { + DataFusionError::Plan(format!("Error serializing plan: {}", e)) + })?; + serde_json::to_string(&protobuf) + .map_err(|e| DataFusionError::Plan(format!("Error serializing plan: {}", e))) +} + +/// Serialize a PhysicalPlan as bytes, using the provided extension codec +pub fn physical_plan_to_bytes_with_extension_codec( + plan: Arc, + extension_codec: &dyn PhysicalExtensionCodec, +) -> Result { + let protobuf = + protobuf::PhysicalPlanNode::try_from_physical_plan(plan, extension_codec)?; + let mut buffer = BytesMut::new(); + protobuf.encode(&mut buffer).map_err(|e| { + DataFusionError::Plan(format!("Error encoding protobuf as bytes: {}", e)) + })?; + Ok(buffer.into()) +} + +/// Deserialize a PhysicalPlan from json +#[cfg(feature = "json")] +pub fn physical_plan_from_json( + json: &str, + ctx: &SessionContext, +) -> Result> { + let back: protobuf::PhysicalPlanNode = serde_json::from_str(json) + .map_err(|e| DataFusionError::Plan(format!("Error serializing plan: {}", e)))?; + let extension_codec = DefaultPhysicalExtensionCodec {}; + back.try_into_physical_plan(ctx, ctx.runtime_env(), &extension_codec) +} + +/// Deserialize a PhysicalPlan from bytes +pub fn physical_plan_from_bytes( + bytes: &[u8], + ctx: &SessionContext, +) -> Result> { + let extension_codec = DefaultPhysicalExtensionCodec {}; + physical_plan_from_bytes_with_extension_codec(bytes, ctx, &extension_codec) +} + +/// Deserialize a PhysicalPlan from bytes +pub fn physical_plan_from_bytes_with_extension_codec( + bytes: &[u8], + ctx: &SessionContext, + extension_codec: &dyn PhysicalExtensionCodec, +) -> Result> { + let protobuf = protobuf::PhysicalPlanNode::decode(bytes).map_err(|e| { + DataFusionError::Plan(format!("Error decoding expr as protobuf: {}", e)) + })?; + protobuf.try_into_physical_plan(ctx, &ctx.runtime_env(), extension_codec) +} + #[derive(Debug)] -struct DefaultExtensionCodec {} +struct DefaultLogicalExtensionCodec {} -impl LogicalExtensionCodec for DefaultExtensionCodec { +impl LogicalExtensionCodec for DefaultLogicalExtensionCodec { fn try_decode( &self, _buf: &[u8], @@ -247,6 +315,32 @@ impl LogicalExtensionCodec for DefaultExtensionCodec { } } +#[derive(Debug)] +pub struct DefaultPhysicalExtensionCodec {} + +impl PhysicalExtensionCodec for DefaultPhysicalExtensionCodec { + fn try_decode( + &self, + _buf: &[u8], + _inputs: &[Arc], + _registry: &dyn FunctionRegistry, + ) -> Result> { + Err(DataFusionError::NotImplemented( + "PhysicalExtensionCodec is not provided".to_string(), + )) + } + + fn try_encode( + &self, + _node: Arc, + _buf: &mut Vec, + ) -> Result<()> { + Err(DataFusionError::NotImplemented( + "PhysicalExtensionCodec is not provided".to_string(), + )) + } +} + #[cfg(test)] mod test { use super::*; diff --git a/datafusion/proto/src/common.rs b/datafusion/proto/src/common.rs new file mode 100644 index 000000000000..c6a12da872b8 --- /dev/null +++ b/datafusion/proto/src/common.rs @@ -0,0 +1,21 @@ +use datafusion_common::DataFusionError; + +pub fn byte_to_string(b: u8) -> Result { + let b = &[b]; + let b = std::str::from_utf8(b) + .map_err(|_| DataFusionError::Internal("Invalid CSV delimiter".to_owned()))?; + Ok(b.to_owned()) +} + +pub fn str_to_byte(s: &String) -> Result { + if s.len() != 1 { + return Err(DataFusionError::Internal( + "Invalid CSV delimiter".to_owned(), + )); + } + Ok(s.as_bytes()[0]) +} + +pub(crate) fn proto_error>(message: S) -> DataFusionError { + DataFusionError::Internal(message.into()) +} diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs index 3752c64d2d99..f7c817acf00f 100644 --- a/datafusion/proto/src/generated/pbjson.rs +++ b/datafusion/proto/src/generated/pbjson.rs @@ -1,3 +1,238 @@ +impl serde::Serialize for AggregateExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.group_expr.is_empty() { + len += 1; + } + if !self.aggr_expr.is_empty() { + len += 1; + } + if self.mode != 0 { + len += 1; + } + if self.input.is_some() { + len += 1; + } + if !self.group_expr_name.is_empty() { + len += 1; + } + if !self.aggr_expr_name.is_empty() { + len += 1; + } + if self.input_schema.is_some() { + len += 1; + } + if !self.null_expr.is_empty() { + len += 1; + } + if !self.groups.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExecNode", len)?; + if !self.group_expr.is_empty() { + struct_ser.serialize_field("groupExpr", &self.group_expr)?; + } + if !self.aggr_expr.is_empty() { + struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?; + } + if self.mode != 0 { + let v = AggregateMode::from_i32(self.mode) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?; + struct_ser.serialize_field("mode", &v)?; + } + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.group_expr_name.is_empty() { + struct_ser.serialize_field("groupExprName", &self.group_expr_name)?; + } + if !self.aggr_expr_name.is_empty() { + struct_ser.serialize_field("aggrExprName", &self.aggr_expr_name)?; + } + if let Some(v) = self.input_schema.as_ref() { + struct_ser.serialize_field("inputSchema", v)?; + } + if !self.null_expr.is_empty() { + struct_ser.serialize_field("nullExpr", &self.null_expr)?; + } + if !self.groups.is_empty() { + struct_ser.serialize_field("groups", &self.groups)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AggregateExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "group_expr", + "groupExpr", + "aggr_expr", + "aggrExpr", + "mode", + "input", + "group_expr_name", + "groupExprName", + "aggr_expr_name", + "aggrExprName", + "input_schema", + "inputSchema", + "null_expr", + "nullExpr", + "groups", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + GroupExpr, + AggrExpr, + Mode, + Input, + GroupExprName, + AggrExprName, + InputSchema, + NullExpr, + Groups, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr), + "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr), + "mode" => Ok(GeneratedField::Mode), + "input" => Ok(GeneratedField::Input), + "groupExprName" | "group_expr_name" => Ok(GeneratedField::GroupExprName), + "aggrExprName" | "aggr_expr_name" => Ok(GeneratedField::AggrExprName), + "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema), + "nullExpr" | "null_expr" => Ok(GeneratedField::NullExpr), + "groups" => Ok(GeneratedField::Groups), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AggregateExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.AggregateExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut group_expr__ = None; + let mut aggr_expr__ = None; + let mut mode__ = None; + let mut input__ = None; + let mut group_expr_name__ = None; + let mut aggr_expr_name__ = None; + let mut input_schema__ = None; + let mut null_expr__ = None; + let mut groups__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::GroupExpr => { + if group_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("groupExpr")); + } + group_expr__ = Some(map.next_value()?); + } + GeneratedField::AggrExpr => { + if aggr_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrExpr")); + } + aggr_expr__ = Some(map.next_value()?); + } + GeneratedField::Mode => { + if mode__.is_some() { + return Err(serde::de::Error::duplicate_field("mode")); + } + mode__ = Some(map.next_value::()? as i32); + } + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::GroupExprName => { + if group_expr_name__.is_some() { + return Err(serde::de::Error::duplicate_field("groupExprName")); + } + group_expr_name__ = Some(map.next_value()?); + } + GeneratedField::AggrExprName => { + if aggr_expr_name__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrExprName")); + } + aggr_expr_name__ = Some(map.next_value()?); + } + GeneratedField::InputSchema => { + if input_schema__.is_some() { + return Err(serde::de::Error::duplicate_field("inputSchema")); + } + input_schema__ = map.next_value()?; + } + GeneratedField::NullExpr => { + if null_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("nullExpr")); + } + null_expr__ = Some(map.next_value()?); + } + GeneratedField::Groups => { + if groups__.is_some() { + return Err(serde::de::Error::duplicate_field("groups")); + } + groups__ = Some(map.next_value()?); + } + } + } + Ok(AggregateExecNode { + group_expr: group_expr__.unwrap_or_default(), + aggr_expr: aggr_expr__.unwrap_or_default(), + mode: mode__.unwrap_or_default(), + input: input__, + group_expr_name: group_expr_name__.unwrap_or_default(), + aggr_expr_name: aggr_expr_name__.unwrap_or_default(), + input_schema: input_schema__, + null_expr: null_expr__.unwrap_or_default(), + groups: groups__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.AggregateExecNode", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for AggregateExprNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -267,6 +502,82 @@ impl<'de> serde::Deserialize<'de> for AggregateFunction { deserializer.deserialize_any(GeneratedVisitor) } } +impl serde::Serialize for AggregateMode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Partial => "PARTIAL", + Self::Final => "FINAL", + Self::FinalPartitioned => "FINAL_PARTITIONED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for AggregateMode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "PARTIAL", + "FINAL", + "FINAL_PARTITIONED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AggregateMode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(AggregateMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(AggregateMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "PARTIAL" => Ok(AggregateMode::Partial), + "FINAL" => Ok(AggregateMode::Final), + "FINAL_PARTITIONED" => Ok(AggregateMode::FinalPartitioned), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} impl serde::Serialize for AggregateNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -1314,7 +1625,7 @@ impl<'de> serde::Deserialize<'de> for AvroFormat { deserializer.deserialize_struct("datafusion.AvroFormat", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for BetweenNode { +impl serde::Serialize for AvroScanExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1322,53 +1633,30 @@ impl serde::Serialize for BetweenNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.negated { + if self.base_conf.is_some() { len += 1; } - if self.low.is_some() { - len += 1; - } - if self.high.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.BetweenNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - if let Some(v) = self.low.as_ref() { - struct_ser.serialize_field("low", v)?; - } - if let Some(v) = self.high.as_ref() { - struct_ser.serialize_field("high", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.AvroScanExecNode", len)?; + if let Some(v) = self.base_conf.as_ref() { + struct_ser.serialize_field("baseConf", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for BetweenNode { +impl<'de> serde::Deserialize<'de> for AvroScanExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", - "negated", - "low", - "high", + "base_conf", + "baseConf", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, - Negated, - Low, - High, + BaseConf, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1390,10 +1678,7 @@ impl<'de> serde::Deserialize<'de> for BetweenNode { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), - "negated" => Ok(GeneratedField::Negated), - "low" => Ok(GeneratedField::Low), - "high" => Ok(GeneratedField::High), + "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1403,24 +1688,142 @@ impl<'de> serde::Deserialize<'de> for BetweenNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = BetweenNode; + type Value = AvroScanExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.BetweenNode") + formatter.write_str("struct datafusion.AvroScanExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; - let mut negated__ = None; - let mut low__ = None; - let mut high__ = None; + let mut base_conf__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { + GeneratedField::BaseConf => { + if base_conf__.is_some() { + return Err(serde::de::Error::duplicate_field("baseConf")); + } + base_conf__ = map.next_value()?; + } + } + } + Ok(AvroScanExecNode { + base_conf: base_conf__, + }) + } + } + deserializer.deserialize_struct("datafusion.AvroScanExecNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BetweenNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.negated { + len += 1; + } + if self.low.is_some() { + len += 1; + } + if self.high.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.BetweenNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.low.as_ref() { + struct_ser.serialize_field("low", v)?; + } + if let Some(v) = self.high.as_ref() { + struct_ser.serialize_field("high", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for BetweenNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "negated", + "low", + "high", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Negated, + Low, + High, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "negated" => Ok(GeneratedField::Negated), + "low" => Ok(GeneratedField::Low), + "high" => Ok(GeneratedField::High), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BetweenNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.BetweenNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut negated__ = None; + let mut low__ = None; + let mut high__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } expr__ = map.next_value()?; @@ -1900,7 +2303,7 @@ impl<'de> serde::Deserialize<'de> for CastNode { deserializer.deserialize_struct("datafusion.CastNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Column { +impl serde::Serialize for CoalesceBatchesExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -1908,37 +2311,38 @@ impl serde::Serialize for Column { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { + if self.input.is_some() { len += 1; } - if self.relation.is_some() { + if self.target_batch_size != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.Column", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CoalesceBatchesExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; } - if let Some(v) = self.relation.as_ref() { - struct_ser.serialize_field("relation", v)?; + if self.target_batch_size != 0 { + struct_ser.serialize_field("targetBatchSize", &self.target_batch_size)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Column { +impl<'de> serde::Deserialize<'de> for CoalesceBatchesExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", - "relation", + "input", + "target_batch_size", + "targetBatchSize", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, - Relation, + Input, + TargetBatchSize, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -1960,8 +2364,8 @@ impl<'de> serde::Deserialize<'de> for Column { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), - "relation" => Ok(GeneratedField::Relation), + "input" => Ok(GeneratedField::Input), + "targetBatchSize" | "target_batch_size" => Ok(GeneratedField::TargetBatchSize), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -1971,44 +2375,46 @@ impl<'de> serde::Deserialize<'de> for Column { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Column; + type Value = CoalesceBatchesExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Column") + formatter.write_str("struct datafusion.CoalesceBatchesExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; - let mut relation__ = None; + let mut input__ = None; + let mut target_batch_size__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - name__ = Some(map.next_value()?); + input__ = map.next_value()?; } - GeneratedField::Relation => { - if relation__.is_some() { - return Err(serde::de::Error::duplicate_field("relation")); + GeneratedField::TargetBatchSize => { + if target_batch_size__.is_some() { + return Err(serde::de::Error::duplicate_field("targetBatchSize")); } - relation__ = map.next_value()?; + target_batch_size__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(Column { - name: name__.unwrap_or_default(), - relation: relation__, + Ok(CoalesceBatchesExecNode { + input: input__, + target_batch_size: target_batch_size__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.Column", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CoalesceBatchesExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ColumnRelation { +impl serde::Serialize for CoalescePartitionsExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2016,29 +2422,29 @@ impl serde::Serialize for ColumnRelation { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.relation.is_empty() { + if self.input.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ColumnRelation", len)?; - if !self.relation.is_empty() { - struct_ser.serialize_field("relation", &self.relation)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CoalescePartitionsExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ColumnRelation { +impl<'de> serde::Deserialize<'de> for CoalescePartitionsExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "relation", + "input", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Relation, + Input, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2060,7 +2466,7 @@ impl<'de> serde::Deserialize<'de> for ColumnRelation { E: serde::de::Error, { match value { - "relation" => Ok(GeneratedField::Relation), + "input" => Ok(GeneratedField::Input), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2070,36 +2476,36 @@ impl<'de> serde::Deserialize<'de> for ColumnRelation { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ColumnRelation; + type Value = CoalescePartitionsExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ColumnRelation") + formatter.write_str("struct datafusion.CoalescePartitionsExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut relation__ = None; + let mut input__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Relation => { - if relation__.is_some() { - return Err(serde::de::Error::duplicate_field("relation")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - relation__ = Some(map.next_value()?); + input__ = map.next_value()?; } } } - Ok(ColumnRelation { - relation: relation__.unwrap_or_default(), + Ok(CoalescePartitionsExecNode { + input: input__, }) } } - deserializer.deserialize_struct("datafusion.ColumnRelation", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CoalescePartitionsExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateCatalogNode { +impl serde::Serialize for Column { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2107,47 +2513,37 @@ impl serde::Serialize for CreateCatalogNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.catalog_name.is_empty() { - len += 1; - } - if self.if_not_exists { + if !self.name.is_empty() { len += 1; } - if self.schema.is_some() { + if self.relation.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogNode", len)?; - if !self.catalog_name.is_empty() { - struct_ser.serialize_field("catalogName", &self.catalog_name)?; - } - if self.if_not_exists { - struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + let mut struct_ser = serializer.serialize_struct("datafusion.Column", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; + if let Some(v) = self.relation.as_ref() { + struct_ser.serialize_field("relation", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateCatalogNode { +impl<'de> serde::Deserialize<'de> for Column { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "catalog_name", - "catalogName", - "if_not_exists", - "ifNotExists", - "schema", + "name", + "relation", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - CatalogName, - IfNotExists, - Schema, + Name, + Relation, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2169,9 +2565,8 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogNode { E: serde::de::Error, { match value { - "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName), - "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists), - "schema" => Ok(GeneratedField::Schema), + "name" => Ok(GeneratedField::Name), + "relation" => Ok(GeneratedField::Relation), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2181,52 +2576,44 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateCatalogNode; + type Value = Column; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateCatalogNode") + formatter.write_str("struct datafusion.Column") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut catalog_name__ = None; - let mut if_not_exists__ = None; - let mut schema__ = None; + let mut name__ = None; + let mut relation__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::CatalogName => { - if catalog_name__.is_some() { - return Err(serde::de::Error::duplicate_field("catalogName")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - catalog_name__ = Some(map.next_value()?); + name__ = Some(map.next_value()?); } - GeneratedField::IfNotExists => { - if if_not_exists__.is_some() { - return Err(serde::de::Error::duplicate_field("ifNotExists")); - } - if_not_exists__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); + GeneratedField::Relation => { + if relation__.is_some() { + return Err(serde::de::Error::duplicate_field("relation")); } - schema__ = map.next_value()?; + relation__ = map.next_value()?; } } } - Ok(CreateCatalogNode { - catalog_name: catalog_name__.unwrap_or_default(), - if_not_exists: if_not_exists__.unwrap_or_default(), - schema: schema__, + Ok(Column { + name: name__.unwrap_or_default(), + relation: relation__, }) } } - deserializer.deserialize_struct("datafusion.CreateCatalogNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.Column", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateCatalogSchemaNode { +impl serde::Serialize for ColumnIndex { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2234,47 +2621,39 @@ impl serde::Serialize for CreateCatalogSchemaNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.schema_name.is_empty() { - len += 1; - } - if self.if_not_exists { + if self.index != 0 { len += 1; } - if self.schema.is_some() { + if self.side != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogSchemaNode", len)?; - if !self.schema_name.is_empty() { - struct_ser.serialize_field("schemaName", &self.schema_name)?; - } - if self.if_not_exists { - struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ColumnIndex", len)?; + if self.index != 0 { + struct_ser.serialize_field("index", &self.index)?; } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; + if self.side != 0 { + let v = JoinSide::from_i32(self.side) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.side)))?; + struct_ser.serialize_field("side", &v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode { +impl<'de> serde::Deserialize<'de> for ColumnIndex { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "schema_name", - "schemaName", - "if_not_exists", - "ifNotExists", - "schema", + "index", + "side", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - SchemaName, - IfNotExists, - Schema, + Index, + Side, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2296,9 +2675,8 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode { E: serde::de::Error, { match value { - "schemaName" | "schema_name" => Ok(GeneratedField::SchemaName), - "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists), - "schema" => Ok(GeneratedField::Schema), + "index" => Ok(GeneratedField::Index), + "side" => Ok(GeneratedField::Side), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2308,52 +2686,46 @@ impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateCatalogSchemaNode; + type Value = ColumnIndex; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateCatalogSchemaNode") + formatter.write_str("struct datafusion.ColumnIndex") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut schema_name__ = None; - let mut if_not_exists__ = None; - let mut schema__ = None; + let mut index__ = None; + let mut side__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::SchemaName => { - if schema_name__.is_some() { - return Err(serde::de::Error::duplicate_field("schemaName")); + GeneratedField::Index => { + if index__.is_some() { + return Err(serde::de::Error::duplicate_field("index")); } - schema_name__ = Some(map.next_value()?); - } - GeneratedField::IfNotExists => { - if if_not_exists__.is_some() { - return Err(serde::de::Error::duplicate_field("ifNotExists")); - } - if_not_exists__ = Some(map.next_value()?); + index__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); + GeneratedField::Side => { + if side__.is_some() { + return Err(serde::de::Error::duplicate_field("side")); } - schema__ = map.next_value()?; + side__ = Some(map.next_value::()? as i32); } } } - Ok(CreateCatalogSchemaNode { - schema_name: schema_name__.unwrap_or_default(), - if_not_exists: if_not_exists__.unwrap_or_default(), - schema: schema__, + Ok(ColumnIndex { + index: index__.unwrap_or_default(), + side: side__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.CreateCatalogSchemaNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ColumnIndex", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateExternalTableNode { +impl serde::Serialize for ColumnRelation { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2361,114 +2733,148 @@ impl serde::Serialize for CreateExternalTableNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if !self.location.is_empty() { - len += 1; - } - if !self.file_type.is_empty() { + if !self.relation.is_empty() { len += 1; } - if self.has_header { - len += 1; + let mut struct_ser = serializer.serialize_struct("datafusion.ColumnRelation", len)?; + if !self.relation.is_empty() { + struct_ser.serialize_field("relation", &self.relation)?; } - if self.schema.is_some() { - len += 1; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ColumnRelation { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "relation", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Relation, } - if !self.table_partition_cols.is_empty() { - len += 1; + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "relation" => Ok(GeneratedField::Relation), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } } - if self.if_not_exists { - len += 1; + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ColumnRelation; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ColumnRelation") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut relation__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Relation => { + if relation__.is_some() { + return Err(serde::de::Error::duplicate_field("relation")); + } + relation__ = Some(map.next_value()?); + } + } + } + Ok(ColumnRelation { + relation: relation__.unwrap_or_default(), + }) + } } - if !self.delimiter.is_empty() { + deserializer.deserialize_struct("datafusion.ColumnRelation", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ColumnStats { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.min_value.is_some() { len += 1; } - if !self.definition.is_empty() { + if self.max_value.is_some() { len += 1; } - if !self.file_compression_type.is_empty() { + if self.null_count != 0 { len += 1; } - if !self.options.is_empty() { + if self.distinct_count != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateExternalTableNode", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if !self.location.is_empty() { - struct_ser.serialize_field("location", &self.location)?; - } - if !self.file_type.is_empty() { - struct_ser.serialize_field("fileType", &self.file_type)?; - } - if self.has_header { - struct_ser.serialize_field("hasHeader", &self.has_header)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.table_partition_cols.is_empty() { - struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; - } - if self.if_not_exists { - struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ColumnStats", len)?; + if let Some(v) = self.min_value.as_ref() { + struct_ser.serialize_field("minValue", v)?; } - if !self.delimiter.is_empty() { - struct_ser.serialize_field("delimiter", &self.delimiter)?; - } - if !self.definition.is_empty() { - struct_ser.serialize_field("definition", &self.definition)?; + if let Some(v) = self.max_value.as_ref() { + struct_ser.serialize_field("maxValue", v)?; } - if !self.file_compression_type.is_empty() { - struct_ser.serialize_field("fileCompressionType", &self.file_compression_type)?; + if self.null_count != 0 { + struct_ser.serialize_field("nullCount", &self.null_count)?; } - if !self.options.is_empty() { - struct_ser.serialize_field("options", &self.options)?; + if self.distinct_count != 0 { + struct_ser.serialize_field("distinctCount", &self.distinct_count)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateExternalTableNode { +impl<'de> serde::Deserialize<'de> for ColumnStats { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", - "location", - "file_type", - "fileType", - "has_header", - "hasHeader", - "schema", - "table_partition_cols", - "tablePartitionCols", - "if_not_exists", - "ifNotExists", - "delimiter", - "definition", - "file_compression_type", - "fileCompressionType", - "options", + "min_value", + "minValue", + "max_value", + "maxValue", + "null_count", + "nullCount", + "distinct_count", + "distinctCount", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, - Location, - FileType, - HasHeader, - Schema, - TablePartitionCols, - IfNotExists, - Delimiter, - Definition, - FileCompressionType, - Options, + MinValue, + MaxValue, + NullCount, + DistinctCount, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2490,17 +2896,10 @@ impl<'de> serde::Deserialize<'de> for CreateExternalTableNode { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), - "location" => Ok(GeneratedField::Location), - "fileType" | "file_type" => Ok(GeneratedField::FileType), - "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader), - "schema" => Ok(GeneratedField::Schema), - "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), - "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists), - "delimiter" => Ok(GeneratedField::Delimiter), - "definition" => Ok(GeneratedField::Definition), - "fileCompressionType" | "file_compression_type" => Ok(GeneratedField::FileCompressionType), - "options" => Ok(GeneratedField::Options), + "minValue" | "min_value" => Ok(GeneratedField::MinValue), + "maxValue" | "max_value" => Ok(GeneratedField::MaxValue), + "nullCount" | "null_count" => Ok(GeneratedField::NullCount), + "distinctCount" | "distinct_count" => Ok(GeneratedField::DistinctCount), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2510,118 +2909,64 @@ impl<'de> serde::Deserialize<'de> for CreateExternalTableNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateExternalTableNode; + type Value = ColumnStats; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateExternalTableNode") + formatter.write_str("struct datafusion.ColumnStats") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; - let mut location__ = None; - let mut file_type__ = None; - let mut has_header__ = None; - let mut schema__ = None; - let mut table_partition_cols__ = None; - let mut if_not_exists__ = None; - let mut delimiter__ = None; - let mut definition__ = None; - let mut file_compression_type__ = None; - let mut options__ = None; + let mut min_value__ = None; + let mut max_value__ = None; + let mut null_count__ = None; + let mut distinct_count__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::Location => { - if location__.is_some() { - return Err(serde::de::Error::duplicate_field("location")); - } - location__ = Some(map.next_value()?); - } - GeneratedField::FileType => { - if file_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fileType")); - } - file_type__ = Some(map.next_value()?); - } - GeneratedField::HasHeader => { - if has_header__.is_some() { - return Err(serde::de::Error::duplicate_field("hasHeader")); - } - has_header__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::TablePartitionCols => { - if table_partition_cols__.is_some() { - return Err(serde::de::Error::duplicate_field("tablePartitionCols")); - } - table_partition_cols__ = Some(map.next_value()?); - } - GeneratedField::IfNotExists => { - if if_not_exists__.is_some() { - return Err(serde::de::Error::duplicate_field("ifNotExists")); - } - if_not_exists__ = Some(map.next_value()?); - } - GeneratedField::Delimiter => { - if delimiter__.is_some() { - return Err(serde::de::Error::duplicate_field("delimiter")); + GeneratedField::MinValue => { + if min_value__.is_some() { + return Err(serde::de::Error::duplicate_field("minValue")); } - delimiter__ = Some(map.next_value()?); + min_value__ = map.next_value()?; } - GeneratedField::Definition => { - if definition__.is_some() { - return Err(serde::de::Error::duplicate_field("definition")); + GeneratedField::MaxValue => { + if max_value__.is_some() { + return Err(serde::de::Error::duplicate_field("maxValue")); } - definition__ = Some(map.next_value()?); + max_value__ = map.next_value()?; } - GeneratedField::FileCompressionType => { - if file_compression_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fileCompressionType")); + GeneratedField::NullCount => { + if null_count__.is_some() { + return Err(serde::de::Error::duplicate_field("nullCount")); } - file_compression_type__ = Some(map.next_value()?); + null_count__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Options => { - if options__.is_some() { - return Err(serde::de::Error::duplicate_field("options")); + GeneratedField::DistinctCount => { + if distinct_count__.is_some() { + return Err(serde::de::Error::duplicate_field("distinctCount")); } - options__ = Some( - map.next_value::>()? - ); + distinct_count__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(CreateExternalTableNode { - name: name__.unwrap_or_default(), - location: location__.unwrap_or_default(), - file_type: file_type__.unwrap_or_default(), - has_header: has_header__.unwrap_or_default(), - schema: schema__, - table_partition_cols: table_partition_cols__.unwrap_or_default(), - if_not_exists: if_not_exists__.unwrap_or_default(), - delimiter: delimiter__.unwrap_or_default(), - definition: definition__.unwrap_or_default(), - file_compression_type: file_compression_type__.unwrap_or_default(), - options: options__.unwrap_or_default(), + Ok(ColumnStats { + min_value: min_value__, + max_value: max_value__, + null_count: null_count__.unwrap_or_default(), + distinct_count: distinct_count__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.CreateExternalTableNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ColumnStats", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CreateViewNode { +impl serde::Serialize for CreateCatalogNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2629,54 +2974,47 @@ impl serde::Serialize for CreateViewNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.input.is_some() { + if !self.catalog_name.is_empty() { len += 1; } - if self.or_replace { + if self.if_not_exists { len += 1; } - if !self.definition.is_empty() { + if self.schema.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateViewNode", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogNode", len)?; + if !self.catalog_name.is_empty() { + struct_ser.serialize_field("catalogName", &self.catalog_name)?; } - if self.or_replace { - struct_ser.serialize_field("orReplace", &self.or_replace)?; + if self.if_not_exists { + struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; } - if !self.definition.is_empty() { - struct_ser.serialize_field("definition", &self.definition)?; + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CreateViewNode { +impl<'de> serde::Deserialize<'de> for CreateCatalogNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", - "input", - "or_replace", - "orReplace", - "definition", + "catalog_name", + "catalogName", + "if_not_exists", + "ifNotExists", + "schema", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, - Input, - OrReplace, - Definition, + CatalogName, + IfNotExists, + Schema, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2698,10 +3036,9 @@ impl<'de> serde::Deserialize<'de> for CreateViewNode { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), - "input" => Ok(GeneratedField::Input), - "orReplace" | "or_replace" => Ok(GeneratedField::OrReplace), - "definition" => Ok(GeneratedField::Definition), + "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)), } } @@ -2711,60 +3048,52 @@ impl<'de> serde::Deserialize<'de> for CreateViewNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateViewNode; + type Value = CreateCatalogNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateViewNode") + formatter.write_str("struct datafusion.CreateCatalogNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; - let mut input__ = None; - let mut or_replace__ = None; - let mut definition__ = None; + let mut catalog_name__ = None; + let mut if_not_exists__ = None; + let mut schema__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); + GeneratedField::CatalogName => { + if catalog_name__.is_some() { + return Err(serde::de::Error::duplicate_field("catalogName")); } - input__ = map.next_value()?; + catalog_name__ = Some(map.next_value()?); } - GeneratedField::OrReplace => { - if or_replace__.is_some() { - return Err(serde::de::Error::duplicate_field("orReplace")); + GeneratedField::IfNotExists => { + if if_not_exists__.is_some() { + return Err(serde::de::Error::duplicate_field("ifNotExists")); } - or_replace__ = Some(map.next_value()?); + if_not_exists__ = Some(map.next_value()?); } - GeneratedField::Definition => { - if definition__.is_some() { - return Err(serde::de::Error::duplicate_field("definition")); + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); } - definition__ = Some(map.next_value()?); + schema__ = map.next_value()?; } } } - Ok(CreateViewNode { - name: name__.unwrap_or_default(), - input: input__, - or_replace: or_replace__.unwrap_or_default(), - definition: definition__.unwrap_or_default(), + Ok(CreateCatalogNode { + catalog_name: catalog_name__.unwrap_or_default(), + if_not_exists: if_not_exists__.unwrap_or_default(), + schema: schema__, }) } } - deserializer.deserialize_struct("datafusion.CreateViewNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CreateCatalogNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CrossJoinNode { +impl serde::Serialize for CreateCatalogSchemaNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2772,37 +3101,47 @@ impl serde::Serialize for CrossJoinNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.left.is_some() { + if !self.schema_name.is_empty() { len += 1; } - if self.right.is_some() { + if self.if_not_exists { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinNode", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; + if self.schema.is_some() { + len += 1; } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogSchemaNode", len)?; + if !self.schema_name.is_empty() { + struct_ser.serialize_field("schemaName", &self.schema_name)?; + } + if self.if_not_exists { + struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CrossJoinNode { +impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "left", - "right", + "schema_name", + "schemaName", + "if_not_exists", + "ifNotExists", + "schema", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Left, - Right, + SchemaName, + IfNotExists, + Schema, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2824,8 +3163,9 @@ impl<'de> serde::Deserialize<'de> for CrossJoinNode { E: serde::de::Error, { match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), + "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)), } } @@ -2835,44 +3175,52 @@ impl<'de> serde::Deserialize<'de> for CrossJoinNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CrossJoinNode; + type Value = CreateCatalogSchemaNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CrossJoinNode") + formatter.write_str("struct datafusion.CreateCatalogSchemaNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut left__ = None; - let mut right__ = None; + let mut schema_name__ = None; + let mut if_not_exists__ = None; + let mut schema__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); + GeneratedField::SchemaName => { + if schema_name__.is_some() { + return Err(serde::de::Error::duplicate_field("schemaName")); } - left__ = map.next_value()?; + schema_name__ = Some(map.next_value()?); } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); - } - right__ = map.next_value()?; + GeneratedField::IfNotExists => { + if if_not_exists__.is_some() { + return Err(serde::de::Error::duplicate_field("ifNotExists")); + } + if_not_exists__ = Some(map.next_value()?); + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = map.next_value()?; } } } - Ok(CrossJoinNode { - left: left__, - right: right__, + Ok(CreateCatalogSchemaNode { + schema_name: schema_name__.unwrap_or_default(), + if_not_exists: if_not_exists__.unwrap_or_default(), + schema: schema__, }) } } - deserializer.deserialize_struct("datafusion.CrossJoinNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CreateCatalogSchemaNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CsvFormat { +impl serde::Serialize for CreateExternalTableNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2880,38 +3228,114 @@ impl serde::Serialize for CsvFormat { { use serde::ser::SerializeStruct; let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if !self.location.is_empty() { + len += 1; + } + if !self.file_type.is_empty() { + len += 1; + } if self.has_header { len += 1; } + if self.schema.is_some() { + len += 1; + } + if !self.table_partition_cols.is_empty() { + len += 1; + } + if self.if_not_exists { + len += 1; + } if !self.delimiter.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CsvFormat", len)?; + if !self.definition.is_empty() { + len += 1; + } + if !self.file_compression_type.is_empty() { + len += 1; + } + if !self.options.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CreateExternalTableNode", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.location.is_empty() { + struct_ser.serialize_field("location", &self.location)?; + } + if !self.file_type.is_empty() { + struct_ser.serialize_field("fileType", &self.file_type)?; + } if self.has_header { struct_ser.serialize_field("hasHeader", &self.has_header)?; } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if !self.table_partition_cols.is_empty() { + struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; + } + if self.if_not_exists { + struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; + } if !self.delimiter.is_empty() { struct_ser.serialize_field("delimiter", &self.delimiter)?; } + if !self.definition.is_empty() { + struct_ser.serialize_field("definition", &self.definition)?; + } + if !self.file_compression_type.is_empty() { + struct_ser.serialize_field("fileCompressionType", &self.file_compression_type)?; + } + if !self.options.is_empty() { + struct_ser.serialize_field("options", &self.options)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CsvFormat { +impl<'de> serde::Deserialize<'de> for CreateExternalTableNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "name", + "location", + "file_type", + "fileType", "has_header", "hasHeader", + "schema", + "table_partition_cols", + "tablePartitionCols", + "if_not_exists", + "ifNotExists", "delimiter", + "definition", + "file_compression_type", + "fileCompressionType", + "options", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Name, + Location, + FileType, HasHeader, + Schema, + TablePartitionCols, + IfNotExists, Delimiter, + Definition, + FileCompressionType, + Options, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -2933,8 +3357,17 @@ impl<'de> serde::Deserialize<'de> for CsvFormat { E: serde::de::Error, { match value { + "name" => Ok(GeneratedField::Name), + "location" => Ok(GeneratedField::Location), + "fileType" | "file_type" => Ok(GeneratedField::FileType), "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader), + "schema" => Ok(GeneratedField::Schema), + "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), + "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists), "delimiter" => Ok(GeneratedField::Delimiter), + "definition" => Ok(GeneratedField::Definition), + "fileCompressionType" | "file_compression_type" => Ok(GeneratedField::FileCompressionType), + "options" => Ok(GeneratedField::Options), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -2944,44 +3377,118 @@ impl<'de> serde::Deserialize<'de> for CsvFormat { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CsvFormat; + type Value = CreateExternalTableNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CsvFormat") + formatter.write_str("struct datafusion.CreateExternalTableNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { + let mut name__ = None; + let mut location__ = None; + let mut file_type__ = None; let mut has_header__ = None; + let mut schema__ = None; + let mut table_partition_cols__ = None; + let mut if_not_exists__ = None; let mut delimiter__ = None; + let mut definition__ = None; + let mut file_compression_type__ = None; + let mut options__ = None; while let Some(k) = map.next_key()? { match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Location => { + if location__.is_some() { + return Err(serde::de::Error::duplicate_field("location")); + } + location__ = Some(map.next_value()?); + } + GeneratedField::FileType => { + if file_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fileType")); + } + file_type__ = Some(map.next_value()?); + } GeneratedField::HasHeader => { if has_header__.is_some() { return Err(serde::de::Error::duplicate_field("hasHeader")); } has_header__ = Some(map.next_value()?); } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = map.next_value()?; + } + GeneratedField::TablePartitionCols => { + if table_partition_cols__.is_some() { + return Err(serde::de::Error::duplicate_field("tablePartitionCols")); + } + table_partition_cols__ = Some(map.next_value()?); + } + GeneratedField::IfNotExists => { + if if_not_exists__.is_some() { + return Err(serde::de::Error::duplicate_field("ifNotExists")); + } + if_not_exists__ = Some(map.next_value()?); + } GeneratedField::Delimiter => { if delimiter__.is_some() { return Err(serde::de::Error::duplicate_field("delimiter")); } delimiter__ = Some(map.next_value()?); } + GeneratedField::Definition => { + if definition__.is_some() { + return Err(serde::de::Error::duplicate_field("definition")); + } + definition__ = Some(map.next_value()?); + } + GeneratedField::FileCompressionType => { + if file_compression_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fileCompressionType")); + } + file_compression_type__ = Some(map.next_value()?); + } + GeneratedField::Options => { + if options__.is_some() { + return Err(serde::de::Error::duplicate_field("options")); + } + options__ = Some( + map.next_value::>()? + ); + } } } - Ok(CsvFormat { + Ok(CreateExternalTableNode { + name: name__.unwrap_or_default(), + location: location__.unwrap_or_default(), + file_type: file_type__.unwrap_or_default(), has_header: has_header__.unwrap_or_default(), + schema: schema__, + table_partition_cols: table_partition_cols__.unwrap_or_default(), + if_not_exists: if_not_exists__.unwrap_or_default(), delimiter: delimiter__.unwrap_or_default(), + definition: definition__.unwrap_or_default(), + file_compression_type: file_compression_type__.unwrap_or_default(), + options: options__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.CsvFormat", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CreateExternalTableNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CubeNode { +impl serde::Serialize for CreateViewNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -2989,29 +3496,54 @@ impl serde::Serialize for CubeNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.expr.is_empty() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CubeNode", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; + if self.input.is_some() { + len += 1; + } + if self.or_replace { + len += 1; + } + if !self.definition.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CreateViewNode", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.or_replace { + struct_ser.serialize_field("orReplace", &self.or_replace)?; + } + if !self.definition.is_empty() { + struct_ser.serialize_field("definition", &self.definition)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CubeNode { +impl<'de> serde::Deserialize<'de> for CreateViewNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "name", + "input", + "or_replace", + "orReplace", + "definition", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Name, + Input, + OrReplace, + Definition, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3033,7 +3565,10 @@ impl<'de> serde::Deserialize<'de> for CubeNode { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "name" => Ok(GeneratedField::Name), + "input" => Ok(GeneratedField::Input), + "orReplace" | "or_replace" => Ok(GeneratedField::OrReplace), + "definition" => Ok(GeneratedField::Definition), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3043,36 +3578,60 @@ impl<'de> serde::Deserialize<'de> for CubeNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CubeNode; + type Value = CreateViewNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CubeNode") + formatter.write_str("struct datafusion.CreateViewNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut name__ = None; + let mut input__ = None; + let mut or_replace__ = None; + let mut definition__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::OrReplace => { + if or_replace__.is_some() { + return Err(serde::de::Error::duplicate_field("orReplace")); + } + or_replace__ = Some(map.next_value()?); + } + GeneratedField::Definition => { + if definition__.is_some() { + return Err(serde::de::Error::duplicate_field("definition")); + } + definition__ = Some(map.next_value()?); } } } - Ok(CubeNode { - expr: expr__.unwrap_or_default(), + Ok(CreateViewNode { + name: name__.unwrap_or_default(), + input: input__, + or_replace: or_replace__.unwrap_or_default(), + definition: definition__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.CubeNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CreateViewNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for CustomTableScanNode { +impl serde::Serialize for CrossJoinExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3080,63 +3639,37 @@ impl serde::Serialize for CustomTableScanNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.table_name.is_empty() { - len += 1; - } - if self.projection.is_some() { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if !self.filters.is_empty() { + if self.left.is_some() { len += 1; } - if !self.custom_table_data.is_empty() { + if self.right.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.CustomTableScanNode", len)?; - if !self.table_name.is_empty() { - struct_ser.serialize_field("tableName", &self.table_name)?; - } - if let Some(v) = self.projection.as_ref() { - struct_ser.serialize_field("projection", v)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.filters.is_empty() { - struct_ser.serialize_field("filters", &self.filters)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinExecNode", len)?; + if let Some(v) = self.left.as_ref() { + struct_ser.serialize_field("left", v)?; } - if !self.custom_table_data.is_empty() { - struct_ser.serialize_field("customTableData", pbjson::private::base64::encode(&self.custom_table_data).as_str())?; + if let Some(v) = self.right.as_ref() { + struct_ser.serialize_field("right", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for CustomTableScanNode { +impl<'de> serde::Deserialize<'de> for CrossJoinExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "table_name", - "tableName", - "projection", - "schema", - "filters", - "custom_table_data", - "customTableData", + "left", + "right", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - TableName, - Projection, - Schema, - Filters, - CustomTableData, + Left, + Right, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3158,11 +3691,8 @@ impl<'de> serde::Deserialize<'de> for CustomTableScanNode { E: serde::de::Error, { match value { - "tableName" | "table_name" => Ok(GeneratedField::TableName), - "projection" => Ok(GeneratedField::Projection), - "schema" => Ok(GeneratedField::Schema), - "filters" => Ok(GeneratedField::Filters), - "customTableData" | "custom_table_data" => Ok(GeneratedField::CustomTableData), + "left" => Ok(GeneratedField::Left), + "right" => Ok(GeneratedField::Right), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3172,143 +3702,44 @@ impl<'de> serde::Deserialize<'de> for CustomTableScanNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CustomTableScanNode; + type Value = CrossJoinExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CustomTableScanNode") + formatter.write_str("struct datafusion.CrossJoinExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut table_name__ = None; - let mut projection__ = None; - let mut schema__ = None; - let mut filters__ = None; - let mut custom_table_data__ = None; + let mut left__ = None; + let mut right__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::TableName => { - if table_name__.is_some() { - return Err(serde::de::Error::duplicate_field("tableName")); - } - table_name__ = Some(map.next_value()?); - } - GeneratedField::Projection => { - if projection__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - projection__ = map.next_value()?; - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::Filters => { - if filters__.is_some() { - return Err(serde::de::Error::duplicate_field("filters")); + GeneratedField::Left => { + if left__.is_some() { + return Err(serde::de::Error::duplicate_field("left")); } - filters__ = Some(map.next_value()?); + left__ = map.next_value()?; } - GeneratedField::CustomTableData => { - if custom_table_data__.is_some() { - return Err(serde::de::Error::duplicate_field("customTableData")); + GeneratedField::Right => { + if right__.is_some() { + return Err(serde::de::Error::duplicate_field("right")); } - custom_table_data__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + right__ = map.next_value()?; } } } - Ok(CustomTableScanNode { - table_name: table_name__.unwrap_or_default(), - projection: projection__, - schema: schema__, - filters: filters__.unwrap_or_default(), - custom_table_data: custom_table_data__.unwrap_or_default(), + Ok(CrossJoinExecNode { + left: left__, + right: right__, }) } } - deserializer.deserialize_struct("datafusion.CustomTableScanNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DateUnit { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Day => "Day", - Self::DateMillisecond => "DateMillisecond", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for DateUnit { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "Day", - "DateMillisecond", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DateUnit; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(DateUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(DateUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "Day" => Ok(DateUnit::Day), - "DateMillisecond" => Ok(DateUnit::DateMillisecond), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CrossJoinExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Decimal { +impl serde::Serialize for CrossJoinNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3316,37 +3747,37 @@ impl serde::Serialize for Decimal { { use serde::ser::SerializeStruct; let mut len = 0; - if self.precision != 0 { + if self.left.is_some() { len += 1; } - if self.scale != 0 { + if self.right.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.Decimal", len)?; - if self.precision != 0 { - struct_ser.serialize_field("precision", &self.precision)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinNode", len)?; + if let Some(v) = self.left.as_ref() { + struct_ser.serialize_field("left", v)?; } - if self.scale != 0 { - struct_ser.serialize_field("scale", &self.scale)?; + if let Some(v) = self.right.as_ref() { + struct_ser.serialize_field("right", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Decimal { +impl<'de> serde::Deserialize<'de> for CrossJoinNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "precision", - "scale", + "left", + "right", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Precision, - Scale, + Left, + Right, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3368,8 +3799,8 @@ impl<'de> serde::Deserialize<'de> for Decimal { E: serde::de::Error, { match value { - "precision" => Ok(GeneratedField::Precision), - "scale" => Ok(GeneratedField::Scale), + "left" => Ok(GeneratedField::Left), + "right" => Ok(GeneratedField::Right), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3379,48 +3810,44 @@ impl<'de> serde::Deserialize<'de> for Decimal { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Decimal; + type Value = CrossJoinNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Decimal") + formatter.write_str("struct datafusion.CrossJoinNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut precision__ = None; - let mut scale__ = None; - while let Some(k) = map.next_key()? { + let mut left__ = None; + let mut right__ = None; + while let Some(k) = map.next_key()? { match k { - GeneratedField::Precision => { - if precision__.is_some() { - return Err(serde::de::Error::duplicate_field("precision")); + GeneratedField::Left => { + if left__.is_some() { + return Err(serde::de::Error::duplicate_field("left")); } - precision__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + left__ = map.next_value()?; } - GeneratedField::Scale => { - if scale__.is_some() { - return Err(serde::de::Error::duplicate_field("scale")); + GeneratedField::Right => { + if right__.is_some() { + return Err(serde::de::Error::duplicate_field("right")); } - scale__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + right__ = map.next_value()?; } } } - Ok(Decimal { - precision: precision__.unwrap_or_default(), - scale: scale__.unwrap_or_default(), + Ok(CrossJoinNode { + left: left__, + right: right__, }) } } - deserializer.deserialize_struct("datafusion.Decimal", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CrossJoinNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Decimal128 { +impl serde::Serialize for CsvFormat { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3428,45 +3855,38 @@ impl serde::Serialize for Decimal128 { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.value.is_empty() { - len += 1; - } - if self.p != 0 { + if self.has_header { len += 1; } - if self.s != 0 { + if !self.delimiter.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.Decimal128", len)?; - if !self.value.is_empty() { - struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; - } - if self.p != 0 { - struct_ser.serialize_field("p", ToString::to_string(&self.p).as_str())?; + let mut struct_ser = serializer.serialize_struct("datafusion.CsvFormat", len)?; + if self.has_header { + struct_ser.serialize_field("hasHeader", &self.has_header)?; } - if self.s != 0 { - struct_ser.serialize_field("s", ToString::to_string(&self.s).as_str())?; + if !self.delimiter.is_empty() { + struct_ser.serialize_field("delimiter", &self.delimiter)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Decimal128 { +impl<'de> serde::Deserialize<'de> for CsvFormat { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "value", - "p", - "s", + "has_header", + "hasHeader", + "delimiter", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Value, - P, - S, + HasHeader, + Delimiter, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3488,9 +3908,8 @@ impl<'de> serde::Deserialize<'de> for Decimal128 { E: serde::de::Error, { match value { - "value" => Ok(GeneratedField::Value), - "p" => Ok(GeneratedField::P), - "s" => Ok(GeneratedField::S), + "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader), + "delimiter" => Ok(GeneratedField::Delimiter), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3500,58 +3919,44 @@ impl<'de> serde::Deserialize<'de> for Decimal128 { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Decimal128; + type Value = CsvFormat; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Decimal128") + formatter.write_str("struct datafusion.CsvFormat") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut value__ = None; - let mut p__ = None; - let mut s__ = None; + let mut has_header__ = None; + let mut delimiter__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); - } - value__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::P => { - if p__.is_some() { - return Err(serde::de::Error::duplicate_field("p")); + GeneratedField::HasHeader => { + if has_header__.is_some() { + return Err(serde::de::Error::duplicate_field("hasHeader")); } - p__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + has_header__ = Some(map.next_value()?); } - GeneratedField::S => { - if s__.is_some() { - return Err(serde::de::Error::duplicate_field("s")); + GeneratedField::Delimiter => { + if delimiter__.is_some() { + return Err(serde::de::Error::duplicate_field("delimiter")); } - s__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + delimiter__ = Some(map.next_value()?); } } } - Ok(Decimal128 { - value: value__.unwrap_or_default(), - p: p__.unwrap_or_default(), - s: s__.unwrap_or_default(), + Ok(CsvFormat { + has_header: has_header__.unwrap_or_default(), + delimiter: delimiter__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.Decimal128", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CsvFormat", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DfField { +impl serde::Serialize for CsvScanExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3559,37 +3964,47 @@ impl serde::Serialize for DfField { { use serde::ser::SerializeStruct; let mut len = 0; - if self.field.is_some() { + if self.base_conf.is_some() { len += 1; } - if self.qualifier.is_some() { + if self.has_header { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.DfField", len)?; - if let Some(v) = self.field.as_ref() { - struct_ser.serialize_field("field", v)?; + if !self.delimiter.is_empty() { + len += 1; } - if let Some(v) = self.qualifier.as_ref() { - struct_ser.serialize_field("qualifier", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CsvScanExecNode", len)?; + if let Some(v) = self.base_conf.as_ref() { + struct_ser.serialize_field("baseConf", v)?; + } + if self.has_header { + struct_ser.serialize_field("hasHeader", &self.has_header)?; + } + if !self.delimiter.is_empty() { + struct_ser.serialize_field("delimiter", &self.delimiter)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DfField { +impl<'de> serde::Deserialize<'de> for CsvScanExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "field", - "qualifier", + "base_conf", + "baseConf", + "has_header", + "hasHeader", + "delimiter", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Field, - Qualifier, + BaseConf, + HasHeader, + Delimiter, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3611,8 +4026,9 @@ impl<'de> serde::Deserialize<'de> for DfField { E: serde::de::Error, { match value { - "field" => Ok(GeneratedField::Field), - "qualifier" => Ok(GeneratedField::Qualifier), + "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf), + "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader), + "delimiter" => Ok(GeneratedField::Delimiter), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3622,44 +4038,52 @@ impl<'de> serde::Deserialize<'de> for DfField { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DfField; + type Value = CsvScanExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.DfField") + formatter.write_str("struct datafusion.CsvScanExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut field__ = None; - let mut qualifier__ = None; + let mut base_conf__ = None; + let mut has_header__ = None; + let mut delimiter__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Field => { - if field__.is_some() { - return Err(serde::de::Error::duplicate_field("field")); + GeneratedField::BaseConf => { + if base_conf__.is_some() { + return Err(serde::de::Error::duplicate_field("baseConf")); } - field__ = map.next_value()?; + base_conf__ = map.next_value()?; } - GeneratedField::Qualifier => { - if qualifier__.is_some() { - return Err(serde::de::Error::duplicate_field("qualifier")); + GeneratedField::HasHeader => { + if has_header__.is_some() { + return Err(serde::de::Error::duplicate_field("hasHeader")); } - qualifier__ = map.next_value()?; + has_header__ = Some(map.next_value()?); + } + GeneratedField::Delimiter => { + if delimiter__.is_some() { + return Err(serde::de::Error::duplicate_field("delimiter")); + } + delimiter__ = Some(map.next_value()?); } } } - Ok(DfField { - field: field__, - qualifier: qualifier__, + Ok(CsvScanExecNode { + base_conf: base_conf__, + has_header: has_header__.unwrap_or_default(), + delimiter: delimiter__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.DfField", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CsvScanExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DfSchema { +impl serde::Serialize for CubeNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3667,37 +4091,29 @@ impl serde::Serialize for DfSchema { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.columns.is_empty() { - len += 1; - } - if !self.metadata.is_empty() { + if !self.expr.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.DfSchema", len)?; - if !self.columns.is_empty() { - struct_ser.serialize_field("columns", &self.columns)?; - } - if !self.metadata.is_empty() { - struct_ser.serialize_field("metadata", &self.metadata)?; + let mut struct_ser = serializer.serialize_struct("datafusion.CubeNode", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for DfSchema { +impl<'de> serde::Deserialize<'de> for CubeNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "columns", - "metadata", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Columns, - Metadata, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3719,8 +4135,7 @@ impl<'de> serde::Deserialize<'de> for DfSchema { E: serde::de::Error, { match value { - "columns" => Ok(GeneratedField::Columns), - "metadata" => Ok(GeneratedField::Metadata), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3730,46 +4145,36 @@ impl<'de> serde::Deserialize<'de> for DfSchema { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DfSchema; + type Value = CubeNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.DfSchema") + formatter.write_str("struct datafusion.CubeNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut columns__ = None; - let mut metadata__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Columns => { - if columns__.is_some() { - return Err(serde::de::Error::duplicate_field("columns")); - } - columns__ = Some(map.next_value()?); - } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - metadata__ = Some( - map.next_value::>()? - ); + expr__ = Some(map.next_value()?); } } } - Ok(DfSchema { - columns: columns__.unwrap_or_default(), - metadata: metadata__.unwrap_or_default(), + Ok(CubeNode { + expr: expr__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.DfSchema", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CubeNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Dictionary { +impl serde::Serialize for CustomTableScanNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -3777,37 +4182,63 @@ impl serde::Serialize for Dictionary { { use serde::ser::SerializeStruct; let mut len = 0; - if self.key.is_some() { + if !self.table_name.is_empty() { len += 1; } - if self.value.is_some() { + if self.projection.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.Dictionary", len)?; - if let Some(v) = self.key.as_ref() { - struct_ser.serialize_field("key", v)?; + if self.schema.is_some() { + len += 1; } - if let Some(v) = self.value.as_ref() { - struct_ser.serialize_field("value", v)?; + if !self.filters.is_empty() { + len += 1; } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Dictionary { + if !self.custom_table_data.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.CustomTableScanNode", len)?; + if !self.table_name.is_empty() { + struct_ser.serialize_field("tableName", &self.table_name)?; + } + if let Some(v) = self.projection.as_ref() { + struct_ser.serialize_field("projection", v)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if !self.filters.is_empty() { + struct_ser.serialize_field("filters", &self.filters)?; + } + if !self.custom_table_data.is_empty() { + struct_ser.serialize_field("customTableData", pbjson::private::base64::encode(&self.custom_table_data).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CustomTableScanNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "key", - "value", + "table_name", + "tableName", + "projection", + "schema", + "filters", + "custom_table_data", + "customTableData", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Key, - Value, + TableName, + Projection, + Schema, + Filters, + CustomTableData, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -3829,8 +4260,11 @@ impl<'de> serde::Deserialize<'de> for Dictionary { E: serde::de::Error, { match value { - "key" => Ok(GeneratedField::Key), - "value" => Ok(GeneratedField::Value), + "tableName" | "table_name" => Ok(GeneratedField::TableName), + "projection" => Ok(GeneratedField::Projection), + "schema" => Ok(GeneratedField::Schema), + "filters" => Ok(GeneratedField::Filters), + "customTableData" | "custom_table_data" => Ok(GeneratedField::CustomTableData), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -3840,157 +4274,181 @@ impl<'de> serde::Deserialize<'de> for Dictionary { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Dictionary; + type Value = CustomTableScanNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Dictionary") + formatter.write_str("struct datafusion.CustomTableScanNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut key__ = None; - let mut value__ = None; + let mut table_name__ = None; + let mut projection__ = None; + let mut schema__ = None; + let mut filters__ = None; + let mut custom_table_data__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); + GeneratedField::TableName => { + if table_name__.is_some() { + return Err(serde::de::Error::duplicate_field("tableName")); } - key__ = map.next_value()?; + table_name__ = Some(map.next_value()?); } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); + GeneratedField::Projection => { + if projection__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); } - value__ = map.next_value()?; + projection__ = map.next_value()?; + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = map.next_value()?; + } + GeneratedField::Filters => { + if filters__.is_some() { + return Err(serde::de::Error::duplicate_field("filters")); + } + filters__ = Some(map.next_value()?); + } + GeneratedField::CustomTableData => { + if custom_table_data__.is_some() { + return Err(serde::de::Error::duplicate_field("customTableData")); + } + custom_table_data__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; } } } - Ok(Dictionary { - key: key__, - value: value__, + Ok(CustomTableScanNode { + table_name: table_name__.unwrap_or_default(), + projection: projection__, + schema: schema__, + filters: filters__.unwrap_or_default(), + custom_table_data: custom_table_data__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.Dictionary", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.CustomTableScanNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for DistinctNode { +impl serde::Serialize for DateUnit { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.DistinctNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - struct_ser.end() + let variant = match self { + Self::Day => "Day", + Self::DateMillisecond => "DateMillisecond", + }; + serializer.serialize_str(variant) } } -impl<'de> serde::Deserialize<'de> for DistinctNode { +impl<'de> serde::Deserialize<'de> for DateUnit { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "input", + "Day", + "DateMillisecond", ]; - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; + struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DateUnit; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(DateUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DistinctNode; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.DistinctNode") + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(DateUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) } - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, { - let mut input__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - } + match value { + "Day" => Ok(DateUnit::Day), + "DateMillisecond" => Ok(DateUnit::DateMillisecond), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } - Ok(DistinctNode { - input: input__, - }) } } - deserializer.deserialize_struct("datafusion.DistinctNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_any(GeneratedVisitor) } } -impl serde::Serialize for EmptyMessage { +impl serde::Serialize for Decimal { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("datafusion.EmptyMessage", len)?; + let mut len = 0; + if self.precision != 0 { + len += 1; + } + if self.scale != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Decimal", len)?; + if self.precision != 0 { + struct_ser.serialize_field("precision", &self.precision)?; + } + if self.scale != 0 { + struct_ser.serialize_field("scale", &self.scale)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for EmptyMessage { +impl<'de> serde::Deserialize<'de> for Decimal { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "precision", + "scale", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Precision, + Scale, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4011,7 +4469,11 @@ impl<'de> serde::Deserialize<'de> for EmptyMessage { where E: serde::de::Error, { - Err(serde::de::Error::unknown_field(value, FIELDS)) + match value { + "precision" => Ok(GeneratedField::Precision), + "scale" => Ok(GeneratedField::Scale), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -4019,27 +4481,48 @@ impl<'de> serde::Deserialize<'de> for EmptyMessage { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = EmptyMessage; + type Value = Decimal; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.EmptyMessage") + formatter.write_str("struct datafusion.Decimal") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - while map.next_key::()?.is_some() { - let _ = map.next_value::()?; - } - Ok(EmptyMessage { - }) + let mut precision__ = None; + let mut scale__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Precision => { + if precision__.is_some() { + return Err(serde::de::Error::duplicate_field("precision")); + } + precision__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Scale => { + if scale__.is_some() { + return Err(serde::de::Error::duplicate_field("scale")); + } + scale__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(Decimal { + precision: precision__.unwrap_or_default(), + scale: scale__.unwrap_or_default(), + }) } } - deserializer.deserialize_struct("datafusion.EmptyMessage", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.Decimal", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for EmptyRelationNode { +impl serde::Serialize for Decimal128 { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4047,30 +4530,45 @@ impl serde::Serialize for EmptyRelationNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.produce_one_row { + if !self.value.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.EmptyRelationNode", len)?; - if self.produce_one_row { - struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?; + if self.p != 0 { + len += 1; + } + if self.s != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Decimal128", len)?; + if !self.value.is_empty() { + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if self.p != 0 { + struct_ser.serialize_field("p", ToString::to_string(&self.p).as_str())?; + } + if self.s != 0 { + struct_ser.serialize_field("s", ToString::to_string(&self.s).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for EmptyRelationNode { +impl<'de> serde::Deserialize<'de> for Decimal128 { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "produce_one_row", - "produceOneRow", + "value", + "p", + "s", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ProduceOneRow, + Value, + P, + S, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4092,7 +4590,9 @@ impl<'de> serde::Deserialize<'de> for EmptyRelationNode { E: serde::de::Error, { match value { - "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow), + "value" => Ok(GeneratedField::Value), + "p" => Ok(GeneratedField::P), + "s" => Ok(GeneratedField::S), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4102,36 +4602,58 @@ impl<'de> serde::Deserialize<'de> for EmptyRelationNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = EmptyRelationNode; + type Value = Decimal128; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.EmptyRelationNode") + formatter.write_str("struct datafusion.Decimal128") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut produce_one_row__ = None; + let mut value__ = None; + let mut p__ = None; + let mut s__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::ProduceOneRow => { - if produce_one_row__.is_some() { - return Err(serde::de::Error::duplicate_field("produceOneRow")); + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); } - produce_one_row__ = Some(map.next_value()?); + value__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::P => { + if p__.is_some() { + return Err(serde::de::Error::duplicate_field("p")); + } + p__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::S => { + if s__.is_some() { + return Err(serde::de::Error::duplicate_field("s")); + } + s__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(EmptyRelationNode { - produce_one_row: produce_one_row__.unwrap_or_default(), + Ok(Decimal128 { + value: value__.unwrap_or_default(), + p: p__.unwrap_or_default(), + s: s__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.EmptyRelationNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.Decimal128", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ExplainNode { +impl serde::Serialize for DfField { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4139,37 +4661,37 @@ impl serde::Serialize for ExplainNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.input.is_some() { + if self.field.is_some() { len += 1; } - if self.verbose { + if self.qualifier.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ExplainNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.DfField", len)?; + if let Some(v) = self.field.as_ref() { + struct_ser.serialize_field("field", v)?; } - if self.verbose { - struct_ser.serialize_field("verbose", &self.verbose)?; + if let Some(v) = self.qualifier.as_ref() { + struct_ser.serialize_field("qualifier", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ExplainNode { +impl<'de> serde::Deserialize<'de> for DfField { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "input", - "verbose", + "field", + "qualifier", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Input, - Verbose, + Field, + Qualifier, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4191,8 +4713,8 @@ impl<'de> serde::Deserialize<'de> for ExplainNode { E: serde::de::Error, { match value { - "input" => Ok(GeneratedField::Input), - "verbose" => Ok(GeneratedField::Verbose), + "field" => Ok(GeneratedField::Field), + "qualifier" => Ok(GeneratedField::Qualifier), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4202,44 +4724,44 @@ impl<'de> serde::Deserialize<'de> for ExplainNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExplainNode; + type Value = DfField; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ExplainNode") + formatter.write_str("struct datafusion.DfField") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut input__ = None; - let mut verbose__ = None; + let mut field__ = None; + let mut qualifier__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); + GeneratedField::Field => { + if field__.is_some() { + return Err(serde::de::Error::duplicate_field("field")); } - input__ = map.next_value()?; + field__ = map.next_value()?; } - GeneratedField::Verbose => { - if verbose__.is_some() { - return Err(serde::de::Error::duplicate_field("verbose")); + GeneratedField::Qualifier => { + if qualifier__.is_some() { + return Err(serde::de::Error::duplicate_field("qualifier")); } - verbose__ = Some(map.next_value()?); + qualifier__ = map.next_value()?; } } } - Ok(ExplainNode { - input: input__, - verbose: verbose__.unwrap_or_default(), + Ok(DfField { + field: field__, + qualifier: qualifier__, }) } } - deserializer.deserialize_struct("datafusion.ExplainNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.DfField", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Field { +impl serde::Serialize for DfSchema { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4247,54 +4769,37 @@ impl serde::Serialize for Field { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.arrow_type.is_some() { - len += 1; - } - if self.nullable { + if !self.columns.is_empty() { len += 1; } - if !self.children.is_empty() { + if !self.metadata.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.Field", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if let Some(v) = self.arrow_type.as_ref() { - struct_ser.serialize_field("arrowType", v)?; - } - if self.nullable { - struct_ser.serialize_field("nullable", &self.nullable)?; + let mut struct_ser = serializer.serialize_struct("datafusion.DfSchema", len)?; + if !self.columns.is_empty() { + struct_ser.serialize_field("columns", &self.columns)?; } - if !self.children.is_empty() { - struct_ser.serialize_field("children", &self.children)?; + if !self.metadata.is_empty() { + struct_ser.serialize_field("metadata", &self.metadata)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Field { +impl<'de> serde::Deserialize<'de> for DfSchema { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "name", - "arrow_type", - "arrowType", - "nullable", - "children", + "columns", + "metadata", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Name, - ArrowType, - Nullable, - Children, + Columns, + Metadata, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4316,10 +4821,8 @@ impl<'de> serde::Deserialize<'de> for Field { E: serde::de::Error, { match value { - "name" => Ok(GeneratedField::Name), - "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), - "nullable" => Ok(GeneratedField::Nullable), - "children" => Ok(GeneratedField::Children), + "columns" => Ok(GeneratedField::Columns), + "metadata" => Ok(GeneratedField::Metadata), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4329,60 +4832,46 @@ impl<'de> serde::Deserialize<'de> for Field { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Field; + type Value = DfSchema; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Field") + formatter.write_str("struct datafusion.DfSchema") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut name__ = None; - let mut arrow_type__ = None; - let mut nullable__ = None; - let mut children__ = None; + let mut columns__ = None; + let mut metadata__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::ArrowType => { - if arrow_type__.is_some() { - return Err(serde::de::Error::duplicate_field("arrowType")); + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); } - arrow_type__ = map.next_value()?; + columns__ = Some(map.next_value()?); } - GeneratedField::Nullable => { - if nullable__.is_some() { - return Err(serde::de::Error::duplicate_field("nullable")); + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); } - nullable__ = Some(map.next_value()?); - } - GeneratedField::Children => { - if children__.is_some() { - return Err(serde::de::Error::duplicate_field("children")); - } - children__ = Some(map.next_value()?); + metadata__ = Some( + map.next_value::>()? + ); } } } - Ok(Field { - name: name__.unwrap_or_default(), - arrow_type: arrow_type__, - nullable: nullable__.unwrap_or_default(), - children: children__.unwrap_or_default(), + Ok(DfSchema { + columns: columns__.unwrap_or_default(), + metadata: metadata__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.Field", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.DfSchema", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for FixedSizeBinary { +impl serde::Serialize for Dictionary { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4390,29 +4879,37 @@ impl serde::Serialize for FixedSizeBinary { { use serde::ser::SerializeStruct; let mut len = 0; - if self.length != 0 { + if self.key.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeBinary", len)?; - if self.length != 0 { - struct_ser.serialize_field("length", &self.length)?; + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Dictionary", len)?; + if let Some(v) = self.key.as_ref() { + struct_ser.serialize_field("key", v)?; + } + if let Some(v) = self.value.as_ref() { + struct_ser.serialize_field("value", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for FixedSizeBinary { +impl<'de> serde::Deserialize<'de> for Dictionary { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "length", + "key", + "value", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Length, + Key, + Value, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4434,7 +4931,8 @@ impl<'de> serde::Deserialize<'de> for FixedSizeBinary { E: serde::de::Error, { match value { - "length" => Ok(GeneratedField::Length), + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4444,38 +4942,44 @@ impl<'de> serde::Deserialize<'de> for FixedSizeBinary { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FixedSizeBinary; + type Value = Dictionary; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FixedSizeBinary") + formatter.write_str("struct datafusion.Dictionary") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut length__ = None; + let mut key__ = None; + let mut value__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Length => { - if length__.is_some() { - return Err(serde::de::Error::duplicate_field("length")); + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); } - length__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + key__ = map.next_value()?; + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = map.next_value()?; } } } - Ok(FixedSizeBinary { - length: length__.unwrap_or_default(), + Ok(Dictionary { + key: key__, + value: value__, }) } } - deserializer.deserialize_struct("datafusion.FixedSizeBinary", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.Dictionary", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for FixedSizeList { +impl serde::Serialize for DistinctNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4483,39 +4987,29 @@ impl serde::Serialize for FixedSizeList { { use serde::ser::SerializeStruct; let mut len = 0; - if self.field_type.is_some() { - len += 1; - } - if self.list_size != 0 { + if self.input.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeList", len)?; - if let Some(v) = self.field_type.as_ref() { - struct_ser.serialize_field("fieldType", v)?; - } - if self.list_size != 0 { - struct_ser.serialize_field("listSize", &self.list_size)?; + let mut struct_ser = serializer.serialize_struct("datafusion.DistinctNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for FixedSizeList { +impl<'de> serde::Deserialize<'de> for DistinctNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "field_type", - "fieldType", - "list_size", - "listSize", + "input", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - FieldType, - ListSize, + Input, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4537,8 +5031,7 @@ impl<'de> serde::Deserialize<'de> for FixedSizeList { E: serde::de::Error, { match value { - "fieldType" | "field_type" => Ok(GeneratedField::FieldType), - "listSize" | "list_size" => Ok(GeneratedField::ListSize), + "input" => Ok(GeneratedField::Input), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4548,46 +5041,36 @@ impl<'de> serde::Deserialize<'de> for FixedSizeList { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FixedSizeList; + type Value = DistinctNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FixedSizeList") + formatter.write_str("struct datafusion.DistinctNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut field_type__ = None; - let mut list_size__ = None; + let mut input__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::FieldType => { - if field_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fieldType")); - } - field_type__ = map.next_value()?; - } - GeneratedField::ListSize => { - if list_size__.is_some() { - return Err(serde::de::Error::duplicate_field("listSize")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - list_size__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + input__ = map.next_value()?; } } } - Ok(FixedSizeList { - field_type: field_type__, - list_size: list_size__.unwrap_or_default(), + Ok(DistinctNode { + input: input__, }) } } - deserializer.deserialize_struct("datafusion.FixedSizeList", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.DistinctNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GetIndexedField { +impl serde::Serialize for EmptyExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4595,37 +5078,38 @@ impl serde::Serialize for GetIndexedField { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if self.produce_one_row { len += 1; } - if self.key.is_some() { + if self.schema.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.GetIndexedField", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.EmptyExecNode", len)?; + if self.produce_one_row { + struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?; } - if let Some(v) = self.key.as_ref() { - struct_ser.serialize_field("key", v)?; + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GetIndexedField { +impl<'de> serde::Deserialize<'de> for EmptyExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", - "key", + "produce_one_row", + "produceOneRow", + "schema", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, - Key, + ProduceOneRow, + Schema, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4647,8 +5131,8 @@ impl<'de> serde::Deserialize<'de> for GetIndexedField { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), - "key" => Ok(GeneratedField::Key), + "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow), + "schema" => Ok(GeneratedField::Schema), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4658,74 +5142,66 @@ impl<'de> serde::Deserialize<'de> for GetIndexedField { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetIndexedField; + type Value = EmptyExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.GetIndexedField") + formatter.write_str("struct datafusion.EmptyExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; - let mut key__ = None; + let mut produce_one_row__ = None; + let mut schema__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::ProduceOneRow => { + if produce_one_row__.is_some() { + return Err(serde::de::Error::duplicate_field("produceOneRow")); } - expr__ = map.next_value()?; + produce_one_row__ = Some(map.next_value()?); } - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); } - key__ = map.next_value()?; + schema__ = map.next_value()?; } } } - Ok(GetIndexedField { - expr: expr__, - key: key__, + Ok(EmptyExecNode { + produce_one_row: produce_one_row__.unwrap_or_default(), + schema: schema__, }) } } - deserializer.deserialize_struct("datafusion.GetIndexedField", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.EmptyExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for GroupingSetNode { +impl serde::Serialize for EmptyMessage { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { use serde::ser::SerializeStruct; - let mut len = 0; - if !self.expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.GroupingSetNode", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } + let len = 0; + let struct_ser = serializer.serialize_struct("datafusion.EmptyMessage", len)?; struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for GroupingSetNode { +impl<'de> serde::Deserialize<'de> for EmptyMessage { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4746,10 +5222,7 @@ impl<'de> serde::Deserialize<'de> for GroupingSetNode { where E: serde::de::Error, { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } + Err(serde::de::Error::unknown_field(value, FIELDS)) } } deserializer.deserialize_identifier(GeneratedVisitor) @@ -4757,36 +5230,27 @@ impl<'de> serde::Deserialize<'de> for GroupingSetNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GroupingSetNode; + type Value = EmptyMessage; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.GroupingSetNode") + formatter.write_str("struct datafusion.EmptyMessage") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - } + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; } - Ok(GroupingSetNode { - expr: expr__.unwrap_or_default(), + Ok(EmptyMessage { }) } } - deserializer.deserialize_struct("datafusion.GroupingSetNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.EmptyMessage", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for HashRepartition { +impl serde::Serialize for EmptyRelationNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4794,39 +5258,30 @@ impl serde::Serialize for HashRepartition { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.hash_expr.is_empty() { - len += 1; - } - if self.partition_count != 0 { + if self.produce_one_row { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.HashRepartition", len)?; - if !self.hash_expr.is_empty() { - struct_ser.serialize_field("hashExpr", &self.hash_expr)?; - } - if self.partition_count != 0 { - struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?; + let mut struct_ser = serializer.serialize_struct("datafusion.EmptyRelationNode", len)?; + if self.produce_one_row { + struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for HashRepartition { +impl<'de> serde::Deserialize<'de> for EmptyRelationNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "hash_expr", - "hashExpr", - "partition_count", - "partitionCount", + "produce_one_row", + "produceOneRow", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - HashExpr, - PartitionCount, + ProduceOneRow, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4848,8 +5303,7 @@ impl<'de> serde::Deserialize<'de> for HashRepartition { E: serde::de::Error, { match value { - "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr), - "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount), + "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4859,46 +5313,36 @@ impl<'de> serde::Deserialize<'de> for HashRepartition { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = HashRepartition; + type Value = EmptyRelationNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.HashRepartition") + formatter.write_str("struct datafusion.EmptyRelationNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut hash_expr__ = None; - let mut partition_count__ = None; + let mut produce_one_row__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::HashExpr => { - if hash_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("hashExpr")); - } - hash_expr__ = Some(map.next_value()?); - } - GeneratedField::PartitionCount => { - if partition_count__.is_some() { - return Err(serde::de::Error::duplicate_field("partitionCount")); + GeneratedField::ProduceOneRow => { + if produce_one_row__.is_some() { + return Err(serde::de::Error::duplicate_field("produceOneRow")); } - partition_count__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + produce_one_row__ = Some(map.next_value()?); } } } - Ok(HashRepartition { - hash_expr: hash_expr__.unwrap_or_default(), - partition_count: partition_count__.unwrap_or_default(), + Ok(EmptyRelationNode { + produce_one_row: produce_one_row__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.HashRepartition", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.EmptyRelationNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ILikeNode { +impl serde::Serialize for ExecutorHeartbeat { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -4906,54 +5350,54 @@ impl serde::Serialize for ILikeNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.negated { + if !self.executor_id.is_empty() { len += 1; } - if self.expr.is_some() { + if self.timestamp != 0 { len += 1; } - if self.pattern.is_some() { + if !self.metrics.is_empty() { len += 1; } - if !self.escape_char.is_empty() { + if self.status.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ILikeNode", len)?; - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ExecutorHeartbeat", len)?; + if !self.executor_id.is_empty() { + struct_ser.serialize_field("executorId", &self.executor_id)?; } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + if self.timestamp != 0 { + struct_ser.serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?; } - if let Some(v) = self.pattern.as_ref() { - struct_ser.serialize_field("pattern", v)?; + if !self.metrics.is_empty() { + struct_ser.serialize_field("metrics", &self.metrics)?; } - if !self.escape_char.is_empty() { - struct_ser.serialize_field("escapeChar", &self.escape_char)?; + if let Some(v) = self.status.as_ref() { + struct_ser.serialize_field("status", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ILikeNode { +impl<'de> serde::Deserialize<'de> for ExecutorHeartbeat { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "negated", - "expr", - "pattern", - "escape_char", - "escapeChar", + "executor_id", + "executorId", + "timestamp", + "metrics", + "status", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Negated, - Expr, - Pattern, - EscapeChar, + ExecutorId, + Timestamp, + Metrics, + Status, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -4975,10 +5419,10 @@ impl<'de> serde::Deserialize<'de> for ILikeNode { E: serde::de::Error, { match value { - "negated" => Ok(GeneratedField::Negated), - "expr" => Ok(GeneratedField::Expr), - "pattern" => Ok(GeneratedField::Pattern), - "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), + "executorId" | "executor_id" => Ok(GeneratedField::ExecutorId), + "timestamp" => Ok(GeneratedField::Timestamp), + "metrics" => Ok(GeneratedField::Metrics), + "status" => Ok(GeneratedField::Status), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -4988,60 +5432,62 @@ impl<'de> serde::Deserialize<'de> for ILikeNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ILikeNode; + type Value = ExecutorHeartbeat; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ILikeNode") + formatter.write_str("struct datafusion.ExecutorHeartbeat") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut negated__ = None; - let mut expr__ = None; - let mut pattern__ = None; - let mut escape_char__ = None; + let mut executor_id__ = None; + let mut timestamp__ = None; + let mut metrics__ = None; + let mut status__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); + GeneratedField::ExecutorId => { + if executor_id__.is_some() { + return Err(serde::de::Error::duplicate_field("executorId")); } - negated__ = Some(map.next_value()?); + executor_id__ = Some(map.next_value()?); } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Timestamp => { + if timestamp__.is_some() { + return Err(serde::de::Error::duplicate_field("timestamp")); } - expr__ = map.next_value()?; + timestamp__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Pattern => { - if pattern__.is_some() { - return Err(serde::de::Error::duplicate_field("pattern")); + GeneratedField::Metrics => { + if metrics__.is_some() { + return Err(serde::de::Error::duplicate_field("metrics")); } - pattern__ = map.next_value()?; + metrics__ = Some(map.next_value()?); } - GeneratedField::EscapeChar => { - if escape_char__.is_some() { - return Err(serde::de::Error::duplicate_field("escapeChar")); + GeneratedField::Status => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("status")); } - escape_char__ = Some(map.next_value()?); + status__ = map.next_value()?; } } } - Ok(ILikeNode { - negated: negated__.unwrap_or_default(), - expr: expr__, - pattern: pattern__, - escape_char: escape_char__.unwrap_or_default(), + Ok(ExecutorHeartbeat { + executor_id: executor_id__.unwrap_or_default(), + timestamp: timestamp__.unwrap_or_default(), + metrics: metrics__.unwrap_or_default(), + status: status__, }) } } - deserializer.deserialize_struct("datafusion.ILikeNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExecutorHeartbeat", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for InListNode { +impl serde::Serialize for ExecutorMetadata { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5049,45 +5495,62 @@ impl serde::Serialize for InListNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if !self.id.is_empty() { len += 1; } - if !self.list.is_empty() { + if !self.host.is_empty() { len += 1; } - if self.negated { + if self.port != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.InListNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + if self.grpc_port != 0 { + len += 1; } - if !self.list.is_empty() { - struct_ser.serialize_field("list", &self.list)?; + if self.specification.is_some() { + len += 1; } - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ExecutorMetadata", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if !self.host.is_empty() { + struct_ser.serialize_field("host", &self.host)?; + } + if self.port != 0 { + struct_ser.serialize_field("port", &self.port)?; + } + if self.grpc_port != 0 { + struct_ser.serialize_field("grpcPort", &self.grpc_port)?; + } + if let Some(v) = self.specification.as_ref() { + struct_ser.serialize_field("specification", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for InListNode { +impl<'de> serde::Deserialize<'de> for ExecutorMetadata { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", - "list", - "negated", + "id", + "host", + "port", + "grpc_port", + "grpcPort", + "specification", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, - List, - Negated, + Id, + Host, + Port, + GrpcPort, + Specification, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5109,9 +5572,11 @@ impl<'de> serde::Deserialize<'de> for InListNode { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), - "list" => Ok(GeneratedField::List), - "negated" => Ok(GeneratedField::Negated), + "id" => Ok(GeneratedField::Id), + "host" => Ok(GeneratedField::Host), + "port" => Ok(GeneratedField::Port), + "grpcPort" | "grpc_port" => Ok(GeneratedField::GrpcPort), + "specification" => Ok(GeneratedField::Specification), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5121,52 +5586,72 @@ impl<'de> serde::Deserialize<'de> for InListNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = InListNode; + type Value = ExecutorMetadata; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.InListNode") + formatter.write_str("struct datafusion.ExecutorMetadata") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; - let mut list__ = None; - let mut negated__ = None; + let mut id__ = None; + let mut host__ = None; + let mut port__ = None; + let mut grpc_port__ = None; + let mut specification__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - expr__ = map.next_value()?; + id__ = Some(map.next_value()?); } - GeneratedField::List => { - if list__.is_some() { - return Err(serde::de::Error::duplicate_field("list")); + GeneratedField::Host => { + if host__.is_some() { + return Err(serde::de::Error::duplicate_field("host")); } - list__ = Some(map.next_value()?); + host__ = Some(map.next_value()?); } - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); + GeneratedField::Port => { + if port__.is_some() { + return Err(serde::de::Error::duplicate_field("port")); } - negated__ = Some(map.next_value()?); + port__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::GrpcPort => { + if grpc_port__.is_some() { + return Err(serde::de::Error::duplicate_field("grpcPort")); + } + grpc_port__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Specification => { + if specification__.is_some() { + return Err(serde::de::Error::duplicate_field("specification")); + } + specification__ = map.next_value()?; } } } - Ok(InListNode { - expr: expr__, - list: list__.unwrap_or_default(), - negated: negated__.unwrap_or_default(), + Ok(ExecutorMetadata { + id: id__.unwrap_or_default(), + host: host__.unwrap_or_default(), + port: port__.unwrap_or_default(), + grpc_port: grpc_port__.unwrap_or_default(), + specification: specification__, }) } } - deserializer.deserialize_struct("datafusion.InListNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExecutorMetadata", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IntervalMonthDayNanoValue { +impl serde::Serialize for ExecutorMetric { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5174,45 +5659,34 @@ impl serde::Serialize for IntervalMonthDayNanoValue { { use serde::ser::SerializeStruct; let mut len = 0; - if self.months != 0 { - len += 1; - } - if self.days != 0 { - len += 1; - } - if self.nanos != 0 { + if self.metric.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IntervalMonthDayNanoValue", len)?; - if self.months != 0 { - struct_ser.serialize_field("months", &self.months)?; - } - if self.days != 0 { - struct_ser.serialize_field("days", &self.days)?; - } - if self.nanos != 0 { - struct_ser.serialize_field("nanos", ToString::to_string(&self.nanos).as_str())?; + let mut struct_ser = serializer.serialize_struct("datafusion.ExecutorMetric", len)?; + if let Some(v) = self.metric.as_ref() { + match v { + executor_metric::Metric::AvailableMemory(v) => { + struct_ser.serialize_field("availableMemory", ToString::to_string(&v).as_str())?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue { +impl<'de> serde::Deserialize<'de> for ExecutorMetric { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "months", - "days", - "nanos", + "available_memory", + "availableMemory", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Months, - Days, - Nanos, + AvailableMemory, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5234,9 +5708,7 @@ impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue { E: serde::de::Error, { match value { - "months" => Ok(GeneratedField::Months), - "days" => Ok(GeneratedField::Days), - "nanos" => Ok(GeneratedField::Nanos), + "availableMemory" | "available_memory" => Ok(GeneratedField::AvailableMemory), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5246,164 +5718,103 @@ impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IntervalMonthDayNanoValue; + type Value = ExecutorMetric; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IntervalMonthDayNanoValue") + formatter.write_str("struct datafusion.ExecutorMetric") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut months__ = None; - let mut days__ = None; - let mut nanos__ = None; + let mut metric__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Months => { - if months__.is_some() { - return Err(serde::de::Error::duplicate_field("months")); - } - months__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Days => { - if days__.is_some() { - return Err(serde::de::Error::duplicate_field("days")); - } - days__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Nanos => { - if nanos__.is_some() { - return Err(serde::de::Error::duplicate_field("nanos")); + GeneratedField::AvailableMemory => { + if metric__.is_some() { + return Err(serde::de::Error::duplicate_field("availableMemory")); } - nanos__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + metric__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| executor_metric::Metric::AvailableMemory(x.0)); } } } - Ok(IntervalMonthDayNanoValue { - months: months__.unwrap_or_default(), - days: days__.unwrap_or_default(), - nanos: nanos__.unwrap_or_default(), + Ok(ExecutorMetric { + metric: metric__, }) } } - deserializer.deserialize_struct("datafusion.IntervalMonthDayNanoValue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExecutorMetric", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IntervalUnit { +impl serde::Serialize for ExecutorRegistration { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::YearMonth => "YearMonth", - Self::DayTime => "DayTime", - Self::MonthDayNano => "MonthDayNano", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if self.port != 0 { + len += 1; + } + if self.grpc_port != 0 { + len += 1; + } + if self.specification.is_some() { + len += 1; + } + if self.optional_host.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ExecutorRegistration", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if self.port != 0 { + struct_ser.serialize_field("port", &self.port)?; + } + if self.grpc_port != 0 { + struct_ser.serialize_field("grpcPort", &self.grpc_port)?; + } + if let Some(v) = self.specification.as_ref() { + struct_ser.serialize_field("specification", v)?; + } + if let Some(v) = self.optional_host.as_ref() { + match v { + executor_registration::OptionalHost::Host(v) => { + struct_ser.serialize_field("host", v)?; + } + } + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IntervalUnit { +impl<'de> serde::Deserialize<'de> for ExecutorRegistration { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "YearMonth", - "DayTime", - "MonthDayNano", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IntervalUnit; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(IntervalUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(IntervalUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "YearMonth" => Ok(IntervalUnit::YearMonth), - "DayTime" => Ok(IntervalUnit::DayTime), - "MonthDayNano" => Ok(IntervalUnit::MonthDayNano), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for IsFalse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsFalse", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsFalse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", + "id", + "port", + "grpc_port", + "grpcPort", + "specification", + "host", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Id, + Port, + GrpcPort, + Specification, + Host, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5425,7 +5836,11 @@ impl<'de> serde::Deserialize<'de> for IsFalse { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "id" => Ok(GeneratedField::Id), + "port" => Ok(GeneratedField::Port), + "grpcPort" | "grpc_port" => Ok(GeneratedField::GrpcPort), + "specification" => Ok(GeneratedField::Specification), + "host" => Ok(GeneratedField::Host), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5435,36 +5850,72 @@ impl<'de> serde::Deserialize<'de> for IsFalse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsFalse; + type Value = ExecutorRegistration; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsFalse") + formatter.write_str("struct datafusion.ExecutorRegistration") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut id__ = None; + let mut port__ = None; + let mut grpc_port__ = None; + let mut specification__ = None; + let mut optional_host__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); } - expr__ = map.next_value()?; + id__ = Some(map.next_value()?); + } + GeneratedField::Port => { + if port__.is_some() { + return Err(serde::de::Error::duplicate_field("port")); + } + port__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::GrpcPort => { + if grpc_port__.is_some() { + return Err(serde::de::Error::duplicate_field("grpcPort")); + } + grpc_port__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Specification => { + if specification__.is_some() { + return Err(serde::de::Error::duplicate_field("specification")); + } + specification__ = map.next_value()?; + } + GeneratedField::Host => { + if optional_host__.is_some() { + return Err(serde::de::Error::duplicate_field("host")); + } + optional_host__ = map.next_value::<::std::option::Option<_>>()?.map(executor_registration::OptionalHost::Host); } } } - Ok(IsFalse { - expr: expr__, + Ok(ExecutorRegistration { + id: id__.unwrap_or_default(), + port: port__.unwrap_or_default(), + grpc_port: grpc_port__.unwrap_or_default(), + specification: specification__, + optional_host: optional_host__, }) } } - deserializer.deserialize_struct("datafusion.IsFalse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExecutorRegistration", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IsNotFalse { +impl serde::Serialize for ExecutorResource { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5472,29 +5923,34 @@ impl serde::Serialize for IsNotFalse { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if self.resource.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotFalse", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ExecutorResource", len)?; + if let Some(v) = self.resource.as_ref() { + match v { + executor_resource::Resource::TaskSlots(v) => { + struct_ser.serialize_field("taskSlots", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IsNotFalse { +impl<'de> serde::Deserialize<'de> for ExecutorResource { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "task_slots", + "taskSlots", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + TaskSlots, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5516,7 +5972,7 @@ impl<'de> serde::Deserialize<'de> for IsNotFalse { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "taskSlots" | "task_slots" => Ok(GeneratedField::TaskSlots), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5526,36 +5982,36 @@ impl<'de> serde::Deserialize<'de> for IsNotFalse { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotFalse; + type Value = ExecutorResource; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotFalse") + formatter.write_str("struct datafusion.ExecutorResource") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut resource__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::TaskSlots => { + if resource__.is_some() { + return Err(serde::de::Error::duplicate_field("taskSlots")); } - expr__ = map.next_value()?; + resource__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| executor_resource::Resource::TaskSlots(x.0)); } } } - Ok(IsNotFalse { - expr: expr__, + Ok(ExecutorResource { + resource: resource__, }) } } - deserializer.deserialize_struct("datafusion.IsNotFalse", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExecutorResource", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IsNotNull { +impl serde::Serialize for ExecutorSpecification { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5563,29 +6019,29 @@ impl serde::Serialize for IsNotNull { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if !self.resources.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotNull", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ExecutorSpecification", len)?; + if !self.resources.is_empty() { + struct_ser.serialize_field("resources", &self.resources)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IsNotNull { +impl<'de> serde::Deserialize<'de> for ExecutorSpecification { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "resources", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Resources, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5607,7 +6063,7 @@ impl<'de> serde::Deserialize<'de> for IsNotNull { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "resources" => Ok(GeneratedField::Resources), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5617,36 +6073,36 @@ impl<'de> serde::Deserialize<'de> for IsNotNull { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotNull; + type Value = ExecutorSpecification; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotNull") + formatter.write_str("struct datafusion.ExecutorSpecification") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut resources__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Resources => { + if resources__.is_some() { + return Err(serde::de::Error::duplicate_field("resources")); } - expr__ = map.next_value()?; + resources__ = Some(map.next_value()?); } } } - Ok(IsNotNull { - expr: expr__, + Ok(ExecutorSpecification { + resources: resources__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.IsNotNull", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExecutorSpecification", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IsNotTrue { +impl serde::Serialize for ExecutorStatus { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5654,29 +6110,43 @@ impl serde::Serialize for IsNotTrue { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if self.status.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotTrue", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ExecutorStatus", len)?; + if let Some(v) = self.status.as_ref() { + match v { + executor_status::Status::Active(v) => { + struct_ser.serialize_field("active", v)?; + } + executor_status::Status::Dead(v) => { + struct_ser.serialize_field("dead", v)?; + } + executor_status::Status::Unknown(v) => { + struct_ser.serialize_field("unknown", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IsNotTrue { +impl<'de> serde::Deserialize<'de> for ExecutorStatus { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "active", + "dead", + "unknown", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Active, + Dead, + Unknown, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5698,7 +6168,9 @@ impl<'de> serde::Deserialize<'de> for IsNotTrue { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "active" => Ok(GeneratedField::Active), + "dead" => Ok(GeneratedField::Dead), + "unknown" => Ok(GeneratedField::Unknown), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5708,36 +6180,48 @@ impl<'de> serde::Deserialize<'de> for IsNotTrue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotTrue; + type Value = ExecutorStatus; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotTrue") + formatter.write_str("struct datafusion.ExecutorStatus") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut status__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Active => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("active")); } - expr__ = map.next_value()?; + status__ = map.next_value::<::std::option::Option<_>>()?.map(executor_status::Status::Active); + } + GeneratedField::Dead => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("dead")); + } + status__ = map.next_value::<::std::option::Option<_>>()?.map(executor_status::Status::Dead); + } + GeneratedField::Unknown => { + if status__.is_some() { + return Err(serde::de::Error::duplicate_field("unknown")); + } + status__ = map.next_value::<::std::option::Option<_>>()?.map(executor_status::Status::Unknown); } } } - Ok(IsNotTrue { - expr: expr__, + Ok(ExecutorStatus { + status: status__, }) } } - deserializer.deserialize_struct("datafusion.IsNotTrue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExecutorStatus", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IsNotUnknown { +impl serde::Serialize for ExplainExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5745,29 +6229,46 @@ impl serde::Serialize for IsNotUnknown { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if self.schema.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotUnknown", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + if !self.stringified_plans.is_empty() { + len += 1; + } + if self.verbose { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ExplainExecNode", len)?; + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if !self.stringified_plans.is_empty() { + struct_ser.serialize_field("stringifiedPlans", &self.stringified_plans)?; + } + if self.verbose { + struct_ser.serialize_field("verbose", &self.verbose)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IsNotUnknown { +impl<'de> serde::Deserialize<'de> for ExplainExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "schema", + "stringified_plans", + "stringifiedPlans", + "verbose", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Schema, + StringifiedPlans, + Verbose, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5789,7 +6290,9 @@ impl<'de> serde::Deserialize<'de> for IsNotUnknown { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "schema" => Ok(GeneratedField::Schema), + "stringifiedPlans" | "stringified_plans" => Ok(GeneratedField::StringifiedPlans), + "verbose" => Ok(GeneratedField::Verbose), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5799,36 +6302,52 @@ impl<'de> serde::Deserialize<'de> for IsNotUnknown { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotUnknown; + type Value = ExplainExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotUnknown") + formatter.write_str("struct datafusion.ExplainExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut schema__ = None; + let mut stringified_plans__ = None; + let mut verbose__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); } - expr__ = map.next_value()?; + schema__ = map.next_value()?; + } + GeneratedField::StringifiedPlans => { + if stringified_plans__.is_some() { + return Err(serde::de::Error::duplicate_field("stringifiedPlans")); + } + stringified_plans__ = Some(map.next_value()?); + } + GeneratedField::Verbose => { + if verbose__.is_some() { + return Err(serde::de::Error::duplicate_field("verbose")); + } + verbose__ = Some(map.next_value()?); } } } - Ok(IsNotUnknown { - expr: expr__, + Ok(ExplainExecNode { + schema: schema__, + stringified_plans: stringified_plans__.unwrap_or_default(), + verbose: verbose__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.IsNotUnknown", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExplainExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IsNull { +impl serde::Serialize for ExplainNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5836,29 +6355,37 @@ impl serde::Serialize for IsNull { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if self.input.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNull", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + if self.verbose { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ExplainNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.verbose { + struct_ser.serialize_field("verbose", &self.verbose)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IsNull { +impl<'de> serde::Deserialize<'de> for ExplainNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "input", + "verbose", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Input, + Verbose, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5880,8 +6407,9 @@ impl<'de> serde::Deserialize<'de> for IsNull { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + "input" => Ok(GeneratedField::Input), + "verbose" => Ok(GeneratedField::Verbose), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } } @@ -5890,36 +6418,44 @@ impl<'de> serde::Deserialize<'de> for IsNull { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNull; + type Value = ExplainNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNull") + formatter.write_str("struct datafusion.ExplainNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut input__ = None; + let mut verbose__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - expr__ = map.next_value()?; + input__ = map.next_value()?; + } + GeneratedField::Verbose => { + if verbose__.is_some() { + return Err(serde::de::Error::duplicate_field("verbose")); + } + verbose__ = Some(map.next_value()?); } } } - Ok(IsNull { - expr: expr__, + Ok(ExplainNode { + input: input__, + verbose: verbose__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.IsNull", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ExplainNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IsTrue { +impl serde::Serialize for Field { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -5927,29 +6463,54 @@ impl serde::Serialize for IsTrue { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if !self.name.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IsTrue", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + if self.arrow_type.is_some() { + len += 1; + } + if self.nullable { + len += 1; + } + if !self.children.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Field", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if let Some(v) = self.arrow_type.as_ref() { + struct_ser.serialize_field("arrowType", v)?; + } + if self.nullable { + struct_ser.serialize_field("nullable", &self.nullable)?; + } + if !self.children.is_empty() { + struct_ser.serialize_field("children", &self.children)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IsTrue { +impl<'de> serde::Deserialize<'de> for Field { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "name", + "arrow_type", + "arrowType", + "nullable", + "children", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Name, + ArrowType, + Nullable, + Children, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -5971,7 +6532,10 @@ impl<'de> serde::Deserialize<'de> for IsTrue { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "name" => Ok(GeneratedField::Name), + "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), + "nullable" => Ok(GeneratedField::Nullable), + "children" => Ok(GeneratedField::Children), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -5981,36 +6545,60 @@ impl<'de> serde::Deserialize<'de> for IsTrue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsTrue; + type Value = Field; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsTrue") + formatter.write_str("struct datafusion.Field") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut name__ = None; + let mut arrow_type__ = None; + let mut nullable__ = None; + let mut children__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); } - expr__ = map.next_value()?; + name__ = Some(map.next_value()?); + } + GeneratedField::ArrowType => { + if arrow_type__.is_some() { + return Err(serde::de::Error::duplicate_field("arrowType")); + } + arrow_type__ = map.next_value()?; + } + GeneratedField::Nullable => { + if nullable__.is_some() { + return Err(serde::de::Error::duplicate_field("nullable")); + } + nullable__ = Some(map.next_value()?); + } + GeneratedField::Children => { + if children__.is_some() { + return Err(serde::de::Error::duplicate_field("children")); + } + children__ = Some(map.next_value()?); } } } - Ok(IsTrue { - expr: expr__, + Ok(Field { + name: name__.unwrap_or_default(), + arrow_type: arrow_type__, + nullable: nullable__.unwrap_or_default(), + children: children__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.IsTrue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.Field", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for IsUnknown { +impl serde::Serialize for FileGroup { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6018,29 +6606,29 @@ impl serde::Serialize for IsUnknown { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if !self.files.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.IsUnknown", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.FileGroup", len)?; + if !self.files.is_empty() { + struct_ser.serialize_field("files", &self.files)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for IsUnknown { +impl<'de> serde::Deserialize<'de> for FileGroup { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "files", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Files, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6062,7 +6650,7 @@ impl<'de> serde::Deserialize<'de> for IsUnknown { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "files" => Ok(GeneratedField::Files), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6072,109 +6660,148 @@ impl<'de> serde::Deserialize<'de> for IsUnknown { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsUnknown; + type Value = FileGroup; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsUnknown") + formatter.write_str("struct datafusion.FileGroup") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut files__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Files => { + if files__.is_some() { + return Err(serde::de::Error::duplicate_field("files")); } - expr__ = map.next_value()?; + files__ = Some(map.next_value()?); } } } - Ok(IsUnknown { - expr: expr__, + Ok(FileGroup { + files: files__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.IsUnknown", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.FileGroup", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for JoinConstraint { +impl serde::Serialize for FileRange { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::On => "ON", - Self::Using => "USING", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if self.start != 0 { + len += 1; + } + if self.end != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.FileRange", len)?; + if self.start != 0 { + struct_ser.serialize_field("start", ToString::to_string(&self.start).as_str())?; + } + if self.end != 0 { + struct_ser.serialize_field("end", ToString::to_string(&self.end).as_str())?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for JoinConstraint { +impl<'de> serde::Deserialize<'de> for FileRange { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "ON", - "USING", + "start", + "end", ]; - struct GeneratedVisitor; + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Start, + End, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinConstraint; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinConstraint::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "start" => Ok(GeneratedField::Start), + "end" => Ok(GeneratedField::End), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = FileRange; - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinConstraint::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.FileRange") } - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, { - match value { - "ON" => Ok(JoinConstraint::On), - "USING" => Ok(JoinConstraint::Using), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + let mut start__ = None; + let mut end__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Start => { + if start__.is_some() { + return Err(serde::de::Error::duplicate_field("start")); + } + start__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::End => { + if end__.is_some() { + return Err(serde::de::Error::duplicate_field("end")); + } + end__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } } + Ok(FileRange { + start: start__.unwrap_or_default(), + end: end__.unwrap_or_default(), + }) } } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("datafusion.FileRange", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for JoinNode { +impl serde::Serialize for FileScanExecConf { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6182,94 +6809,80 @@ impl serde::Serialize for JoinNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.left.is_some() { + if !self.file_groups.is_empty() { len += 1; } - if self.right.is_some() { + if self.schema.is_some() { len += 1; } - if self.join_type != 0 { + if !self.projection.is_empty() { len += 1; } - if self.join_constraint != 0 { + if self.limit.is_some() { len += 1; } - if !self.left_join_column.is_empty() { + if self.statistics.is_some() { len += 1; } - if !self.right_join_column.is_empty() { + if !self.table_partition_cols.is_empty() { len += 1; } - if self.null_equals_null { + if !self.object_store_url.is_empty() { len += 1; } - if self.filter.is_some() { - len += 1; + let mut struct_ser = serializer.serialize_struct("datafusion.FileScanExecConf", len)?; + if !self.file_groups.is_empty() { + struct_ser.serialize_field("fileGroups", &self.file_groups)?; } - let mut struct_ser = serializer.serialize_struct("datafusion.JoinNode", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; - } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; - } - if self.join_type != 0 { - let v = JoinType::from_i32(self.join_type) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?; - struct_ser.serialize_field("joinType", &v)?; + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; } - if self.join_constraint != 0 { - let v = JoinConstraint::from_i32(self.join_constraint) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_constraint)))?; - struct_ser.serialize_field("joinConstraint", &v)?; + if !self.projection.is_empty() { + struct_ser.serialize_field("projection", &self.projection)?; } - if !self.left_join_column.is_empty() { - struct_ser.serialize_field("leftJoinColumn", &self.left_join_column)?; + if let Some(v) = self.limit.as_ref() { + struct_ser.serialize_field("limit", v)?; } - if !self.right_join_column.is_empty() { - struct_ser.serialize_field("rightJoinColumn", &self.right_join_column)?; + if let Some(v) = self.statistics.as_ref() { + struct_ser.serialize_field("statistics", v)?; } - if self.null_equals_null { - struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?; + if !self.table_partition_cols.is_empty() { + struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; } - if let Some(v) = self.filter.as_ref() { - struct_ser.serialize_field("filter", v)?; + if !self.object_store_url.is_empty() { + struct_ser.serialize_field("objectStoreUrl", &self.object_store_url)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for JoinNode { +impl<'de> serde::Deserialize<'de> for FileScanExecConf { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "left", - "right", - "join_type", - "joinType", - "join_constraint", - "joinConstraint", - "left_join_column", - "leftJoinColumn", - "right_join_column", - "rightJoinColumn", - "null_equals_null", - "nullEqualsNull", - "filter", + "file_groups", + "fileGroups", + "schema", + "projection", + "limit", + "statistics", + "table_partition_cols", + "tablePartitionCols", + "object_store_url", + "objectStoreUrl", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Left, - Right, - JoinType, - JoinConstraint, - LeftJoinColumn, - RightJoinColumn, - NullEqualsNull, - Filter, + FileGroups, + Schema, + Projection, + Limit, + Statistics, + TablePartitionCols, + ObjectStoreUrl, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6291,14 +6904,13 @@ impl<'de> serde::Deserialize<'de> for JoinNode { E: serde::de::Error, { match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), - "joinType" | "join_type" => Ok(GeneratedField::JoinType), - "joinConstraint" | "join_constraint" => Ok(GeneratedField::JoinConstraint), - "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), + "fileGroups" | "file_groups" => Ok(GeneratedField::FileGroups), + "schema" => Ok(GeneratedField::Schema), + "projection" => Ok(GeneratedField::Projection), + "limit" => Ok(GeneratedField::Limit), + "statistics" => Ok(GeneratedField::Statistics), + "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), + "objectStoreUrl" | "object_store_url" => Ok(GeneratedField::ObjectStoreUrl), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6308,183 +6920,87 @@ impl<'de> serde::Deserialize<'de> for JoinNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinNode; + type Value = FileScanExecConf; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.JoinNode") + formatter.write_str("struct datafusion.FileScanExecConf") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut left__ = None; - let mut right__ = None; - let mut join_type__ = None; - let mut join_constraint__ = None; - let mut left_join_column__ = None; - let mut right_join_column__ = None; - let mut null_equals_null__ = None; - let mut filter__ = None; + let mut file_groups__ = None; + let mut schema__ = None; + let mut projection__ = None; + let mut limit__ = None; + let mut statistics__ = None; + let mut table_partition_cols__ = None; + let mut object_store_url__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); - } - left__ = map.next_value()?; - } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); + GeneratedField::FileGroups => { + if file_groups__.is_some() { + return Err(serde::de::Error::duplicate_field("fileGroups")); } - right__ = map.next_value()?; + file_groups__ = Some(map.next_value()?); } - GeneratedField::JoinType => { - if join_type__.is_some() { - return Err(serde::de::Error::duplicate_field("joinType")); + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); } - join_type__ = Some(map.next_value::()? as i32); + schema__ = map.next_value()?; } - GeneratedField::JoinConstraint => { - if join_constraint__.is_some() { - return Err(serde::de::Error::duplicate_field("joinConstraint")); + GeneratedField::Projection => { + if projection__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); } - join_constraint__ = Some(map.next_value::()? as i32); + projection__ = + Some(map.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; } - GeneratedField::LeftJoinColumn => { - if left_join_column__.is_some() { - return Err(serde::de::Error::duplicate_field("leftJoinColumn")); + GeneratedField::Limit => { + if limit__.is_some() { + return Err(serde::de::Error::duplicate_field("limit")); } - left_join_column__ = Some(map.next_value()?); + limit__ = map.next_value()?; } - GeneratedField::RightJoinColumn => { - if right_join_column__.is_some() { - return Err(serde::de::Error::duplicate_field("rightJoinColumn")); + GeneratedField::Statistics => { + if statistics__.is_some() { + return Err(serde::de::Error::duplicate_field("statistics")); } - right_join_column__ = Some(map.next_value()?); + statistics__ = map.next_value()?; } - GeneratedField::NullEqualsNull => { - if null_equals_null__.is_some() { - return Err(serde::de::Error::duplicate_field("nullEqualsNull")); + GeneratedField::TablePartitionCols => { + if table_partition_cols__.is_some() { + return Err(serde::de::Error::duplicate_field("tablePartitionCols")); } - null_equals_null__ = Some(map.next_value()?); + table_partition_cols__ = Some(map.next_value()?); } - GeneratedField::Filter => { - if filter__.is_some() { - return Err(serde::de::Error::duplicate_field("filter")); + GeneratedField::ObjectStoreUrl => { + if object_store_url__.is_some() { + return Err(serde::de::Error::duplicate_field("objectStoreUrl")); } - filter__ = map.next_value()?; + object_store_url__ = Some(map.next_value()?); } } } - Ok(JoinNode { - left: left__, - right: right__, - join_type: join_type__.unwrap_or_default(), - join_constraint: join_constraint__.unwrap_or_default(), - left_join_column: left_join_column__.unwrap_or_default(), - right_join_column: right_join_column__.unwrap_or_default(), - null_equals_null: null_equals_null__.unwrap_or_default(), - filter: filter__, + Ok(FileScanExecConf { + file_groups: file_groups__.unwrap_or_default(), + schema: schema__, + projection: projection__.unwrap_or_default(), + limit: limit__, + statistics: statistics__, + table_partition_cols: table_partition_cols__.unwrap_or_default(), + object_store_url: object_store_url__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.JoinNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for JoinType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Inner => "INNER", - Self::Left => "LEFT", - Self::Right => "RIGHT", - Self::Full => "FULL", - Self::Leftsemi => "LEFTSEMI", - Self::Leftanti => "LEFTANTI", - Self::Rightsemi => "RIGHTSEMI", - Self::Rightanti => "RIGHTANTI", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for JoinType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "INNER", - "LEFT", - "RIGHT", - "FULL", - "LEFTSEMI", - "LEFTANTI", - "RIGHTSEMI", - "RIGHTANTI", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinType::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinType::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "INNER" => Ok(JoinType::Inner), - "LEFT" => Ok(JoinType::Left), - "RIGHT" => Ok(JoinType::Right), - "FULL" => Ok(JoinType::Full), - "LEFTSEMI" => Ok(JoinType::Leftsemi), - "LEFTANTI" => Ok(JoinType::Leftanti), - "RIGHTSEMI" => Ok(JoinType::Rightsemi), - "RIGHTANTI" => Ok(JoinType::Rightanti), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) + deserializer.deserialize_struct("datafusion.FileScanExecConf", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for LikeNode { +impl serde::Serialize for FilterExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6492,54 +7008,37 @@ impl serde::Serialize for LikeNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.negated { + if self.input.is_some() { len += 1; } if self.expr.is_some() { len += 1; } - if self.pattern.is_some() { - len += 1; - } - if !self.escape_char.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LikeNode", len)?; - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; + let mut struct_ser = serializer.serialize_struct("datafusion.FilterExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; } if let Some(v) = self.expr.as_ref() { struct_ser.serialize_field("expr", v)?; } - if let Some(v) = self.pattern.as_ref() { - struct_ser.serialize_field("pattern", v)?; - } - if !self.escape_char.is_empty() { - struct_ser.serialize_field("escapeChar", &self.escape_char)?; - } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for LikeNode { +impl<'de> serde::Deserialize<'de> for FilterExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "negated", + "input", "expr", - "pattern", - "escape_char", - "escapeChar", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Negated, + Input, Expr, - Pattern, - EscapeChar, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6561,10 +7060,8 @@ impl<'de> serde::Deserialize<'de> for LikeNode { E: serde::de::Error, { match value { - "negated" => Ok(GeneratedField::Negated), + "input" => Ok(GeneratedField::Input), "expr" => Ok(GeneratedField::Expr), - "pattern" => Ok(GeneratedField::Pattern), - "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6574,27 +7071,25 @@ impl<'de> serde::Deserialize<'de> for LikeNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LikeNode; + type Value = FilterExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LikeNode") + formatter.write_str("struct datafusion.FilterExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut negated__ = None; + let mut input__ = None; let mut expr__ = None; - let mut pattern__ = None; - let mut escape_char__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - negated__ = Some(map.next_value()?); + input__ = map.next_value()?; } GeneratedField::Expr => { if expr__.is_some() { @@ -6602,32 +7097,18 @@ impl<'de> serde::Deserialize<'de> for LikeNode { } expr__ = map.next_value()?; } - GeneratedField::Pattern => { - if pattern__.is_some() { - return Err(serde::de::Error::duplicate_field("pattern")); - } - pattern__ = map.next_value()?; - } - GeneratedField::EscapeChar => { - if escape_char__.is_some() { - return Err(serde::de::Error::duplicate_field("escapeChar")); - } - escape_char__ = Some(map.next_value()?); - } } } - Ok(LikeNode { - negated: negated__.unwrap_or_default(), + Ok(FilterExecNode { + input: input__, expr: expr__, - pattern: pattern__, - escape_char: escape_char__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.LikeNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.FilterExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for LimitNode { +impl serde::Serialize for FixedSizeBinary { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6635,45 +7116,29 @@ impl serde::Serialize for LimitNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.skip != 0 { - len += 1; - } - if self.fetch != 0 { + if self.length != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.LimitNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.skip != 0 { - struct_ser.serialize_field("skip", ToString::to_string(&self.skip).as_str())?; - } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; + let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeBinary", len)?; + if self.length != 0 { + struct_ser.serialize_field("length", &self.length)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for LimitNode { +impl<'de> serde::Deserialize<'de> for FixedSizeBinary { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "input", - "skip", - "fetch", + "length", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Input, - Skip, - Fetch, + Length, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6695,9 +7160,7 @@ impl<'de> serde::Deserialize<'de> for LimitNode { E: serde::de::Error, { match value { - "input" => Ok(GeneratedField::Input), - "skip" => Ok(GeneratedField::Skip), - "fetch" => Ok(GeneratedField::Fetch), + "length" => Ok(GeneratedField::Length), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6707,56 +7170,38 @@ impl<'de> serde::Deserialize<'de> for LimitNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LimitNode; + type Value = FixedSizeBinary; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LimitNode") + formatter.write_str("struct datafusion.FixedSizeBinary") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut input__ = None; - let mut skip__ = None; - let mut fetch__ = None; + let mut length__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Skip => { - if skip__.is_some() { - return Err(serde::de::Error::duplicate_field("skip")); - } - skip__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); + GeneratedField::Length => { + if length__.is_some() { + return Err(serde::de::Error::duplicate_field("length")); } - fetch__ = + length__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } } } - Ok(LimitNode { - input: input__, - skip: skip__.unwrap_or_default(), - fetch: fetch__.unwrap_or_default(), + Ok(FixedSizeBinary { + length: length__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.LimitNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.FixedSizeBinary", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for List { +impl serde::Serialize for FixedSizeList { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6767,14 +7212,20 @@ impl serde::Serialize for List { if self.field_type.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.List", len)?; + if self.list_size != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeList", len)?; if let Some(v) = self.field_type.as_ref() { struct_ser.serialize_field("fieldType", v)?; } + if self.list_size != 0 { + struct_ser.serialize_field("listSize", &self.list_size)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for List { +impl<'de> serde::Deserialize<'de> for FixedSizeList { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -6783,11 +7234,14 @@ impl<'de> serde::Deserialize<'de> for List { const FIELDS: &[&str] = &[ "field_type", "fieldType", + "list_size", + "listSize", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { FieldType, + ListSize, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -6810,6 +7264,7 @@ impl<'de> serde::Deserialize<'de> for List { { match value { "fieldType" | "field_type" => Ok(GeneratedField::FieldType), + "listSize" | "list_size" => Ok(GeneratedField::ListSize), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -6819,17 +7274,18 @@ impl<'de> serde::Deserialize<'de> for List { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = List; + type Value = FixedSizeList; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.List") + formatter.write_str("struct datafusion.FixedSizeList") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { let mut field_type__ = None; + let mut list_size__ = None; while let Some(k) = map.next_key()? { match k { GeneratedField::FieldType => { @@ -6838,17 +7294,26 @@ impl<'de> serde::Deserialize<'de> for List { } field_type__ = map.next_value()?; } + GeneratedField::ListSize => { + if list_size__.is_some() { + return Err(serde::de::Error::duplicate_field("listSize")); + } + list_size__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } } } - Ok(List { + Ok(FixedSizeList { field_type: field_type__, + list_size: list_size__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.List", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.FixedSizeList", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ListingTableScanNode { +impl serde::Serialize for GetIndexedField { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -6856,129 +7321,37 @@ impl serde::Serialize for ListingTableScanNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.table_name.is_empty() { - len += 1; - } - if !self.paths.is_empty() { - len += 1; - } - if !self.file_extension.is_empty() { - len += 1; - } - if self.projection.is_some() { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if !self.filters.is_empty() { - len += 1; - } - if !self.table_partition_cols.is_empty() { - len += 1; - } - if self.collect_stat { - len += 1; - } - if self.target_partitions != 0 { - len += 1; - } - if !self.file_sort_order.is_empty() { + if self.expr.is_some() { len += 1; } - if self.file_format_type.is_some() { + if self.key.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ListingTableScanNode", len)?; - if !self.table_name.is_empty() { - struct_ser.serialize_field("tableName", &self.table_name)?; - } - if !self.paths.is_empty() { - struct_ser.serialize_field("paths", &self.paths)?; - } - if !self.file_extension.is_empty() { - struct_ser.serialize_field("fileExtension", &self.file_extension)?; - } - if let Some(v) = self.projection.as_ref() { - struct_ser.serialize_field("projection", v)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.filters.is_empty() { - struct_ser.serialize_field("filters", &self.filters)?; - } - if !self.table_partition_cols.is_empty() { - struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; - } - if self.collect_stat { - struct_ser.serialize_field("collectStat", &self.collect_stat)?; - } - if self.target_partitions != 0 { - struct_ser.serialize_field("targetPartitions", &self.target_partitions)?; - } - if !self.file_sort_order.is_empty() { - struct_ser.serialize_field("fileSortOrder", &self.file_sort_order)?; + let mut struct_ser = serializer.serialize_struct("datafusion.GetIndexedField", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } - if let Some(v) = self.file_format_type.as_ref() { - match v { - listing_table_scan_node::FileFormatType::Csv(v) => { - struct_ser.serialize_field("csv", v)?; - } - listing_table_scan_node::FileFormatType::Parquet(v) => { - struct_ser.serialize_field("parquet", v)?; - } - listing_table_scan_node::FileFormatType::Avro(v) => { - struct_ser.serialize_field("avro", v)?; - } - } + if let Some(v) = self.key.as_ref() { + struct_ser.serialize_field("key", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ListingTableScanNode { +impl<'de> serde::Deserialize<'de> for GetIndexedField { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "table_name", - "tableName", - "paths", - "file_extension", - "fileExtension", - "projection", - "schema", - "filters", - "table_partition_cols", - "tablePartitionCols", - "collect_stat", - "collectStat", - "target_partitions", - "targetPartitions", - "file_sort_order", - "fileSortOrder", - "csv", - "parquet", - "avro", + "expr", + "key", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - TableName, - Paths, - FileExtension, - Projection, - Schema, - Filters, - TablePartitionCols, - CollectStat, - TargetPartitions, - FileSortOrder, - Csv, - Parquet, - Avro, + Expr, + Key, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7000,19 +7373,8 @@ impl<'de> serde::Deserialize<'de> for ListingTableScanNode { E: serde::de::Error, { match value { - "tableName" | "table_name" => Ok(GeneratedField::TableName), - "paths" => Ok(GeneratedField::Paths), - "fileExtension" | "file_extension" => Ok(GeneratedField::FileExtension), - "projection" => Ok(GeneratedField::Projection), - "schema" => Ok(GeneratedField::Schema), - "filters" => Ok(GeneratedField::Filters), - "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), - "collectStat" | "collect_stat" => Ok(GeneratedField::CollectStat), - "targetPartitions" | "target_partitions" => Ok(GeneratedField::TargetPartitions), - "fileSortOrder" | "file_sort_order" => Ok(GeneratedField::FileSortOrder), - "csv" => Ok(GeneratedField::Csv), - "parquet" => Ok(GeneratedField::Parquet), - "avro" => Ok(GeneratedField::Avro), + "expr" => Ok(GeneratedField::Expr), + "key" => Ok(GeneratedField::Key), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7022,133 +7384,44 @@ impl<'de> serde::Deserialize<'de> for ListingTableScanNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListingTableScanNode; + type Value = GetIndexedField; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ListingTableScanNode") + formatter.write_str("struct datafusion.GetIndexedField") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut table_name__ = None; - let mut paths__ = None; - let mut file_extension__ = None; - let mut projection__ = None; - let mut schema__ = None; - let mut filters__ = None; - let mut table_partition_cols__ = None; - let mut collect_stat__ = None; - let mut target_partitions__ = None; - let mut file_sort_order__ = None; - let mut file_format_type__ = None; + let mut expr__ = None; + let mut key__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::TableName => { - if table_name__.is_some() { - return Err(serde::de::Error::duplicate_field("tableName")); - } - table_name__ = Some(map.next_value()?); - } - GeneratedField::Paths => { - if paths__.is_some() { - return Err(serde::de::Error::duplicate_field("paths")); - } - paths__ = Some(map.next_value()?); - } - GeneratedField::FileExtension => { - if file_extension__.is_some() { - return Err(serde::de::Error::duplicate_field("fileExtension")); - } - file_extension__ = Some(map.next_value()?); - } - GeneratedField::Projection => { - if projection__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - projection__ = map.next_value()?; - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::Filters => { - if filters__.is_some() { - return Err(serde::de::Error::duplicate_field("filters")); - } - filters__ = Some(map.next_value()?); - } - GeneratedField::TablePartitionCols => { - if table_partition_cols__.is_some() { - return Err(serde::de::Error::duplicate_field("tablePartitionCols")); - } - table_partition_cols__ = Some(map.next_value()?); - } - GeneratedField::CollectStat => { - if collect_stat__.is_some() { - return Err(serde::de::Error::duplicate_field("collectStat")); - } - collect_stat__ = Some(map.next_value()?); - } - GeneratedField::TargetPartitions => { - if target_partitions__.is_some() { - return Err(serde::de::Error::duplicate_field("targetPartitions")); - } - target_partitions__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::FileSortOrder => { - if file_sort_order__.is_some() { - return Err(serde::de::Error::duplicate_field("fileSortOrder")); - } - file_sort_order__ = Some(map.next_value()?); - } - GeneratedField::Csv => { - if file_format_type__.is_some() { - return Err(serde::de::Error::duplicate_field("csv")); - } - file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Csv) -; - } - GeneratedField::Parquet => { - if file_format_type__.is_some() { - return Err(serde::de::Error::duplicate_field("parquet")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Parquet) -; + expr__ = map.next_value()?; } - GeneratedField::Avro => { - if file_format_type__.is_some() { - return Err(serde::de::Error::duplicate_field("avro")); + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); } - file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Avro) -; + key__ = map.next_value()?; } } } - Ok(ListingTableScanNode { - table_name: table_name__.unwrap_or_default(), - paths: paths__.unwrap_or_default(), - file_extension: file_extension__.unwrap_or_default(), - projection: projection__, - schema: schema__, - filters: filters__.unwrap_or_default(), - table_partition_cols: table_partition_cols__.unwrap_or_default(), - collect_stat: collect_stat__.unwrap_or_default(), - target_partitions: target_partitions__.unwrap_or_default(), - file_sort_order: file_sort_order__.unwrap_or_default(), - file_format_type: file_format_type__, + Ok(GetIndexedField { + expr: expr__, + key: key__, }) } } - deserializer.deserialize_struct("datafusion.ListingTableScanNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.GetIndexedField", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for LogicalExprList { +impl serde::Serialize for GlobalLimitExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7156,29 +7429,45 @@ impl serde::Serialize for LogicalExprList { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.expr.is_empty() { + if self.input.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprList", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; + if self.skip != 0 { + len += 1; + } + if self.fetch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.GlobalLimitExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.skip != 0 { + struct_ser.serialize_field("skip", &self.skip)?; + } + if self.fetch != 0 { + struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for LogicalExprList { +impl<'de> serde::Deserialize<'de> for GlobalLimitExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "expr", + "input", + "skip", + "fetch", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Expr, + Input, + Skip, + Fetch, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7200,7 +7489,9 @@ impl<'de> serde::Deserialize<'de> for LogicalExprList { E: serde::de::Error, { match value { - "expr" => Ok(GeneratedField::Expr), + "input" => Ok(GeneratedField::Input), + "skip" => Ok(GeneratedField::Skip), + "fetch" => Ok(GeneratedField::Fetch), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7210,36 +7501,56 @@ impl<'de> serde::Deserialize<'de> for LogicalExprList { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalExprList; + type Value = GlobalLimitExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalExprList") + formatter.write_str("struct datafusion.GlobalLimitExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr__ = None; + let mut input__ = None; + let mut skip__ = None; + let mut fetch__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - expr__ = 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) + ; + } + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); + } + fetch__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(LogicalExprList { - expr: expr__.unwrap_or_default(), + Ok(GlobalLimitExecNode { + input: input__, + skip: skip__.unwrap_or_default(), + fetch: fetch__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.LogicalExprList", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.GlobalLimitExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for LogicalExprNode { +impl serde::Serialize for GroupingSetNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7247,214 +7558,29 @@ impl serde::Serialize for LogicalExprNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr_type.is_some() { + if !self.expr.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNode", len)?; - if let Some(v) = self.expr_type.as_ref() { - match v { - logical_expr_node::ExprType::Column(v) => { - struct_ser.serialize_field("column", v)?; - } - logical_expr_node::ExprType::Alias(v) => { - struct_ser.serialize_field("alias", v)?; - } - logical_expr_node::ExprType::Literal(v) => { - struct_ser.serialize_field("literal", v)?; - } - logical_expr_node::ExprType::BinaryExpr(v) => { - struct_ser.serialize_field("binaryExpr", v)?; - } - logical_expr_node::ExprType::AggregateExpr(v) => { - struct_ser.serialize_field("aggregateExpr", v)?; - } - logical_expr_node::ExprType::IsNullExpr(v) => { - struct_ser.serialize_field("isNullExpr", v)?; - } - logical_expr_node::ExprType::IsNotNullExpr(v) => { - struct_ser.serialize_field("isNotNullExpr", v)?; - } - logical_expr_node::ExprType::NotExpr(v) => { - struct_ser.serialize_field("notExpr", v)?; - } - logical_expr_node::ExprType::Between(v) => { - struct_ser.serialize_field("between", v)?; - } - logical_expr_node::ExprType::Case(v) => { - struct_ser.serialize_field("case", v)?; - } - logical_expr_node::ExprType::Cast(v) => { - struct_ser.serialize_field("cast", v)?; - } - logical_expr_node::ExprType::Sort(v) => { - struct_ser.serialize_field("sort", v)?; - } - logical_expr_node::ExprType::Negative(v) => { - struct_ser.serialize_field("negative", v)?; - } - logical_expr_node::ExprType::InList(v) => { - struct_ser.serialize_field("inList", v)?; - } - logical_expr_node::ExprType::Wildcard(v) => { - struct_ser.serialize_field("wildcard", v)?; - } - logical_expr_node::ExprType::ScalarFunction(v) => { - struct_ser.serialize_field("scalarFunction", v)?; - } - logical_expr_node::ExprType::TryCast(v) => { - struct_ser.serialize_field("tryCast", v)?; - } - logical_expr_node::ExprType::WindowExpr(v) => { - struct_ser.serialize_field("windowExpr", v)?; - } - logical_expr_node::ExprType::AggregateUdfExpr(v) => { - struct_ser.serialize_field("aggregateUdfExpr", v)?; - } - logical_expr_node::ExprType::ScalarUdfExpr(v) => { - struct_ser.serialize_field("scalarUdfExpr", v)?; - } - logical_expr_node::ExprType::GetIndexedField(v) => { - struct_ser.serialize_field("getIndexedField", v)?; - } - logical_expr_node::ExprType::GroupingSet(v) => { - struct_ser.serialize_field("groupingSet", v)?; - } - logical_expr_node::ExprType::Cube(v) => { - struct_ser.serialize_field("cube", v)?; - } - logical_expr_node::ExprType::Rollup(v) => { - struct_ser.serialize_field("rollup", v)?; - } - logical_expr_node::ExprType::IsTrue(v) => { - struct_ser.serialize_field("isTrue", v)?; - } - logical_expr_node::ExprType::IsFalse(v) => { - struct_ser.serialize_field("isFalse", v)?; - } - logical_expr_node::ExprType::IsUnknown(v) => { - struct_ser.serialize_field("isUnknown", v)?; - } - logical_expr_node::ExprType::IsNotTrue(v) => { - struct_ser.serialize_field("isNotTrue", v)?; - } - logical_expr_node::ExprType::IsNotFalse(v) => { - struct_ser.serialize_field("isNotFalse", v)?; - } - logical_expr_node::ExprType::IsNotUnknown(v) => { - struct_ser.serialize_field("isNotUnknown", v)?; - } - logical_expr_node::ExprType::Like(v) => { - struct_ser.serialize_field("like", v)?; - } - logical_expr_node::ExprType::Ilike(v) => { - struct_ser.serialize_field("ilike", v)?; - } - logical_expr_node::ExprType::SimilarTo(v) => { - struct_ser.serialize_field("similarTo", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("datafusion.GroupingSetNode", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for LogicalExprNode { +impl<'de> serde::Deserialize<'de> for GroupingSetNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "column", - "alias", - "literal", - "binary_expr", - "binaryExpr", - "aggregate_expr", - "aggregateExpr", - "is_null_expr", - "isNullExpr", - "is_not_null_expr", - "isNotNullExpr", - "not_expr", - "notExpr", - "between", - "case_", - "case", - "cast", - "sort", - "negative", - "in_list", - "inList", - "wildcard", - "scalar_function", - "scalarFunction", - "try_cast", - "tryCast", - "window_expr", - "windowExpr", - "aggregate_udf_expr", - "aggregateUdfExpr", - "scalar_udf_expr", - "scalarUdfExpr", - "get_indexed_field", - "getIndexedField", - "grouping_set", - "groupingSet", - "cube", - "rollup", - "is_true", - "isTrue", - "is_false", - "isFalse", - "is_unknown", - "isUnknown", - "is_not_true", - "isNotTrue", - "is_not_false", - "isNotFalse", - "is_not_unknown", - "isNotUnknown", - "like", - "ilike", - "similar_to", - "similarTo", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Column, - Alias, - Literal, - BinaryExpr, - AggregateExpr, - IsNullExpr, - IsNotNullExpr, - NotExpr, - Between, - Case, - Cast, - Sort, - Negative, - InList, - Wildcard, - ScalarFunction, - TryCast, - WindowExpr, - AggregateUdfExpr, - ScalarUdfExpr, - GetIndexedField, - GroupingSet, - Cube, - Rollup, - IsTrue, - IsFalse, - IsUnknown, - IsNotTrue, - IsNotFalse, - IsNotUnknown, - Like, - Ilike, - SimilarTo, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7476,39 +7602,7 @@ impl<'de> serde::Deserialize<'de> for LogicalExprNode { E: serde::de::Error, { match value { - "column" => Ok(GeneratedField::Column), - "alias" => Ok(GeneratedField::Alias), - "literal" => Ok(GeneratedField::Literal), - "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr), - "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr), - "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr), - "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr), - "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr), - "between" => Ok(GeneratedField::Between), - "case" | "case_" => Ok(GeneratedField::Case), - "cast" => Ok(GeneratedField::Cast), - "sort" => Ok(GeneratedField::Sort), - "negative" => Ok(GeneratedField::Negative), - "inList" | "in_list" => Ok(GeneratedField::InList), - "wildcard" => Ok(GeneratedField::Wildcard), - "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction), - "tryCast" | "try_cast" => Ok(GeneratedField::TryCast), - "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), - "aggregateUdfExpr" | "aggregate_udf_expr" => Ok(GeneratedField::AggregateUdfExpr), - "scalarUdfExpr" | "scalar_udf_expr" => Ok(GeneratedField::ScalarUdfExpr), - "getIndexedField" | "get_indexed_field" => Ok(GeneratedField::GetIndexedField), - "groupingSet" | "grouping_set" => Ok(GeneratedField::GroupingSet), - "cube" => Ok(GeneratedField::Cube), - "rollup" => Ok(GeneratedField::Rollup), - "isTrue" | "is_true" => Ok(GeneratedField::IsTrue), - "isFalse" | "is_false" => Ok(GeneratedField::IsFalse), - "isUnknown" | "is_unknown" => Ok(GeneratedField::IsUnknown), - "isNotTrue" | "is_not_true" => Ok(GeneratedField::IsNotTrue), - "isNotFalse" | "is_not_false" => Ok(GeneratedField::IsNotFalse), - "isNotUnknown" | "is_not_unknown" => Ok(GeneratedField::IsNotUnknown), - "like" => Ok(GeneratedField::Like), - "ilike" => Ok(GeneratedField::Ilike), - "similarTo" | "similar_to" => Ok(GeneratedField::SimilarTo), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -7518,260 +7612,36 @@ impl<'de> serde::Deserialize<'de> for LogicalExprNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalExprNode; + type Value = GroupingSetNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalExprNode") + formatter.write_str("struct datafusion.GroupingSetNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut expr_type__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Column => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("column")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Column) -; - } - GeneratedField::Alias => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("alias")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Alias) -; - } - GeneratedField::Literal => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("literal")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Literal) -; - } - GeneratedField::BinaryExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("binaryExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::BinaryExpr) -; - } - GeneratedField::AggregateExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregateExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateExpr) -; - } - GeneratedField::IsNullExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNullExpr")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNullExpr) -; - } - GeneratedField::IsNotNullExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotNullExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotNullExpr) -; - } - GeneratedField::NotExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("notExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::NotExpr) -; - } - GeneratedField::Between => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("between")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Between) -; - } - GeneratedField::Case => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("case")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Case) -; - } - GeneratedField::Cast => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("cast")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cast) -; - } - GeneratedField::Sort => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("sort")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Sort) -; - } - GeneratedField::Negative => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("negative")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Negative) -; - } - GeneratedField::InList => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("inList")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::InList) -; - } - GeneratedField::Wildcard => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("wildcard")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Wildcard); - } - GeneratedField::ScalarFunction => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("scalarFunction")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarFunction) -; - } - GeneratedField::TryCast => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("tryCast")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::TryCast) -; - } - GeneratedField::WindowExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("windowExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::WindowExpr) -; - } - GeneratedField::AggregateUdfExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregateUdfExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateUdfExpr) -; - } - GeneratedField::ScalarUdfExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("scalarUdfExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarUdfExpr) -; - } - GeneratedField::GetIndexedField => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("getIndexedField")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GetIndexedField) -; - } - GeneratedField::GroupingSet => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("groupingSet")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GroupingSet) -; - } - GeneratedField::Cube => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("cube")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cube) -; - } - GeneratedField::Rollup => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("rollup")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Rollup) -; - } - GeneratedField::IsTrue => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isTrue")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsTrue) -; - } - GeneratedField::IsFalse => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isFalse")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsFalse) -; - } - GeneratedField::IsUnknown => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isUnknown")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsUnknown) -; - } - GeneratedField::IsNotTrue => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotTrue")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotTrue) -; - } - GeneratedField::IsNotFalse => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotFalse")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotFalse) -; - } - GeneratedField::IsNotUnknown => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotUnknown")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotUnknown) -; - } - GeneratedField::Like => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("like")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Like) -; - } - GeneratedField::Ilike => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("ilike")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Ilike) -; - } - GeneratedField::SimilarTo => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("similarTo")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::SimilarTo) -; + expr__ = Some(map.next_value()?); } } } - Ok(LogicalExprNode { - expr_type: expr_type__, + Ok(GroupingSetNode { + expr: expr__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.LogicalExprNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.GroupingSetNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for LogicalExtensionNode { +impl serde::Serialize for HashJoinExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7779,37 +7649,84 @@ impl serde::Serialize for LogicalExtensionNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.node.is_empty() { + if self.left.is_some() { len += 1; } - if !self.inputs.is_empty() { + if self.right.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExtensionNode", len)?; - if !self.node.is_empty() { - struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?; + if !self.on.is_empty() { + len += 1; } - if !self.inputs.is_empty() { - struct_ser.serialize_field("inputs", &self.inputs)?; + if self.join_type != 0 { + len += 1; + } + if self.partition_mode != 0 { + len += 1; + } + if self.null_equals_null { + len += 1; + } + if self.filter.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.HashJoinExecNode", len)?; + if let Some(v) = self.left.as_ref() { + struct_ser.serialize_field("left", v)?; + } + if let Some(v) = self.right.as_ref() { + struct_ser.serialize_field("right", v)?; + } + if !self.on.is_empty() { + struct_ser.serialize_field("on", &self.on)?; + } + if self.join_type != 0 { + let v = JoinType::from_i32(self.join_type) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?; + struct_ser.serialize_field("joinType", &v)?; + } + if self.partition_mode != 0 { + let v = PartitionMode::from_i32(self.partition_mode) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.partition_mode)))?; + struct_ser.serialize_field("partitionMode", &v)?; + } + if self.null_equals_null { + struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?; + } + if let Some(v) = self.filter.as_ref() { + struct_ser.serialize_field("filter", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for LogicalExtensionNode { +impl<'de> serde::Deserialize<'de> for HashJoinExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "node", - "inputs", + "left", + "right", + "on", + "join_type", + "joinType", + "partition_mode", + "partitionMode", + "null_equals_null", + "nullEqualsNull", + "filter", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Node, - Inputs, + Left, + Right, + On, + JoinType, + PartitionMode, + NullEqualsNull, + Filter, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -7831,57 +7748,100 @@ impl<'de> serde::Deserialize<'de> for LogicalExtensionNode { E: serde::de::Error, { match value { - "node" => Ok(GeneratedField::Node), - "inputs" => Ok(GeneratedField::Inputs), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } + "left" => Ok(GeneratedField::Left), + "right" => Ok(GeneratedField::Right), + "on" => Ok(GeneratedField::On), + "joinType" | "join_type" => Ok(GeneratedField::JoinType), + "partitionMode" | "partition_mode" => Ok(GeneratedField::PartitionMode), + "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull), + "filter" => Ok(GeneratedField::Filter), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } } deserializer.deserialize_identifier(GeneratedVisitor) } } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalExtensionNode; + type Value = HashJoinExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalExtensionNode") + formatter.write_str("struct datafusion.HashJoinExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut node__ = None; - let mut inputs__ = None; + let mut left__ = None; + let mut right__ = None; + let mut on__ = None; + let mut join_type__ = None; + let mut partition_mode__ = None; + let mut null_equals_null__ = None; + let mut filter__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Node => { - if node__.is_some() { - return Err(serde::de::Error::duplicate_field("node")); + GeneratedField::Left => { + if left__.is_some() { + return Err(serde::de::Error::duplicate_field("left")); } - node__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + left__ = map.next_value()?; } - GeneratedField::Inputs => { - if inputs__.is_some() { - return Err(serde::de::Error::duplicate_field("inputs")); + GeneratedField::Right => { + if right__.is_some() { + return Err(serde::de::Error::duplicate_field("right")); } - inputs__ = Some(map.next_value()?); + right__ = map.next_value()?; + } + GeneratedField::On => { + if on__.is_some() { + return Err(serde::de::Error::duplicate_field("on")); + } + on__ = Some(map.next_value()?); + } + GeneratedField::JoinType => { + if join_type__.is_some() { + return Err(serde::de::Error::duplicate_field("joinType")); + } + join_type__ = Some(map.next_value::()? as i32); + } + GeneratedField::PartitionMode => { + if partition_mode__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionMode")); + } + partition_mode__ = Some(map.next_value::()? as i32); + } + GeneratedField::NullEqualsNull => { + if null_equals_null__.is_some() { + return Err(serde::de::Error::duplicate_field("nullEqualsNull")); + } + null_equals_null__ = Some(map.next_value()?); + } + GeneratedField::Filter => { + if filter__.is_some() { + return Err(serde::de::Error::duplicate_field("filter")); + } + filter__ = map.next_value()?; } } } - Ok(LogicalExtensionNode { - node: node__.unwrap_or_default(), - inputs: inputs__.unwrap_or_default(), + Ok(HashJoinExecNode { + left: left__, + right: right__, + on: on__.unwrap_or_default(), + join_type: join_type__.unwrap_or_default(), + partition_mode: partition_mode__.unwrap_or_default(), + null_equals_null: null_equals_null__.unwrap_or_default(), + filter: filter__, }) } } - deserializer.deserialize_struct("datafusion.LogicalExtensionNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.HashJoinExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for LogicalPlanNode { +impl serde::Serialize for HashRepartition { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -7889,158 +7849,39 @@ impl serde::Serialize for LogicalPlanNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.logical_plan_type.is_some() { + if !self.hash_expr.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalPlanNode", len)?; - if let Some(v) = self.logical_plan_type.as_ref() { - match v { - logical_plan_node::LogicalPlanType::ListingScan(v) => { - struct_ser.serialize_field("listingScan", v)?; - } - logical_plan_node::LogicalPlanType::Projection(v) => { - struct_ser.serialize_field("projection", v)?; - } - logical_plan_node::LogicalPlanType::Selection(v) => { - struct_ser.serialize_field("selection", v)?; - } - logical_plan_node::LogicalPlanType::Limit(v) => { - struct_ser.serialize_field("limit", v)?; - } - logical_plan_node::LogicalPlanType::Aggregate(v) => { - struct_ser.serialize_field("aggregate", v)?; - } - logical_plan_node::LogicalPlanType::Join(v) => { - struct_ser.serialize_field("join", v)?; - } - logical_plan_node::LogicalPlanType::Sort(v) => { - struct_ser.serialize_field("sort", v)?; - } - logical_plan_node::LogicalPlanType::Repartition(v) => { - struct_ser.serialize_field("repartition", v)?; - } - logical_plan_node::LogicalPlanType::EmptyRelation(v) => { - struct_ser.serialize_field("emptyRelation", v)?; - } - logical_plan_node::LogicalPlanType::CreateExternalTable(v) => { - struct_ser.serialize_field("createExternalTable", v)?; - } - logical_plan_node::LogicalPlanType::Explain(v) => { - struct_ser.serialize_field("explain", v)?; - } - logical_plan_node::LogicalPlanType::Window(v) => { - struct_ser.serialize_field("window", v)?; - } - logical_plan_node::LogicalPlanType::Analyze(v) => { - struct_ser.serialize_field("analyze", v)?; - } - logical_plan_node::LogicalPlanType::CrossJoin(v) => { - struct_ser.serialize_field("crossJoin", v)?; - } - logical_plan_node::LogicalPlanType::Values(v) => { - struct_ser.serialize_field("values", v)?; - } - logical_plan_node::LogicalPlanType::Extension(v) => { - struct_ser.serialize_field("extension", v)?; - } - logical_plan_node::LogicalPlanType::CreateCatalogSchema(v) => { - struct_ser.serialize_field("createCatalogSchema", v)?; - } - logical_plan_node::LogicalPlanType::Union(v) => { - struct_ser.serialize_field("union", v)?; - } - logical_plan_node::LogicalPlanType::CreateCatalog(v) => { - struct_ser.serialize_field("createCatalog", v)?; - } - logical_plan_node::LogicalPlanType::SubqueryAlias(v) => { - struct_ser.serialize_field("subqueryAlias", v)?; - } - logical_plan_node::LogicalPlanType::CreateView(v) => { - struct_ser.serialize_field("createView", v)?; - } - logical_plan_node::LogicalPlanType::Distinct(v) => { - struct_ser.serialize_field("distinct", v)?; - } - logical_plan_node::LogicalPlanType::ViewScan(v) => { - struct_ser.serialize_field("viewScan", v)?; - } - logical_plan_node::LogicalPlanType::CustomScan(v) => { - struct_ser.serialize_field("customScan", v)?; - } - } + if self.partition_count != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.HashRepartition", len)?; + if !self.hash_expr.is_empty() { + struct_ser.serialize_field("hashExpr", &self.hash_expr)?; + } + if self.partition_count != 0 { + struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for LogicalPlanNode { +impl<'de> serde::Deserialize<'de> for HashRepartition { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "listing_scan", - "listingScan", - "projection", - "selection", - "limit", - "aggregate", - "join", - "sort", - "repartition", - "empty_relation", - "emptyRelation", - "create_external_table", - "createExternalTable", - "explain", - "window", - "analyze", - "cross_join", - "crossJoin", - "values", - "extension", - "create_catalog_schema", - "createCatalogSchema", - "union", - "create_catalog", - "createCatalog", - "subquery_alias", - "subqueryAlias", - "create_view", - "createView", - "distinct", - "view_scan", - "viewScan", - "custom_scan", - "customScan", + "hash_expr", + "hashExpr", + "partition_count", + "partitionCount", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - ListingScan, - Projection, - Selection, - Limit, - Aggregate, - Join, - Sort, - Repartition, - EmptyRelation, - CreateExternalTable, - Explain, - Window, - Analyze, - CrossJoin, - Values, - Extension, - CreateCatalogSchema, - Union, - CreateCatalog, - SubqueryAlias, - CreateView, - Distinct, - ViewScan, - CustomScan, + HashExpr, + PartitionCount, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8062,30 +7903,8 @@ impl<'de> serde::Deserialize<'de> for LogicalPlanNode { E: serde::de::Error, { match value { - "listingScan" | "listing_scan" => Ok(GeneratedField::ListingScan), - "projection" => Ok(GeneratedField::Projection), - "selection" => Ok(GeneratedField::Selection), - "limit" => Ok(GeneratedField::Limit), - "aggregate" => Ok(GeneratedField::Aggregate), - "join" => Ok(GeneratedField::Join), - "sort" => Ok(GeneratedField::Sort), - "repartition" => Ok(GeneratedField::Repartition), - "emptyRelation" | "empty_relation" => Ok(GeneratedField::EmptyRelation), - "createExternalTable" | "create_external_table" => Ok(GeneratedField::CreateExternalTable), - "explain" => Ok(GeneratedField::Explain), - "window" => Ok(GeneratedField::Window), - "analyze" => Ok(GeneratedField::Analyze), - "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin), - "values" => Ok(GeneratedField::Values), - "extension" => Ok(GeneratedField::Extension), - "createCatalogSchema" | "create_catalog_schema" => Ok(GeneratedField::CreateCatalogSchema), - "union" => Ok(GeneratedField::Union), - "createCatalog" | "create_catalog" => Ok(GeneratedField::CreateCatalog), - "subqueryAlias" | "subquery_alias" => Ok(GeneratedField::SubqueryAlias), - "createView" | "create_view" => Ok(GeneratedField::CreateView), - "distinct" => Ok(GeneratedField::Distinct), - "viewScan" | "view_scan" => Ok(GeneratedField::ViewScan), - "customScan" | "custom_scan" => Ok(GeneratedField::CustomScan), + "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr), + "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8095,198 +7914,46 @@ impl<'de> serde::Deserialize<'de> for LogicalPlanNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalPlanNode; + type Value = HashRepartition; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalPlanNode") + formatter.write_str("struct datafusion.HashRepartition") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut logical_plan_type__ = None; - while let Some(k) = map.next_key()? { + let mut hash_expr__ = None; + let mut partition_count__ = None; + while let Some(k) = map.next_key()? { match k { - GeneratedField::ListingScan => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("listingScan")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ListingScan) -; - } - GeneratedField::Projection => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Projection) -; - } - GeneratedField::Selection => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("selection")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Selection) -; - } - GeneratedField::Limit => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("limit")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Limit) -; - } - GeneratedField::Aggregate => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregate")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Aggregate) -; - } - GeneratedField::Join => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("join")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Join) -; - } - GeneratedField::Sort => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("sort")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Sort) -; - } - GeneratedField::Repartition => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("repartition")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Repartition) -; - } - GeneratedField::EmptyRelation => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("emptyRelation")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::EmptyRelation) -; - } - GeneratedField::CreateExternalTable => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createExternalTable")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateExternalTable) -; - } - GeneratedField::Explain => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("explain")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Explain) -; - } - GeneratedField::Window => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("window")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Window) -; - } - GeneratedField::Analyze => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("analyze")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Analyze) -; - } - GeneratedField::CrossJoin => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("crossJoin")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CrossJoin) -; - } - GeneratedField::Values => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("values")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Values) -; - } - GeneratedField::Extension => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("extension")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Extension) -; - } - GeneratedField::CreateCatalogSchema => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createCatalogSchema")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalogSchema) -; - } - GeneratedField::Union => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("union")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Union) -; - } - GeneratedField::CreateCatalog => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createCatalog")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalog) -; - } - GeneratedField::SubqueryAlias => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("subqueryAlias")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::SubqueryAlias) -; - } - GeneratedField::CreateView => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createView")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateView) -; - } - GeneratedField::Distinct => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("distinct")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Distinct) -; - } - GeneratedField::ViewScan => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("viewScan")); + GeneratedField::HashExpr => { + if hash_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("hashExpr")); } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ViewScan) -; + hash_expr__ = Some(map.next_value()?); } - GeneratedField::CustomScan => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("customScan")); + GeneratedField::PartitionCount => { + if partition_count__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionCount")); } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CustomScan) -; + partition_count__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(LogicalPlanNode { - logical_plan_type: logical_plan_type__, + Ok(HashRepartition { + hash_expr: hash_expr__.unwrap_or_default(), + partition_count: partition_count__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.LogicalPlanNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.HashRepartition", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for NegativeNode { +impl serde::Serialize for ILikeNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8294,29 +7961,54 @@ impl serde::Serialize for NegativeNode { { use serde::ser::SerializeStruct; let mut len = 0; + if self.negated { + len += 1; + } if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.NegativeNode", len)?; + if self.pattern.is_some() { + len += 1; + } + if !self.escape_char.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ILikeNode", len)?; + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } if let Some(v) = self.expr.as_ref() { struct_ser.serialize_field("expr", v)?; } + if let Some(v) = self.pattern.as_ref() { + struct_ser.serialize_field("pattern", v)?; + } + if !self.escape_char.is_empty() { + struct_ser.serialize_field("escapeChar", &self.escape_char)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for NegativeNode { +impl<'de> serde::Deserialize<'de> for ILikeNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "negated", "expr", + "pattern", + "escape_char", + "escapeChar", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Negated, Expr, + Pattern, + EscapeChar, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8338,7 +8030,10 @@ impl<'de> serde::Deserialize<'de> for NegativeNode { E: serde::de::Error, { match value { + "negated" => Ok(GeneratedField::Negated), "expr" => Ok(GeneratedField::Expr), + "pattern" => Ok(GeneratedField::Pattern), + "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8348,36 +8043,60 @@ impl<'de> serde::Deserialize<'de> for NegativeNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = NegativeNode; + type Value = ILikeNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.NegativeNode") + formatter.write_str("struct datafusion.ILikeNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { + let mut negated__ = None; let mut expr__ = None; + let mut pattern__ = None; + let mut escape_char__ = None; while let Some(k) = map.next_key()? { match k { + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } GeneratedField::Expr => { if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } expr__ = map.next_value()?; } + GeneratedField::Pattern => { + if pattern__.is_some() { + return Err(serde::de::Error::duplicate_field("pattern")); + } + pattern__ = map.next_value()?; + } + GeneratedField::EscapeChar => { + if escape_char__.is_some() { + return Err(serde::de::Error::duplicate_field("escapeChar")); + } + escape_char__ = Some(map.next_value()?); + } } } - Ok(NegativeNode { + Ok(ILikeNode { + negated: negated__.unwrap_or_default(), expr: expr__, + pattern: pattern__, + escape_char: escape_char__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.NegativeNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ILikeNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Not { +impl serde::Serialize for InListNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8388,14 +8107,26 @@ impl serde::Serialize for Not { if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.Not", len)?; - if let Some(v) = self.expr.as_ref() { + if !self.list.is_empty() { + len += 1; + } + if self.negated { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.InListNode", len)?; + if let Some(v) = self.expr.as_ref() { struct_ser.serialize_field("expr", v)?; } + if !self.list.is_empty() { + struct_ser.serialize_field("list", &self.list)?; + } + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Not { +impl<'de> serde::Deserialize<'de> for InListNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -8403,11 +8134,15 @@ impl<'de> serde::Deserialize<'de> for Not { { const FIELDS: &[&str] = &[ "expr", + "list", + "negated", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { Expr, + List, + Negated, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8430,6 +8165,8 @@ impl<'de> serde::Deserialize<'de> for Not { { match value { "expr" => Ok(GeneratedField::Expr), + "list" => Ok(GeneratedField::List), + "negated" => Ok(GeneratedField::Negated), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8439,17 +8176,19 @@ impl<'de> serde::Deserialize<'de> for Not { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Not; + type Value = InListNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Not") + formatter.write_str("struct datafusion.InListNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { let mut expr__ = None; + let mut list__ = None; + let mut negated__ = None; while let Some(k) = map.next_key()? { match k { GeneratedField::Expr => { @@ -8458,17 +8197,31 @@ impl<'de> serde::Deserialize<'de> for Not { } expr__ = map.next_value()?; } + GeneratedField::List => { + if list__.is_some() { + return Err(serde::de::Error::duplicate_field("list")); + } + list__ = Some(map.next_value()?); + } + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } } } - Ok(Not { + Ok(InListNode { expr: expr__, + list: list__.unwrap_or_default(), + negated: negated__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.Not", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.InListNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OptimizedLogicalPlanType { +impl serde::Serialize for IntervalMonthDayNanoValue { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8476,30 +8229,45 @@ impl serde::Serialize for OptimizedLogicalPlanType { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.optimizer_name.is_empty() { + if self.months != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedLogicalPlanType", len)?; - if !self.optimizer_name.is_empty() { - struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; + if self.days != 0 { + len += 1; + } + if self.nanos != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.IntervalMonthDayNanoValue", len)?; + if self.months != 0 { + struct_ser.serialize_field("months", &self.months)?; + } + if self.days != 0 { + struct_ser.serialize_field("days", &self.days)?; + } + if self.nanos != 0 { + struct_ser.serialize_field("nanos", ToString::to_string(&self.nanos).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType { +impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "optimizer_name", - "optimizerName", + "months", + "days", + "nanos", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - OptimizerName, + Months, + Days, + Nanos, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8521,7 +8289,9 @@ impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType { E: serde::de::Error, { match value { - "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName), + "months" => Ok(GeneratedField::Months), + "days" => Ok(GeneratedField::Days), + "nanos" => Ok(GeneratedField::Nanos), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8531,36 +8301,134 @@ impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OptimizedLogicalPlanType; + type Value = IntervalMonthDayNanoValue; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.OptimizedLogicalPlanType") + formatter.write_str("struct datafusion.IntervalMonthDayNanoValue") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut optimizer_name__ = None; + let mut months__ = None; + let mut days__ = None; + let mut nanos__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::OptimizerName => { - if optimizer_name__.is_some() { - return Err(serde::de::Error::duplicate_field("optimizerName")); + GeneratedField::Months => { + if months__.is_some() { + return Err(serde::de::Error::duplicate_field("months")); } - optimizer_name__ = Some(map.next_value()?); + months__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Days => { + if days__.is_some() { + return Err(serde::de::Error::duplicate_field("days")); + } + days__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Nanos => { + if nanos__.is_some() { + return Err(serde::de::Error::duplicate_field("nanos")); + } + nanos__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(OptimizedLogicalPlanType { - optimizer_name: optimizer_name__.unwrap_or_default(), + Ok(IntervalMonthDayNanoValue { + months: months__.unwrap_or_default(), + days: days__.unwrap_or_default(), + nanos: nanos__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.OptimizedLogicalPlanType", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IntervalMonthDayNanoValue", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for OptimizedPhysicalPlanType { +impl serde::Serialize for IntervalUnit { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::YearMonth => "YearMonth", + Self::DayTime => "DayTime", + Self::MonthDayNano => "MonthDayNano", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for IntervalUnit { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "YearMonth", + "DayTime", + "MonthDayNano", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IntervalUnit; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(IntervalUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(IntervalUnit::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "YearMonth" => Ok(IntervalUnit::YearMonth), + "DayTime" => Ok(IntervalUnit::DayTime), + "MonthDayNano" => Ok(IntervalUnit::MonthDayNano), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for IsFalse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8568,30 +8436,29 @@ impl serde::Serialize for OptimizedPhysicalPlanType { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.optimizer_name.is_empty() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedPhysicalPlanType", len)?; - if !self.optimizer_name.is_empty() { - struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; + let mut struct_ser = serializer.serialize_struct("datafusion.IsFalse", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType { +impl<'de> serde::Deserialize<'de> for IsFalse { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "optimizer_name", - "optimizerName", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - OptimizerName, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8613,7 +8480,7 @@ impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType { E: serde::de::Error, { match value { - "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8623,36 +8490,36 @@ impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OptimizedPhysicalPlanType; + type Value = IsFalse; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.OptimizedPhysicalPlanType") + formatter.write_str("struct datafusion.IsFalse") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut optimizer_name__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::OptimizerName => { - if optimizer_name__.is_some() { - return Err(serde::de::Error::duplicate_field("optimizerName")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - optimizer_name__ = Some(map.next_value()?); + expr__ = map.next_value()?; } } } - Ok(OptimizedPhysicalPlanType { - optimizer_name: optimizer_name__.unwrap_or_default(), + Ok(IsFalse { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.OptimizedPhysicalPlanType", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsFalse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ParquetFormat { +impl serde::Serialize for IsNotFalse { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8660,30 +8527,29 @@ impl serde::Serialize for ParquetFormat { { use serde::ser::SerializeStruct; let mut len = 0; - if self.enable_pruning { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ParquetFormat", len)?; - if self.enable_pruning { - struct_ser.serialize_field("enablePruning", &self.enable_pruning)?; + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotFalse", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ParquetFormat { +impl<'de> serde::Deserialize<'de> for IsNotFalse { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "enable_pruning", - "enablePruning", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - EnablePruning, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8705,7 +8571,7 @@ impl<'de> serde::Deserialize<'de> for ParquetFormat { E: serde::de::Error, { match value { - "enablePruning" | "enable_pruning" => Ok(GeneratedField::EnablePruning), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8715,36 +8581,36 @@ impl<'de> serde::Deserialize<'de> for ParquetFormat { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ParquetFormat; + type Value = IsNotFalse; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ParquetFormat") + formatter.write_str("struct datafusion.IsNotFalse") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut enable_pruning__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::EnablePruning => { - if enable_pruning__.is_some() { - return Err(serde::de::Error::duplicate_field("enablePruning")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - enable_pruning__ = Some(map.next_value()?); + expr__ = map.next_value()?; } } } - Ok(ParquetFormat { - enable_pruning: enable_pruning__.unwrap_or_default(), + Ok(IsNotFalse { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.ParquetFormat", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsNotFalse", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for PlanType { +impl serde::Serialize for IsNotNull { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8752,58 +8618,29 @@ impl serde::Serialize for PlanType { { use serde::ser::SerializeStruct; let mut len = 0; - if self.plan_type_enum.is_some() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.PlanType", len)?; - if let Some(v) = self.plan_type_enum.as_ref() { - match v { - plan_type::PlanTypeEnum::InitialLogicalPlan(v) => { - struct_ser.serialize_field("InitialLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::OptimizedLogicalPlan(v) => { - struct_ser.serialize_field("OptimizedLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::FinalLogicalPlan(v) => { - struct_ser.serialize_field("FinalLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::InitialPhysicalPlan(v) => { - struct_ser.serialize_field("InitialPhysicalPlan", v)?; - } - plan_type::PlanTypeEnum::OptimizedPhysicalPlan(v) => { - struct_ser.serialize_field("OptimizedPhysicalPlan", v)?; - } - plan_type::PlanTypeEnum::FinalPhysicalPlan(v) => { - struct_ser.serialize_field("FinalPhysicalPlan", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotNull", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for PlanType { +impl<'de> serde::Deserialize<'de> for IsNotNull { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "InitialLogicalPlan", - "OptimizedLogicalPlan", - "FinalLogicalPlan", - "InitialPhysicalPlan", - "OptimizedPhysicalPlan", - "FinalPhysicalPlan", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - InitialLogicalPlan, - OptimizedLogicalPlan, - FinalLogicalPlan, - InitialPhysicalPlan, - OptimizedPhysicalPlan, - FinalPhysicalPlan, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8825,12 +8662,7 @@ impl<'de> serde::Deserialize<'de> for PlanType { E: serde::de::Error, { match value { - "InitialLogicalPlan" => Ok(GeneratedField::InitialLogicalPlan), - "OptimizedLogicalPlan" => Ok(GeneratedField::OptimizedLogicalPlan), - "FinalLogicalPlan" => Ok(GeneratedField::FinalLogicalPlan), - "InitialPhysicalPlan" => Ok(GeneratedField::InitialPhysicalPlan), - "OptimizedPhysicalPlan" => Ok(GeneratedField::OptimizedPhysicalPlan), - "FinalPhysicalPlan" => Ok(GeneratedField::FinalPhysicalPlan), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8840,72 +8672,36 @@ impl<'de> serde::Deserialize<'de> for PlanType { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PlanType; + type Value = IsNotNull; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PlanType") + formatter.write_str("struct datafusion.IsNotNull") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut plan_type_enum__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::InitialLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("InitialLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialLogicalPlan) -; - } - GeneratedField::OptimizedLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("OptimizedLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedLogicalPlan) -; - } - GeneratedField::FinalLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FinalLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalLogicalPlan) -; - } - GeneratedField::InitialPhysicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialPhysicalPlan) -; - } - GeneratedField::OptimizedPhysicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedPhysicalPlan) -; - } - GeneratedField::FinalPhysicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalPhysicalPlan) -; + expr__ = map.next_value()?; } } } - Ok(PlanType { - plan_type_enum: plan_type_enum__, + Ok(IsNotNull { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.PlanType", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsNotNull", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ProjectionColumns { +impl serde::Serialize for IsNotTrue { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -8913,29 +8709,29 @@ impl serde::Serialize for ProjectionColumns { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.columns.is_empty() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionColumns", len)?; - if !self.columns.is_empty() { - struct_ser.serialize_field("columns", &self.columns)?; + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotTrue", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ProjectionColumns { +impl<'de> serde::Deserialize<'de> for IsNotTrue { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "columns", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Columns, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -8957,7 +8753,7 @@ impl<'de> serde::Deserialize<'de> for ProjectionColumns { E: serde::de::Error, { match value { - "columns" => Ok(GeneratedField::Columns), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -8967,36 +8763,36 @@ impl<'de> serde::Deserialize<'de> for ProjectionColumns { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProjectionColumns; + type Value = IsNotTrue; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ProjectionColumns") + formatter.write_str("struct datafusion.IsNotTrue") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut columns__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Columns => { - if columns__.is_some() { - return Err(serde::de::Error::duplicate_field("columns")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - columns__ = Some(map.next_value()?); + expr__ = map.next_value()?; } } } - Ok(ProjectionColumns { - columns: columns__.unwrap_or_default(), + Ok(IsNotTrue { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.ProjectionColumns", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsNotTrue", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ProjectionNode { +impl serde::Serialize for IsNotUnknown { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9004,49 +8800,29 @@ impl serde::Serialize for ProjectionNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.expr.is_empty() { - len += 1; - } - if self.optional_alias.is_some() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if let Some(v) = self.optional_alias.as_ref() { - match v { - projection_node::OptionalAlias::Alias(v) => { - struct_ser.serialize_field("alias", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNotUnknown", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ProjectionNode { +impl<'de> serde::Deserialize<'de> for IsNotUnknown { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "input", "expr", - "alias", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Input, Expr, - Alias, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9068,9 +8844,7 @@ impl<'de> serde::Deserialize<'de> for ProjectionNode { E: serde::de::Error, { match value { - "input" => Ok(GeneratedField::Input), "expr" => Ok(GeneratedField::Expr), - "alias" => Ok(GeneratedField::Alias), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9080,52 +8854,36 @@ impl<'de> serde::Deserialize<'de> for ProjectionNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProjectionNode; + type Value = IsNotUnknown; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ProjectionNode") + formatter.write_str("struct datafusion.IsNotUnknown") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut input__ = None; let mut expr__ = None; - let mut optional_alias__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } GeneratedField::Expr => { if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } - expr__ = Some(map.next_value()?); - } - GeneratedField::Alias => { - if optional_alias__.is_some() { - return Err(serde::de::Error::duplicate_field("alias")); - } - optional_alias__ = map.next_value::<::std::option::Option<_>>()?.map(projection_node::OptionalAlias::Alias); + expr__ = map.next_value()?; } } } - Ok(ProjectionNode { - input: input__, - expr: expr__.unwrap_or_default(), - optional_alias: optional_alias__, + Ok(IsNotUnknown { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.ProjectionNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsNotUnknown", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for RepartitionNode { +impl serde::Serialize for IsNull { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9133,47 +8891,29 @@ impl serde::Serialize for RepartitionNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.input.is_some() { + if self.expr.is_some() { len += 1; } - if self.partition_method.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.partition_method.as_ref() { - match v { - repartition_node::PartitionMethod::RoundRobin(v) => { - struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?; - } - repartition_node::PartitionMethod::Hash(v) => { - struct_ser.serialize_field("hash", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("datafusion.IsNull", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for RepartitionNode { +impl<'de> serde::Deserialize<'de> for IsNull { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "input", - "round_robin", - "roundRobin", - "hash", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Input, - RoundRobin, - Hash, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9195,9 +8935,7 @@ impl<'de> serde::Deserialize<'de> for RepartitionNode { E: serde::de::Error, { match value { - "input" => Ok(GeneratedField::Input), - "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin), - "hash" => Ok(GeneratedField::Hash), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9207,51 +8945,36 @@ impl<'de> serde::Deserialize<'de> for RepartitionNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = RepartitionNode; + type Value = IsNull; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.RepartitionNode") + formatter.write_str("struct datafusion.IsNull") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut input__ = None; - let mut partition_method__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::RoundRobin => { - if partition_method__.is_some() { - return Err(serde::de::Error::duplicate_field("roundRobin")); - } - partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_node::PartitionMethod::RoundRobin(x.0)); - } - GeneratedField::Hash => { - if partition_method__.is_some() { - return Err(serde::de::Error::duplicate_field("hash")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_node::PartitionMethod::Hash) -; + expr__ = map.next_value()?; } } } - Ok(RepartitionNode { - input: input__, - partition_method: partition_method__, + Ok(IsNull { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.RepartitionNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsNull", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for RollupNode { +impl serde::Serialize for IsTrue { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9259,17 +8982,17 @@ impl serde::Serialize for RollupNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.expr.is_empty() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.RollupNode", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; + let mut struct_ser = serializer.serialize_struct("datafusion.IsTrue", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for RollupNode { +impl<'de> serde::Deserialize<'de> for IsTrue { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where @@ -9313,13 +9036,13 @@ impl<'de> serde::Deserialize<'de> for RollupNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = RollupNode; + type Value = IsTrue; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.RollupNode") + formatter.write_str("struct datafusion.IsTrue") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { @@ -9330,19 +9053,19 @@ impl<'de> serde::Deserialize<'de> for RollupNode { if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } - expr__ = Some(map.next_value()?); + expr__ = map.next_value()?; } } } - Ok(RollupNode { - expr: expr__.unwrap_or_default(), + Ok(IsTrue { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.RollupNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsTrue", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarDictionaryValue { +impl serde::Serialize for IsUnknown { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9350,38 +9073,29 @@ impl serde::Serialize for ScalarDictionaryValue { { use serde::ser::SerializeStruct; let mut len = 0; - if self.index_type.is_some() { - len += 1; - } - if self.value.is_some() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarDictionaryValue", len)?; - if let Some(v) = self.index_type.as_ref() { - struct_ser.serialize_field("indexType", v)?; - } - if let Some(v) = self.value.as_ref() { - struct_ser.serialize_field("value", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.IsUnknown", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue { +impl<'de> serde::Deserialize<'de> for IsUnknown { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "index_type", - "indexType", - "value", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - IndexType, - Value, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9403,8 +9117,7 @@ impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue { E: serde::de::Error, { match value { - "indexType" | "index_type" => Ok(GeneratedField::IndexType), - "value" => Ok(GeneratedField::Value), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9414,44 +9127,109 @@ impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarDictionaryValue; + type Value = IsUnknown; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarDictionaryValue") + formatter.write_str("struct datafusion.IsUnknown") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut index_type__ = None; - let mut value__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::IndexType => { - if index_type__.is_some() { - return Err(serde::de::Error::duplicate_field("indexType")); - } - index_type__ = map.next_value()?; - } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - value__ = map.next_value()?; + expr__ = map.next_value()?; } } } - Ok(ScalarDictionaryValue { - index_type: index_type__, - value: value__, + Ok(IsUnknown { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.IsUnknown", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarFixedSizeBinary { +impl serde::Serialize for JoinConstraint { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::On => "ON", + Self::Using => "USING", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for JoinConstraint { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ON", + "USING", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinConstraint; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinConstraint::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinConstraint::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ON" => Ok(JoinConstraint::On), + "USING" => Ok(JoinConstraint::Using), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for JoinFilter { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9459,37 +9237,46 @@ impl serde::Serialize for ScalarFixedSizeBinary { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.values.is_empty() { + if self.expression.is_some() { len += 1; } - if self.length != 0 { + if !self.column_indices.is_empty() { 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.schema.is_some() { + len += 1; } - if self.length != 0 { - struct_ser.serialize_field("length", &self.length)?; + let mut struct_ser = serializer.serialize_struct("datafusion.JoinFilter", len)?; + if let Some(v) = self.expression.as_ref() { + struct_ser.serialize_field("expression", v)?; + } + if !self.column_indices.is_empty() { + struct_ser.serialize_field("columnIndices", &self.column_indices)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarFixedSizeBinary { +impl<'de> serde::Deserialize<'de> for JoinFilter { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "values", - "length", + "expression", + "column_indices", + "columnIndices", + "schema", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Values, - Length, + Expression, + ColumnIndices, + Schema, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -9511,8 +9298,9 @@ impl<'de> serde::Deserialize<'de> for ScalarFixedSizeBinary { E: serde::de::Error, { match value { - "values" => Ok(GeneratedField::Values), - "length" => Ok(GeneratedField::Length), + "expression" => Ok(GeneratedField::Expression), + "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices), + "schema" => Ok(GeneratedField::Schema), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -9522,334 +9310,8642 @@ impl<'de> serde::Deserialize<'de> for ScalarFixedSizeBinary { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarFixedSizeBinary; + type Value = JoinFilter; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarFixedSizeBinary") + formatter.write_str("struct datafusion.JoinFilter") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut values__ = None; - let mut length__ = None; + let mut expression__ = None; + let mut column_indices__ = None; + let mut schema__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Values => { - if values__.is_some() { - return Err(serde::de::Error::duplicate_field("values")); + GeneratedField::Expression => { + if expression__.is_some() { + return Err(serde::de::Error::duplicate_field("expression")); } - values__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; + expression__ = map.next_value()?; } - GeneratedField::Length => { - if length__.is_some() { - return Err(serde::de::Error::duplicate_field("length")); + GeneratedField::ColumnIndices => { + if column_indices__.is_some() { + return Err(serde::de::Error::duplicate_field("columnIndices")); } - length__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; + column_indices__ = Some(map.next_value()?); + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = map.next_value()?; } } } - Ok(ScalarFixedSizeBinary { - values: values__.unwrap_or_default(), - length: length__.unwrap_or_default(), + Ok(JoinFilter { + expression: expression__, + column_indices: column_indices__.unwrap_or_default(), + schema: schema__, }) } } - deserializer.deserialize_struct("datafusion.ScalarFixedSizeBinary", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.JoinFilter", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarFunction { +impl serde::Serialize for JoinNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where S: serde::Serializer, { - let variant = match self { - Self::Abs => "Abs", - Self::Acos => "Acos", - Self::Asin => "Asin", - Self::Atan => "Atan", - Self::Ascii => "Ascii", - Self::Ceil => "Ceil", - Self::Cos => "Cos", - Self::Digest => "Digest", - Self::Exp => "Exp", - Self::Floor => "Floor", - Self::Ln => "Ln", - Self::Log => "Log", - Self::Log10 => "Log10", - Self::Log2 => "Log2", - Self::Round => "Round", - Self::Signum => "Signum", - Self::Sin => "Sin", - Self::Sqrt => "Sqrt", - Self::Tan => "Tan", - Self::Trunc => "Trunc", - Self::Array => "Array", - Self::RegexpMatch => "RegexpMatch", - Self::BitLength => "BitLength", - Self::Btrim => "Btrim", - Self::CharacterLength => "CharacterLength", - Self::Chr => "Chr", - Self::Concat => "Concat", - Self::ConcatWithSeparator => "ConcatWithSeparator", - Self::DatePart => "DatePart", - Self::DateTrunc => "DateTrunc", - Self::InitCap => "InitCap", - Self::Left => "Left", - Self::Lpad => "Lpad", - Self::Lower => "Lower", - Self::Ltrim => "Ltrim", - Self::Md5 => "MD5", - Self::NullIf => "NullIf", - Self::OctetLength => "OctetLength", - Self::Random => "Random", - Self::RegexpReplace => "RegexpReplace", - Self::Repeat => "Repeat", - Self::Replace => "Replace", - Self::Reverse => "Reverse", - Self::Right => "Right", - Self::Rpad => "Rpad", - Self::Rtrim => "Rtrim", - Self::Sha224 => "SHA224", - Self::Sha256 => "SHA256", - Self::Sha384 => "SHA384", - Self::Sha512 => "SHA512", - Self::SplitPart => "SplitPart", - Self::StartsWith => "StartsWith", - Self::Strpos => "Strpos", - Self::Substr => "Substr", - Self::ToHex => "ToHex", - Self::ToTimestamp => "ToTimestamp", - Self::ToTimestampMillis => "ToTimestampMillis", - Self::ToTimestampMicros => "ToTimestampMicros", - Self::ToTimestampSeconds => "ToTimestampSeconds", - Self::Now => "Now", - Self::Translate => "Translate", - Self::Trim => "Trim", - Self::Upper => "Upper", - Self::Coalesce => "Coalesce", - Self::Power => "Power", - Self::StructFun => "StructFun", - Self::FromUnixtime => "FromUnixtime", - Self::Atan2 => "Atan2", - Self::DateBin => "DateBin", - Self::ArrowTypeof => "ArrowTypeof", - Self::CurrentDate => "CurrentDate", - Self::CurrentTime => "CurrentTime", - Self::Uuid => "Uuid", - }; - serializer.serialize_str(variant) + use serde::ser::SerializeStruct; + let mut len = 0; + if self.left.is_some() { + len += 1; + } + if self.right.is_some() { + len += 1; + } + if self.join_type != 0 { + len += 1; + } + if self.join_constraint != 0 { + len += 1; + } + if !self.left_join_column.is_empty() { + len += 1; + } + if !self.right_join_column.is_empty() { + len += 1; + } + if self.null_equals_null { + len += 1; + } + if self.filter.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.JoinNode", len)?; + if let Some(v) = self.left.as_ref() { + struct_ser.serialize_field("left", v)?; + } + if let Some(v) = self.right.as_ref() { + struct_ser.serialize_field("right", v)?; + } + if self.join_type != 0 { + let v = JoinType::from_i32(self.join_type) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?; + struct_ser.serialize_field("joinType", &v)?; + } + if self.join_constraint != 0 { + let v = JoinConstraint::from_i32(self.join_constraint) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_constraint)))?; + struct_ser.serialize_field("joinConstraint", &v)?; + } + if !self.left_join_column.is_empty() { + struct_ser.serialize_field("leftJoinColumn", &self.left_join_column)?; + } + if !self.right_join_column.is_empty() { + struct_ser.serialize_field("rightJoinColumn", &self.right_join_column)?; + } + if self.null_equals_null { + struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?; + } + if let Some(v) = self.filter.as_ref() { + struct_ser.serialize_field("filter", v)?; + } + struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarFunction { +impl<'de> serde::Deserialize<'de> for JoinNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "Abs", - "Acos", - "Asin", - "Atan", - "Ascii", - "Ceil", - "Cos", - "Digest", - "Exp", - "Floor", - "Ln", - "Log", - "Log10", - "Log2", - "Round", - "Signum", - "Sin", - "Sqrt", - "Tan", - "Trunc", - "Array", - "RegexpMatch", - "BitLength", - "Btrim", - "CharacterLength", - "Chr", - "Concat", - "ConcatWithSeparator", - "DatePart", - "DateTrunc", - "InitCap", - "Left", - "Lpad", - "Lower", - "Ltrim", - "MD5", - "NullIf", - "OctetLength", - "Random", - "RegexpReplace", - "Repeat", - "Replace", - "Reverse", - "Right", - "Rpad", - "Rtrim", - "SHA224", - "SHA256", - "SHA384", - "SHA512", - "SplitPart", - "StartsWith", - "Strpos", - "Substr", - "ToHex", - "ToTimestamp", - "ToTimestampMillis", - "ToTimestampMicros", - "ToTimestampSeconds", - "Now", - "Translate", - "Trim", - "Upper", - "Coalesce", - "Power", - "StructFun", - "FromUnixtime", - "Atan2", - "DateBin", - "ArrowTypeof", - "CurrentDate", - "CurrentTime", - "Uuid", + "left", + "right", + "join_type", + "joinType", + "join_constraint", + "joinConstraint", + "left_join_column", + "leftJoinColumn", + "right_join_column", + "rightJoinColumn", + "null_equals_null", + "nullEqualsNull", + "filter", ]; - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarFunction; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Left, + Right, + JoinType, + JoinConstraint, + LeftJoinColumn, + RightJoinColumn, + NullEqualsNull, + Filter, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "left" => Ok(GeneratedField::Left), + "right" => Ok(GeneratedField::Right), + "joinType" | "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)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.JoinNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut left__ = None; + let mut right__ = None; + let mut join_type__ = None; + let mut join_constraint__ = None; + let mut left_join_column__ = None; + let mut right_join_column__ = None; + let mut null_equals_null__ = None; + let mut filter__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Left => { + if left__.is_some() { + return Err(serde::de::Error::duplicate_field("left")); + } + left__ = map.next_value()?; + } + GeneratedField::Right => { + if right__.is_some() { + return Err(serde::de::Error::duplicate_field("right")); + } + right__ = map.next_value()?; + } + GeneratedField::JoinType => { + if join_type__.is_some() { + return Err(serde::de::Error::duplicate_field("joinType")); + } + join_type__ = Some(map.next_value::()? as i32); + } + GeneratedField::JoinConstraint => { + if join_constraint__.is_some() { + return Err(serde::de::Error::duplicate_field("joinConstraint")); + } + join_constraint__ = Some(map.next_value::()? as i32); + } + GeneratedField::LeftJoinColumn => { + if left_join_column__.is_some() { + return Err(serde::de::Error::duplicate_field("leftJoinColumn")); + } + left_join_column__ = Some(map.next_value()?); + } + GeneratedField::RightJoinColumn => { + if right_join_column__.is_some() { + return Err(serde::de::Error::duplicate_field("rightJoinColumn")); + } + right_join_column__ = Some(map.next_value()?); + } + GeneratedField::NullEqualsNull => { + if null_equals_null__.is_some() { + return Err(serde::de::Error::duplicate_field("nullEqualsNull")); + } + null_equals_null__ = Some(map.next_value()?); + } + GeneratedField::Filter => { + if filter__.is_some() { + return Err(serde::de::Error::duplicate_field("filter")); + } + filter__ = map.next_value()?; + } + } + } + Ok(JoinNode { + left: left__, + right: right__, + join_type: join_type__.unwrap_or_default(), + join_constraint: join_constraint__.unwrap_or_default(), + left_join_column: left_join_column__.unwrap_or_default(), + right_join_column: right_join_column__.unwrap_or_default(), + null_equals_null: null_equals_null__.unwrap_or_default(), + filter: filter__, + }) + } + } + deserializer.deserialize_struct("datafusion.JoinNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for JoinOn { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.left.is_some() { + len += 1; + } + if self.right.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.JoinOn", len)?; + if let Some(v) = self.left.as_ref() { + struct_ser.serialize_field("left", v)?; + } + if let Some(v) = self.right.as_ref() { + struct_ser.serialize_field("right", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for JoinOn { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "left", + "right", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Left, + Right, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "left" => Ok(GeneratedField::Left), + "right" => Ok(GeneratedField::Right), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinOn; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.JoinOn") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut left__ = None; + let mut right__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Left => { + if left__.is_some() { + return Err(serde::de::Error::duplicate_field("left")); + } + left__ = map.next_value()?; + } + GeneratedField::Right => { + if right__.is_some() { + return Err(serde::de::Error::duplicate_field("right")); + } + right__ = map.next_value()?; + } + } + } + Ok(JoinOn { + left: left__, + right: right__, + }) + } + } + deserializer.deserialize_struct("datafusion.JoinOn", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for JoinSide { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::LeftSide => "LEFT_SIDE", + Self::RightSide => "RIGHT_SIDE", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for JoinSide { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "LEFT_SIDE", + "RIGHT_SIDE", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinSide; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinSide::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinSide::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "LEFT_SIDE" => Ok(JoinSide::LeftSide), + "RIGHT_SIDE" => Ok(JoinSide::RightSide), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for JoinType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Inner => "INNER", + Self::Left => "LEFT", + Self::Right => "RIGHT", + Self::Full => "FULL", + Self::Leftsemi => "LEFTSEMI", + Self::Leftanti => "LEFTANTI", + Self::Rightsemi => "RIGHTSEMI", + Self::Rightanti => "RIGHTANTI", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for JoinType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "INNER", + "LEFT", + "RIGHT", + "FULL", + "LEFTSEMI", + "LEFTANTI", + "RIGHTSEMI", + "RIGHTANTI", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = JoinType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(JoinType::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "INNER" => Ok(JoinType::Inner), + "LEFT" => Ok(JoinType::Left), + "RIGHT" => Ok(JoinType::Right), + "FULL" => Ok(JoinType::Full), + "LEFTSEMI" => Ok(JoinType::Leftsemi), + "LEFTANTI" => Ok(JoinType::Leftanti), + "RIGHTSEMI" => Ok(JoinType::Rightsemi), + "RIGHTANTI" => Ok(JoinType::Rightanti), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for LikeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.negated { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + if self.pattern.is_some() { + len += 1; + } + if !self.escape_char.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LikeNode", len)?; + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.pattern.as_ref() { + struct_ser.serialize_field("pattern", v)?; + } + if !self.escape_char.is_empty() { + struct_ser.serialize_field("escapeChar", &self.escape_char)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LikeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "negated", + "expr", + "pattern", + "escape_char", + "escapeChar", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Negated, + Expr, + Pattern, + EscapeChar, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "negated" => Ok(GeneratedField::Negated), + "expr" => Ok(GeneratedField::Expr), + "pattern" => Ok(GeneratedField::Pattern), + "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LikeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LikeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut negated__ = None; + let mut expr__ = None; + let mut pattern__ = None; + let mut escape_char__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::Pattern => { + if pattern__.is_some() { + return Err(serde::de::Error::duplicate_field("pattern")); + } + pattern__ = map.next_value()?; + } + GeneratedField::EscapeChar => { + if escape_char__.is_some() { + return Err(serde::de::Error::duplicate_field("escapeChar")); + } + escape_char__ = Some(map.next_value()?); + } + } + } + Ok(LikeNode { + negated: negated__.unwrap_or_default(), + expr: expr__, + pattern: pattern__, + escape_char: escape_char__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LikeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LimitNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.skip != 0 { + len += 1; + } + if self.fetch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LimitNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.skip != 0 { + struct_ser.serialize_field("skip", ToString::to_string(&self.skip).as_str())?; + } + if self.fetch != 0 { + struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LimitNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "skip", + "fetch", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Skip, + Fetch, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "skip" => Ok(GeneratedField::Skip), + "fetch" => Ok(GeneratedField::Fetch), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LimitNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LimitNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut skip__ = None; + let mut fetch__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::Skip => { + if skip__.is_some() { + return Err(serde::de::Error::duplicate_field("skip")); + } + skip__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); + } + fetch__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(LimitNode { + input: input__, + skip: skip__.unwrap_or_default(), + fetch: fetch__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LimitNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for List { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.field_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.List", len)?; + if let Some(v) = self.field_type.as_ref() { + struct_ser.serialize_field("fieldType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for List { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "field_type", + "fieldType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + FieldType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "fieldType" | "field_type" => Ok(GeneratedField::FieldType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = List; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.List") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut field_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::FieldType => { + if field_type__.is_some() { + return Err(serde::de::Error::duplicate_field("fieldType")); + } + field_type__ = map.next_value()?; + } + } + } + Ok(List { + field_type: field_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.List", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ListingTableScanNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.table_name.is_empty() { + len += 1; + } + if !self.paths.is_empty() { + len += 1; + } + if !self.file_extension.is_empty() { + len += 1; + } + if self.projection.is_some() { + len += 1; + } + if self.schema.is_some() { + len += 1; + } + if !self.filters.is_empty() { + len += 1; + } + if !self.table_partition_cols.is_empty() { + len += 1; + } + if self.collect_stat { + len += 1; + } + if self.target_partitions != 0 { + len += 1; + } + if !self.file_sort_order.is_empty() { + len += 1; + } + if self.file_format_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ListingTableScanNode", len)?; + if !self.table_name.is_empty() { + struct_ser.serialize_field("tableName", &self.table_name)?; + } + if !self.paths.is_empty() { + struct_ser.serialize_field("paths", &self.paths)?; + } + if !self.file_extension.is_empty() { + struct_ser.serialize_field("fileExtension", &self.file_extension)?; + } + if let Some(v) = self.projection.as_ref() { + struct_ser.serialize_field("projection", v)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if !self.filters.is_empty() { + struct_ser.serialize_field("filters", &self.filters)?; + } + if !self.table_partition_cols.is_empty() { + struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; + } + if self.collect_stat { + struct_ser.serialize_field("collectStat", &self.collect_stat)?; + } + if self.target_partitions != 0 { + struct_ser.serialize_field("targetPartitions", &self.target_partitions)?; + } + if !self.file_sort_order.is_empty() { + struct_ser.serialize_field("fileSortOrder", &self.file_sort_order)?; + } + if let Some(v) = self.file_format_type.as_ref() { + match v { + listing_table_scan_node::FileFormatType::Csv(v) => { + struct_ser.serialize_field("csv", v)?; + } + listing_table_scan_node::FileFormatType::Parquet(v) => { + struct_ser.serialize_field("parquet", v)?; + } + listing_table_scan_node::FileFormatType::Avro(v) => { + struct_ser.serialize_field("avro", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ListingTableScanNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "table_name", + "tableName", + "paths", + "file_extension", + "fileExtension", + "projection", + "schema", + "filters", + "table_partition_cols", + "tablePartitionCols", + "collect_stat", + "collectStat", + "target_partitions", + "targetPartitions", + "file_sort_order", + "fileSortOrder", + "csv", + "parquet", + "avro", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TableName, + Paths, + FileExtension, + Projection, + Schema, + Filters, + TablePartitionCols, + CollectStat, + TargetPartitions, + FileSortOrder, + Csv, + Parquet, + Avro, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "tableName" | "table_name" => Ok(GeneratedField::TableName), + "paths" => Ok(GeneratedField::Paths), + "fileExtension" | "file_extension" => Ok(GeneratedField::FileExtension), + "projection" => Ok(GeneratedField::Projection), + "schema" => Ok(GeneratedField::Schema), + "filters" => Ok(GeneratedField::Filters), + "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), + "collectStat" | "collect_stat" => Ok(GeneratedField::CollectStat), + "targetPartitions" | "target_partitions" => Ok(GeneratedField::TargetPartitions), + "fileSortOrder" | "file_sort_order" => Ok(GeneratedField::FileSortOrder), + "csv" => Ok(GeneratedField::Csv), + "parquet" => Ok(GeneratedField::Parquet), + "avro" => Ok(GeneratedField::Avro), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ListingTableScanNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ListingTableScanNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut table_name__ = None; + let mut paths__ = None; + let mut file_extension__ = None; + let mut projection__ = None; + let mut schema__ = None; + let mut filters__ = None; + let mut table_partition_cols__ = None; + let mut collect_stat__ = None; + let mut target_partitions__ = None; + let mut file_sort_order__ = None; + let mut file_format_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::TableName => { + if table_name__.is_some() { + return Err(serde::de::Error::duplicate_field("tableName")); + } + table_name__ = Some(map.next_value()?); + } + GeneratedField::Paths => { + if paths__.is_some() { + return Err(serde::de::Error::duplicate_field("paths")); + } + paths__ = Some(map.next_value()?); + } + GeneratedField::FileExtension => { + if file_extension__.is_some() { + return Err(serde::de::Error::duplicate_field("fileExtension")); + } + file_extension__ = Some(map.next_value()?); + } + GeneratedField::Projection => { + if projection__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); + } + projection__ = map.next_value()?; + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = map.next_value()?; + } + GeneratedField::Filters => { + if filters__.is_some() { + return Err(serde::de::Error::duplicate_field("filters")); + } + filters__ = Some(map.next_value()?); + } + GeneratedField::TablePartitionCols => { + if table_partition_cols__.is_some() { + return Err(serde::de::Error::duplicate_field("tablePartitionCols")); + } + table_partition_cols__ = Some(map.next_value()?); + } + GeneratedField::CollectStat => { + if collect_stat__.is_some() { + return Err(serde::de::Error::duplicate_field("collectStat")); + } + collect_stat__ = Some(map.next_value()?); + } + GeneratedField::TargetPartitions => { + if target_partitions__.is_some() { + return Err(serde::de::Error::duplicate_field("targetPartitions")); + } + target_partitions__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::FileSortOrder => { + if file_sort_order__.is_some() { + return Err(serde::de::Error::duplicate_field("fileSortOrder")); + } + file_sort_order__ = Some(map.next_value()?); + } + GeneratedField::Csv => { + if file_format_type__.is_some() { + return Err(serde::de::Error::duplicate_field("csv")); + } + file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Csv) +; + } + GeneratedField::Parquet => { + if file_format_type__.is_some() { + return Err(serde::de::Error::duplicate_field("parquet")); + } + file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Parquet) +; + } + GeneratedField::Avro => { + if file_format_type__.is_some() { + return Err(serde::de::Error::duplicate_field("avro")); + } + file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Avro) +; + } + } + } + Ok(ListingTableScanNode { + table_name: table_name__.unwrap_or_default(), + paths: paths__.unwrap_or_default(), + file_extension: file_extension__.unwrap_or_default(), + projection: projection__, + schema: schema__, + filters: filters__.unwrap_or_default(), + table_partition_cols: table_partition_cols__.unwrap_or_default(), + collect_stat: collect_stat__.unwrap_or_default(), + target_partitions: target_partitions__.unwrap_or_default(), + file_sort_order: file_sort_order__.unwrap_or_default(), + file_format_type: file_format_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.ListingTableScanNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LocalLimitExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.fetch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LocalLimitExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if self.fetch != 0 { + struct_ser.serialize_field("fetch", &self.fetch)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LocalLimitExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "fetch", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Fetch, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "fetch" => Ok(GeneratedField::Fetch), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LocalLimitExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LocalLimitExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut fetch__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); + } + fetch__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(LocalLimitExecNode { + input: input__, + fetch: fetch__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LocalLimitExecNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalExprList { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprList", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalExprList { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalExprList; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalExprList") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(LogicalExprList { + expr: expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalExprList", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNode", len)?; + if let Some(v) = self.expr_type.as_ref() { + match v { + logical_expr_node::ExprType::Column(v) => { + struct_ser.serialize_field("column", v)?; + } + logical_expr_node::ExprType::Alias(v) => { + struct_ser.serialize_field("alias", v)?; + } + logical_expr_node::ExprType::Literal(v) => { + struct_ser.serialize_field("literal", v)?; + } + logical_expr_node::ExprType::BinaryExpr(v) => { + struct_ser.serialize_field("binaryExpr", v)?; + } + logical_expr_node::ExprType::AggregateExpr(v) => { + struct_ser.serialize_field("aggregateExpr", v)?; + } + logical_expr_node::ExprType::IsNullExpr(v) => { + struct_ser.serialize_field("isNullExpr", v)?; + } + logical_expr_node::ExprType::IsNotNullExpr(v) => { + struct_ser.serialize_field("isNotNullExpr", v)?; + } + logical_expr_node::ExprType::NotExpr(v) => { + struct_ser.serialize_field("notExpr", v)?; + } + logical_expr_node::ExprType::Between(v) => { + struct_ser.serialize_field("between", v)?; + } + logical_expr_node::ExprType::Case(v) => { + struct_ser.serialize_field("case", v)?; + } + logical_expr_node::ExprType::Cast(v) => { + struct_ser.serialize_field("cast", v)?; + } + logical_expr_node::ExprType::Sort(v) => { + struct_ser.serialize_field("sort", v)?; + } + logical_expr_node::ExprType::Negative(v) => { + struct_ser.serialize_field("negative", v)?; + } + logical_expr_node::ExprType::InList(v) => { + struct_ser.serialize_field("inList", v)?; + } + logical_expr_node::ExprType::Wildcard(v) => { + struct_ser.serialize_field("wildcard", v)?; + } + logical_expr_node::ExprType::ScalarFunction(v) => { + struct_ser.serialize_field("scalarFunction", v)?; + } + logical_expr_node::ExprType::TryCast(v) => { + struct_ser.serialize_field("tryCast", v)?; + } + logical_expr_node::ExprType::WindowExpr(v) => { + struct_ser.serialize_field("windowExpr", v)?; + } + logical_expr_node::ExprType::AggregateUdfExpr(v) => { + struct_ser.serialize_field("aggregateUdfExpr", v)?; + } + logical_expr_node::ExprType::ScalarUdfExpr(v) => { + struct_ser.serialize_field("scalarUdfExpr", v)?; + } + logical_expr_node::ExprType::GetIndexedField(v) => { + struct_ser.serialize_field("getIndexedField", v)?; + } + logical_expr_node::ExprType::GroupingSet(v) => { + struct_ser.serialize_field("groupingSet", v)?; + } + logical_expr_node::ExprType::Cube(v) => { + struct_ser.serialize_field("cube", v)?; + } + logical_expr_node::ExprType::Rollup(v) => { + struct_ser.serialize_field("rollup", v)?; + } + logical_expr_node::ExprType::IsTrue(v) => { + struct_ser.serialize_field("isTrue", v)?; + } + logical_expr_node::ExprType::IsFalse(v) => { + struct_ser.serialize_field("isFalse", v)?; + } + logical_expr_node::ExprType::IsUnknown(v) => { + struct_ser.serialize_field("isUnknown", v)?; + } + logical_expr_node::ExprType::IsNotTrue(v) => { + struct_ser.serialize_field("isNotTrue", v)?; + } + logical_expr_node::ExprType::IsNotFalse(v) => { + struct_ser.serialize_field("isNotFalse", v)?; + } + logical_expr_node::ExprType::IsNotUnknown(v) => { + struct_ser.serialize_field("isNotUnknown", v)?; + } + logical_expr_node::ExprType::Like(v) => { + struct_ser.serialize_field("like", v)?; + } + logical_expr_node::ExprType::Ilike(v) => { + struct_ser.serialize_field("ilike", v)?; + } + logical_expr_node::ExprType::SimilarTo(v) => { + struct_ser.serialize_field("similarTo", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "column", + "alias", + "literal", + "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", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Column, + Alias, + Literal, + BinaryExpr, + AggregateExpr, + IsNullExpr, + IsNotNullExpr, + NotExpr, + Between, + Case, + Cast, + Sort, + Negative, + InList, + Wildcard, + ScalarFunction, + TryCast, + WindowExpr, + AggregateUdfExpr, + ScalarUdfExpr, + GetIndexedField, + GroupingSet, + Cube, + Rollup, + IsTrue, + IsFalse, + IsUnknown, + IsNotTrue, + IsNotFalse, + IsNotUnknown, + Like, + Ilike, + SimilarTo, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "column" => Ok(GeneratedField::Column), + "alias" => Ok(GeneratedField::Alias), + "literal" => Ok(GeneratedField::Literal), + "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr), + "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr), + "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr), + "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr), + "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr), + "between" => Ok(GeneratedField::Between), + "case" | "case_" => Ok(GeneratedField::Case), + "cast" => Ok(GeneratedField::Cast), + "sort" => Ok(GeneratedField::Sort), + "negative" => Ok(GeneratedField::Negative), + "inList" | "in_list" => Ok(GeneratedField::InList), + "wildcard" => Ok(GeneratedField::Wildcard), + "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction), + "tryCast" | "try_cast" => Ok(GeneratedField::TryCast), + "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), + "aggregateUdfExpr" | "aggregate_udf_expr" => Ok(GeneratedField::AggregateUdfExpr), + "scalarUdfExpr" | "scalar_udf_expr" => Ok(GeneratedField::ScalarUdfExpr), + "getIndexedField" | "get_indexed_field" => Ok(GeneratedField::GetIndexedField), + "groupingSet" | "grouping_set" => Ok(GeneratedField::GroupingSet), + "cube" => Ok(GeneratedField::Cube), + "rollup" => Ok(GeneratedField::Rollup), + "isTrue" | "is_true" => Ok(GeneratedField::IsTrue), + "isFalse" | "is_false" => Ok(GeneratedField::IsFalse), + "isUnknown" | "is_unknown" => Ok(GeneratedField::IsUnknown), + "isNotTrue" | "is_not_true" => Ok(GeneratedField::IsNotTrue), + "isNotFalse" | "is_not_false" => Ok(GeneratedField::IsNotFalse), + "isNotUnknown" | "is_not_unknown" => Ok(GeneratedField::IsNotUnknown), + "like" => Ok(GeneratedField::Like), + "ilike" => Ok(GeneratedField::Ilike), + "similarTo" | "similar_to" => Ok(GeneratedField::SimilarTo), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Column => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("column")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Column) +; + } + GeneratedField::Alias => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Alias) +; + } + GeneratedField::Literal => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("literal")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Literal) +; + } + GeneratedField::BinaryExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("binaryExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::BinaryExpr) +; + } + GeneratedField::AggregateExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregateExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateExpr) +; + } + GeneratedField::IsNullExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNullExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNullExpr) +; + } + GeneratedField::IsNotNullExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotNullExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotNullExpr) +; + } + GeneratedField::NotExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("notExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::NotExpr) +; + } + GeneratedField::Between => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("between")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Between) +; + } + GeneratedField::Case => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("case")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Case) +; + } + GeneratedField::Cast => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("cast")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cast) +; + } + GeneratedField::Sort => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("sort")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Sort) +; + } + GeneratedField::Negative => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("negative")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Negative) +; + } + GeneratedField::InList => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("inList")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::InList) +; + } + GeneratedField::Wildcard => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("wildcard")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Wildcard); + } + GeneratedField::ScalarFunction => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("scalarFunction")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarFunction) +; + } + GeneratedField::TryCast => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("tryCast")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::TryCast) +; + } + GeneratedField::WindowExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("windowExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::WindowExpr) +; + } + GeneratedField::AggregateUdfExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregateUdfExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateUdfExpr) +; + } + GeneratedField::ScalarUdfExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("scalarUdfExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarUdfExpr) +; + } + GeneratedField::GetIndexedField => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("getIndexedField")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GetIndexedField) +; + } + GeneratedField::GroupingSet => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("groupingSet")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GroupingSet) +; + } + GeneratedField::Cube => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("cube")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cube) +; + } + GeneratedField::Rollup => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("rollup")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Rollup) +; + } + GeneratedField::IsTrue => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isTrue")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsTrue) +; + } + GeneratedField::IsFalse => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isFalse")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsFalse) +; + } + GeneratedField::IsUnknown => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isUnknown")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsUnknown) +; + } + GeneratedField::IsNotTrue => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotTrue")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotTrue) +; + } + GeneratedField::IsNotFalse => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotFalse")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotFalse) +; + } + GeneratedField::IsNotUnknown => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotUnknown")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotUnknown) +; + } + GeneratedField::Like => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("like")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Like) +; + } + GeneratedField::Ilike => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("ilike")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Ilike) +; + } + GeneratedField::SimilarTo => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("similarTo")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::SimilarTo) +; + } + } + } + Ok(LogicalExprNode { + expr_type: expr_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalExtensionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.node.is_empty() { + len += 1; + } + if !self.inputs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExtensionNode", len)?; + if !self.node.is_empty() { + struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?; + } + if !self.inputs.is_empty() { + struct_ser.serialize_field("inputs", &self.inputs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalExtensionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "node", + "inputs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Node, + Inputs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "node" => Ok(GeneratedField::Node), + "inputs" => Ok(GeneratedField::Inputs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalExtensionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalExtensionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut node__ = None; + let mut inputs__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Node => { + if node__.is_some() { + return Err(serde::de::Error::duplicate_field("node")); + } + node__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Inputs => { + if inputs__.is_some() { + return Err(serde::de::Error::duplicate_field("inputs")); + } + inputs__ = Some(map.next_value()?); + } + } + } + Ok(LogicalExtensionNode { + node: node__.unwrap_or_default(), + inputs: inputs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalExtensionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for LogicalPlanNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.logical_plan_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.LogicalPlanNode", len)?; + if let Some(v) = self.logical_plan_type.as_ref() { + match v { + logical_plan_node::LogicalPlanType::ListingScan(v) => { + struct_ser.serialize_field("listingScan", v)?; + } + logical_plan_node::LogicalPlanType::Projection(v) => { + struct_ser.serialize_field("projection", v)?; + } + logical_plan_node::LogicalPlanType::Selection(v) => { + struct_ser.serialize_field("selection", v)?; + } + logical_plan_node::LogicalPlanType::Limit(v) => { + struct_ser.serialize_field("limit", v)?; + } + logical_plan_node::LogicalPlanType::Aggregate(v) => { + struct_ser.serialize_field("aggregate", v)?; + } + logical_plan_node::LogicalPlanType::Join(v) => { + struct_ser.serialize_field("join", v)?; + } + logical_plan_node::LogicalPlanType::Sort(v) => { + struct_ser.serialize_field("sort", v)?; + } + logical_plan_node::LogicalPlanType::Repartition(v) => { + struct_ser.serialize_field("repartition", v)?; + } + logical_plan_node::LogicalPlanType::EmptyRelation(v) => { + struct_ser.serialize_field("emptyRelation", v)?; + } + logical_plan_node::LogicalPlanType::CreateExternalTable(v) => { + struct_ser.serialize_field("createExternalTable", v)?; + } + logical_plan_node::LogicalPlanType::Explain(v) => { + struct_ser.serialize_field("explain", v)?; + } + logical_plan_node::LogicalPlanType::Window(v) => { + struct_ser.serialize_field("window", v)?; + } + logical_plan_node::LogicalPlanType::Analyze(v) => { + struct_ser.serialize_field("analyze", v)?; + } + logical_plan_node::LogicalPlanType::CrossJoin(v) => { + struct_ser.serialize_field("crossJoin", v)?; + } + logical_plan_node::LogicalPlanType::Values(v) => { + struct_ser.serialize_field("values", v)?; + } + logical_plan_node::LogicalPlanType::Extension(v) => { + struct_ser.serialize_field("extension", v)?; + } + logical_plan_node::LogicalPlanType::CreateCatalogSchema(v) => { + struct_ser.serialize_field("createCatalogSchema", v)?; + } + logical_plan_node::LogicalPlanType::Union(v) => { + struct_ser.serialize_field("union", v)?; + } + logical_plan_node::LogicalPlanType::CreateCatalog(v) => { + struct_ser.serialize_field("createCatalog", v)?; + } + logical_plan_node::LogicalPlanType::SubqueryAlias(v) => { + struct_ser.serialize_field("subqueryAlias", v)?; + } + logical_plan_node::LogicalPlanType::CreateView(v) => { + struct_ser.serialize_field("createView", v)?; + } + logical_plan_node::LogicalPlanType::Distinct(v) => { + struct_ser.serialize_field("distinct", v)?; + } + logical_plan_node::LogicalPlanType::ViewScan(v) => { + struct_ser.serialize_field("viewScan", v)?; + } + logical_plan_node::LogicalPlanType::CustomScan(v) => { + struct_ser.serialize_field("customScan", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for LogicalPlanNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "listing_scan", + "listingScan", + "projection", + "selection", + "limit", + "aggregate", + "join", + "sort", + "repartition", + "empty_relation", + "emptyRelation", + "create_external_table", + "createExternalTable", + "explain", + "window", + "analyze", + "cross_join", + "crossJoin", + "values", + "extension", + "create_catalog_schema", + "createCatalogSchema", + "union", + "create_catalog", + "createCatalog", + "subquery_alias", + "subqueryAlias", + "create_view", + "createView", + "distinct", + "view_scan", + "viewScan", + "custom_scan", + "customScan", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ListingScan, + Projection, + Selection, + Limit, + Aggregate, + Join, + Sort, + Repartition, + EmptyRelation, + CreateExternalTable, + Explain, + Window, + Analyze, + CrossJoin, + Values, + Extension, + CreateCatalogSchema, + Union, + CreateCatalog, + SubqueryAlias, + CreateView, + Distinct, + ViewScan, + CustomScan, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "listingScan" | "listing_scan" => Ok(GeneratedField::ListingScan), + "projection" => Ok(GeneratedField::Projection), + "selection" => Ok(GeneratedField::Selection), + "limit" => Ok(GeneratedField::Limit), + "aggregate" => Ok(GeneratedField::Aggregate), + "join" => Ok(GeneratedField::Join), + "sort" => Ok(GeneratedField::Sort), + "repartition" => Ok(GeneratedField::Repartition), + "emptyRelation" | "empty_relation" => Ok(GeneratedField::EmptyRelation), + "createExternalTable" | "create_external_table" => Ok(GeneratedField::CreateExternalTable), + "explain" => Ok(GeneratedField::Explain), + "window" => Ok(GeneratedField::Window), + "analyze" => Ok(GeneratedField::Analyze), + "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin), + "values" => Ok(GeneratedField::Values), + "extension" => Ok(GeneratedField::Extension), + "createCatalogSchema" | "create_catalog_schema" => Ok(GeneratedField::CreateCatalogSchema), + "union" => Ok(GeneratedField::Union), + "createCatalog" | "create_catalog" => Ok(GeneratedField::CreateCatalog), + "subqueryAlias" | "subquery_alias" => Ok(GeneratedField::SubqueryAlias), + "createView" | "create_view" => Ok(GeneratedField::CreateView), + "distinct" => Ok(GeneratedField::Distinct), + "viewScan" | "view_scan" => Ok(GeneratedField::ViewScan), + "customScan" | "custom_scan" => Ok(GeneratedField::CustomScan), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = LogicalPlanNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.LogicalPlanNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut logical_plan_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ListingScan => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("listingScan")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ListingScan) +; + } + GeneratedField::Projection => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Projection) +; + } + GeneratedField::Selection => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("selection")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Selection) +; + } + GeneratedField::Limit => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("limit")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Limit) +; + } + GeneratedField::Aggregate => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregate")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Aggregate) +; + } + GeneratedField::Join => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("join")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Join) +; + } + GeneratedField::Sort => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("sort")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Sort) +; + } + GeneratedField::Repartition => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("repartition")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Repartition) +; + } + GeneratedField::EmptyRelation => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("emptyRelation")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::EmptyRelation) +; + } + GeneratedField::CreateExternalTable => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createExternalTable")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateExternalTable) +; + } + GeneratedField::Explain => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("explain")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Explain) +; + } + GeneratedField::Window => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("window")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Window) +; + } + GeneratedField::Analyze => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("analyze")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Analyze) +; + } + GeneratedField::CrossJoin => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("crossJoin")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CrossJoin) +; + } + GeneratedField::Values => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("values")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Values) +; + } + GeneratedField::Extension => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("extension")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Extension) +; + } + GeneratedField::CreateCatalogSchema => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createCatalogSchema")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalogSchema) +; + } + GeneratedField::Union => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("union")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Union) +; + } + GeneratedField::CreateCatalog => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createCatalog")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalog) +; + } + GeneratedField::SubqueryAlias => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("subqueryAlias")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::SubqueryAlias) +; + } + GeneratedField::CreateView => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("createView")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateView) +; + } + GeneratedField::Distinct => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("distinct")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Distinct) +; + } + GeneratedField::ViewScan => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("viewScan")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ViewScan) +; + } + GeneratedField::CustomScan => { + if logical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("customScan")); + } + logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CustomScan) +; + } + } + } + Ok(LogicalPlanNode { + logical_plan_type: logical_plan_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.LogicalPlanNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for NegativeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.NegativeNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for NegativeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = NegativeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.NegativeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + } + } + Ok(NegativeNode { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.NegativeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Not { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.Not", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Not { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Not; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Not") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + } + } + Ok(Not { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.Not", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for OptimizedLogicalPlanType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.optimizer_name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedLogicalPlanType", len)?; + if !self.optimizer_name.is_empty() { + struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "optimizer_name", + "optimizerName", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OptimizerName, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = OptimizedLogicalPlanType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.OptimizedLogicalPlanType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut optimizer_name__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::OptimizerName => { + if optimizer_name__.is_some() { + return Err(serde::de::Error::duplicate_field("optimizerName")); + } + optimizer_name__ = Some(map.next_value()?); + } + } + } + Ok(OptimizedLogicalPlanType { + optimizer_name: optimizer_name__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.OptimizedLogicalPlanType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for OptimizedPhysicalPlanType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.optimizer_name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedPhysicalPlanType", len)?; + if !self.optimizer_name.is_empty() { + struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "optimizer_name", + "optimizerName", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + OptimizerName, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = OptimizedPhysicalPlanType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.OptimizedPhysicalPlanType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut optimizer_name__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::OptimizerName => { + if optimizer_name__.is_some() { + return Err(serde::de::Error::duplicate_field("optimizerName")); + } + optimizer_name__ = Some(map.next_value()?); + } + } + } + Ok(OptimizedPhysicalPlanType { + optimizer_name: optimizer_name__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.OptimizedPhysicalPlanType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ParquetFormat { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.enable_pruning { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ParquetFormat", len)?; + if self.enable_pruning { + struct_ser.serialize_field("enablePruning", &self.enable_pruning)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ParquetFormat { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "enable_pruning", + "enablePruning", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EnablePruning, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "enablePruning" | "enable_pruning" => Ok(GeneratedField::EnablePruning), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ParquetFormat; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ParquetFormat") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut enable_pruning__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::EnablePruning => { + if enable_pruning__.is_some() { + return Err(serde::de::Error::duplicate_field("enablePruning")); + } + enable_pruning__ = Some(map.next_value()?); + } + } + } + Ok(ParquetFormat { + enable_pruning: enable_pruning__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ParquetFormat", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ParquetScanExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.base_conf.is_some() { + len += 1; + } + if self.pruning_predicate.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ParquetScanExecNode", len)?; + if let Some(v) = self.base_conf.as_ref() { + struct_ser.serialize_field("baseConf", v)?; + } + if let Some(v) = self.pruning_predicate.as_ref() { + struct_ser.serialize_field("pruningPredicate", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ParquetScanExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "base_conf", + "baseConf", + "pruning_predicate", + "pruningPredicate", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + BaseConf, + PruningPredicate, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf), + "pruningPredicate" | "pruning_predicate" => Ok(GeneratedField::PruningPredicate), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ParquetScanExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ParquetScanExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut base_conf__ = None; + let mut pruning_predicate__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::BaseConf => { + if base_conf__.is_some() { + return Err(serde::de::Error::duplicate_field("baseConf")); + } + base_conf__ = map.next_value()?; + } + GeneratedField::PruningPredicate => { + if pruning_predicate__.is_some() { + return Err(serde::de::Error::duplicate_field("pruningPredicate")); + } + pruning_predicate__ = map.next_value()?; + } + } + } + Ok(ParquetScanExecNode { + base_conf: base_conf__, + pruning_predicate: pruning_predicate__, + }) + } + } + deserializer.deserialize_struct("datafusion.ParquetScanExecNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PartitionId { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.job_id.is_empty() { + len += 1; + } + if self.stage_id != 0 { + len += 1; + } + if self.partition_id != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PartitionId", len)?; + if !self.job_id.is_empty() { + struct_ser.serialize_field("jobId", &self.job_id)?; + } + if self.stage_id != 0 { + struct_ser.serialize_field("stageId", &self.stage_id)?; + } + if self.partition_id != 0 { + struct_ser.serialize_field("partitionId", &self.partition_id)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PartitionId { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "job_id", + "jobId", + "stage_id", + "stageId", + "partition_id", + "partitionId", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + JobId, + StageId, + PartitionId, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "jobId" | "job_id" => Ok(GeneratedField::JobId), + "stageId" | "stage_id" => Ok(GeneratedField::StageId), + "partitionId" | "partition_id" => Ok(GeneratedField::PartitionId), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PartitionId; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PartitionId") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut job_id__ = None; + let mut stage_id__ = None; + let mut partition_id__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::JobId => { + if job_id__.is_some() { + return Err(serde::de::Error::duplicate_field("jobId")); + } + job_id__ = Some(map.next_value()?); + } + GeneratedField::StageId => { + if stage_id__.is_some() { + return Err(serde::de::Error::duplicate_field("stageId")); + } + stage_id__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PartitionId => { + if partition_id__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionId")); + } + partition_id__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(PartitionId { + job_id: job_id__.unwrap_or_default(), + stage_id: stage_id__.unwrap_or_default(), + partition_id: partition_id__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PartitionId", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PartitionLocation { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.map_partition_id != 0 { + len += 1; + } + if self.partition_id.is_some() { + len += 1; + } + if self.executor_meta.is_some() { + len += 1; + } + if self.partition_stats.is_some() { + len += 1; + } + if !self.path.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PartitionLocation", len)?; + if self.map_partition_id != 0 { + struct_ser.serialize_field("mapPartitionId", &self.map_partition_id)?; + } + if let Some(v) = self.partition_id.as_ref() { + struct_ser.serialize_field("partitionId", v)?; + } + if let Some(v) = self.executor_meta.as_ref() { + struct_ser.serialize_field("executorMeta", v)?; + } + if let Some(v) = self.partition_stats.as_ref() { + struct_ser.serialize_field("partitionStats", v)?; + } + if !self.path.is_empty() { + struct_ser.serialize_field("path", &self.path)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PartitionLocation { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "map_partition_id", + "mapPartitionId", + "partition_id", + "partitionId", + "executor_meta", + "executorMeta", + "partition_stats", + "partitionStats", + "path", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + MapPartitionId, + PartitionId, + ExecutorMeta, + PartitionStats, + Path, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "mapPartitionId" | "map_partition_id" => Ok(GeneratedField::MapPartitionId), + "partitionId" | "partition_id" => Ok(GeneratedField::PartitionId), + "executorMeta" | "executor_meta" => Ok(GeneratedField::ExecutorMeta), + "partitionStats" | "partition_stats" => Ok(GeneratedField::PartitionStats), + "path" => Ok(GeneratedField::Path), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PartitionLocation; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PartitionLocation") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut map_partition_id__ = None; + let mut partition_id__ = None; + let mut executor_meta__ = None; + let mut partition_stats__ = None; + let mut path__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::MapPartitionId => { + if map_partition_id__.is_some() { + return Err(serde::de::Error::duplicate_field("mapPartitionId")); + } + map_partition_id__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PartitionId => { + if partition_id__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionId")); + } + partition_id__ = map.next_value()?; + } + GeneratedField::ExecutorMeta => { + if executor_meta__.is_some() { + return Err(serde::de::Error::duplicate_field("executorMeta")); + } + executor_meta__ = map.next_value()?; + } + GeneratedField::PartitionStats => { + if partition_stats__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionStats")); + } + partition_stats__ = map.next_value()?; + } + GeneratedField::Path => { + if path__.is_some() { + return Err(serde::de::Error::duplicate_field("path")); + } + path__ = Some(map.next_value()?); + } + } + } + Ok(PartitionLocation { + map_partition_id: map_partition_id__.unwrap_or_default(), + partition_id: partition_id__, + executor_meta: executor_meta__, + partition_stats: partition_stats__, + path: path__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PartitionLocation", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PartitionMode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::CollectLeft => "COLLECT_LEFT", + Self::Partitioned => "PARTITIONED", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for PartitionMode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "COLLECT_LEFT", + "PARTITIONED", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PartitionMode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(PartitionMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(PartitionMode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "COLLECT_LEFT" => Ok(PartitionMode::CollectLeft), + "PARTITIONED" => Ok(PartitionMode::Partitioned), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for PartitionStats { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.num_rows != 0 { + len += 1; + } + if self.num_batches != 0 { + len += 1; + } + if self.num_bytes != 0 { + len += 1; + } + if !self.column_stats.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PartitionStats", len)?; + if self.num_rows != 0 { + struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?; + } + if self.num_batches != 0 { + struct_ser.serialize_field("numBatches", ToString::to_string(&self.num_batches).as_str())?; + } + if self.num_bytes != 0 { + struct_ser.serialize_field("numBytes", ToString::to_string(&self.num_bytes).as_str())?; + } + if !self.column_stats.is_empty() { + struct_ser.serialize_field("columnStats", &self.column_stats)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PartitionStats { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "num_rows", + "numRows", + "num_batches", + "numBatches", + "num_bytes", + "numBytes", + "column_stats", + "columnStats", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + NumRows, + NumBatches, + NumBytes, + ColumnStats, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "numRows" | "num_rows" => Ok(GeneratedField::NumRows), + "numBatches" | "num_batches" => Ok(GeneratedField::NumBatches), + "numBytes" | "num_bytes" => Ok(GeneratedField::NumBytes), + "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PartitionStats; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PartitionStats") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut num_rows__ = None; + let mut num_batches__ = None; + let mut num_bytes__ = None; + let mut column_stats__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::NumRows => { + if num_rows__.is_some() { + return Err(serde::de::Error::duplicate_field("numRows")); + } + num_rows__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::NumBatches => { + if num_batches__.is_some() { + return Err(serde::de::Error::duplicate_field("numBatches")); + } + num_batches__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::NumBytes => { + if num_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("numBytes")); + } + num_bytes__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ColumnStats => { + if column_stats__.is_some() { + return Err(serde::de::Error::duplicate_field("columnStats")); + } + column_stats__ = Some(map.next_value()?); + } + } + } + Ok(PartitionStats { + num_rows: num_rows__.unwrap_or_default(), + num_batches: num_batches__.unwrap_or_default(), + num_bytes: num_bytes__.unwrap_or_default(), + column_stats: column_stats__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PartitionStats", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PartitionedFile { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.path.is_empty() { + len += 1; + } + if self.size != 0 { + len += 1; + } + if self.last_modified_ns != 0 { + len += 1; + } + if !self.partition_values.is_empty() { + len += 1; + } + if self.range.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PartitionedFile", len)?; + if !self.path.is_empty() { + struct_ser.serialize_field("path", &self.path)?; + } + if self.size != 0 { + struct_ser.serialize_field("size", ToString::to_string(&self.size).as_str())?; + } + if self.last_modified_ns != 0 { + struct_ser.serialize_field("lastModifiedNs", ToString::to_string(&self.last_modified_ns).as_str())?; + } + if !self.partition_values.is_empty() { + struct_ser.serialize_field("partitionValues", &self.partition_values)?; + } + if let Some(v) = self.range.as_ref() { + struct_ser.serialize_field("range", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PartitionedFile { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "path", + "size", + "last_modified_ns", + "lastModifiedNs", + "partition_values", + "partitionValues", + "range", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Path, + Size, + LastModifiedNs, + PartitionValues, + Range, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "path" => Ok(GeneratedField::Path), + "size" => Ok(GeneratedField::Size), + "lastModifiedNs" | "last_modified_ns" => Ok(GeneratedField::LastModifiedNs), + "partitionValues" | "partition_values" => Ok(GeneratedField::PartitionValues), + "range" => Ok(GeneratedField::Range), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PartitionedFile; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PartitionedFile") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut path__ = None; + let mut size__ = None; + let mut last_modified_ns__ = None; + let mut partition_values__ = None; + let mut range__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Path => { + if path__.is_some() { + return Err(serde::de::Error::duplicate_field("path")); + } + path__ = Some(map.next_value()?); + } + GeneratedField::Size => { + if size__.is_some() { + return Err(serde::de::Error::duplicate_field("size")); + } + size__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::LastModifiedNs => { + if last_modified_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("lastModifiedNs")); + } + last_modified_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PartitionValues => { + if partition_values__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionValues")); + } + partition_values__ = Some(map.next_value()?); + } + GeneratedField::Range => { + if range__.is_some() { + return Err(serde::de::Error::duplicate_field("range")); + } + range__ = map.next_value()?; + } + } + } + Ok(PartitionedFile { + path: path__.unwrap_or_default(), + size: size__.unwrap_or_default(), + last_modified_ns: last_modified_ns__.unwrap_or_default(), + partition_values: partition_values__.unwrap_or_default(), + range: range__, + }) + } + } + deserializer.deserialize_struct("datafusion.PartitionedFile", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalAggregateExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.aggr_function != 0 { + len += 1; + } + if !self.expr.is_empty() { + len += 1; + } + if self.distinct { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAggregateExprNode", len)?; + if self.aggr_function != 0 { + let v = AggregateFunction::from_i32(self.aggr_function) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.aggr_function)))?; + struct_ser.serialize_field("aggrFunction", &v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if self.distinct { + struct_ser.serialize_field("distinct", &self.distinct)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalAggregateExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "aggr_function", + "aggrFunction", + "expr", + "distinct", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AggrFunction, + Expr, + Distinct, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction), + "expr" => Ok(GeneratedField::Expr), + "distinct" => Ok(GeneratedField::Distinct), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalAggregateExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalAggregateExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut aggr_function__ = None; + let mut expr__ = None; + let mut distinct__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::AggrFunction => { + if aggr_function__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrFunction")); + } + aggr_function__ = Some(map.next_value::()? as i32); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Distinct => { + if distinct__.is_some() { + return Err(serde::de::Error::duplicate_field("distinct")); + } + distinct__ = Some(map.next_value()?); + } + } + } + Ok(PhysicalAggregateExprNode { + aggr_function: aggr_function__.unwrap_or_default(), + expr: expr__.unwrap_or_default(), + distinct: distinct__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalAggregateExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalAliasNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.alias.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAliasNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.alias.is_empty() { + struct_ser.serialize_field("alias", &self.alias)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalAliasNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "alias", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Alias, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "alias" => Ok(GeneratedField::Alias), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalAliasNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalAliasNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut alias__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::Alias => { + if alias__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + alias__ = Some(map.next_value()?); + } + } + } + Ok(PhysicalAliasNode { + expr: expr__, + alias: alias__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalAliasNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalBinaryExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.l.is_some() { + len += 1; + } + if self.r.is_some() { + len += 1; + } + if !self.op.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalBinaryExprNode", len)?; + if let Some(v) = self.l.as_ref() { + struct_ser.serialize_field("l", v)?; + } + if let Some(v) = self.r.as_ref() { + struct_ser.serialize_field("r", v)?; + } + if !self.op.is_empty() { + struct_ser.serialize_field("op", &self.op)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalBinaryExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "l", + "r", + "op", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + L, + R, + Op, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "l" => Ok(GeneratedField::L), + "r" => Ok(GeneratedField::R), + "op" => Ok(GeneratedField::Op), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalBinaryExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalBinaryExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut l__ = None; + let mut r__ = None; + let mut op__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::L => { + if l__.is_some() { + return Err(serde::de::Error::duplicate_field("l")); + } + l__ = map.next_value()?; + } + GeneratedField::R => { + if r__.is_some() { + return Err(serde::de::Error::duplicate_field("r")); + } + r__ = map.next_value()?; + } + GeneratedField::Op => { + if op__.is_some() { + return Err(serde::de::Error::duplicate_field("op")); + } + op__ = Some(map.next_value()?); + } + } + } + Ok(PhysicalBinaryExprNode { + l: l__, + r: r__, + op: op__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalBinaryExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalCaseNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.when_then_expr.is_empty() { + len += 1; + } + if self.else_expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCaseNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.when_then_expr.is_empty() { + struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?; + } + if let Some(v) = self.else_expr.as_ref() { + struct_ser.serialize_field("elseExpr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalCaseNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "when_then_expr", + "whenThenExpr", + "else_expr", + "elseExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + WhenThenExpr, + ElseExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr), + "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalCaseNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalCaseNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut when_then_expr__ = None; + let mut else_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::WhenThenExpr => { + if when_then_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("whenThenExpr")); + } + when_then_expr__ = Some(map.next_value()?); + } + GeneratedField::ElseExpr => { + if else_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("elseExpr")); + } + else_expr__ = map.next_value()?; + } + } + } + Ok(PhysicalCaseNode { + expr: expr__, + when_then_expr: when_then_expr__.unwrap_or_default(), + else_expr: else_expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalCaseNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalCastNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.arrow_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCastNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.arrow_type.as_ref() { + struct_ser.serialize_field("arrowType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalCastNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "arrow_type", + "arrowType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + ArrowType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalCastNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalCastNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut arrow_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::ArrowType => { + if arrow_type__.is_some() { + return Err(serde::de::Error::duplicate_field("arrowType")); + } + arrow_type__ = map.next_value()?; + } + } + } + Ok(PhysicalCastNode { + expr: expr__, + arrow_type: arrow_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalCastNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalColumn { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if self.index != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalColumn", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if self.index != 0 { + struct_ser.serialize_field("index", &self.index)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalColumn { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "index", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + Index, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "index" => Ok(GeneratedField::Index), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalColumn; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalColumn") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut index__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Index => { + if index__.is_some() { + return Err(serde::de::Error::duplicate_field("index")); + } + index__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(PhysicalColumn { + name: name__.unwrap_or_default(), + index: index__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalColumn", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalDateTimeIntervalExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.l.is_some() { + len += 1; + } + if self.r.is_some() { + len += 1; + } + if !self.op.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", len)?; + if let Some(v) = self.l.as_ref() { + struct_ser.serialize_field("l", v)?; + } + if let Some(v) = self.r.as_ref() { + struct_ser.serialize_field("r", v)?; + } + if !self.op.is_empty() { + struct_ser.serialize_field("op", &self.op)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalDateTimeIntervalExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "l", + "r", + "op", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + L, + R, + Op, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "l" => Ok(GeneratedField::L), + "r" => Ok(GeneratedField::R), + "op" => Ok(GeneratedField::Op), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalDateTimeIntervalExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalDateTimeIntervalExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut l__ = None; + let mut r__ = None; + let mut op__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::L => { + if l__.is_some() { + return Err(serde::de::Error::duplicate_field("l")); + } + l__ = map.next_value()?; + } + GeneratedField::R => { + if r__.is_some() { + return Err(serde::de::Error::duplicate_field("r")); + } + r__ = map.next_value()?; + } + GeneratedField::Op => { + if op__.is_some() { + return Err(serde::de::Error::duplicate_field("op")); + } + op__ = Some(map.next_value()?); + } + } + } + Ok(PhysicalDateTimeIntervalExprNode { + l: l__, + r: r__, + op: op__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExprNode", len)?; + if let Some(v) = self.expr_type.as_ref() { + match v { + physical_expr_node::ExprType::Column(v) => { + struct_ser.serialize_field("column", v)?; + } + physical_expr_node::ExprType::Literal(v) => { + struct_ser.serialize_field("literal", v)?; + } + physical_expr_node::ExprType::BinaryExpr(v) => { + struct_ser.serialize_field("binaryExpr", v)?; + } + physical_expr_node::ExprType::AggregateExpr(v) => { + struct_ser.serialize_field("aggregateExpr", v)?; + } + physical_expr_node::ExprType::IsNullExpr(v) => { + struct_ser.serialize_field("isNullExpr", v)?; + } + physical_expr_node::ExprType::IsNotNullExpr(v) => { + struct_ser.serialize_field("isNotNullExpr", v)?; + } + physical_expr_node::ExprType::NotExpr(v) => { + struct_ser.serialize_field("notExpr", v)?; + } + physical_expr_node::ExprType::Case(v) => { + struct_ser.serialize_field("case", v)?; + } + physical_expr_node::ExprType::Cast(v) => { + struct_ser.serialize_field("cast", v)?; + } + physical_expr_node::ExprType::Sort(v) => { + struct_ser.serialize_field("sort", v)?; + } + physical_expr_node::ExprType::Negative(v) => { + struct_ser.serialize_field("negative", v)?; + } + physical_expr_node::ExprType::InList(v) => { + struct_ser.serialize_field("inList", v)?; + } + physical_expr_node::ExprType::ScalarFunction(v) => { + struct_ser.serialize_field("scalarFunction", v)?; + } + physical_expr_node::ExprType::TryCast(v) => { + struct_ser.serialize_field("tryCast", v)?; + } + physical_expr_node::ExprType::WindowExpr(v) => { + struct_ser.serialize_field("windowExpr", v)?; + } + physical_expr_node::ExprType::ScalarUdf(v) => { + struct_ser.serialize_field("scalarUdf", v)?; + } + physical_expr_node::ExprType::DateTimeIntervalExpr(v) => { + struct_ser.serialize_field("dateTimeIntervalExpr", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "column", + "literal", + "binary_expr", + "binaryExpr", + "aggregate_expr", + "aggregateExpr", + "is_null_expr", + "isNullExpr", + "is_not_null_expr", + "isNotNullExpr", + "not_expr", + "notExpr", + "case_", + "case", + "cast", + "sort", + "negative", + "in_list", + "inList", + "scalar_function", + "scalarFunction", + "try_cast", + "tryCast", + "window_expr", + "windowExpr", + "scalar_udf", + "scalarUdf", + "date_time_interval_expr", + "dateTimeIntervalExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Column, + Literal, + BinaryExpr, + AggregateExpr, + IsNullExpr, + IsNotNullExpr, + NotExpr, + Case, + Cast, + Sort, + Negative, + InList, + ScalarFunction, + TryCast, + WindowExpr, + ScalarUdf, + DateTimeIntervalExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "column" => Ok(GeneratedField::Column), + "literal" => Ok(GeneratedField::Literal), + "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr), + "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr), + "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr), + "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr), + "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr), + "case" | "case_" => Ok(GeneratedField::Case), + "cast" => Ok(GeneratedField::Cast), + "sort" => Ok(GeneratedField::Sort), + "negative" => Ok(GeneratedField::Negative), + "inList" | "in_list" => Ok(GeneratedField::InList), + "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction), + "tryCast" | "try_cast" => Ok(GeneratedField::TryCast), + "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), + "scalarUdf" | "scalar_udf" => Ok(GeneratedField::ScalarUdf), + "dateTimeIntervalExpr" | "date_time_interval_expr" => Ok(GeneratedField::DateTimeIntervalExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Column => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("column")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Column) +; + } + GeneratedField::Literal => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("literal")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Literal) +; + } + GeneratedField::BinaryExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("binaryExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::BinaryExpr) +; + } + GeneratedField::AggregateExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregateExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::AggregateExpr) +; + } + GeneratedField::IsNullExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNullExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNullExpr) +; + } + GeneratedField::IsNotNullExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("isNotNullExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNotNullExpr) +; + } + GeneratedField::NotExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("notExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::NotExpr) +; + } + GeneratedField::Case => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("case")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Case) +; + } + GeneratedField::Cast => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("cast")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Cast) +; + } + GeneratedField::Sort => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("sort")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Sort) +; + } + GeneratedField::Negative => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("negative")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Negative) +; + } + GeneratedField::InList => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("inList")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::InList) +; + } + GeneratedField::ScalarFunction => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("scalarFunction")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarFunction) +; + } + GeneratedField::TryCast => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("tryCast")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::TryCast) +; + } + GeneratedField::WindowExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("windowExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::WindowExpr) +; + } + GeneratedField::ScalarUdf => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("scalarUdf")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarUdf) +; + } + GeneratedField::DateTimeIntervalExpr => { + if expr_type__.is_some() { + return Err(serde::de::Error::duplicate_field("dateTimeIntervalExpr")); + } + expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::DateTimeIntervalExpr) +; + } + } + } + Ok(PhysicalExprNode { + expr_type: expr_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalExtensionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.node.is_empty() { + len += 1; + } + if !self.inputs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExtensionNode", len)?; + if !self.node.is_empty() { + struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?; + } + if !self.inputs.is_empty() { + struct_ser.serialize_field("inputs", &self.inputs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalExtensionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "node", + "inputs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Node, + Inputs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "node" => Ok(GeneratedField::Node), + "inputs" => Ok(GeneratedField::Inputs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalExtensionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalExtensionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut node__ = None; + let mut inputs__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Node => { + if node__.is_some() { + return Err(serde::de::Error::duplicate_field("node")); + } + node__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Inputs => { + if inputs__.is_some() { + return Err(serde::de::Error::duplicate_field("inputs")); + } + inputs__ = Some(map.next_value()?); + } + } + } + Ok(PhysicalExtensionNode { + node: node__.unwrap_or_default(), + inputs: inputs__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalExtensionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalHashRepartition { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.hash_expr.is_empty() { + len += 1; + } + if self.partition_count != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalHashRepartition", len)?; + if !self.hash_expr.is_empty() { + struct_ser.serialize_field("hashExpr", &self.hash_expr)?; + } + if self.partition_count != 0 { + struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalHashRepartition { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hash_expr", + "hashExpr", + "partition_count", + "partitionCount", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + HashExpr, + PartitionCount, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr), + "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalHashRepartition; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalHashRepartition") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hash_expr__ = None; + let mut partition_count__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::HashExpr => { + if hash_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("hashExpr")); + } + hash_expr__ = Some(map.next_value()?); + } + GeneratedField::PartitionCount => { + if partition_count__.is_some() { + return Err(serde::de::Error::duplicate_field("partitionCount")); + } + partition_count__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(PhysicalHashRepartition { + hash_expr: hash_expr__.unwrap_or_default(), + partition_count: partition_count__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalHashRepartition", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalInListNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if !self.list.is_empty() { + len += 1; + } + if self.negated { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalInListNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if !self.list.is_empty() { + struct_ser.serialize_field("list", &self.list)?; + } + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalInListNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "list", + "negated", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + List, + Negated, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "list" => Ok(GeneratedField::List), + "negated" => Ok(GeneratedField::Negated), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalInListNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalInListNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut list__ = None; + let mut negated__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::List => { + if list__.is_some() { + return Err(serde::de::Error::duplicate_field("list")); + } + list__ = Some(map.next_value()?); + } + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); + } + negated__ = Some(map.next_value()?); + } + } + } + Ok(PhysicalInListNode { + expr: expr__, + list: list__.unwrap_or_default(), + negated: negated__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalInListNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalIsNotNull { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNotNull", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalIsNotNull { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalIsNotNull; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalIsNotNull") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + } + } + Ok(PhysicalIsNotNull { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalIsNotNull", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalIsNull { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNull", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalIsNull { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalIsNull; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalIsNull") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + } + } + Ok(PhysicalIsNull { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalIsNull", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalNegativeNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNegativeNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalNegativeNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalNegativeNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalNegativeNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + } + } + Ok(PhysicalNegativeNode { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalNegativeNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalNot { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNot", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalNot { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalNot; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalNot") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + } + } + Ok(PhysicalNot { + expr: expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalNot", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalPlanNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.physical_plan_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalPlanNode", len)?; + if let Some(v) = self.physical_plan_type.as_ref() { + match v { + physical_plan_node::PhysicalPlanType::ParquetScan(v) => { + struct_ser.serialize_field("parquetScan", v)?; + } + physical_plan_node::PhysicalPlanType::CsvScan(v) => { + struct_ser.serialize_field("csvScan", v)?; + } + physical_plan_node::PhysicalPlanType::Empty(v) => { + struct_ser.serialize_field("empty", v)?; + } + physical_plan_node::PhysicalPlanType::Projection(v) => { + struct_ser.serialize_field("projection", v)?; + } + physical_plan_node::PhysicalPlanType::GlobalLimit(v) => { + struct_ser.serialize_field("globalLimit", v)?; + } + physical_plan_node::PhysicalPlanType::LocalLimit(v) => { + struct_ser.serialize_field("localLimit", v)?; + } + physical_plan_node::PhysicalPlanType::Aggregate(v) => { + struct_ser.serialize_field("aggregate", v)?; + } + physical_plan_node::PhysicalPlanType::HashJoin(v) => { + struct_ser.serialize_field("hashJoin", v)?; + } + physical_plan_node::PhysicalPlanType::Sort(v) => { + struct_ser.serialize_field("sort", v)?; + } + physical_plan_node::PhysicalPlanType::CoalesceBatches(v) => { + struct_ser.serialize_field("coalesceBatches", v)?; + } + physical_plan_node::PhysicalPlanType::Filter(v) => { + struct_ser.serialize_field("filter", v)?; + } + physical_plan_node::PhysicalPlanType::Merge(v) => { + struct_ser.serialize_field("merge", v)?; + } + physical_plan_node::PhysicalPlanType::Repartition(v) => { + struct_ser.serialize_field("repartition", v)?; + } + physical_plan_node::PhysicalPlanType::Window(v) => { + struct_ser.serialize_field("window", v)?; + } + physical_plan_node::PhysicalPlanType::CrossJoin(v) => { + struct_ser.serialize_field("crossJoin", v)?; + } + physical_plan_node::PhysicalPlanType::AvroScan(v) => { + struct_ser.serialize_field("avroScan", v)?; + } + physical_plan_node::PhysicalPlanType::Extension(v) => { + struct_ser.serialize_field("extension", v)?; + } + physical_plan_node::PhysicalPlanType::Union(v) => { + struct_ser.serialize_field("union", v)?; + } + physical_plan_node::PhysicalPlanType::Explain(v) => { + struct_ser.serialize_field("explain", v)?; + } + physical_plan_node::PhysicalPlanType::SortPreservingMerge(v) => { + struct_ser.serialize_field("sortPreservingMerge", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalPlanNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "parquet_scan", + "parquetScan", + "csv_scan", + "csvScan", + "empty", + "projection", + "global_limit", + "globalLimit", + "local_limit", + "localLimit", + "aggregate", + "hash_join", + "hashJoin", + "sort", + "coalesce_batches", + "coalesceBatches", + "filter", + "merge", + "repartition", + "window", + "cross_join", + "crossJoin", + "avro_scan", + "avroScan", + "extension", + "union", + "explain", + "sort_preserving_merge", + "sortPreservingMerge", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ParquetScan, + CsvScan, + Empty, + Projection, + GlobalLimit, + LocalLimit, + Aggregate, + HashJoin, + Sort, + CoalesceBatches, + Filter, + Merge, + Repartition, + Window, + CrossJoin, + AvroScan, + Extension, + Union, + Explain, + SortPreservingMerge, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "parquetScan" | "parquet_scan" => Ok(GeneratedField::ParquetScan), + "csvScan" | "csv_scan" => Ok(GeneratedField::CsvScan), + "empty" => Ok(GeneratedField::Empty), + "projection" => Ok(GeneratedField::Projection), + "globalLimit" | "global_limit" => Ok(GeneratedField::GlobalLimit), + "localLimit" | "local_limit" => Ok(GeneratedField::LocalLimit), + "aggregate" => Ok(GeneratedField::Aggregate), + "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin), + "sort" => Ok(GeneratedField::Sort), + "coalesceBatches" | "coalesce_batches" => Ok(GeneratedField::CoalesceBatches), + "filter" => Ok(GeneratedField::Filter), + "merge" => Ok(GeneratedField::Merge), + "repartition" => Ok(GeneratedField::Repartition), + "window" => Ok(GeneratedField::Window), + "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin), + "avroScan" | "avro_scan" => Ok(GeneratedField::AvroScan), + "extension" => Ok(GeneratedField::Extension), + "union" => Ok(GeneratedField::Union), + "explain" => Ok(GeneratedField::Explain), + "sortPreservingMerge" | "sort_preserving_merge" => Ok(GeneratedField::SortPreservingMerge), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalPlanNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalPlanNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut physical_plan_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ParquetScan => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("parquetScan")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::ParquetScan) +; + } + GeneratedField::CsvScan => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("csvScan")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CsvScan) +; + } + GeneratedField::Empty => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("empty")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Empty) +; + } + GeneratedField::Projection => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("projection")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Projection) +; + } + GeneratedField::GlobalLimit => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("globalLimit")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::GlobalLimit) +; + } + GeneratedField::LocalLimit => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("localLimit")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::LocalLimit) +; + } + GeneratedField::Aggregate => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("aggregate")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Aggregate) +; + } + GeneratedField::HashJoin => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("hashJoin")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::HashJoin) +; + } + GeneratedField::Sort => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("sort")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Sort) +; + } + GeneratedField::CoalesceBatches => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("coalesceBatches")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CoalesceBatches) +; + } + GeneratedField::Filter => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("filter")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Filter) +; + } + GeneratedField::Merge => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("merge")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Merge) +; + } + GeneratedField::Repartition => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("repartition")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Repartition) +; + } + GeneratedField::Window => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("window")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Window) +; + } + GeneratedField::CrossJoin => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("crossJoin")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CrossJoin) +; + } + GeneratedField::AvroScan => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("avroScan")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::AvroScan) +; + } + GeneratedField::Extension => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("extension")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Extension) +; + } + GeneratedField::Union => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("union")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Union) +; + } + GeneratedField::Explain => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("explain")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Explain) +; + } + GeneratedField::SortPreservingMerge => { + if physical_plan_type__.is_some() { + return Err(serde::de::Error::duplicate_field("sortPreservingMerge")); + } + physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::SortPreservingMerge) +; + } + } + } + Ok(PhysicalPlanNode { + physical_plan_type: physical_plan_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalPlanNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalScalarFunctionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if self.fun != 0 { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + if self.return_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarFunctionNode", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if self.fun != 0 { + let v = ScalarFunction::from_i32(self.fun) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?; + struct_ser.serialize_field("fun", &v)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + if let Some(v) = self.return_type.as_ref() { + struct_ser.serialize_field("returnType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalScalarFunctionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "fun", + "args", + "return_type", + "returnType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + Fun, + Args, + ReturnType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "fun" => Ok(GeneratedField::Fun), + "args" => Ok(GeneratedField::Args), + "returnType" | "return_type" => Ok(GeneratedField::ReturnType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalScalarFunctionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalScalarFunctionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut fun__ = None; + let mut args__ = None; + let mut return_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Fun => { + if fun__.is_some() { + return Err(serde::de::Error::duplicate_field("fun")); + } + fun__ = Some(map.next_value::()? as i32); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map.next_value()?); + } + GeneratedField::ReturnType => { + if return_type__.is_some() { + return Err(serde::de::Error::duplicate_field("returnType")); + } + return_type__ = map.next_value()?; + } + } + } + Ok(PhysicalScalarFunctionNode { + name: name__.unwrap_or_default(), + fun: fun__.unwrap_or_default(), + args: args__.unwrap_or_default(), + return_type: return_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalScalarFunctionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalScalarUdfNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.name.is_empty() { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + if self.return_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarUdfNode", len)?; + if !self.name.is_empty() { + struct_ser.serialize_field("name", &self.name)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + if let Some(v) = self.return_type.as_ref() { + struct_ser.serialize_field("returnType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalScalarUdfNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "name", + "args", + "return_type", + "returnType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Name, + Args, + ReturnType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "name" => Ok(GeneratedField::Name), + "args" => Ok(GeneratedField::Args), + "returnType" | "return_type" => Ok(GeneratedField::ReturnType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalScalarUdfNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalScalarUdfNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut name__ = None; + let mut args__ = None; + let mut return_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Name => { + if name__.is_some() { + return Err(serde::de::Error::duplicate_field("name")); + } + name__ = Some(map.next_value()?); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map.next_value()?); + } + GeneratedField::ReturnType => { + if return_type__.is_some() { + return Err(serde::de::Error::duplicate_field("returnType")); + } + return_type__ = map.next_value()?; + } + } + } + Ok(PhysicalScalarUdfNode { + name: name__.unwrap_or_default(), + args: args__.unwrap_or_default(), + return_type: return_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalScalarUdfNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalSortExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.asc { + len += 1; + } + if self.nulls_first { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalSortExprNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if self.asc { + struct_ser.serialize_field("asc", &self.asc)?; + } + if self.nulls_first { + struct_ser.serialize_field("nullsFirst", &self.nulls_first)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalSortExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "asc", + "nulls_first", + "nullsFirst", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + Asc, + NullsFirst, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "asc" => Ok(GeneratedField::Asc), + "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalSortExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalSortExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut asc__ = None; + let mut nulls_first__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::Asc => { + if asc__.is_some() { + return Err(serde::de::Error::duplicate_field("asc")); + } + asc__ = Some(map.next_value()?); + } + GeneratedField::NullsFirst => { + if nulls_first__.is_some() { + return Err(serde::de::Error::duplicate_field("nullsFirst")); + } + nulls_first__ = Some(map.next_value()?); + } + } + } + Ok(PhysicalSortExprNode { + expr: expr__, + asc: asc__.unwrap_or_default(), + nulls_first: nulls_first__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalSortExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalTryCastNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.arrow_type.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalTryCastNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.arrow_type.as_ref() { + struct_ser.serialize_field("arrowType", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalTryCastNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "arrow_type", + "arrowType", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + ArrowType, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalTryCastNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalTryCastNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut arrow_type__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::ArrowType => { + if arrow_type__.is_some() { + return Err(serde::de::Error::duplicate_field("arrowType")); + } + arrow_type__ = map.next_value()?; + } + } + } + Ok(PhysicalTryCastNode { + expr: expr__, + arrow_type: arrow_type__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalTryCastNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalWhenThen { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.when_expr.is_some() { + len += 1; + } + if self.then_expr.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWhenThen", len)?; + if let Some(v) = self.when_expr.as_ref() { + struct_ser.serialize_field("whenExpr", v)?; + } + if let Some(v) = self.then_expr.as_ref() { + struct_ser.serialize_field("thenExpr", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalWhenThen { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "when_expr", + "whenExpr", + "then_expr", + "thenExpr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WhenExpr, + ThenExpr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr), + "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalWhenThen; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalWhenThen") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut when_expr__ = None; + let mut then_expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WhenExpr => { + if when_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("whenExpr")); + } + when_expr__ = map.next_value()?; + } + GeneratedField::ThenExpr => { + if then_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("thenExpr")); + } + then_expr__ = map.next_value()?; + } + } + } + Ok(PhysicalWhenThen { + when_expr: when_expr__, + then_expr: then_expr__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalWhenThen", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PhysicalWindowExprNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.expr.is_some() { + len += 1; + } + if self.window_function.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWindowExprNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.window_function.as_ref() { + match v { + physical_window_expr_node::WindowFunction::AggrFunction(v) => { + let v = AggregateFunction::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("aggrFunction", &v)?; + } + physical_window_expr_node::WindowFunction::BuiltInFunction(v) => { + let v = BuiltInWindowFunction::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("builtInFunction", &v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PhysicalWindowExprNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + "aggr_function", + "aggrFunction", + "built_in_function", + "builtInFunction", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + AggrFunction, + BuiltInFunction, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction), + "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PhysicalWindowExprNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PhysicalWindowExprNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + let mut window_function__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::AggrFunction => { + if window_function__.is_some() { + return Err(serde::de::Error::duplicate_field("aggrFunction")); + } + window_function__ = map.next_value::<::std::option::Option>()?.map(|x| physical_window_expr_node::WindowFunction::AggrFunction(x as i32)); + } + GeneratedField::BuiltInFunction => { + if window_function__.is_some() { + return Err(serde::de::Error::duplicate_field("builtInFunction")); + } + window_function__ = map.next_value::<::std::option::Option>()?.map(|x| physical_window_expr_node::WindowFunction::BuiltInFunction(x as i32)); + } + } + } + Ok(PhysicalWindowExprNode { + expr: expr__, + window_function: window_function__, + }) + } + } + deserializer.deserialize_struct("datafusion.PhysicalWindowExprNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PlanType { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.plan_type_enum.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.PlanType", len)?; + if let Some(v) = self.plan_type_enum.as_ref() { + match v { + plan_type::PlanTypeEnum::InitialLogicalPlan(v) => { + struct_ser.serialize_field("InitialLogicalPlan", v)?; + } + plan_type::PlanTypeEnum::OptimizedLogicalPlan(v) => { + struct_ser.serialize_field("OptimizedLogicalPlan", v)?; + } + plan_type::PlanTypeEnum::FinalLogicalPlan(v) => { + struct_ser.serialize_field("FinalLogicalPlan", v)?; + } + plan_type::PlanTypeEnum::InitialPhysicalPlan(v) => { + struct_ser.serialize_field("InitialPhysicalPlan", v)?; + } + plan_type::PlanTypeEnum::OptimizedPhysicalPlan(v) => { + struct_ser.serialize_field("OptimizedPhysicalPlan", v)?; + } + plan_type::PlanTypeEnum::FinalPhysicalPlan(v) => { + struct_ser.serialize_field("FinalPhysicalPlan", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PlanType { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "InitialLogicalPlan", + "OptimizedLogicalPlan", + "FinalLogicalPlan", + "InitialPhysicalPlan", + "OptimizedPhysicalPlan", + "FinalPhysicalPlan", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + InitialLogicalPlan, + OptimizedLogicalPlan, + FinalLogicalPlan, + InitialPhysicalPlan, + OptimizedPhysicalPlan, + FinalPhysicalPlan, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "InitialLogicalPlan" => Ok(GeneratedField::InitialLogicalPlan), + "OptimizedLogicalPlan" => Ok(GeneratedField::OptimizedLogicalPlan), + "FinalLogicalPlan" => Ok(GeneratedField::FinalLogicalPlan), + "InitialPhysicalPlan" => Ok(GeneratedField::InitialPhysicalPlan), + "OptimizedPhysicalPlan" => Ok(GeneratedField::OptimizedPhysicalPlan), + "FinalPhysicalPlan" => Ok(GeneratedField::FinalPhysicalPlan), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PlanType; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.PlanType") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut plan_type_enum__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::InitialLogicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("InitialLogicalPlan")); + } + plan_type_enum__ = 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__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedLogicalPlan) +; + } + GeneratedField::FinalLogicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FinalLogicalPlan")); + } + plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalLogicalPlan) +; + } + GeneratedField::InitialPhysicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan")); + } + plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialPhysicalPlan) +; + } + GeneratedField::OptimizedPhysicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan")); + } + plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedPhysicalPlan) +; + } + GeneratedField::FinalPhysicalPlan => { + if plan_type_enum__.is_some() { + return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan")); + } + plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalPhysicalPlan) +; + } + } + } + Ok(PlanType { + plan_type_enum: plan_type_enum__, + }) + } + } + deserializer.deserialize_struct("datafusion.PlanType", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ProjectionColumns { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.columns.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionColumns", len)?; + if !self.columns.is_empty() { + struct_ser.serialize_field("columns", &self.columns)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ProjectionColumns { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "columns", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Columns, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "columns" => Ok(GeneratedField::Columns), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProjectionColumns; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ProjectionColumns") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut columns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); + } + columns__ = Some(map.next_value()?); + } + } + } + Ok(ProjectionColumns { + columns: columns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ProjectionColumns", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ProjectionExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.expr.is_empty() { + len += 1; + } + if !self.expr_name.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if !self.expr_name.is_empty() { + struct_ser.serialize_field("exprName", &self.expr_name)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ProjectionExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "expr", + "expr_name", + "exprName", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Expr, + ExprName, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), + "exprName" | "expr_name" => Ok(GeneratedField::ExprName), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProjectionExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ProjectionExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut expr__ = None; + let mut expr_name__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::ExprName => { + if expr_name__.is_some() { + return Err(serde::de::Error::duplicate_field("exprName")); + } + expr_name__ = Some(map.next_value()?); + } + } + } + Ok(ProjectionExecNode { + input: input__, + expr: expr__.unwrap_or_default(), + expr_name: expr_name__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ProjectionExecNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ProjectionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.expr.is_empty() { + len += 1; + } + if self.optional_alias.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if let Some(v) = self.optional_alias.as_ref() { + match v { + projection_node::OptionalAlias::Alias(v) => { + struct_ser.serialize_field("alias", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ProjectionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "expr", + "alias", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + Expr, + Alias, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), + "alias" => Ok(GeneratedField::Alias), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ProjectionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ProjectionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut expr__ = None; + let mut optional_alias__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + GeneratedField::Alias => { + if optional_alias__.is_some() { + return Err(serde::de::Error::duplicate_field("alias")); + } + optional_alias__ = map.next_value::<::std::option::Option<_>>()?.map(projection_node::OptionalAlias::Alias); + } + } + } + Ok(ProjectionNode { + input: input__, + expr: expr__.unwrap_or_default(), + optional_alias: optional_alias__, + }) + } + } + deserializer.deserialize_struct("datafusion.ProjectionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for RepartitionExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.partition_method.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.partition_method.as_ref() { + match v { + repartition_exec_node::PartitionMethod::RoundRobin(v) => { + struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?; + } + repartition_exec_node::PartitionMethod::Hash(v) => { + struct_ser.serialize_field("hash", v)?; + } + repartition_exec_node::PartitionMethod::Unknown(v) => { + struct_ser.serialize_field("unknown", ToString::to_string(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for RepartitionExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "round_robin", + "roundRobin", + "hash", + "unknown", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + RoundRobin, + Hash, + Unknown, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin), + "hash" => Ok(GeneratedField::Hash), + "unknown" => Ok(GeneratedField::Unknown), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RepartitionExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.RepartitionExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut partition_method__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::RoundRobin => { + if partition_method__.is_some() { + return Err(serde::de::Error::duplicate_field("roundRobin")); + } + partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::RoundRobin(x.0)); + } + GeneratedField::Hash => { + if partition_method__.is_some() { + return Err(serde::de::Error::duplicate_field("hash")); + } + partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_exec_node::PartitionMethod::Hash) +; + } + GeneratedField::Unknown => { + if partition_method__.is_some() { + return Err(serde::de::Error::duplicate_field("unknown")); + } + partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::Unknown(x.0)); + } + } + } + Ok(RepartitionExecNode { + input: input__, + partition_method: partition_method__, + }) + } + } + deserializer.deserialize_struct("datafusion.RepartitionExecNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for RepartitionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if self.partition_method.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.partition_method.as_ref() { + match v { + repartition_node::PartitionMethod::RoundRobin(v) => { + struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?; + } + repartition_node::PartitionMethod::Hash(v) => { + struct_ser.serialize_field("hash", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for RepartitionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "round_robin", + "roundRobin", + "hash", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + RoundRobin, + Hash, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin), + "hash" => Ok(GeneratedField::Hash), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RepartitionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.RepartitionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut partition_method__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::RoundRobin => { + if partition_method__.is_some() { + return Err(serde::de::Error::duplicate_field("roundRobin")); + } + partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_node::PartitionMethod::RoundRobin(x.0)); + } + GeneratedField::Hash => { + if partition_method__.is_some() { + return Err(serde::de::Error::duplicate_field("hash")); + } + partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_node::PartitionMethod::Hash) +; + } + } + } + Ok(RepartitionNode { + input: input__, + partition_method: partition_method__, + }) + } + } + deserializer.deserialize_struct("datafusion.RepartitionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for RollupNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.expr.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.RollupNode", len)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for RollupNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "expr", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Expr, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "expr" => Ok(GeneratedField::Expr), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = RollupNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.RollupNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut expr__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = Some(map.next_value()?); + } + } + } + Ok(RollupNode { + expr: expr__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.RollupNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarDictionaryValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.index_type.is_some() { + len += 1; + } + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarDictionaryValue", len)?; + if let Some(v) = self.index_type.as_ref() { + struct_ser.serialize_field("indexType", v)?; + } + if let Some(v) = self.value.as_ref() { + struct_ser.serialize_field("value", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "index_type", + "indexType", + "value", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IndexType, + Value, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "indexType" | "index_type" => Ok(GeneratedField::IndexType), + "value" => Ok(GeneratedField::Value), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarDictionaryValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarDictionaryValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut index_type__ = None; + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IndexType => { + if index_type__.is_some() { + return Err(serde::de::Error::duplicate_field("indexType")); + } + index_type__ = map.next_value()?; + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = map.next_value()?; + } + } + } + Ok(ScalarDictionaryValue { + index_type: index_type__, + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarFixedSizeBinary { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + 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(deserializer: D) -> std::result::Result + 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(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "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(self, mut map: V) -> std::result::Result + 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(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Abs => "Abs", + Self::Acos => "Acos", + Self::Asin => "Asin", + Self::Atan => "Atan", + Self::Ascii => "Ascii", + Self::Ceil => "Ceil", + Self::Cos => "Cos", + Self::Digest => "Digest", + Self::Exp => "Exp", + Self::Floor => "Floor", + Self::Ln => "Ln", + Self::Log => "Log", + Self::Log10 => "Log10", + Self::Log2 => "Log2", + Self::Round => "Round", + Self::Signum => "Signum", + Self::Sin => "Sin", + Self::Sqrt => "Sqrt", + Self::Tan => "Tan", + Self::Trunc => "Trunc", + Self::Array => "Array", + Self::RegexpMatch => "RegexpMatch", + Self::BitLength => "BitLength", + Self::Btrim => "Btrim", + Self::CharacterLength => "CharacterLength", + Self::Chr => "Chr", + Self::Concat => "Concat", + Self::ConcatWithSeparator => "ConcatWithSeparator", + Self::DatePart => "DatePart", + Self::DateTrunc => "DateTrunc", + Self::InitCap => "InitCap", + Self::Left => "Left", + Self::Lpad => "Lpad", + Self::Lower => "Lower", + Self::Ltrim => "Ltrim", + Self::Md5 => "MD5", + Self::NullIf => "NullIf", + Self::OctetLength => "OctetLength", + Self::Random => "Random", + Self::RegexpReplace => "RegexpReplace", + Self::Repeat => "Repeat", + Self::Replace => "Replace", + Self::Reverse => "Reverse", + Self::Right => "Right", + Self::Rpad => "Rpad", + Self::Rtrim => "Rtrim", + Self::Sha224 => "SHA224", + Self::Sha256 => "SHA256", + Self::Sha384 => "SHA384", + Self::Sha512 => "SHA512", + Self::SplitPart => "SplitPart", + Self::StartsWith => "StartsWith", + Self::Strpos => "Strpos", + Self::Substr => "Substr", + Self::ToHex => "ToHex", + Self::ToTimestamp => "ToTimestamp", + Self::ToTimestampMillis => "ToTimestampMillis", + Self::ToTimestampMicros => "ToTimestampMicros", + Self::ToTimestampSeconds => "ToTimestampSeconds", + Self::Now => "Now", + Self::Translate => "Translate", + Self::Trim => "Trim", + Self::Upper => "Upper", + Self::Coalesce => "Coalesce", + Self::Power => "Power", + Self::StructFun => "StructFun", + Self::FromUnixtime => "FromUnixtime", + Self::Atan2 => "Atan2", + Self::DateBin => "DateBin", + Self::ArrowTypeof => "ArrowTypeof", + Self::CurrentDate => "CurrentDate", + Self::CurrentTime => "CurrentTime", + Self::Uuid => "Uuid", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ScalarFunction { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "Abs", + "Acos", + "Asin", + "Atan", + "Ascii", + "Ceil", + "Cos", + "Digest", + "Exp", + "Floor", + "Ln", + "Log", + "Log10", + "Log2", + "Round", + "Signum", + "Sin", + "Sqrt", + "Tan", + "Trunc", + "Array", + "RegexpMatch", + "BitLength", + "Btrim", + "CharacterLength", + "Chr", + "Concat", + "ConcatWithSeparator", + "DatePart", + "DateTrunc", + "InitCap", + "Left", + "Lpad", + "Lower", + "Ltrim", + "MD5", + "NullIf", + "OctetLength", + "Random", + "RegexpReplace", + "Repeat", + "Replace", + "Reverse", + "Right", + "Rpad", + "Rtrim", + "SHA224", + "SHA256", + "SHA384", + "SHA512", + "SplitPart", + "StartsWith", + "Strpos", + "Substr", + "ToHex", + "ToTimestamp", + "ToTimestampMillis", + "ToTimestampMicros", + "ToTimestampSeconds", + "Now", + "Translate", + "Trim", + "Upper", + "Coalesce", + "Power", + "StructFun", + "FromUnixtime", + "Atan2", + "DateBin", + "ArrowTypeof", + "CurrentDate", + "CurrentTime", + "Uuid", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarFunction; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() .and_then(ScalarFunction::from_i32) .ok_or_else(|| { serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) }) } - fn visit_u64(self, v: u64) -> std::result::Result + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(ScalarFunction::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "Abs" => Ok(ScalarFunction::Abs), + "Acos" => Ok(ScalarFunction::Acos), + "Asin" => Ok(ScalarFunction::Asin), + "Atan" => Ok(ScalarFunction::Atan), + "Ascii" => Ok(ScalarFunction::Ascii), + "Ceil" => Ok(ScalarFunction::Ceil), + "Cos" => Ok(ScalarFunction::Cos), + "Digest" => Ok(ScalarFunction::Digest), + "Exp" => Ok(ScalarFunction::Exp), + "Floor" => Ok(ScalarFunction::Floor), + "Ln" => Ok(ScalarFunction::Ln), + "Log" => Ok(ScalarFunction::Log), + "Log10" => Ok(ScalarFunction::Log10), + "Log2" => Ok(ScalarFunction::Log2), + "Round" => Ok(ScalarFunction::Round), + "Signum" => Ok(ScalarFunction::Signum), + "Sin" => Ok(ScalarFunction::Sin), + "Sqrt" => Ok(ScalarFunction::Sqrt), + "Tan" => Ok(ScalarFunction::Tan), + "Trunc" => Ok(ScalarFunction::Trunc), + "Array" => Ok(ScalarFunction::Array), + "RegexpMatch" => Ok(ScalarFunction::RegexpMatch), + "BitLength" => Ok(ScalarFunction::BitLength), + "Btrim" => Ok(ScalarFunction::Btrim), + "CharacterLength" => Ok(ScalarFunction::CharacterLength), + "Chr" => Ok(ScalarFunction::Chr), + "Concat" => Ok(ScalarFunction::Concat), + "ConcatWithSeparator" => Ok(ScalarFunction::ConcatWithSeparator), + "DatePart" => Ok(ScalarFunction::DatePart), + "DateTrunc" => Ok(ScalarFunction::DateTrunc), + "InitCap" => Ok(ScalarFunction::InitCap), + "Left" => Ok(ScalarFunction::Left), + "Lpad" => Ok(ScalarFunction::Lpad), + "Lower" => Ok(ScalarFunction::Lower), + "Ltrim" => Ok(ScalarFunction::Ltrim), + "MD5" => Ok(ScalarFunction::Md5), + "NullIf" => Ok(ScalarFunction::NullIf), + "OctetLength" => Ok(ScalarFunction::OctetLength), + "Random" => Ok(ScalarFunction::Random), + "RegexpReplace" => Ok(ScalarFunction::RegexpReplace), + "Repeat" => Ok(ScalarFunction::Repeat), + "Replace" => Ok(ScalarFunction::Replace), + "Reverse" => Ok(ScalarFunction::Reverse), + "Right" => Ok(ScalarFunction::Right), + "Rpad" => Ok(ScalarFunction::Rpad), + "Rtrim" => Ok(ScalarFunction::Rtrim), + "SHA224" => Ok(ScalarFunction::Sha224), + "SHA256" => Ok(ScalarFunction::Sha256), + "SHA384" => Ok(ScalarFunction::Sha384), + "SHA512" => Ok(ScalarFunction::Sha512), + "SplitPart" => Ok(ScalarFunction::SplitPart), + "StartsWith" => Ok(ScalarFunction::StartsWith), + "Strpos" => Ok(ScalarFunction::Strpos), + "Substr" => Ok(ScalarFunction::Substr), + "ToHex" => Ok(ScalarFunction::ToHex), + "ToTimestamp" => Ok(ScalarFunction::ToTimestamp), + "ToTimestampMillis" => Ok(ScalarFunction::ToTimestampMillis), + "ToTimestampMicros" => Ok(ScalarFunction::ToTimestampMicros), + "ToTimestampSeconds" => Ok(ScalarFunction::ToTimestampSeconds), + "Now" => Ok(ScalarFunction::Now), + "Translate" => Ok(ScalarFunction::Translate), + "Trim" => Ok(ScalarFunction::Trim), + "Upper" => Ok(ScalarFunction::Upper), + "Coalesce" => Ok(ScalarFunction::Coalesce), + "Power" => Ok(ScalarFunction::Power), + "StructFun" => Ok(ScalarFunction::StructFun), + "FromUnixtime" => Ok(ScalarFunction::FromUnixtime), + "Atan2" => Ok(ScalarFunction::Atan2), + "DateBin" => Ok(ScalarFunction::DateBin), + "ArrowTypeof" => Ok(ScalarFunction::ArrowTypeof), + "CurrentDate" => Ok(ScalarFunction::CurrentDate), + "CurrentTime" => Ok(ScalarFunction::CurrentTime), + "Uuid" => Ok(ScalarFunction::Uuid), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ScalarFunctionNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.fun != 0 { + len += 1; + } + if !self.args.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFunctionNode", len)?; + if self.fun != 0 { + let v = ScalarFunction::from_i32(self.fun) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?; + struct_ser.serialize_field("fun", &v)?; + } + if !self.args.is_empty() { + struct_ser.serialize_field("args", &self.args)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarFunctionNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "fun", + "args", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Fun, + Args, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "fun" => Ok(GeneratedField::Fun), + "args" => Ok(GeneratedField::Args), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarFunctionNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarFunctionNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut fun__ = None; + let mut args__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Fun => { + if fun__.is_some() { + return Err(serde::de::Error::duplicate_field("fun")); + } + fun__ = Some(map.next_value::()? as i32); + } + GeneratedField::Args => { + if args__.is_some() { + return Err(serde::de::Error::duplicate_field("args")); + } + args__ = Some(map.next_value()?); + } + } + } + Ok(ScalarFunctionNode { + fun: fun__.unwrap_or_default(), + args: args__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarFunctionNode", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarListValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.is_null { + len += 1; + } + if self.field.is_some() { + len += 1; + } + if !self.values.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarListValue", len)?; + if self.is_null { + struct_ser.serialize_field("isNull", &self.is_null)?; + } + if let Some(v) = self.field.as_ref() { + struct_ser.serialize_field("field", v)?; + } + if !self.values.is_empty() { + struct_ser.serialize_field("values", &self.values)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarListValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "is_null", + "isNull", + "field", + "values", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IsNull, + Field, + Values, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "isNull" | "is_null" => Ok(GeneratedField::IsNull), + "field" => Ok(GeneratedField::Field), + "values" => Ok(GeneratedField::Values), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarListValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarListValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut is_null__ = None; + let mut field__ = None; + let mut values__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IsNull => { + if is_null__.is_some() { + return Err(serde::de::Error::duplicate_field("isNull")); + } + is_null__ = Some(map.next_value()?); + } + GeneratedField::Field => { + if field__.is_some() { + return Err(serde::de::Error::duplicate_field("field")); + } + field__ = map.next_value()?; + } + GeneratedField::Values => { + if values__.is_some() { + return Err(serde::de::Error::duplicate_field("values")); + } + values__ = Some(map.next_value()?); + } + } + } + Ok(ScalarListValue { + is_null: is_null__.unwrap_or_default(), + field: field__, + values: values__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarListValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarTime32Value { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime32Value", len)?; + if let Some(v) = self.value.as_ref() { + match v { + scalar_time32_value::Value::Time32SecondValue(v) => { + struct_ser.serialize_field("time32SecondValue", v)?; + } + scalar_time32_value::Value::Time32MillisecondValue(v) => { + struct_ser.serialize_field("time32MillisecondValue", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarTime32Value { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "time32_second_value", + "time32SecondValue", + "time32_millisecond_value", + "time32MillisecondValue", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Time32SecondValue, + Time32MillisecondValue, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "time32SecondValue" | "time32_second_value" => Ok(GeneratedField::Time32SecondValue), + "time32MillisecondValue" | "time32_millisecond_value" => Ok(GeneratedField::Time32MillisecondValue), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarTime32Value; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarTime32Value") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Time32SecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("time32SecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32SecondValue(x.0)); + } + GeneratedField::Time32MillisecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("time32MillisecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32MillisecondValue(x.0)); + } + } + } + Ok(ScalarTime32Value { + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarTime32Value", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarTime64Value { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime64Value", len)?; + if let Some(v) = self.value.as_ref() { + match v { + scalar_time64_value::Value::Time64MicrosecondValue(v) => { + struct_ser.serialize_field("time64MicrosecondValue", ToString::to_string(&v).as_str())?; + } + scalar_time64_value::Value::Time64NanosecondValue(v) => { + struct_ser.serialize_field("time64NanosecondValue", ToString::to_string(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarTime64Value { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "time64_microsecond_value", + "time64MicrosecondValue", + "time64_nanosecond_value", + "time64NanosecondValue", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Time64MicrosecondValue, + Time64NanosecondValue, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result where - E: serde::de::Error, + D: serde::Deserializer<'de>, { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(ScalarFunction::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "time64MicrosecondValue" | "time64_microsecond_value" => Ok(GeneratedField::Time64MicrosecondValue), + "time64NanosecondValue" | "time64_nanosecond_value" => Ok(GeneratedField::Time64NanosecondValue), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarTime64Value; - fn visit_str(self, value: &str) -> std::result::Result + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarTime64Value") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Time64MicrosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("time64MicrosecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64MicrosecondValue(x.0)); + } + GeneratedField::Time64NanosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("time64NanosecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64NanosecondValue(x.0)); + } + } + } + Ok(ScalarTime64Value { + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarTime64Value", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ScalarTimestampValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.timezone.is_empty() { + len += 1; + } + if self.value.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTimestampValue", len)?; + if !self.timezone.is_empty() { + struct_ser.serialize_field("timezone", &self.timezone)?; + } + if let Some(v) = self.value.as_ref() { + match v { + scalar_timestamp_value::Value::TimeMicrosecondValue(v) => { + struct_ser.serialize_field("timeMicrosecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeNanosecondValue(v) => { + struct_ser.serialize_field("timeNanosecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeSecondValue(v) => { + struct_ser.serialize_field("timeSecondValue", ToString::to_string(&v).as_str())?; + } + scalar_timestamp_value::Value::TimeMillisecondValue(v) => { + struct_ser.serialize_field("timeMillisecondValue", ToString::to_string(&v).as_str())?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ScalarTimestampValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timezone", + "time_microsecond_value", + "timeMicrosecondValue", + "time_nanosecond_value", + "timeNanosecondValue", + "time_second_value", + "timeSecondValue", + "time_millisecond_value", + "timeMillisecondValue", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Timezone, + TimeMicrosecondValue, + TimeNanosecondValue, + TimeSecondValue, + TimeMillisecondValue, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result where - E: serde::de::Error, + D: serde::Deserializer<'de>, { - match value { - "Abs" => Ok(ScalarFunction::Abs), - "Acos" => Ok(ScalarFunction::Acos), - "Asin" => Ok(ScalarFunction::Asin), - "Atan" => Ok(ScalarFunction::Atan), - "Ascii" => Ok(ScalarFunction::Ascii), - "Ceil" => Ok(ScalarFunction::Ceil), - "Cos" => Ok(ScalarFunction::Cos), - "Digest" => Ok(ScalarFunction::Digest), - "Exp" => Ok(ScalarFunction::Exp), - "Floor" => Ok(ScalarFunction::Floor), - "Ln" => Ok(ScalarFunction::Ln), - "Log" => Ok(ScalarFunction::Log), - "Log10" => Ok(ScalarFunction::Log10), - "Log2" => Ok(ScalarFunction::Log2), - "Round" => Ok(ScalarFunction::Round), - "Signum" => Ok(ScalarFunction::Signum), - "Sin" => Ok(ScalarFunction::Sin), - "Sqrt" => Ok(ScalarFunction::Sqrt), - "Tan" => Ok(ScalarFunction::Tan), - "Trunc" => Ok(ScalarFunction::Trunc), - "Array" => Ok(ScalarFunction::Array), - "RegexpMatch" => Ok(ScalarFunction::RegexpMatch), - "BitLength" => Ok(ScalarFunction::BitLength), - "Btrim" => Ok(ScalarFunction::Btrim), - "CharacterLength" => Ok(ScalarFunction::CharacterLength), - "Chr" => Ok(ScalarFunction::Chr), - "Concat" => Ok(ScalarFunction::Concat), - "ConcatWithSeparator" => Ok(ScalarFunction::ConcatWithSeparator), - "DatePart" => Ok(ScalarFunction::DatePart), - "DateTrunc" => Ok(ScalarFunction::DateTrunc), - "InitCap" => Ok(ScalarFunction::InitCap), - "Left" => Ok(ScalarFunction::Left), - "Lpad" => Ok(ScalarFunction::Lpad), - "Lower" => Ok(ScalarFunction::Lower), - "Ltrim" => Ok(ScalarFunction::Ltrim), - "MD5" => Ok(ScalarFunction::Md5), - "NullIf" => Ok(ScalarFunction::NullIf), - "OctetLength" => Ok(ScalarFunction::OctetLength), - "Random" => Ok(ScalarFunction::Random), - "RegexpReplace" => Ok(ScalarFunction::RegexpReplace), - "Repeat" => Ok(ScalarFunction::Repeat), - "Replace" => Ok(ScalarFunction::Replace), - "Reverse" => Ok(ScalarFunction::Reverse), - "Right" => Ok(ScalarFunction::Right), - "Rpad" => Ok(ScalarFunction::Rpad), - "Rtrim" => Ok(ScalarFunction::Rtrim), - "SHA224" => Ok(ScalarFunction::Sha224), - "SHA256" => Ok(ScalarFunction::Sha256), - "SHA384" => Ok(ScalarFunction::Sha384), - "SHA512" => Ok(ScalarFunction::Sha512), - "SplitPart" => Ok(ScalarFunction::SplitPart), - "StartsWith" => Ok(ScalarFunction::StartsWith), - "Strpos" => Ok(ScalarFunction::Strpos), - "Substr" => Ok(ScalarFunction::Substr), - "ToHex" => Ok(ScalarFunction::ToHex), - "ToTimestamp" => Ok(ScalarFunction::ToTimestamp), - "ToTimestampMillis" => Ok(ScalarFunction::ToTimestampMillis), - "ToTimestampMicros" => Ok(ScalarFunction::ToTimestampMicros), - "ToTimestampSeconds" => Ok(ScalarFunction::ToTimestampSeconds), - "Now" => Ok(ScalarFunction::Now), - "Translate" => Ok(ScalarFunction::Translate), - "Trim" => Ok(ScalarFunction::Trim), - "Upper" => Ok(ScalarFunction::Upper), - "Coalesce" => Ok(ScalarFunction::Coalesce), - "Power" => Ok(ScalarFunction::Power), - "StructFun" => Ok(ScalarFunction::StructFun), - "FromUnixtime" => Ok(ScalarFunction::FromUnixtime), - "Atan2" => Ok(ScalarFunction::Atan2), - "DateBin" => Ok(ScalarFunction::DateBin), - "ArrowTypeof" => Ok(ScalarFunction::ArrowTypeof), - "CurrentDate" => Ok(ScalarFunction::CurrentDate), - "CurrentTime" => Ok(ScalarFunction::CurrentTime), - "Uuid" => Ok(ScalarFunction::Uuid), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timezone" => Ok(GeneratedField::Timezone), + "timeMicrosecondValue" | "time_microsecond_value" => Ok(GeneratedField::TimeMicrosecondValue), + "timeNanosecondValue" | "time_nanosecond_value" => Ok(GeneratedField::TimeNanosecondValue), + "timeSecondValue" | "time_second_value" => Ok(GeneratedField::TimeSecondValue), + "timeMillisecondValue" | "time_millisecond_value" => Ok(GeneratedField::TimeMillisecondValue), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } } + deserializer.deserialize_identifier(GeneratedVisitor) } } - deserializer.deserialize_any(GeneratedVisitor) + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ScalarTimestampValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.ScalarTimestampValue") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut timezone__ = None; + let mut value__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Timezone => { + if timezone__.is_some() { + return Err(serde::de::Error::duplicate_field("timezone")); + } + timezone__ = Some(map.next_value()?); + } + GeneratedField::TimeMicrosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeMicrosecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMicrosecondValue(x.0)); + } + GeneratedField::TimeNanosecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeNanosecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeNanosecondValue(x.0)); + } + GeneratedField::TimeSecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeSecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeSecondValue(x.0)); + } + GeneratedField::TimeMillisecondValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timeMillisecondValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMillisecondValue(x.0)); + } + } + } + Ok(ScalarTimestampValue { + timezone: timezone__.unwrap_or_default(), + value: value__, + }) + } + } + deserializer.deserialize_struct("datafusion.ScalarTimestampValue", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarFunctionNode { +impl serde::Serialize for ScalarUdfExprNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9857,17 +17953,15 @@ impl serde::Serialize for ScalarFunctionNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.fun != 0 { + if !self.fun_name.is_empty() { len += 1; } if !self.args.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFunctionNode", len)?; - if self.fun != 0 { - let v = ScalarFunction::from_i32(self.fun) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?; - struct_ser.serialize_field("fun", &v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarUDFExprNode", len)?; + if !self.fun_name.is_empty() { + struct_ser.serialize_field("funName", &self.fun_name)?; } if !self.args.is_empty() { struct_ser.serialize_field("args", &self.args)?; @@ -9875,20 +17969,21 @@ impl serde::Serialize for ScalarFunctionNode { struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarFunctionNode { +impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "fun", + "fun_name", + "funName", "args", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Fun, + FunName, Args, } impl<'de> serde::Deserialize<'de> for GeneratedField { @@ -9911,7 +18006,7 @@ impl<'de> serde::Deserialize<'de> for ScalarFunctionNode { E: serde::de::Error, { match value { - "fun" => Ok(GeneratedField::Fun), + "funName" | "fun_name" => Ok(GeneratedField::FunName), "args" => Ok(GeneratedField::Args), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } @@ -9922,25 +18017,25 @@ impl<'de> serde::Deserialize<'de> for ScalarFunctionNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarFunctionNode; + type Value = ScalarUdfExprNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarFunctionNode") + formatter.write_str("struct datafusion.ScalarUDFExprNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut fun__ = None; + let mut fun_name__ = None; let mut args__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Fun => { - if fun__.is_some() { - return Err(serde::de::Error::duplicate_field("fun")); + GeneratedField::FunName => { + if fun_name__.is_some() { + return Err(serde::de::Error::duplicate_field("funName")); } - fun__ = Some(map.next_value::()? as i32); + fun_name__ = Some(map.next_value()?); } GeneratedField::Args => { if args__.is_some() { @@ -9950,16 +18045,16 @@ impl<'de> serde::Deserialize<'de> for ScalarFunctionNode { } } } - Ok(ScalarFunctionNode { - fun: fun__.unwrap_or_default(), + Ok(ScalarUdfExprNode { + fun_name: fun_name__.unwrap_or_default(), args: args__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.ScalarFunctionNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ScalarUDFExprNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarListValue { +impl serde::Serialize for ScalarValue { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -9967,46 +18062,202 @@ impl serde::Serialize for ScalarListValue { { use serde::ser::SerializeStruct; let mut len = 0; - if self.is_null { - len += 1; - } - if self.field.is_some() { - len += 1; - } - if !self.values.is_empty() { + if self.value.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarListValue", len)?; - if self.is_null { - struct_ser.serialize_field("isNull", &self.is_null)?; - } - if let Some(v) = self.field.as_ref() { - struct_ser.serialize_field("field", v)?; - } - if !self.values.is_empty() { - struct_ser.serialize_field("values", &self.values)?; + let mut struct_ser = serializer.serialize_struct("datafusion.ScalarValue", len)?; + if let Some(v) = self.value.as_ref() { + match v { + scalar_value::Value::NullValue(v) => { + struct_ser.serialize_field("nullValue", v)?; + } + scalar_value::Value::BoolValue(v) => { + struct_ser.serialize_field("boolValue", v)?; + } + scalar_value::Value::Utf8Value(v) => { + struct_ser.serialize_field("utf8Value", v)?; + } + scalar_value::Value::LargeUtf8Value(v) => { + struct_ser.serialize_field("largeUtf8Value", v)?; + } + scalar_value::Value::Int8Value(v) => { + struct_ser.serialize_field("int8Value", v)?; + } + scalar_value::Value::Int16Value(v) => { + struct_ser.serialize_field("int16Value", v)?; + } + scalar_value::Value::Int32Value(v) => { + struct_ser.serialize_field("int32Value", v)?; + } + scalar_value::Value::Int64Value(v) => { + struct_ser.serialize_field("int64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::Uint8Value(v) => { + struct_ser.serialize_field("uint8Value", v)?; + } + scalar_value::Value::Uint16Value(v) => { + struct_ser.serialize_field("uint16Value", v)?; + } + scalar_value::Value::Uint32Value(v) => { + struct_ser.serialize_field("uint32Value", v)?; + } + scalar_value::Value::Uint64Value(v) => { + struct_ser.serialize_field("uint64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::Float32Value(v) => { + struct_ser.serialize_field("float32Value", v)?; + } + scalar_value::Value::Float64Value(v) => { + struct_ser.serialize_field("float64Value", v)?; + } + scalar_value::Value::Date32Value(v) => { + struct_ser.serialize_field("date32Value", v)?; + } + scalar_value::Value::Time32Value(v) => { + struct_ser.serialize_field("time32Value", v)?; + } + scalar_value::Value::ListValue(v) => { + struct_ser.serialize_field("listValue", v)?; + } + scalar_value::Value::Decimal128Value(v) => { + struct_ser.serialize_field("decimal128Value", v)?; + } + scalar_value::Value::Date64Value(v) => { + struct_ser.serialize_field("date64Value", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::IntervalYearmonthValue(v) => { + struct_ser.serialize_field("intervalYearmonthValue", v)?; + } + scalar_value::Value::IntervalDaytimeValue(v) => { + struct_ser.serialize_field("intervalDaytimeValue", ToString::to_string(&v).as_str())?; + } + scalar_value::Value::TimestampValue(v) => { + struct_ser.serialize_field("timestampValue", v)?; + } + scalar_value::Value::DictionaryValue(v) => { + struct_ser.serialize_field("dictionaryValue", v)?; + } + scalar_value::Value::BinaryValue(v) => { + struct_ser.serialize_field("binaryValue", pbjson::private::base64::encode(&v).as_str())?; + } + scalar_value::Value::LargeBinaryValue(v) => { + struct_ser.serialize_field("largeBinaryValue", pbjson::private::base64::encode(&v).as_str())?; + } + scalar_value::Value::Time64Value(v) => { + struct_ser.serialize_field("time64Value", v)?; + } + scalar_value::Value::IntervalMonthDayNano(v) => { + struct_ser.serialize_field("intervalMonthDayNano", v)?; + } + scalar_value::Value::StructValue(v) => { + struct_ser.serialize_field("structValue", v)?; + } + scalar_value::Value::FixedSizeBinaryValue(v) => { + struct_ser.serialize_field("fixedSizeBinaryValue", v)?; + } + } } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarListValue { +impl<'de> serde::Deserialize<'de> for ScalarValue { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "is_null", - "isNull", - "field", - "values", + "null_value", + "nullValue", + "bool_value", + "boolValue", + "utf8_value", + "utf8Value", + "large_utf8_value", + "largeUtf8Value", + "int8_value", + "int8Value", + "int16_value", + "int16Value", + "int32_value", + "int32Value", + "int64_value", + "int64Value", + "uint8_value", + "uint8Value", + "uint16_value", + "uint16Value", + "uint32_value", + "uint32Value", + "uint64_value", + "uint64Value", + "float32_value", + "float32Value", + "float64_value", + "float64Value", + "date_32_value", + "date32Value", + "time32_value", + "time32Value", + "list_value", + "listValue", + "decimal128_value", + "decimal128Value", + "date_64_value", + "date64Value", + "interval_yearmonth_value", + "intervalYearmonthValue", + "interval_daytime_value", + "intervalDaytimeValue", + "timestamp_value", + "timestampValue", + "dictionary_value", + "dictionaryValue", + "binary_value", + "binaryValue", + "large_binary_value", + "largeBinaryValue", + "time64_value", + "time64Value", + "interval_month_day_nano", + "intervalMonthDayNano", + "struct_value", + "structValue", + "fixed_size_binary_value", + "fixedSizeBinaryValue", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - IsNull, - Field, - Values, + NullValue, + BoolValue, + Utf8Value, + LargeUtf8Value, + Int8Value, + Int16Value, + Int32Value, + Int64Value, + Uint8Value, + Uint16Value, + Uint32Value, + Uint64Value, + Float32Value, + Float64Value, + Date32Value, + Time32Value, + ListValue, + Decimal128Value, + Date64Value, + IntervalYearmonthValue, + IntervalDaytimeValue, + TimestampValue, + DictionaryValue, + BinaryValue, + LargeBinaryValue, + Time64Value, + IntervalMonthDayNano, + StructValue, + FixedSizeBinaryValue, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10028,9 +18279,35 @@ impl<'de> serde::Deserialize<'de> for ScalarListValue { E: serde::de::Error, { match value { - "isNull" | "is_null" => Ok(GeneratedField::IsNull), - "field" => Ok(GeneratedField::Field), - "values" => Ok(GeneratedField::Values), + "nullValue" | "null_value" => Ok(GeneratedField::NullValue), + "boolValue" | "bool_value" => Ok(GeneratedField::BoolValue), + "utf8Value" | "utf8_value" => Ok(GeneratedField::Utf8Value), + "largeUtf8Value" | "large_utf8_value" => Ok(GeneratedField::LargeUtf8Value), + "int8Value" | "int8_value" => Ok(GeneratedField::Int8Value), + "int16Value" | "int16_value" => Ok(GeneratedField::Int16Value), + "int32Value" | "int32_value" => Ok(GeneratedField::Int32Value), + "int64Value" | "int64_value" => Ok(GeneratedField::Int64Value), + "uint8Value" | "uint8_value" => Ok(GeneratedField::Uint8Value), + "uint16Value" | "uint16_value" => Ok(GeneratedField::Uint16Value), + "uint32Value" | "uint32_value" => Ok(GeneratedField::Uint32Value), + "uint64Value" | "uint64_value" => Ok(GeneratedField::Uint64Value), + "float32Value" | "float32_value" => Ok(GeneratedField::Float32Value), + "float64Value" | "float64_value" => Ok(GeneratedField::Float64Value), + "date32Value" | "date_32_value" => Ok(GeneratedField::Date32Value), + "time32Value" | "time32_value" => Ok(GeneratedField::Time32Value), + "listValue" | "list_value" => Ok(GeneratedField::ListValue), + "decimal128Value" | "decimal128_value" => Ok(GeneratedField::Decimal128Value), + "date64Value" | "date_64_value" => Ok(GeneratedField::Date64Value), + "intervalYearmonthValue" | "interval_yearmonth_value" => Ok(GeneratedField::IntervalYearmonthValue), + "intervalDaytimeValue" | "interval_daytime_value" => Ok(GeneratedField::IntervalDaytimeValue), + "timestampValue" | "timestamp_value" => Ok(GeneratedField::TimestampValue), + "dictionaryValue" | "dictionary_value" => Ok(GeneratedField::DictionaryValue), + "binaryValue" | "binary_value" => Ok(GeneratedField::BinaryValue), + "largeBinaryValue" | "large_binary_value" => Ok(GeneratedField::LargeBinaryValue), + "time64Value" | "time64_value" => Ok(GeneratedField::Time64Value), + "intervalMonthDayNano" | "interval_month_day_nano" => Ok(GeneratedField::IntervalMonthDayNano), + "structValue" | "struct_value" => Ok(GeneratedField::StructValue), + "fixedSizeBinaryValue" | "fixed_size_binary_value" => Ok(GeneratedField::FixedSizeBinaryValue), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10040,52 +18317,214 @@ impl<'de> serde::Deserialize<'de> for ScalarListValue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarListValue; + type Value = ScalarValue; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarListValue") + formatter.write_str("struct datafusion.ScalarValue") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut is_null__ = None; - let mut field__ = None; - let mut values__ = None; + let mut value__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::IsNull => { - if is_null__.is_some() { - return Err(serde::de::Error::duplicate_field("isNull")); + GeneratedField::NullValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("nullValue")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::NullValue) +; + } + GeneratedField::BoolValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("boolValue")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::BoolValue); + } + GeneratedField::Utf8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("utf8Value")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Utf8Value); + } + GeneratedField::LargeUtf8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("largeUtf8Value")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::LargeUtf8Value); + } + GeneratedField::Int8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int8Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int8Value(x.0)); + } + GeneratedField::Int16Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int16Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int16Value(x.0)); + } + GeneratedField::Int32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int32Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int32Value(x.0)); + } + GeneratedField::Int64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("int64Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int64Value(x.0)); + } + GeneratedField::Uint8Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint8Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint8Value(x.0)); + } + GeneratedField::Uint16Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint16Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint16Value(x.0)); + } + GeneratedField::Uint32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint32Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint32Value(x.0)); + } + GeneratedField::Uint64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("uint64Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint64Value(x.0)); + } + GeneratedField::Float32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("float32Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float32Value(x.0)); + } + GeneratedField::Float64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("float64Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float64Value(x.0)); + } + GeneratedField::Date32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("date32Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date32Value(x.0)); + } + GeneratedField::Time32Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("time32Value")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time32Value) +; + } + GeneratedField::ListValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("listValue")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::ListValue) +; + } + GeneratedField::Decimal128Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("decimal128Value")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Decimal128Value) +; + } + GeneratedField::Date64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("date64Value")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date64Value(x.0)); + } + GeneratedField::IntervalYearmonthValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalYearmonthValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalYearmonthValue(x.0)); + } + GeneratedField::IntervalDaytimeValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalDaytimeValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalDaytimeValue(x.0)); + } + GeneratedField::TimestampValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("timestampValue")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::TimestampValue) +; + } + GeneratedField::DictionaryValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("dictionaryValue")); + } + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::DictionaryValue) +; + } + GeneratedField::BinaryValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("binaryValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::BinaryValue(x.0)); + } + GeneratedField::LargeBinaryValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("largeBinaryValue")); + } + value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::LargeBinaryValue(x.0)); + } + GeneratedField::Time64Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("time64Value")); } - is_null__ = Some(map.next_value()?); + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time64Value) +; } - GeneratedField::Field => { - if field__.is_some() { - return Err(serde::de::Error::duplicate_field("field")); + GeneratedField::IntervalMonthDayNano => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("intervalMonthDayNano")); } - field__ = map.next_value()?; + value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::IntervalMonthDayNano) +; } - GeneratedField::Values => { - if values__.is_some() { - return Err(serde::de::Error::duplicate_field("values")); + GeneratedField::StructValue => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("structValue")); } - values__ = Some(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) +; } } } - Ok(ScalarListValue { - is_null: is_null__.unwrap_or_default(), - field: field__, - values: values__.unwrap_or_default(), + Ok(ScalarValue { + value: value__, }) } } - deserializer.deserialize_struct("datafusion.ScalarListValue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ScalarValue", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarTime32Value { +impl serde::Serialize for ScanLimit { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10093,40 +18532,29 @@ impl serde::Serialize for ScalarTime32Value { { use serde::ser::SerializeStruct; let mut len = 0; - if self.value.is_some() { + if self.limit != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime32Value", len)?; - if let Some(v) = self.value.as_ref() { - match v { - scalar_time32_value::Value::Time32SecondValue(v) => { - struct_ser.serialize_field("time32SecondValue", v)?; - } - scalar_time32_value::Value::Time32MillisecondValue(v) => { - struct_ser.serialize_field("time32MillisecondValue", v)?; - } - } + let mut struct_ser = serializer.serialize_struct("datafusion.ScanLimit", len)?; + if self.limit != 0 { + struct_ser.serialize_field("limit", &self.limit)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarTime32Value { +impl<'de> serde::Deserialize<'de> for ScanLimit { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "time32_second_value", - "time32SecondValue", - "time32_millisecond_value", - "time32MillisecondValue", + "limit", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Time32SecondValue, - Time32MillisecondValue, + Limit, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10148,8 +18576,7 @@ impl<'de> serde::Deserialize<'de> for ScalarTime32Value { E: serde::de::Error, { match value { - "time32SecondValue" | "time32_second_value" => Ok(GeneratedField::Time32SecondValue), - "time32MillisecondValue" | "time32_millisecond_value" => Ok(GeneratedField::Time32MillisecondValue), + "limit" => Ok(GeneratedField::Limit), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10159,42 +18586,38 @@ impl<'de> serde::Deserialize<'de> for ScalarTime32Value { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarTime32Value; + type Value = ScanLimit; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarTime32Value") + formatter.write_str("struct datafusion.ScanLimit") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut value__ = None; + let mut limit__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Time32SecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time32SecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32SecondValue(x.0)); - } - GeneratedField::Time32MillisecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time32MillisecondValue")); + GeneratedField::Limit => { + if limit__.is_some() { + return Err(serde::de::Error::duplicate_field("limit")); } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32MillisecondValue(x.0)); + limit__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(ScalarTime32Value { - value: value__, + Ok(ScanLimit { + limit: limit__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.ScalarTime32Value", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ScanLimit", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarTime64Value { +impl serde::Serialize for Schema { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10202,40 +18625,29 @@ impl serde::Serialize for ScalarTime64Value { { use serde::ser::SerializeStruct; let mut len = 0; - if self.value.is_some() { + if !self.columns.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime64Value", len)?; - if let Some(v) = self.value.as_ref() { - match v { - scalar_time64_value::Value::Time64MicrosecondValue(v) => { - struct_ser.serialize_field("time64MicrosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_time64_value::Value::Time64NanosecondValue(v) => { - struct_ser.serialize_field("time64NanosecondValue", ToString::to_string(&v).as_str())?; - } - } + let mut struct_ser = serializer.serialize_struct("datafusion.Schema", len)?; + if !self.columns.is_empty() { + struct_ser.serialize_field("columns", &self.columns)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarTime64Value { +impl<'de> serde::Deserialize<'de> for Schema { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "time64_microsecond_value", - "time64MicrosecondValue", - "time64_nanosecond_value", - "time64NanosecondValue", + "columns", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Time64MicrosecondValue, - Time64NanosecondValue, + Columns, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10257,8 +18669,7 @@ impl<'de> serde::Deserialize<'de> for ScalarTime64Value { E: serde::de::Error, { match value { - "time64MicrosecondValue" | "time64_microsecond_value" => Ok(GeneratedField::Time64MicrosecondValue), - "time64NanosecondValue" | "time64_nanosecond_value" => Ok(GeneratedField::Time64NanosecondValue), + "columns" => Ok(GeneratedField::Columns), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10268,42 +18679,36 @@ impl<'de> serde::Deserialize<'de> for ScalarTime64Value { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarTime64Value; + type Value = Schema; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarTime64Value") + formatter.write_str("struct datafusion.Schema") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut value__ = None; + let mut columns__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Time64MicrosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time64MicrosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64MicrosecondValue(x.0)); - } - GeneratedField::Time64NanosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time64NanosecondValue")); + GeneratedField::Columns => { + if columns__.is_some() { + return Err(serde::de::Error::duplicate_field("columns")); } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64NanosecondValue(x.0)); + columns__ = Some(map.next_value()?); } } } - Ok(ScalarTime64Value { - value: value__, + Ok(Schema { + columns: columns__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.ScalarTime64Value", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.Schema", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarTimestampValue { +impl serde::Serialize for SelectionExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10311,60 +18716,29 @@ impl serde::Serialize for ScalarTimestampValue { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.timezone.is_empty() { - len += 1; - } - if self.value.is_some() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTimestampValue", len)?; - if !self.timezone.is_empty() { - struct_ser.serialize_field("timezone", &self.timezone)?; - } - if let Some(v) = self.value.as_ref() { - match v { - scalar_timestamp_value::Value::TimeMicrosecondValue(v) => { - struct_ser.serialize_field("timeMicrosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_timestamp_value::Value::TimeNanosecondValue(v) => { - struct_ser.serialize_field("timeNanosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_timestamp_value::Value::TimeSecondValue(v) => { - struct_ser.serialize_field("timeSecondValue", ToString::to_string(&v).as_str())?; - } - scalar_timestamp_value::Value::TimeMillisecondValue(v) => { - struct_ser.serialize_field("timeMillisecondValue", ToString::to_string(&v).as_str())?; - } - } + let mut struct_ser = serializer.serialize_struct("datafusion.SelectionExecNode", len)?; + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarTimestampValue { +impl<'de> serde::Deserialize<'de> for SelectionExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "timezone", - "time_microsecond_value", - "timeMicrosecondValue", - "time_nanosecond_value", - "timeNanosecondValue", - "time_second_value", - "timeSecondValue", - "time_millisecond_value", - "timeMillisecondValue", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Timezone, - TimeMicrosecondValue, - TimeNanosecondValue, - TimeSecondValue, - TimeMillisecondValue, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10386,11 +18760,7 @@ impl<'de> serde::Deserialize<'de> for ScalarTimestampValue { E: serde::de::Error, { match value { - "timezone" => Ok(GeneratedField::Timezone), - "timeMicrosecondValue" | "time_microsecond_value" => Ok(GeneratedField::TimeMicrosecondValue), - "timeNanosecondValue" | "time_nanosecond_value" => Ok(GeneratedField::TimeNanosecondValue), - "timeSecondValue" | "time_second_value" => Ok(GeneratedField::TimeSecondValue), - "timeMillisecondValue" | "time_millisecond_value" => Ok(GeneratedField::TimeMillisecondValue), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10400,62 +18770,36 @@ impl<'de> serde::Deserialize<'de> for ScalarTimestampValue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarTimestampValue; + type Value = SelectionExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarTimestampValue") + formatter.write_str("struct datafusion.SelectionExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut timezone__ = None; - let mut value__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Timezone => { - if timezone__.is_some() { - return Err(serde::de::Error::duplicate_field("timezone")); - } - timezone__ = Some(map.next_value()?); - } - GeneratedField::TimeMicrosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeMicrosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMicrosecondValue(x.0)); - } - GeneratedField::TimeNanosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeNanosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeNanosecondValue(x.0)); - } - GeneratedField::TimeSecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeSecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeSecondValue(x.0)); - } - GeneratedField::TimeMillisecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeMillisecondValue")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMillisecondValue(x.0)); + expr__ = map.next_value()?; } } } - Ok(ScalarTimestampValue { - timezone: timezone__.unwrap_or_default(), - value: value__, + Ok(SelectionExecNode { + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.ScalarTimestampValue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.SelectionExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarUdfExprNode { +impl serde::Serialize for SelectionNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10463,38 +18807,37 @@ impl serde::Serialize for ScalarUdfExprNode { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.fun_name.is_empty() { + if self.input.is_some() { len += 1; } - if !self.args.is_empty() { + if self.expr.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarUDFExprNode", len)?; - if !self.fun_name.is_empty() { - struct_ser.serialize_field("funName", &self.fun_name)?; - } - if !self.args.is_empty() { - struct_ser.serialize_field("args", &self.args)?; + let mut struct_ser = serializer.serialize_struct("datafusion.SelectionNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode { +impl<'de> serde::Deserialize<'de> for SelectionNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "fun_name", - "funName", - "args", + "input", + "expr", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - FunName, - Args, + Input, + Expr, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10516,8 +18859,8 @@ impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode { E: serde::de::Error, { match value { - "funName" | "fun_name" => Ok(GeneratedField::FunName), - "args" => Ok(GeneratedField::Args), + "input" => Ok(GeneratedField::Input), + "expr" => Ok(GeneratedField::Expr), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10527,44 +18870,44 @@ impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarUdfExprNode; + type Value = SelectionNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarUDFExprNode") + formatter.write_str("struct datafusion.SelectionNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut fun_name__ = None; - let mut args__ = None; + let mut input__ = None; + let mut expr__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::FunName => { - if fun_name__.is_some() { - return Err(serde::de::Error::duplicate_field("funName")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - fun_name__ = Some(map.next_value()?); + input__ = map.next_value()?; } - GeneratedField::Args => { - if args__.is_some() { - return Err(serde::de::Error::duplicate_field("args")); + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); } - args__ = Some(map.next_value()?); + expr__ = map.next_value()?; } } } - Ok(ScalarUdfExprNode { - fun_name: fun_name__.unwrap_or_default(), - args: args__.unwrap_or_default(), + Ok(SelectionNode { + input: input__, + expr: expr__, }) } } - deserializer.deserialize_struct("datafusion.ScalarUDFExprNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ScalarValue { +impl serde::Serialize for ShuffleWriterExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -10572,202 +18915,56 @@ impl serde::Serialize for ScalarValue { { use serde::ser::SerializeStruct; let mut len = 0; - if self.value.is_some() { + if !self.job_id.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarValue", len)?; - if let Some(v) = self.value.as_ref() { - match v { - scalar_value::Value::NullValue(v) => { - struct_ser.serialize_field("nullValue", v)?; - } - scalar_value::Value::BoolValue(v) => { - struct_ser.serialize_field("boolValue", v)?; - } - scalar_value::Value::Utf8Value(v) => { - struct_ser.serialize_field("utf8Value", v)?; - } - scalar_value::Value::LargeUtf8Value(v) => { - struct_ser.serialize_field("largeUtf8Value", v)?; - } - scalar_value::Value::Int8Value(v) => { - struct_ser.serialize_field("int8Value", v)?; - } - scalar_value::Value::Int16Value(v) => { - struct_ser.serialize_field("int16Value", v)?; - } - scalar_value::Value::Int32Value(v) => { - struct_ser.serialize_field("int32Value", v)?; - } - scalar_value::Value::Int64Value(v) => { - struct_ser.serialize_field("int64Value", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::Uint8Value(v) => { - struct_ser.serialize_field("uint8Value", v)?; - } - scalar_value::Value::Uint16Value(v) => { - struct_ser.serialize_field("uint16Value", v)?; - } - scalar_value::Value::Uint32Value(v) => { - struct_ser.serialize_field("uint32Value", v)?; - } - scalar_value::Value::Uint64Value(v) => { - struct_ser.serialize_field("uint64Value", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::Float32Value(v) => { - struct_ser.serialize_field("float32Value", v)?; - } - scalar_value::Value::Float64Value(v) => { - struct_ser.serialize_field("float64Value", v)?; - } - scalar_value::Value::Date32Value(v) => { - struct_ser.serialize_field("date32Value", v)?; - } - scalar_value::Value::Time32Value(v) => { - struct_ser.serialize_field("time32Value", v)?; - } - scalar_value::Value::ListValue(v) => { - struct_ser.serialize_field("listValue", v)?; - } - scalar_value::Value::Decimal128Value(v) => { - struct_ser.serialize_field("decimal128Value", v)?; - } - scalar_value::Value::Date64Value(v) => { - struct_ser.serialize_field("date64Value", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::IntervalYearmonthValue(v) => { - struct_ser.serialize_field("intervalYearmonthValue", v)?; - } - scalar_value::Value::IntervalDaytimeValue(v) => { - struct_ser.serialize_field("intervalDaytimeValue", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::TimestampValue(v) => { - struct_ser.serialize_field("timestampValue", v)?; - } - scalar_value::Value::DictionaryValue(v) => { - struct_ser.serialize_field("dictionaryValue", v)?; - } - scalar_value::Value::BinaryValue(v) => { - struct_ser.serialize_field("binaryValue", pbjson::private::base64::encode(&v).as_str())?; - } - scalar_value::Value::LargeBinaryValue(v) => { - struct_ser.serialize_field("largeBinaryValue", pbjson::private::base64::encode(&v).as_str())?; - } - scalar_value::Value::Time64Value(v) => { - struct_ser.serialize_field("time64Value", v)?; - } - scalar_value::Value::IntervalMonthDayNano(v) => { - struct_ser.serialize_field("intervalMonthDayNano", v)?; - } - scalar_value::Value::StructValue(v) => { - struct_ser.serialize_field("structValue", v)?; - } - scalar_value::Value::FixedSizeBinaryValue(v) => { - struct_ser.serialize_field("fixedSizeBinaryValue", v)?; - } - } + if self.stage_id != 0 { + len += 1; } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarValue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "null_value", - "nullValue", - "bool_value", - "boolValue", - "utf8_value", - "utf8Value", - "large_utf8_value", - "largeUtf8Value", - "int8_value", - "int8Value", - "int16_value", - "int16Value", - "int32_value", - "int32Value", - "int64_value", - "int64Value", - "uint8_value", - "uint8Value", - "uint16_value", - "uint16Value", - "uint32_value", - "uint32Value", - "uint64_value", - "uint64Value", - "float32_value", - "float32Value", - "float64_value", - "float64Value", - "date_32_value", - "date32Value", - "time32_value", - "time32Value", - "list_value", - "listValue", - "decimal128_value", - "decimal128Value", - "date_64_value", - "date64Value", - "interval_yearmonth_value", - "intervalYearmonthValue", - "interval_daytime_value", - "intervalDaytimeValue", - "timestamp_value", - "timestampValue", - "dictionary_value", - "dictionaryValue", - "binary_value", - "binaryValue", - "large_binary_value", - "largeBinaryValue", - "time64_value", - "time64Value", - "interval_month_day_nano", - "intervalMonthDayNano", - "struct_value", - "structValue", - "fixed_size_binary_value", - "fixedSizeBinaryValue", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - NullValue, - BoolValue, - Utf8Value, - LargeUtf8Value, - Int8Value, - Int16Value, - Int32Value, - Int64Value, - Uint8Value, - Uint16Value, - Uint32Value, - Uint64Value, - Float32Value, - Float64Value, - Date32Value, - Time32Value, - ListValue, - Decimal128Value, - Date64Value, - IntervalYearmonthValue, - IntervalDaytimeValue, - TimestampValue, - DictionaryValue, - BinaryValue, - LargeBinaryValue, - Time64Value, - IntervalMonthDayNano, - StructValue, - FixedSizeBinaryValue, + if self.input.is_some() { + len += 1; + } + if self.output_partitioning.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.ShuffleWriterExecNode", len)?; + if !self.job_id.is_empty() { + struct_ser.serialize_field("jobId", &self.job_id)?; + } + if self.stage_id != 0 { + struct_ser.serialize_field("stageId", &self.stage_id)?; + } + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if let Some(v) = self.output_partitioning.as_ref() { + struct_ser.serialize_field("outputPartitioning", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ShuffleWriterExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "job_id", + "jobId", + "stage_id", + "stageId", + "input", + "output_partitioning", + "outputPartitioning", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + JobId, + StageId, + Input, + OutputPartitioning, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -10789,35 +18986,10 @@ impl<'de> serde::Deserialize<'de> for ScalarValue { E: serde::de::Error, { match value { - "nullValue" | "null_value" => Ok(GeneratedField::NullValue), - "boolValue" | "bool_value" => Ok(GeneratedField::BoolValue), - "utf8Value" | "utf8_value" => Ok(GeneratedField::Utf8Value), - "largeUtf8Value" | "large_utf8_value" => Ok(GeneratedField::LargeUtf8Value), - "int8Value" | "int8_value" => Ok(GeneratedField::Int8Value), - "int16Value" | "int16_value" => Ok(GeneratedField::Int16Value), - "int32Value" | "int32_value" => Ok(GeneratedField::Int32Value), - "int64Value" | "int64_value" => Ok(GeneratedField::Int64Value), - "uint8Value" | "uint8_value" => Ok(GeneratedField::Uint8Value), - "uint16Value" | "uint16_value" => Ok(GeneratedField::Uint16Value), - "uint32Value" | "uint32_value" => Ok(GeneratedField::Uint32Value), - "uint64Value" | "uint64_value" => Ok(GeneratedField::Uint64Value), - "float32Value" | "float32_value" => Ok(GeneratedField::Float32Value), - "float64Value" | "float64_value" => Ok(GeneratedField::Float64Value), - "date32Value" | "date_32_value" => Ok(GeneratedField::Date32Value), - "time32Value" | "time32_value" => Ok(GeneratedField::Time32Value), - "listValue" | "list_value" => Ok(GeneratedField::ListValue), - "decimal128Value" | "decimal128_value" => Ok(GeneratedField::Decimal128Value), - "date64Value" | "date_64_value" => Ok(GeneratedField::Date64Value), - "intervalYearmonthValue" | "interval_yearmonth_value" => Ok(GeneratedField::IntervalYearmonthValue), - "intervalDaytimeValue" | "interval_daytime_value" => Ok(GeneratedField::IntervalDaytimeValue), - "timestampValue" | "timestamp_value" => Ok(GeneratedField::TimestampValue), - "dictionaryValue" | "dictionary_value" => Ok(GeneratedField::DictionaryValue), - "binaryValue" | "binary_value" => Ok(GeneratedField::BinaryValue), - "largeBinaryValue" | "large_binary_value" => Ok(GeneratedField::LargeBinaryValue), - "time64Value" | "time64_value" => Ok(GeneratedField::Time64Value), - "intervalMonthDayNano" | "interval_month_day_nano" => Ok(GeneratedField::IntervalMonthDayNano), - "structValue" | "struct_value" => Ok(GeneratedField::StructValue), - "fixedSizeBinaryValue" | "fixed_size_binary_value" => Ok(GeneratedField::FixedSizeBinaryValue), + "jobId" | "job_id" => Ok(GeneratedField::JobId), + "stageId" | "stage_id" => Ok(GeneratedField::StageId), + "input" => Ok(GeneratedField::Input), + "outputPartitioning" | "output_partitioning" => Ok(GeneratedField::OutputPartitioning), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -10827,214 +18999,62 @@ impl<'de> serde::Deserialize<'de> for ScalarValue { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarValue; + type Value = ShuffleWriterExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarValue") + formatter.write_str("struct datafusion.ShuffleWriterExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut value__ = None; + let mut job_id__ = None; + let mut stage_id__ = None; + let mut input__ = None; + let mut output_partitioning__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::NullValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("nullValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::NullValue) -; - } - GeneratedField::BoolValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("boolValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::BoolValue); - } - GeneratedField::Utf8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("utf8Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Utf8Value); - } - GeneratedField::LargeUtf8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("largeUtf8Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::LargeUtf8Value); - } - GeneratedField::Int8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int8Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int8Value(x.0)); - } - GeneratedField::Int16Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int16Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int16Value(x.0)); - } - GeneratedField::Int32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int32Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int32Value(x.0)); - } - GeneratedField::Int64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int64Value(x.0)); - } - GeneratedField::Uint8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint8Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint8Value(x.0)); - } - GeneratedField::Uint16Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint16Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint16Value(x.0)); - } - GeneratedField::Uint32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint32Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint32Value(x.0)); - } - GeneratedField::Uint64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint64Value(x.0)); - } - GeneratedField::Float32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("float32Value")); + GeneratedField::JobId => { + if job_id__.is_some() { + return Err(serde::de::Error::duplicate_field("jobId")); } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float32Value(x.0)); - } - GeneratedField::Float64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("float64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float64Value(x.0)); - } - GeneratedField::Date32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("date32Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date32Value(x.0)); - } - GeneratedField::Time32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time32Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time32Value) -; - } - GeneratedField::ListValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("listValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::ListValue) -; - } - GeneratedField::Decimal128Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("decimal128Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Decimal128Value) -; - } - GeneratedField::Date64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("date64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date64Value(x.0)); - } - GeneratedField::IntervalYearmonthValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("intervalYearmonthValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalYearmonthValue(x.0)); - } - GeneratedField::IntervalDaytimeValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("intervalDaytimeValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalDaytimeValue(x.0)); - } - GeneratedField::TimestampValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timestampValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::TimestampValue) -; - } - GeneratedField::DictionaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("dictionaryValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::DictionaryValue) -; - } - GeneratedField::BinaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("binaryValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::BinaryValue(x.0)); - } - GeneratedField::LargeBinaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("largeBinaryValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::LargeBinaryValue(x.0)); - } - GeneratedField::Time64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time64Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time64Value) -; + job_id__ = Some(map.next_value()?); } - GeneratedField::IntervalMonthDayNano => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("intervalMonthDayNano")); + GeneratedField::StageId => { + if stage_id__.is_some() { + return Err(serde::de::Error::duplicate_field("stageId")); } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::IntervalMonthDayNano) -; + stage_id__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::StructValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("structValue")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::StructValue) -; + input__ = map.next_value()?; } - GeneratedField::FixedSizeBinaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("fixedSizeBinaryValue")); + GeneratedField::OutputPartitioning => { + if output_partitioning__.is_some() { + return Err(serde::de::Error::duplicate_field("outputPartitioning")); } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::FixedSizeBinaryValue) -; + output_partitioning__ = map.next_value()?; } } } - Ok(ScalarValue { - value: value__, + Ok(ShuffleWriterExecNode { + job_id: job_id__.unwrap_or_default(), + stage_id: stage_id__.unwrap_or_default(), + input: input__, + output_partitioning: output_partitioning__, }) } } - deserializer.deserialize_struct("datafusion.ScalarValue", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.ShuffleWriterExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for Schema { +impl serde::Serialize for SimilarToNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11042,29 +19062,54 @@ impl serde::Serialize for Schema { { use serde::ser::SerializeStruct; let mut len = 0; - if !self.columns.is_empty() { + if self.negated { + len += 1; + } + if self.expr.is_some() { + len += 1; + } + if self.pattern.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.Schema", len)?; - if !self.columns.is_empty() { - struct_ser.serialize_field("columns", &self.columns)?; + if !self.escape_char.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?; + if self.negated { + struct_ser.serialize_field("negated", &self.negated)?; + } + if let Some(v) = self.expr.as_ref() { + struct_ser.serialize_field("expr", v)?; + } + if let Some(v) = self.pattern.as_ref() { + struct_ser.serialize_field("pattern", v)?; + } + if !self.escape_char.is_empty() { + struct_ser.serialize_field("escapeChar", &self.escape_char)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for Schema { +impl<'de> serde::Deserialize<'de> for SimilarToNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "columns", + "negated", + "expr", + "pattern", + "escape_char", + "escapeChar", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Columns, + Negated, + Expr, + Pattern, + EscapeChar, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11086,7 +19131,10 @@ impl<'de> serde::Deserialize<'de> for Schema { E: serde::de::Error, { match value { - "columns" => Ok(GeneratedField::Columns), + "negated" => Ok(GeneratedField::Negated), + "expr" => Ok(GeneratedField::Expr), + "pattern" => Ok(GeneratedField::Pattern), + "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11096,36 +19144,60 @@ impl<'de> serde::Deserialize<'de> for Schema { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Schema; + type Value = SimilarToNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Schema") + formatter.write_str("struct datafusion.SimilarToNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut columns__ = None; + let mut negated__ = None; + let mut expr__ = None; + let mut pattern__ = None; + let mut escape_char__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Columns => { - if columns__.is_some() { - return Err(serde::de::Error::duplicate_field("columns")); + GeneratedField::Negated => { + if negated__.is_some() { + return Err(serde::de::Error::duplicate_field("negated")); } - columns__ = Some(map.next_value()?); + negated__ = Some(map.next_value()?); + } + GeneratedField::Expr => { + if expr__.is_some() { + return Err(serde::de::Error::duplicate_field("expr")); + } + expr__ = map.next_value()?; + } + GeneratedField::Pattern => { + if pattern__.is_some() { + return Err(serde::de::Error::duplicate_field("pattern")); + } + pattern__ = map.next_value()?; + } + GeneratedField::EscapeChar => { + if escape_char__.is_some() { + return Err(serde::de::Error::duplicate_field("escapeChar")); + } + escape_char__ = Some(map.next_value()?); } } } - Ok(Schema { - columns: columns__.unwrap_or_default(), + Ok(SimilarToNode { + negated: negated__.unwrap_or_default(), + expr: expr__, + pattern: pattern__, + escape_char: escape_char__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.Schema", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.SimilarToNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SelectionExecNode { +impl serde::Serialize for SortExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11133,29 +19205,45 @@ impl serde::Serialize for SelectionExecNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { + if self.input.is_some() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.SelectionExecNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + if !self.expr.is_empty() { + len += 1; + } + if self.fetch != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.SortExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; + } + if self.fetch != 0 { + struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SelectionExecNode { +impl<'de> serde::Deserialize<'de> for SortExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "input", "expr", + "fetch", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Input, Expr, + Fetch, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11177,7 +19265,9 @@ impl<'de> serde::Deserialize<'de> for SelectionExecNode { E: serde::de::Error, { match value { + "input" => Ok(GeneratedField::Input), "expr" => Ok(GeneratedField::Expr), + "fetch" => Ok(GeneratedField::Fetch), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11187,36 +19277,54 @@ impl<'de> serde::Deserialize<'de> for SelectionExecNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SelectionExecNode; + type Value = SortExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SelectionExecNode") + formatter.write_str("struct datafusion.SortExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { + let mut input__ = None; let mut expr__ = None; + let mut fetch__ = None; while let Some(k) = map.next_key()? { match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } GeneratedField::Expr => { if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } - expr__ = map.next_value()?; + expr__ = Some(map.next_value()?); + } + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); + } + fetch__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(SelectionExecNode { - expr: expr__, + Ok(SortExecNode { + input: input__, + expr: expr__.unwrap_or_default(), + fetch: fetch__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.SelectionExecNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.SortExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SelectionNode { +impl serde::Serialize for SortExprNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11224,37 +19332,46 @@ impl serde::Serialize for SelectionNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.input.is_some() { + if self.expr.is_some() { len += 1; } - if self.expr.is_some() { + if self.asc { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.SelectionNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; + if self.nulls_first { + len += 1; } + let mut struct_ser = serializer.serialize_struct("datafusion.SortExprNode", len)?; if let Some(v) = self.expr.as_ref() { struct_ser.serialize_field("expr", v)?; } + if self.asc { + struct_ser.serialize_field("asc", &self.asc)?; + } + if self.nulls_first { + struct_ser.serialize_field("nullsFirst", &self.nulls_first)?; + } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SelectionNode { +impl<'de> serde::Deserialize<'de> for SortExprNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "input", "expr", + "asc", + "nulls_first", + "nullsFirst", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Input, Expr, + Asc, + NullsFirst, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11276,8 +19393,9 @@ impl<'de> serde::Deserialize<'de> for SelectionNode { E: serde::de::Error, { match value { - "input" => Ok(GeneratedField::Input), "expr" => Ok(GeneratedField::Expr), + "asc" => Ok(GeneratedField::Asc), + "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11287,44 +19405,52 @@ impl<'de> serde::Deserialize<'de> for SelectionNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SelectionNode; + type Value = SortExprNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SelectionNode") + formatter.write_str("struct datafusion.SortExprNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut input__ = None; let mut expr__ = None; + let mut asc__ = None; + let mut nulls_first__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } GeneratedField::Expr => { if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } expr__ = map.next_value()?; } + GeneratedField::Asc => { + if asc__.is_some() { + return Err(serde::de::Error::duplicate_field("asc")); + } + asc__ = Some(map.next_value()?); + } + GeneratedField::NullsFirst => { + if nulls_first__.is_some() { + return Err(serde::de::Error::duplicate_field("nullsFirst")); + } + nulls_first__ = Some(map.next_value()?); + } } } - Ok(SelectionNode { - input: input__, + Ok(SortExprNode { expr: expr__, + asc: asc__.unwrap_or_default(), + nulls_first: nulls_first__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.SortExprNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SimilarToNode { +impl serde::Serialize for SortNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11332,54 +19458,45 @@ impl serde::Serialize for SimilarToNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.negated { - len += 1; - } - if self.expr.is_some() { + if self.input.is_some() { len += 1; } - if self.pattern.is_some() { + if !self.expr.is_empty() { len += 1; } - if !self.escape_char.is_empty() { + if self.fetch != 0 { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?; - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; + let mut struct_ser = serializer.serialize_struct("datafusion.SortNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; } - if let Some(v) = self.pattern.as_ref() { - struct_ser.serialize_field("pattern", v)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; } - if !self.escape_char.is_empty() { - struct_ser.serialize_field("escapeChar", &self.escape_char)?; + if self.fetch != 0 { + struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SimilarToNode { +impl<'de> serde::Deserialize<'de> for SortNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "negated", + "input", "expr", - "pattern", - "escape_char", - "escapeChar", + "fetch", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Negated, + Input, Expr, - Pattern, - EscapeChar, + Fetch, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11401,10 +19518,9 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode { E: serde::de::Error, { match value { - "negated" => Ok(GeneratedField::Negated), + "input" => Ok(GeneratedField::Input), "expr" => Ok(GeneratedField::Expr), - "pattern" => Ok(GeneratedField::Pattern), - "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), + "fetch" => Ok(GeneratedField::Fetch), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11414,60 +19530,54 @@ impl<'de> serde::Deserialize<'de> for SimilarToNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SimilarToNode; + type Value = SortNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SimilarToNode") + formatter.write_str("struct datafusion.SortNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut negated__ = None; + let mut input__ = None; let mut expr__ = None; - let mut pattern__ = None; - let mut escape_char__ = None; + let mut fetch__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); } - negated__ = Some(map.next_value()?); + input__ = map.next_value()?; } GeneratedField::Expr => { if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } - expr__ = map.next_value()?; - } - GeneratedField::Pattern => { - if pattern__.is_some() { - return Err(serde::de::Error::duplicate_field("pattern")); - } - pattern__ = map.next_value()?; + expr__ = Some(map.next_value()?); } - GeneratedField::EscapeChar => { - if escape_char__.is_some() { - return Err(serde::de::Error::duplicate_field("escapeChar")); + GeneratedField::Fetch => { + if fetch__.is_some() { + return Err(serde::de::Error::duplicate_field("fetch")); } - escape_char__ = Some(map.next_value()?); + fetch__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } } } - Ok(SimilarToNode { - negated: negated__.unwrap_or_default(), - expr: expr__, - pattern: pattern__, - escape_char: escape_char__.unwrap_or_default(), + Ok(SortNode { + input: input__, + expr: expr__.unwrap_or_default(), + fetch: fetch__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.SimilarToNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.SortNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SortExprNode { +impl serde::Serialize for SortPreservingMergeExecNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11475,46 +19585,37 @@ impl serde::Serialize for SortExprNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.asc { + if self.input.is_some() { len += 1; } - if self.nulls_first { + if !self.expr.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.SortExprNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if self.asc { - struct_ser.serialize_field("asc", &self.asc)?; + let mut struct_ser = serializer.serialize_struct("datafusion.SortPreservingMergeExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; } - if self.nulls_first { - struct_ser.serialize_field("nullsFirst", &self.nulls_first)?; + if !self.expr.is_empty() { + struct_ser.serialize_field("expr", &self.expr)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SortExprNode { +impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ + "input", "expr", - "asc", - "nulls_first", - "nullsFirst", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { + Input, Expr, - Asc, - NullsFirst, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11536,9 +19637,8 @@ impl<'de> serde::Deserialize<'de> for SortExprNode { E: serde::de::Error, { match value { + "input" => Ok(GeneratedField::Input), "expr" => Ok(GeneratedField::Expr), - "asc" => Ok(GeneratedField::Asc), - "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11548,52 +19648,44 @@ impl<'de> serde::Deserialize<'de> for SortExprNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SortExprNode; + type Value = SortPreservingMergeExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SortExprNode") + formatter.write_str("struct datafusion.SortPreservingMergeExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { + let mut input__ = None; let mut expr__ = None; - let mut asc__ = None; - let mut nulls_first__ = None; while let Some(k) = map.next_key()? { match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } GeneratedField::Expr => { if expr__.is_some() { return Err(serde::de::Error::duplicate_field("expr")); } - expr__ = map.next_value()?; - } - GeneratedField::Asc => { - if asc__.is_some() { - return Err(serde::de::Error::duplicate_field("asc")); - } - asc__ = Some(map.next_value()?); - } - GeneratedField::NullsFirst => { - if nulls_first__.is_some() { - return Err(serde::de::Error::duplicate_field("nullsFirst")); - } - nulls_first__ = Some(map.next_value()?); + expr__ = Some(map.next_value()?); } } } - Ok(SortExprNode { - expr: expr__, - asc: asc__.unwrap_or_default(), - nulls_first: nulls_first__.unwrap_or_default(), + Ok(SortPreservingMergeExecNode { + input: input__, + expr: expr__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.SortExprNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.SortPreservingMergeExecNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for SortNode { +impl serde::Serialize for Statistics { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result where @@ -11601,45 +19693,57 @@ impl serde::Serialize for SortNode { { use serde::ser::SerializeStruct; let mut len = 0; - if self.input.is_some() { + if self.num_rows != 0 { len += 1; } - if !self.expr.is_empty() { + if self.total_byte_size != 0 { len += 1; } - if self.fetch != 0 { + if !self.column_stats.is_empty() { len += 1; } - let mut struct_ser = serializer.serialize_struct("datafusion.SortNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; + if self.is_exact { + len += 1; } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; + let mut struct_ser = serializer.serialize_struct("datafusion.Statistics", len)?; + if self.num_rows != 0 { + struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?; } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; + if self.total_byte_size != 0 { + struct_ser.serialize_field("totalByteSize", ToString::to_string(&self.total_byte_size).as_str())?; + } + if !self.column_stats.is_empty() { + struct_ser.serialize_field("columnStats", &self.column_stats)?; + } + if self.is_exact { + struct_ser.serialize_field("isExact", &self.is_exact)?; } struct_ser.end() } } -impl<'de> serde::Deserialize<'de> for SortNode { +impl<'de> serde::Deserialize<'de> for Statistics { #[allow(deprecated)] fn deserialize(deserializer: D) -> std::result::Result where D: serde::Deserializer<'de>, { const FIELDS: &[&str] = &[ - "input", - "expr", - "fetch", + "num_rows", + "numRows", + "total_byte_size", + "totalByteSize", + "column_stats", + "columnStats", + "is_exact", + "isExact", ]; #[allow(clippy::enum_variant_names)] enum GeneratedField { - Input, - Expr, - Fetch, + NumRows, + TotalByteSize, + ColumnStats, + IsExact, } impl<'de> serde::Deserialize<'de> for GeneratedField { fn deserialize(deserializer: D) -> std::result::Result @@ -11661,9 +19765,10 @@ impl<'de> serde::Deserialize<'de> for SortNode { E: serde::de::Error, { match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - "fetch" => Ok(GeneratedField::Fetch), + "numRows" | "num_rows" => Ok(GeneratedField::NumRows), + "totalByteSize" | "total_byte_size" => Ok(GeneratedField::TotalByteSize), + "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats), + "isExact" | "is_exact" => Ok(GeneratedField::IsExact), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -11673,51 +19778,61 @@ impl<'de> serde::Deserialize<'de> for SortNode { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SortNode; + type Value = Statistics; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SortNode") + formatter.write_str("struct datafusion.Statistics") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut input__ = None; - let mut expr__ = None; - let mut fetch__ = None; + let mut num_rows__ = None; + let mut total_byte_size__ = None; + let mut column_stats__ = None; + let mut is_exact__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); + GeneratedField::NumRows => { + if num_rows__.is_some() { + return Err(serde::de::Error::duplicate_field("numRows")); } - expr__ = Some(map.next_value()?); + num_rows__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); + GeneratedField::TotalByteSize => { + if total_byte_size__.is_some() { + return Err(serde::de::Error::duplicate_field("totalByteSize")); } - fetch__ = + total_byte_size__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } + GeneratedField::ColumnStats => { + if column_stats__.is_some() { + return Err(serde::de::Error::duplicate_field("columnStats")); + } + column_stats__ = Some(map.next_value()?); + } + GeneratedField::IsExact => { + if is_exact__.is_some() { + return Err(serde::de::Error::duplicate_field("isExact")); + } + is_exact__ = Some(map.next_value()?); + } } } - Ok(SortNode { - input: input__, - expr: expr__.unwrap_or_default(), - fetch: fetch__.unwrap_or_default(), + Ok(Statistics { + num_rows: num_rows__.unwrap_or_default(), + total_byte_size: total_byte_size__.unwrap_or_default(), + column_stats: column_stats__.unwrap_or_default(), + is_exact: is_exact__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.SortNode", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.Statistics", FIELDS, GeneratedVisitor) } } impl serde::Serialize for StringifiedPlan { @@ -12510,9 +20625,119 @@ impl<'de> serde::Deserialize<'de> for Union { E: serde::de::Error, { match value { - "unionTypes" | "union_types" => Ok(GeneratedField::UnionTypes), - "unionMode" | "union_mode" => Ok(GeneratedField::UnionMode), - "typeIds" | "type_ids" => 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)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Union; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.Union") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut union_types__ = None; + let mut union_mode__ = None; + let mut type_ids__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::UnionTypes => { + if union_types__.is_some() { + return Err(serde::de::Error::duplicate_field("unionTypes")); + } + union_types__ = Some(map.next_value()?); + } + GeneratedField::UnionMode => { + if union_mode__.is_some() { + return Err(serde::de::Error::duplicate_field("unionMode")); + } + union_mode__ = Some(map.next_value::()? as i32); + } + GeneratedField::TypeIds => { + if type_ids__.is_some() { + return Err(serde::de::Error::duplicate_field("typeIds")); + } + type_ids__ = + Some(map.next_value::>>()? + .into_iter().map(|x| x.0).collect()) + ; + } + } + } + Ok(Union { + union_types: union_types__.unwrap_or_default(), + union_mode: union_mode__.unwrap_or_default(), + type_ids: type_ids__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.Union", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UnionExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.inputs.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.UnionExecNode", len)?; + if !self.inputs.is_empty() { + struct_ser.serialize_field("inputs", &self.inputs)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnionExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "inputs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Inputs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "inputs" => Ok(GeneratedField::Inputs), _ => Err(serde::de::Error::unknown_field(value, FIELDS)), } } @@ -12522,52 +20747,33 @@ impl<'de> serde::Deserialize<'de> for Union { } struct GeneratedVisitor; impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Union; + type Value = UnionExecNode; fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Union") + formatter.write_str("struct datafusion.UnionExecNode") } - fn visit_map(self, mut map: V) -> std::result::Result + fn visit_map(self, mut map: V) -> std::result::Result where V: serde::de::MapAccess<'de>, { - let mut union_types__ = None; - let mut union_mode__ = None; - let mut type_ids__ = None; + let mut inputs__ = None; while let Some(k) = map.next_key()? { match k { - GeneratedField::UnionTypes => { - if union_types__.is_some() { - return Err(serde::de::Error::duplicate_field("unionTypes")); - } - union_types__ = Some(map.next_value()?); - } - GeneratedField::UnionMode => { - if union_mode__.is_some() { - return Err(serde::de::Error::duplicate_field("unionMode")); - } - union_mode__ = Some(map.next_value::()? as i32); - } - GeneratedField::TypeIds => { - if type_ids__.is_some() { - return Err(serde::de::Error::duplicate_field("typeIds")); + GeneratedField::Inputs => { + if inputs__.is_some() { + return Err(serde::de::Error::duplicate_field("inputs")); } - type_ids__ = - Some(map.next_value::>>()? - .into_iter().map(|x| x.0).collect()) - ; + inputs__ = Some(map.next_value()?); } } } - Ok(Union { - union_types: union_types__.unwrap_or_default(), - union_mode: union_mode__.unwrap_or_default(), - type_ids: type_ids__.unwrap_or_default(), + Ok(UnionExecNode { + inputs: inputs__.unwrap_or_default(), }) } } - deserializer.deserialize_struct("datafusion.Union", FIELDS, GeneratedVisitor) + deserializer.deserialize_struct("datafusion.UnionExecNode", FIELDS, GeneratedVisitor) } } impl serde::Serialize for UnionMode { @@ -12734,6 +20940,157 @@ impl<'de> serde::Deserialize<'de> for UnionNode { deserializer.deserialize_struct("datafusion.UnionNode", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for UnresolvedShuffleExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.stage_id != 0 { + len += 1; + } + if self.schema.is_some() { + len += 1; + } + if self.input_partition_count != 0 { + len += 1; + } + if self.output_partition_count != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.UnresolvedShuffleExecNode", len)?; + if self.stage_id != 0 { + struct_ser.serialize_field("stageId", &self.stage_id)?; + } + if let Some(v) = self.schema.as_ref() { + struct_ser.serialize_field("schema", v)?; + } + if self.input_partition_count != 0 { + struct_ser.serialize_field("inputPartitionCount", &self.input_partition_count)?; + } + if self.output_partition_count != 0 { + struct_ser.serialize_field("outputPartitionCount", &self.output_partition_count)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnresolvedShuffleExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "stage_id", + "stageId", + "schema", + "input_partition_count", + "inputPartitionCount", + "output_partition_count", + "outputPartitionCount", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + StageId, + Schema, + InputPartitionCount, + OutputPartitionCount, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "stageId" | "stage_id" => Ok(GeneratedField::StageId), + "schema" => Ok(GeneratedField::Schema), + "inputPartitionCount" | "input_partition_count" => Ok(GeneratedField::InputPartitionCount), + "outputPartitionCount" | "output_partition_count" => Ok(GeneratedField::OutputPartitionCount), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnresolvedShuffleExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.UnresolvedShuffleExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut stage_id__ = None; + let mut schema__ = None; + let mut input_partition_count__ = None; + let mut output_partition_count__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::StageId => { + if stage_id__.is_some() { + return Err(serde::de::Error::duplicate_field("stageId")); + } + stage_id__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Schema => { + if schema__.is_some() { + return Err(serde::de::Error::duplicate_field("schema")); + } + schema__ = map.next_value()?; + } + GeneratedField::InputPartitionCount => { + if input_partition_count__.is_some() { + return Err(serde::de::Error::duplicate_field("inputPartitionCount")); + } + input_partition_count__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::OutputPartitionCount => { + if output_partition_count__.is_some() { + return Err(serde::de::Error::duplicate_field("outputPartitionCount")); + } + output_partition_count__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(UnresolvedShuffleExecNode { + stage_id: stage_id__.unwrap_or_default(), + schema: schema__, + input_partition_count: input_partition_count__.unwrap_or_default(), + output_partition_count: output_partition_count__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("datafusion.UnresolvedShuffleExecNode", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for ValuesNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -13116,6 +21473,151 @@ impl<'de> serde::Deserialize<'de> for WhenThen { deserializer.deserialize_struct("datafusion.WhenThen", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for WindowAggExecNode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.input.is_some() { + len += 1; + } + if !self.window_expr.is_empty() { + len += 1; + } + if !self.window_expr_name.is_empty() { + len += 1; + } + if self.input_schema.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("datafusion.WindowAggExecNode", len)?; + if let Some(v) = self.input.as_ref() { + struct_ser.serialize_field("input", v)?; + } + if !self.window_expr.is_empty() { + struct_ser.serialize_field("windowExpr", &self.window_expr)?; + } + if !self.window_expr_name.is_empty() { + struct_ser.serialize_field("windowExprName", &self.window_expr_name)?; + } + if let Some(v) = self.input_schema.as_ref() { + struct_ser.serialize_field("inputSchema", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WindowAggExecNode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "input", + "window_expr", + "windowExpr", + "window_expr_name", + "windowExprName", + "input_schema", + "inputSchema", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Input, + WindowExpr, + WindowExprName, + InputSchema, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "input" => Ok(GeneratedField::Input), + "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), + "windowExprName" | "window_expr_name" => Ok(GeneratedField::WindowExprName), + "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WindowAggExecNode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct datafusion.WindowAggExecNode") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut input__ = None; + let mut window_expr__ = None; + let mut window_expr_name__ = None; + let mut input_schema__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Input => { + if input__.is_some() { + return Err(serde::de::Error::duplicate_field("input")); + } + input__ = map.next_value()?; + } + GeneratedField::WindowExpr => { + if window_expr__.is_some() { + return Err(serde::de::Error::duplicate_field("windowExpr")); + } + window_expr__ = Some(map.next_value()?); + } + GeneratedField::WindowExprName => { + if window_expr_name__.is_some() { + return Err(serde::de::Error::duplicate_field("windowExprName")); + } + window_expr_name__ = Some(map.next_value()?); + } + GeneratedField::InputSchema => { + if input_schema__.is_some() { + return Err(serde::de::Error::duplicate_field("inputSchema")); + } + input_schema__ = map.next_value()?; + } + } + } + Ok(WindowAggExecNode { + input: input__, + window_expr: window_expr__.unwrap_or_default(), + window_expr_name: window_expr_name__.unwrap_or_default(), + input_schema: input_schema__, + }) + } + } + deserializer.deserialize_struct("datafusion.WindowAggExecNode", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for WindowExprNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs index dfce7f4b67c3..9555e50b262d 100644 --- a/datafusion/proto/src/generated/prost.rs +++ b/datafusion/proto/src/generated/prost.rs @@ -1154,6 +1154,720 @@ pub struct StringifiedPlan { #[prost(string, tag = "2")] pub plan: ::prost::alloc::string::String, } +/// PhysicalPlanNode is a nested type +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalPlanNode { + #[prost( + oneof = "physical_plan_node::PhysicalPlanType", + tags = "1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21" + )] + pub physical_plan_type: ::core::option::Option, +} +/// Nested message and enum types in `PhysicalPlanNode`. +pub mod physical_plan_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PhysicalPlanType { + #[prost(message, tag = "1")] + ParquetScan(super::ParquetScanExecNode), + #[prost(message, tag = "2")] + CsvScan(super::CsvScanExecNode), + #[prost(message, tag = "3")] + Empty(super::EmptyExecNode), + #[prost(message, tag = "4")] + Projection(::prost::alloc::boxed::Box), + #[prost(message, tag = "6")] + GlobalLimit(::prost::alloc::boxed::Box), + #[prost(message, tag = "7")] + LocalLimit(::prost::alloc::boxed::Box), + #[prost(message, tag = "8")] + Aggregate(::prost::alloc::boxed::Box), + #[prost(message, tag = "9")] + HashJoin(::prost::alloc::boxed::Box), + #[prost(message, tag = "10")] + Sort(::prost::alloc::boxed::Box), + #[prost(message, tag = "11")] + CoalesceBatches(::prost::alloc::boxed::Box), + #[prost(message, tag = "12")] + Filter(::prost::alloc::boxed::Box), + #[prost(message, tag = "13")] + Merge(::prost::alloc::boxed::Box), + #[prost(message, tag = "14")] + Repartition(::prost::alloc::boxed::Box), + #[prost(message, tag = "15")] + Window(::prost::alloc::boxed::Box), + #[prost(message, tag = "16")] + CrossJoin(::prost::alloc::boxed::Box), + #[prost(message, tag = "17")] + AvroScan(super::AvroScanExecNode), + #[prost(message, tag = "18")] + Extension(super::PhysicalExtensionNode), + #[prost(message, tag = "19")] + Union(super::UnionExecNode), + #[prost(message, tag = "20")] + Explain(super::ExplainExecNode), + #[prost(message, tag = "21")] + SortPreservingMerge( + ::prost::alloc::boxed::Box, + ), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalExtensionNode { + #[prost(bytes = "vec", tag = "1")] + pub node: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "2")] + pub inputs: ::prost::alloc::vec::Vec, +} +/// physical expressions +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalExprNode { + #[prost( + oneof = "physical_expr_node::ExprType", + tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17" + )] + pub expr_type: ::core::option::Option, +} +/// Nested message and enum types in `PhysicalExprNode`. +pub mod physical_expr_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum ExprType { + /// column references + #[prost(message, tag = "1")] + Column(super::PhysicalColumn), + #[prost(message, tag = "2")] + Literal(super::ScalarValue), + /// binary expressions + #[prost(message, tag = "3")] + BinaryExpr(::prost::alloc::boxed::Box), + /// aggregate expressions + #[prost(message, tag = "4")] + AggregateExpr(super::PhysicalAggregateExprNode), + /// null checks + #[prost(message, tag = "5")] + IsNullExpr(::prost::alloc::boxed::Box), + #[prost(message, tag = "6")] + IsNotNullExpr(::prost::alloc::boxed::Box), + #[prost(message, tag = "7")] + NotExpr(::prost::alloc::boxed::Box), + #[prost(message, tag = "8")] + Case(::prost::alloc::boxed::Box), + #[prost(message, tag = "9")] + Cast(::prost::alloc::boxed::Box), + #[prost(message, tag = "10")] + Sort(::prost::alloc::boxed::Box), + #[prost(message, tag = "11")] + Negative(::prost::alloc::boxed::Box), + #[prost(message, tag = "12")] + InList(::prost::alloc::boxed::Box), + #[prost(message, tag = "13")] + ScalarFunction(super::PhysicalScalarFunctionNode), + #[prost(message, tag = "14")] + TryCast(::prost::alloc::boxed::Box), + /// window expressions + #[prost(message, tag = "15")] + WindowExpr(::prost::alloc::boxed::Box), + #[prost(message, tag = "16")] + ScalarUdf(super::PhysicalScalarUdfNode), + #[prost(message, tag = "17")] + DateTimeIntervalExpr( + ::prost::alloc::boxed::Box, + ), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalScalarUdfNode { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(message, repeated, tag = "2")] + pub args: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "4")] + pub return_type: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalAggregateExprNode { + #[prost(enumeration = "AggregateFunction", tag = "1")] + pub aggr_function: i32, + #[prost(message, repeated, tag = "2")] + pub expr: ::prost::alloc::vec::Vec, + #[prost(bool, tag = "3")] + pub distinct: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalWindowExprNode { + #[prost(message, optional, boxed, tag = "4")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(oneof = "physical_window_expr_node::WindowFunction", tags = "1, 2")] + pub window_function: ::core::option::Option< + physical_window_expr_node::WindowFunction, + >, +} +/// Nested message and enum types in `PhysicalWindowExprNode`. +pub mod physical_window_expr_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum WindowFunction { + #[prost(enumeration = "super::AggregateFunction", tag = "1")] + AggrFunction(i32), + /// udaf = 3 + #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")] + BuiltInFunction(i32), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalIsNull { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalIsNotNull { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalNot { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalAliasNode { + #[prost(message, optional, tag = "1")] + pub expr: ::core::option::Option, + #[prost(string, tag = "2")] + pub alias: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalBinaryExprNode { + #[prost(message, optional, boxed, tag = "1")] + pub l: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub r: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "3")] + pub op: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalDateTimeIntervalExprNode { + #[prost(message, optional, boxed, tag = "1")] + pub l: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub r: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, tag = "3")] + pub op: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalSortExprNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(bool, tag = "2")] + pub asc: bool, + #[prost(bool, tag = "3")] + pub nulls_first: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalWhenThen { + #[prost(message, optional, tag = "1")] + pub when_expr: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub then_expr: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalInListNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub list: ::prost::alloc::vec::Vec, + #[prost(bool, tag = "3")] + pub negated: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalCaseNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub when_then_expr: ::prost::alloc::vec::Vec, + #[prost(message, optional, boxed, tag = "3")] + pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalScalarFunctionNode { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(enumeration = "ScalarFunction", tag = "2")] + pub fun: i32, + #[prost(message, repeated, tag = "3")] + pub args: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "4")] + pub return_type: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalTryCastNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag = "2")] + pub arrow_type: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalCastNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag = "2")] + pub arrow_type: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalNegativeNode { + #[prost(message, optional, boxed, tag = "1")] + pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnresolvedShuffleExecNode { + #[prost(uint32, tag = "1")] + pub stage_id: u32, + #[prost(message, optional, tag = "2")] + pub schema: ::core::option::Option, + #[prost(uint32, tag = "3")] + pub input_partition_count: u32, + #[prost(uint32, tag = "4")] + pub output_partition_count: u32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FilterExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, tag = "2")] + pub expr: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FileGroup { + #[prost(message, repeated, tag = "1")] + pub files: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ScanLimit { + /// wrap into a message to make it optional + #[prost(uint32, tag = "1")] + pub limit: u32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FileScanExecConf { + #[prost(message, repeated, tag = "1")] + pub file_groups: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "2")] + pub schema: ::core::option::Option, + #[prost(uint32, repeated, tag = "4")] + pub projection: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "5")] + pub limit: ::core::option::Option, + #[prost(message, optional, tag = "6")] + pub statistics: ::core::option::Option, + #[prost(string, repeated, tag = "7")] + pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag = "8")] + pub object_store_url: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ParquetScanExecNode { + #[prost(message, optional, tag = "1")] + pub base_conf: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub pruning_predicate: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CsvScanExecNode { + #[prost(message, optional, tag = "1")] + pub base_conf: ::core::option::Option, + #[prost(bool, tag = "2")] + pub has_header: bool, + #[prost(string, tag = "3")] + pub delimiter: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AvroScanExecNode { + #[prost(message, optional, tag = "1")] + pub base_conf: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HashJoinExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub left: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub right: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "3")] + pub on: ::prost::alloc::vec::Vec, + #[prost(enumeration = "JoinType", tag = "4")] + pub join_type: i32, + #[prost(enumeration = "PartitionMode", tag = "6")] + pub partition_mode: i32, + #[prost(bool, tag = "7")] + pub null_equals_null: bool, + #[prost(message, optional, tag = "8")] + pub filter: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnionExecNode { + #[prost(message, repeated, tag = "1")] + pub inputs: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExplainExecNode { + #[prost(message, optional, tag = "1")] + pub schema: ::core::option::Option, + #[prost(message, repeated, tag = "2")] + pub stringified_plans: ::prost::alloc::vec::Vec, + #[prost(bool, tag = "3")] + pub verbose: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CrossJoinExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub left: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, optional, boxed, tag = "2")] + pub right: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalColumn { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(uint32, tag = "2")] + pub index: u32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JoinOn { + #[prost(message, optional, tag = "1")] + pub left: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub right: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EmptyExecNode { + #[prost(bool, tag = "1")] + pub produce_one_row: bool, + #[prost(message, optional, tag = "2")] + pub schema: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ProjectionExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub expr: ::prost::alloc::vec::Vec, + #[prost(string, repeated, tag = "3")] + pub expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WindowAggExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub window_expr: ::prost::alloc::vec::Vec, + #[prost(string, repeated, tag = "3")] + pub window_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, optional, tag = "4")] + pub input_schema: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AggregateExecNode { + #[prost(message, repeated, tag = "1")] + pub group_expr: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "2")] + pub aggr_expr: ::prost::alloc::vec::Vec, + #[prost(enumeration = "AggregateMode", tag = "3")] + pub mode: i32, + #[prost(message, optional, boxed, tag = "4")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(string, repeated, tag = "5")] + pub group_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, repeated, tag = "6")] + pub aggr_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// we need the input schema to the partial aggregate to pass to the final aggregate + #[prost(message, optional, tag = "7")] + pub input_schema: ::core::option::Option, + #[prost(message, repeated, tag = "8")] + pub null_expr: ::prost::alloc::vec::Vec, + #[prost(bool, repeated, tag = "9")] + pub groups: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ShuffleWriterExecNode { + /// TODO it seems redundant to provide job and stage id here since we also have them + /// in the TaskDefinition that wraps this plan + #[prost(string, tag = "1")] + pub job_id: ::prost::alloc::string::String, + #[prost(uint32, tag = "2")] + pub stage_id: u32, + #[prost(message, optional, tag = "3")] + pub input: ::core::option::Option, + #[prost(message, optional, tag = "4")] + pub output_partitioning: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GlobalLimitExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + /// The number of rows to skip before fetch + #[prost(uint32, tag = "2")] + pub skip: u32, + /// Maximum number of rows to fetch; negative means no limit + #[prost(int64, tag = "3")] + pub fetch: i64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct LocalLimitExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(uint32, tag = "2")] + pub fetch: u32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SortExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub expr: ::prost::alloc::vec::Vec, + /// Maximum number of highest/lowest rows to fetch; negative means no limit + #[prost(int64, tag = "3")] + pub fetch: i64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SortPreservingMergeExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(message, repeated, tag = "2")] + pub expr: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CoalesceBatchesExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(uint32, tag = "2")] + pub target_batch_size: u32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CoalescePartitionsExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PhysicalHashRepartition { + #[prost(message, repeated, tag = "1")] + pub hash_expr: ::prost::alloc::vec::Vec, + #[prost(uint64, tag = "2")] + pub partition_count: u64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RepartitionExecNode { + #[prost(message, optional, boxed, tag = "1")] + pub input: ::core::option::Option<::prost::alloc::boxed::Box>, + #[prost(oneof = "repartition_exec_node::PartitionMethod", tags = "2, 3, 4")] + pub partition_method: ::core::option::Option, +} +/// Nested message and enum types in `RepartitionExecNode`. +pub mod repartition_exec_node { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum PartitionMethod { + #[prost(uint64, tag = "2")] + RoundRobin(u64), + #[prost(message, tag = "3")] + Hash(super::PhysicalHashRepartition), + #[prost(uint64, tag = "4")] + Unknown(u64), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct JoinFilter { + #[prost(message, optional, tag = "1")] + pub expression: ::core::option::Option, + #[prost(message, repeated, tag = "2")] + pub column_indices: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "3")] + pub schema: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ColumnIndex { + #[prost(uint32, tag = "1")] + pub index: u32, + #[prost(enumeration = "JoinSide", tag = "2")] + pub side: i32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PartitionedFile { + #[prost(string, tag = "1")] + pub path: ::prost::alloc::string::String, + #[prost(uint64, tag = "2")] + pub size: u64, + #[prost(uint64, tag = "3")] + pub last_modified_ns: u64, + #[prost(message, repeated, tag = "4")] + pub partition_values: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "5")] + pub range: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FileRange { + #[prost(int64, tag = "1")] + pub start: i64, + #[prost(int64, tag = "2")] + pub end: i64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PartitionStats { + #[prost(int64, tag = "1")] + pub num_rows: i64, + #[prost(int64, tag = "2")] + pub num_batches: i64, + #[prost(int64, tag = "3")] + pub num_bytes: i64, + #[prost(message, repeated, tag = "4")] + pub column_stats: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Statistics { + #[prost(int64, tag = "1")] + pub num_rows: i64, + #[prost(int64, tag = "2")] + pub total_byte_size: i64, + #[prost(message, repeated, tag = "3")] + pub column_stats: ::prost::alloc::vec::Vec, + #[prost(bool, tag = "4")] + pub is_exact: bool, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ColumnStats { + #[prost(message, optional, tag = "1")] + pub min_value: ::core::option::Option, + #[prost(message, optional, tag = "2")] + pub max_value: ::core::option::Option, + #[prost(uint32, tag = "3")] + pub null_count: u32, + #[prost(uint32, tag = "4")] + pub distinct_count: u32, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PartitionLocation { + /// partition_id of the map stage who produces the shuffle. + #[prost(uint32, tag = "1")] + pub map_partition_id: u32, + /// partition_id of the shuffle, a composition of(job_id + map_stage_id + partition_id). + #[prost(message, optional, tag = "2")] + pub partition_id: ::core::option::Option, + #[prost(message, optional, tag = "3")] + pub executor_meta: ::core::option::Option, + #[prost(message, optional, tag = "4")] + pub partition_stats: ::core::option::Option, + #[prost(string, tag = "5")] + pub path: ::prost::alloc::string::String, +} +/// Unique identifier for a materialized partition of data +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PartitionId { + #[prost(string, tag = "1")] + pub job_id: ::prost::alloc::string::String, + #[prost(uint32, tag = "2")] + pub stage_id: u32, + #[prost(uint32, tag = "4")] + pub partition_id: u32, +} +/// Used by scheduler +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutorMetadata { + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub host: ::prost::alloc::string::String, + #[prost(uint32, tag = "3")] + pub port: u32, + #[prost(uint32, tag = "4")] + pub grpc_port: u32, + #[prost(message, optional, tag = "5")] + pub specification: ::core::option::Option, +} +/// Used by grpc +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutorRegistration { + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + #[prost(uint32, tag = "3")] + pub port: u32, + #[prost(uint32, tag = "4")] + pub grpc_port: u32, + #[prost(message, optional, tag = "5")] + pub specification: ::core::option::Option, + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[prost(oneof = "executor_registration::OptionalHost", tags = "2")] + pub optional_host: ::core::option::Option, +} +/// Nested message and enum types in `ExecutorRegistration`. +pub mod executor_registration { + /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) + /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum OptionalHost { + #[prost(string, tag = "2")] + Host(::prost::alloc::string::String), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutorHeartbeat { + #[prost(string, tag = "1")] + pub executor_id: ::prost::alloc::string::String, + /// Unix epoch-based timestamp in seconds + #[prost(uint64, tag = "2")] + pub timestamp: u64, + #[prost(message, repeated, tag = "3")] + pub metrics: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag = "4")] + pub status: ::core::option::Option, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutorSpecification { + #[prost(message, repeated, tag = "1")] + pub resources: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutorResource { + /// TODO add more resources + #[prost(oneof = "executor_resource::Resource", tags = "1")] + pub resource: ::core::option::Option, +} +/// Nested message and enum types in `ExecutorResource`. +pub mod executor_resource { + /// TODO add more resources + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Resource { + #[prost(uint32, tag = "1")] + TaskSlots(u32), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutorMetric { + /// TODO add more metrics + #[prost(oneof = "executor_metric::Metric", tags = "1")] + pub metric: ::core::option::Option, +} +/// Nested message and enum types in `ExecutorMetric`. +pub mod executor_metric { + /// TODO add more metrics + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Metric { + #[prost(uint64, tag = "1")] + AvailableMemory(u64), + } +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ExecutorStatus { + #[prost(oneof = "executor_status::Status", tags = "1, 2, 3")] + pub status: ::core::option::Option, +} +/// Nested message and enum types in `ExecutorStatus`. +pub mod executor_status { + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Status { + #[prost(string, tag = "1")] + Active(::prost::alloc::string::String), + #[prost(string, tag = "2")] + Dead(::prost::alloc::string::String), + #[prost(string, tag = "3")] + Unknown(::prost::alloc::string::String), + } +} #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum JoinType { @@ -1570,3 +2284,59 @@ impl UnionMode { } } } +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum PartitionMode { + CollectLeft = 0, + Partitioned = 1, +} +impl PartitionMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + PartitionMode::CollectLeft => "COLLECT_LEFT", + PartitionMode::Partitioned => "PARTITIONED", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum AggregateMode { + Partial = 0, + Final = 1, + FinalPartitioned = 2, +} +impl AggregateMode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + AggregateMode::Partial => "PARTIAL", + AggregateMode::Final => "FINAL", + AggregateMode::FinalPartitioned => "FINAL_PARTITIONED", + } + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum JoinSide { + LeftSide = 0, + RightSide = 1, +} +impl JoinSide { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + JoinSide::LeftSide => "LEFT_SIDE", + JoinSide::RightSide => "RIGHT_SIDE", + } + } +} diff --git a/datafusion/proto/src/lib.rs b/datafusion/proto/src/lib.rs index e4b1c65d26f2..bf4b777ffab3 100644 --- a/datafusion/proto/src/lib.rs +++ b/datafusion/proto/src/lib.rs @@ -20,9 +20,11 @@ use datafusion_common::DataFusionError; pub mod bytes; +mod common; pub mod from_proto; pub mod generated; pub mod logical_plan; +pub mod physical_plan; pub mod to_proto; pub use generated::datafusion as protobuf; diff --git a/datafusion/proto/src/logical_plan.rs b/datafusion/proto/src/logical_plan.rs index c63258858202..4c2827ed7f91 100644 --- a/datafusion/proto/src/logical_plan.rs +++ b/datafusion/proto/src/logical_plan.rs @@ -27,8 +27,6 @@ use crate::{ }; use arrow::datatypes::{Schema, SchemaRef}; use datafusion::datasource::TableProvider; -use datafusion::execution::FunctionRegistry; -use datafusion::physical_plan::ExecutionPlan; use datafusion::{ datasource::{ file_format::{ @@ -98,21 +96,6 @@ pub trait AsLogicalPlan: Debug + Send + Sync + Clone { Self: Sized; } -pub trait PhysicalExtensionCodec: Debug + Send + Sync { - fn try_decode( - &self, - buf: &[u8], - inputs: &[Arc], - registry: &dyn FunctionRegistry, - ) -> Result, DataFusionError>; - - fn try_encode( - &self, - node: Arc, - buf: &mut Vec, - ) -> Result<(), DataFusionError>; -} - pub trait LogicalExtensionCodec: Debug + Send + Sync { fn try_decode( &self, diff --git a/datafusion/proto/src/physical_plan/from_proto.rs b/datafusion/proto/src/physical_plan/from_proto.rs new file mode 100644 index 000000000000..43cc228957c7 --- /dev/null +++ b/datafusion/proto/src/physical_plan/from_proto.rs @@ -0,0 +1,428 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Serde code to convert from protocol buffers to Rust data structures. + +use crate::protobuf; +use chrono::TimeZone; +use chrono::Utc; +use datafusion::arrow::datatypes::Schema; +use datafusion::config::ConfigOptions; +use datafusion::datasource::listing::{FileRange, PartitionedFile}; +use datafusion::datasource::object_store::ObjectStoreUrl; +use datafusion::execution::context::ExecutionProps; +use datafusion::execution::FunctionRegistry; +use datafusion::logical_expr::window_function::WindowFunction; +use datafusion::physical_expr::expressions::DateTimeIntervalExpr; +use datafusion::physical_expr::ScalarFunctionExpr; +use datafusion::physical_plan::file_format::FileScanConfig; +use datafusion::physical_plan::{ + expressions::{ + BinaryExpr, CaseExpr, CastExpr, Column, InListExpr, IsNotNullExpr, IsNullExpr, + Literal, NegativeExpr, NotExpr, TryCastExpr, DEFAULT_DATAFUSION_CAST_OPTIONS, + }, + functions, Partitioning, +}; +use datafusion::physical_plan::{ColumnStatistics, PhysicalExpr, Statistics}; +use datafusion_common::DataFusionError; +use object_store::path::Path; +use object_store::ObjectMeta; +use std::convert::{TryFrom, TryInto}; +use std::ops::Deref; +use std::sync::Arc; + +use crate::common::proto_error; +use crate::convert_required; +use crate::from_proto::from_proto_binary_op; +use crate::protobuf::physical_expr_node::ExprType; +use crate::protobuf::JoinSide; +use parking_lot::RwLock; + +impl From<&protobuf::PhysicalColumn> for Column { + fn from(c: &protobuf::PhysicalColumn) -> Column { + Column::new(&c.name, c.index as usize) + } +} + +pub(crate) fn parse_physical_expr( + proto: &protobuf::PhysicalExprNode, + registry: &dyn FunctionRegistry, + input_schema: &Schema, +) -> Result, DataFusionError> { + let expr_type = proto + .expr_type + .as_ref() + .ok_or_else(|| proto_error("Unexpected empty physical expression"))?; + + let pexpr: Arc = match expr_type { + ExprType::Column(c) => { + let pcol: Column = c.into(); + Arc::new(pcol) + } + ExprType::Literal(scalar) => Arc::new(Literal::new(scalar.try_into()?)), + ExprType::BinaryExpr(binary_expr) => Arc::new(BinaryExpr::new( + parse_required_physical_box_expr( + &binary_expr.l, + registry, + "left", + input_schema, + )?, + from_proto_binary_op(&binary_expr.op)?, + parse_required_physical_box_expr( + &binary_expr.r, + registry, + "right", + input_schema, + )?, + )), + ExprType::DateTimeIntervalExpr(expr) => Arc::new(DateTimeIntervalExpr::try_new( + parse_required_physical_box_expr(&expr.l, registry, "left", input_schema)?, + from_proto_binary_op(&expr.op)?, + parse_required_physical_box_expr(&expr.r, registry, "right", input_schema)?, + input_schema, + )?), + ExprType::AggregateExpr(_) => { + return Err(DataFusionError::Internal( + "Cannot convert aggregate expr node to physical expression".to_owned(), + )); + } + ExprType::WindowExpr(_) => { + return Err(DataFusionError::Internal( + "Cannot convert window expr node to physical expression".to_owned(), + )); + } + ExprType::Sort(_) => { + return Err(DataFusionError::Internal( + "Cannot convert sort expr node to physical expression".to_owned(), + )); + } + ExprType::IsNullExpr(e) => Arc::new(IsNullExpr::new( + parse_required_physical_box_expr(&e.expr, registry, "expr", input_schema)?, + )), + ExprType::IsNotNullExpr(e) => Arc::new(IsNotNullExpr::new( + parse_required_physical_box_expr(&e.expr, registry, "expr", input_schema)?, + )), + ExprType::NotExpr(e) => Arc::new(NotExpr::new(parse_required_physical_box_expr( + &e.expr, + registry, + "expr", + input_schema, + )?)), + ExprType::Negative(e) => Arc::new(NegativeExpr::new( + parse_required_physical_box_expr(&e.expr, registry, "expr", input_schema)?, + )), + ExprType::InList(e) => Arc::new(InListExpr::new( + parse_required_physical_box_expr(&e.expr, registry, "expr", input_schema)?, + e.list + .iter() + .map(|x| parse_physical_expr(x, registry, input_schema)) + .collect::, _>>()?, + e.negated, + input_schema, + )), + ExprType::Case(e) => Arc::new(CaseExpr::try_new( + e.expr + .as_ref() + .map(|e| parse_physical_expr(e.as_ref(), registry, input_schema)) + .transpose()?, + e.when_then_expr + .iter() + .map(|e| { + Ok(( + parse_required_physical_expr( + &e.when_expr, + registry, + "when_expr", + input_schema, + )?, + parse_required_physical_expr( + &e.then_expr, + registry, + "then_expr", + input_schema, + )?, + )) + }) + .collect::, DataFusionError>>()?, + e.else_expr + .as_ref() + .map(|e| parse_physical_expr(e.as_ref(), registry, input_schema)) + .transpose()?, + )?), + ExprType::Cast(e) => Arc::new(CastExpr::new( + parse_required_physical_box_expr(&e.expr, registry, "expr", input_schema)?, + convert_required!(e.arrow_type)?, + DEFAULT_DATAFUSION_CAST_OPTIONS, + )), + ExprType::TryCast(e) => Arc::new(TryCastExpr::new( + parse_required_physical_box_expr(&e.expr, registry, "expr", input_schema)?, + convert_required!(e.arrow_type)?, + )), + ExprType::ScalarFunction(e) => { + let scalar_function = + protobuf::ScalarFunction::from_i32(e.fun).ok_or_else(|| { + proto_error( + format!("Received an unknown scalar function: {}", e.fun,), + ) + })?; + + let args = e + .args + .iter() + .map(|x| parse_physical_expr(x, registry, input_schema)) + .collect::, _>>()?; + + // TODO Do not create new the ExecutionProps + let execution_props = ExecutionProps::new(); + + let fun_expr = functions::create_physical_fun( + &(&scalar_function).into(), + &execution_props, + )?; + + Arc::new(ScalarFunctionExpr::new( + &e.name, + fun_expr, + args, + &convert_required!(e.return_type)?, + )) + } + ExprType::ScalarUdf(e) => { + let scalar_fun = registry.udf(e.name.as_str())?.deref().clone().fun; + + let args = e + .args + .iter() + .map(|x| parse_physical_expr(x, registry, input_schema)) + .collect::, _>>()?; + + Arc::new(ScalarFunctionExpr::new( + e.name.as_str(), + scalar_fun, + args, + &convert_required!(e.return_type)?, + )) + } + }; + + Ok(pexpr) +} + +fn parse_required_physical_box_expr( + expr: &Option>, + registry: &dyn FunctionRegistry, + field: &str, + input_schema: &Schema, +) -> Result, DataFusionError> { + expr.as_ref() + .map(|e| parse_physical_expr(e.as_ref(), registry, input_schema)) + .transpose()? + .ok_or_else(|| { + DataFusionError::Internal(format!("Missing required field {:?}", field)) + }) +} + +fn parse_required_physical_expr( + expr: &Option, + registry: &dyn FunctionRegistry, + field: &str, + input_schema: &Schema, +) -> Result, DataFusionError> { + expr.as_ref() + .map(|e| parse_physical_expr(e, registry, input_schema)) + .transpose()? + .ok_or_else(|| { + DataFusionError::Internal(format!("Missing required field {:?}", field)) + }) +} + +impl TryFrom<&protobuf::physical_window_expr_node::WindowFunction> for WindowFunction { + type Error = DataFusionError; + + fn try_from( + expr: &protobuf::physical_window_expr_node::WindowFunction, + ) -> Result { + match expr { + protobuf::physical_window_expr_node::WindowFunction::AggrFunction(n) => { + let f = protobuf::AggregateFunction::from_i32(*n).ok_or_else(|| { + proto_error(format!( + "Received an unknown window aggregate function: {}", + n + )) + })?; + + Ok(WindowFunction::AggregateFunction(f.into())) + } + protobuf::physical_window_expr_node::WindowFunction::BuiltInFunction(n) => { + let f = + protobuf::BuiltInWindowFunction::from_i32(*n).ok_or_else(|| { + proto_error(format!( + "Received an unknown window builtin function: {}", + n + )) + })?; + + Ok(WindowFunction::BuiltInWindowFunction(f.into())) + } + } + } +} + +pub fn parse_protobuf_hash_partitioning( + partitioning: Option<&protobuf::PhysicalHashRepartition>, + registry: &dyn FunctionRegistry, + input_schema: &Schema, +) -> Result, DataFusionError> { + match partitioning { + Some(hash_part) => { + let expr = hash_part + .hash_expr + .iter() + .map(|e| parse_physical_expr(e, registry, input_schema)) + .collect::>, _>>()?; + + Ok(Some(Partitioning::Hash( + expr, + hash_part.partition_count.try_into().unwrap(), + ))) + } + None => Ok(None), + } +} + +impl TryFrom<&protobuf::PartitionedFile> for PartitionedFile { + type Error = DataFusionError; + + fn try_from(val: &protobuf::PartitionedFile) -> Result { + Ok(PartitionedFile { + object_meta: ObjectMeta { + location: Path::from(val.path.as_str()), + last_modified: Utc.timestamp_nanos(val.last_modified_ns as i64), + size: val.size as usize, + }, + partition_values: val + .partition_values + .iter() + .map(|v| v.try_into()) + .collect::, _>>()?, + range: val.range.as_ref().map(|v| v.try_into()).transpose()?, + extensions: None, + }) + } +} + +impl TryFrom<&protobuf::FileRange> for FileRange { + type Error = DataFusionError; + + fn try_from(value: &protobuf::FileRange) -> Result { + Ok(FileRange { + start: value.start, + end: value.end, + }) + } +} + +impl TryFrom<&protobuf::FileGroup> for Vec { + type Error = DataFusionError; + + fn try_from(val: &protobuf::FileGroup) -> Result { + val.files + .iter() + .map(|f| f.try_into()) + .collect::, _>>() + } +} + +impl From<&protobuf::ColumnStats> for ColumnStatistics { + fn from(cs: &protobuf::ColumnStats) -> ColumnStatistics { + ColumnStatistics { + null_count: Some(cs.null_count as usize), + max_value: cs.max_value.as_ref().map(|m| m.try_into().unwrap()), + min_value: cs.min_value.as_ref().map(|m| m.try_into().unwrap()), + distinct_count: Some(cs.distinct_count as usize), + } + } +} + +impl TryInto for &protobuf::Statistics { + type Error = DataFusionError; + + fn try_into(self) -> Result { + let column_statistics = self + .column_stats + .iter() + .map(|s| s.into()) + .collect::>(); + Ok(Statistics { + num_rows: Some(self.num_rows as usize), + total_byte_size: Some(self.total_byte_size as usize), + // No column statistic (None) is encoded with empty array + column_statistics: if column_statistics.is_empty() { + None + } else { + Some(column_statistics) + }, + is_exact: self.is_exact, + }) + } +} + +impl TryInto for &protobuf::FileScanExecConf { + type Error = DataFusionError; + + fn try_into(self) -> Result { + let schema = Arc::new(convert_required!(self.schema)?); + let projection = self + .projection + .iter() + .map(|i| *i as usize) + .collect::>(); + let projection = if projection.is_empty() { + None + } else { + Some(projection) + }; + let statistics = convert_required!(self.statistics)?; + + Ok(FileScanConfig { + config_options: Arc::new(RwLock::new(ConfigOptions::new())), // TODO add serde + object_store_url: ObjectStoreUrl::parse(&self.object_store_url)?, + file_schema: schema, + file_groups: self + .file_groups + .iter() + .map(|f| f.try_into()) + .collect::, _>>()?, + statistics, + projection, + limit: self.limit.as_ref().map(|sl| sl.limit as usize), + table_partition_cols: vec![], + output_ordering: None, + }) + } +} + +impl From for datafusion::physical_plan::joins::utils::JoinSide { + fn from(t: JoinSide) -> Self { + match t { + JoinSide::LeftSide => datafusion::physical_plan::joins::utils::JoinSide::Left, + JoinSide::RightSide => { + datafusion::physical_plan::joins::utils::JoinSide::Right + } + } + } +} diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs new file mode 100644 index 000000000000..c9db1f3bf248 --- /dev/null +++ b/datafusion/proto/src/physical_plan/mod.rs @@ -0,0 +1,1590 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +use std::convert::TryInto; +use std::fmt::Debug; +use std::sync::Arc; + +use datafusion::arrow::compute::SortOptions; +use datafusion::arrow::datatypes::SchemaRef; +use datafusion::config::ConfigOptions; +use datafusion::datasource::file_format::file_type::FileCompressionType; +use datafusion::datasource::listing::PartitionedFile; +use datafusion::datasource::object_store::ObjectStoreUrl; +use datafusion::execution::runtime_env::RuntimeEnv; +use datafusion::execution::FunctionRegistry; +use datafusion::logical_expr::WindowFrame; +use datafusion::physical_plan::aggregates::{create_aggregate_expr, AggregateMode}; +use datafusion::physical_plan::aggregates::{AggregateExec, PhysicalGroupBy}; +use datafusion::physical_plan::coalesce_batches::CoalesceBatchesExec; +use datafusion::physical_plan::coalesce_partitions::CoalescePartitionsExec; +use datafusion::physical_plan::empty::EmptyExec; +use datafusion::physical_plan::explain::ExplainExec; +use datafusion::physical_plan::expressions::{Column, PhysicalSortExpr}; +use datafusion::physical_plan::file_format::{ + AvroExec, CsvExec, FileScanConfig, ParquetExec, +}; +use datafusion::physical_plan::filter::FilterExec; +use datafusion::physical_plan::joins::utils::{ColumnIndex, JoinFilter}; +use datafusion::physical_plan::joins::CrossJoinExec; +use datafusion::physical_plan::joins::{HashJoinExec, PartitionMode}; +use datafusion::physical_plan::limit::{GlobalLimitExec, LocalLimitExec}; +use datafusion::physical_plan::projection::ProjectionExec; +use datafusion::physical_plan::repartition::RepartitionExec; +use datafusion::physical_plan::sorts::sort::SortExec; +use datafusion::physical_plan::sorts::sort_preserving_merge::SortPreservingMergeExec; +use datafusion::physical_plan::union::UnionExec; +use datafusion::physical_plan::windows::{create_window_expr, WindowAggExec}; +use datafusion::physical_plan::{ + AggregateExpr, ExecutionPlan, Partitioning, PhysicalExpr, WindowExpr, +}; +use datafusion_common::DataFusionError; +use parking_lot::RwLock; +use prost::bytes::BufMut; +use prost::Message; + +use crate::common::proto_error; +use crate::common::{byte_to_string, str_to_byte}; +use crate::from_proto::parse_expr; +use crate::physical_plan::from_proto::parse_physical_expr; +use crate::protobuf::physical_expr_node::ExprType; +use crate::protobuf::physical_plan_node::PhysicalPlanType; +use crate::protobuf::repartition_exec_node::PartitionMethod; +use crate::protobuf::{self, PhysicalPlanNode}; +use crate::{convert_required, into_physical_plan, into_required}; + +pub mod from_proto; +pub mod to_proto; + +impl AsExecutionPlan for PhysicalPlanNode { + fn try_decode(buf: &[u8]) -> Result + where + Self: Sized, + { + protobuf::PhysicalPlanNode::decode(buf).map_err(|e| { + DataFusionError::Internal(format!("failed to decode physical plan: {:?}", e)) + }) + } + + fn try_encode(&self, buf: &mut B) -> Result<(), DataFusionError> + where + B: BufMut, + Self: Sized, + { + self.encode(buf).map_err(|e| { + DataFusionError::Internal(format!("failed to encode physical plan: {:?}", e)) + }) + } + + #[allow(clippy::only_used_in_recursion)] + fn try_into_physical_plan( + &self, + registry: &dyn FunctionRegistry, + runtime: &RuntimeEnv, + extension_codec: &dyn PhysicalExtensionCodec, + ) -> Result, DataFusionError> { + let plan = self.physical_plan_type.as_ref().ok_or_else(|| { + proto_error(format!( + "physical_plan::from_proto() Unsupported physical plan '{:?}'", + self + )) + })?; + match plan { + PhysicalPlanType::Explain(explain) => Ok(Arc::new(ExplainExec::new( + Arc::new(explain.schema.as_ref().unwrap().try_into()?), + explain + .stringified_plans + .iter() + .map(|plan| plan.into()) + .collect(), + explain.verbose, + ))), + PhysicalPlanType::Projection(projection) => { + let input: Arc = into_physical_plan!( + projection.input, + registry, + runtime, + extension_codec + )?; + let exprs = projection + .expr + .iter() + .zip(projection.expr_name.iter()) + .map(|(expr, name)| Ok((parse_physical_expr(expr,registry, input.schema().as_ref())?, name.to_string()))) + .collect::, String)>, DataFusionError>>( + )?; + Ok(Arc::new(ProjectionExec::try_new(exprs, input)?)) + } + PhysicalPlanType::Filter(filter) => { + let input: Arc = into_physical_plan!( + filter.input, + registry, + runtime, + extension_codec + )?; + let predicate = filter + .expr + .as_ref() + .map(|expr| { + parse_physical_expr(expr, registry, input.schema().as_ref()) + }) + .transpose()? + .ok_or_else(|| { + DataFusionError::Internal( + "filter (FilterExecNode) in PhysicalPlanNode is missing." + .to_owned(), + ) + })?; + Ok(Arc::new(FilterExec::try_new(predicate, input)?)) + } + PhysicalPlanType::CsvScan(scan) => Ok(Arc::new(CsvExec::new( + decode_scan_config(scan.base_conf.as_ref().unwrap())?, + scan.has_header, + str_to_byte(&scan.delimiter)?, + FileCompressionType::UNCOMPRESSED, + ))), + PhysicalPlanType::ParquetScan(scan) => { + let predicate = scan + .pruning_predicate + .as_ref() + .map(|expr| parse_expr(expr, registry)) + .transpose()?; + Ok(Arc::new(ParquetExec::new( + decode_scan_config(scan.base_conf.as_ref().unwrap())?, + predicate, + None, + ))) + } + PhysicalPlanType::AvroScan(scan) => Ok(Arc::new(AvroExec::new( + decode_scan_config(scan.base_conf.as_ref().unwrap())?, + ))), + PhysicalPlanType::CoalesceBatches(coalesce_batches) => { + let input: Arc = into_physical_plan!( + coalesce_batches.input, + registry, + runtime, + extension_codec + )?; + Ok(Arc::new(CoalesceBatchesExec::new( + input, + coalesce_batches.target_batch_size as usize, + ))) + } + PhysicalPlanType::Merge(merge) => { + let input: Arc = + into_physical_plan!(merge.input, registry, runtime, extension_codec)?; + Ok(Arc::new(CoalescePartitionsExec::new(input))) + } + PhysicalPlanType::Repartition(repart) => { + let input: Arc = into_physical_plan!( + repart.input, + registry, + runtime, + extension_codec + )?; + match repart.partition_method { + Some(PartitionMethod::Hash(ref hash_part)) => { + let expr = hash_part + .hash_expr + .iter() + .map(|e| { + parse_physical_expr(e, registry, input.schema().as_ref()) + }) + .collect::>, _>>()?; + + Ok(Arc::new(RepartitionExec::try_new( + input, + Partitioning::Hash( + expr, + hash_part.partition_count.try_into().unwrap(), + ), + )?)) + } + Some(PartitionMethod::RoundRobin(partition_count)) => { + Ok(Arc::new(RepartitionExec::try_new( + input, + Partitioning::RoundRobinBatch( + partition_count.try_into().unwrap(), + ), + )?)) + } + Some(PartitionMethod::Unknown(partition_count)) => { + Ok(Arc::new(RepartitionExec::try_new( + input, + Partitioning::UnknownPartitioning( + partition_count.try_into().unwrap(), + ), + )?)) + } + _ => Err(DataFusionError::Internal( + "Invalid partitioning scheme".to_owned(), + )), + } + } + PhysicalPlanType::GlobalLimit(limit) => { + let input: Arc = + into_physical_plan!(limit.input, registry, runtime, extension_codec)?; + let fetch = if limit.fetch >= 0 { + Some(limit.fetch as usize) + } else { + None + }; + Ok(Arc::new(GlobalLimitExec::new( + input, + limit.skip as usize, + fetch, + ))) + } + PhysicalPlanType::LocalLimit(limit) => { + let input: Arc = + into_physical_plan!(limit.input, registry, runtime, extension_codec)?; + Ok(Arc::new(LocalLimitExec::new(input, limit.fetch as usize))) + } + PhysicalPlanType::Window(window_agg) => { + let input: Arc = into_physical_plan!( + window_agg.input, + registry, + runtime, + extension_codec + )?; + let input_schema = window_agg + .input_schema + .as_ref() + .ok_or_else(|| { + DataFusionError::Internal( + "input_schema in WindowAggrNode is missing.".to_owned(), + ) + })? + .clone(); + let physical_schema: SchemaRef = + SchemaRef::new((&input_schema).try_into()?); + + let physical_window_expr: Vec> = window_agg + .window_expr + .iter() + .zip(window_agg.window_expr_name.iter()) + .map(|(expr, name)| { + let expr_type = expr.expr_type.as_ref().ok_or_else(|| { + proto_error("Unexpected empty window physical expression") + })?; + + match expr_type { + ExprType::WindowExpr(window_node) => { + let window_node_expr = window_node + .expr + .as_ref() + .map(|e| { + parse_physical_expr( + e.as_ref(), + registry, + &physical_schema, + ) + }) + .transpose()? + .ok_or_else(|| { + proto_error( + "missing window_node expr expression" + .to_string(), + ) + })?; + + Ok(create_window_expr( + &convert_required!(window_node.window_function)?, + name.to_owned(), + &[window_node_expr], + &[], + &[], + Some(Arc::new(WindowFrame::default())), + &physical_schema, + )?) + } + _ => Err(DataFusionError::Internal( + "Invalid expression for WindowAggrExec".to_string(), + )), + } + }) + .collect::, _>>()?; + //todo fill partition keys and sort keys + Ok(Arc::new(WindowAggExec::try_new( + physical_window_expr, + input, + Arc::new((&input_schema).try_into()?), + vec![], + None, + )?)) + } + PhysicalPlanType::Aggregate(hash_agg) => { + let input: Arc = into_physical_plan!( + hash_agg.input, + registry, + runtime, + extension_codec + )?; + let mode = protobuf::AggregateMode::from_i32(hash_agg.mode).ok_or_else( + || { + proto_error(format!( + "Received a AggregateNode message with unknown AggregateMode {}", + hash_agg.mode + )) + }, + )?; + let agg_mode: AggregateMode = match mode { + protobuf::AggregateMode::Partial => AggregateMode::Partial, + protobuf::AggregateMode::Final => AggregateMode::Final, + protobuf::AggregateMode::FinalPartitioned => { + AggregateMode::FinalPartitioned + } + }; + + let num_expr = hash_agg.group_expr.len(); + + let group_expr = hash_agg + .group_expr + .iter() + .zip(hash_agg.group_expr_name.iter()) + .map(|(expr, name)| { + parse_physical_expr(expr, registry, input.schema().as_ref()) + .map(|expr| (expr, name.to_string())) + }) + .collect::, _>>()?; + + let null_expr = hash_agg + .null_expr + .iter() + .zip(hash_agg.group_expr_name.iter()) + .map(|(expr, name)| { + parse_physical_expr(expr, registry, input.schema().as_ref()) + .map(|expr| (expr, name.to_string())) + }) + .collect::, _>>()?; + + let groups: Vec> = if !hash_agg.groups.is_empty() { + hash_agg + .groups + .chunks(num_expr) + .map(|g| g.to_vec()) + .collect::>>() + } else { + vec![] + }; + + let input_schema = hash_agg + .input_schema + .as_ref() + .ok_or_else(|| { + DataFusionError::Internal( + "input_schema in AggregateNode is missing.".to_owned(), + ) + })? + .clone(); + let physical_schema: SchemaRef = + SchemaRef::new((&input_schema).try_into()?); + + let physical_aggr_expr: Vec> = hash_agg + .aggr_expr + .iter() + .zip(hash_agg.aggr_expr_name.iter()) + .map(|(expr, name)| { + let expr_type = expr.expr_type.as_ref().ok_or_else(|| { + proto_error("Unexpected empty aggregate physical expression") + })?; + + match expr_type { + ExprType::AggregateExpr(agg_node) => { + let aggr_function = + protobuf::AggregateFunction::from_i32( + agg_node.aggr_function, + ) + .ok_or_else( + || { + proto_error(format!( + "Received an unknown aggregate function: {}", + agg_node.aggr_function + )) + }, + )?; + + let input_phy_expr: Vec> = agg_node.expr.iter() + .map(|e| parse_physical_expr(e, registry, &physical_schema).unwrap()).collect(); + + Ok(create_aggregate_expr( + &aggr_function.into(), + agg_node.distinct, + input_phy_expr.as_slice(), + &physical_schema, + name.to_string(), + )?) + } + _ => Err(DataFusionError::Internal( + "Invalid aggregate expression for AggregateExec" + .to_string(), + )), + } + }) + .collect::, _>>()?; + + Ok(Arc::new(AggregateExec::try_new( + agg_mode, + PhysicalGroupBy::new(group_expr, null_expr, groups), + physical_aggr_expr, + input, + Arc::new((&input_schema).try_into()?), + )?)) + } + PhysicalPlanType::HashJoin(hashjoin) => { + let left: Arc = into_physical_plan!( + hashjoin.left, + registry, + runtime, + extension_codec + )?; + let right: Arc = into_physical_plan!( + hashjoin.right, + registry, + runtime, + extension_codec + )?; + let on: Vec<(Column, Column)> = hashjoin + .on + .iter() + .map(|col| { + let left = into_required!(col.left)?; + let right = into_required!(col.right)?; + Ok((left, right)) + }) + .collect::>()?; + let join_type = protobuf::JoinType::from_i32(hashjoin.join_type) + .ok_or_else(|| { + proto_error(format!( + "Received a HashJoinNode message with unknown JoinType {}", + hashjoin.join_type + )) + })?; + let filter = hashjoin + .filter + .as_ref() + .map(|f| { + let schema = f + .schema + .as_ref() + .ok_or_else(|| proto_error("Missing JoinFilter schema"))? + .try_into()?; + + let expression = parse_physical_expr( + f.expression.as_ref().ok_or_else(|| { + proto_error("Unexpected empty filter expression") + })?, + registry, &schema + )?; + let column_indices = f.column_indices + .iter() + .map(|i| { + let side = protobuf::JoinSide::from_i32(i.side) + .ok_or_else(|| proto_error(format!( + "Received a HashJoinNode message with JoinSide in Filter {}", + i.side)) + )?; + + Ok(ColumnIndex{ + index: i.index as usize, + side: side.into(), + }) + }) + .collect::, DataFusionError>>()?; + + Ok(JoinFilter::new(expression, column_indices, schema)) + }) + .map_or(Ok(None), |v: Result| v.map(Some))?; + + let partition_mode = + protobuf::PartitionMode::from_i32(hashjoin.partition_mode) + .ok_or_else(|| { + proto_error(format!( + "Received a HashJoinNode message with unknown PartitionMode {}", + hashjoin.partition_mode + )) + })?; + let partition_mode = match partition_mode { + protobuf::PartitionMode::CollectLeft => PartitionMode::CollectLeft, + protobuf::PartitionMode::Partitioned => PartitionMode::Partitioned, + }; + Ok(Arc::new(HashJoinExec::try_new( + left, + right, + on, + filter, + &join_type.into(), + partition_mode, + &hashjoin.null_equals_null, + )?)) + } + PhysicalPlanType::Union(union) => { + let mut inputs: Vec> = vec![]; + for input in &union.inputs { + inputs.push(input.try_into_physical_plan( + registry, + runtime, + extension_codec, + )?); + } + Ok(Arc::new(UnionExec::new(inputs))) + } + PhysicalPlanType::CrossJoin(crossjoin) => { + let left: Arc = into_physical_plan!( + crossjoin.left, + registry, + runtime, + extension_codec + )?; + let right: Arc = into_physical_plan!( + crossjoin.right, + registry, + runtime, + extension_codec + )?; + Ok(Arc::new(CrossJoinExec::try_new(left, right)?)) + } + PhysicalPlanType::Empty(empty) => { + let schema = Arc::new(convert_required!(empty.schema)?); + Ok(Arc::new(EmptyExec::new(empty.produce_one_row, schema))) + } + PhysicalPlanType::Sort(sort) => { + let input: Arc = + into_physical_plan!(sort.input, registry, runtime, extension_codec)?; + let exprs = sort + .expr + .iter() + .map(|expr| { + let expr = expr.expr_type.as_ref().ok_or_else(|| { + proto_error(format!( + "physical_plan::from_proto() Unexpected expr {:?}", + self + )) + })?; + if let protobuf::physical_expr_node::ExprType::Sort(sort_expr) = expr { + let expr = sort_expr + .expr + .as_ref() + .ok_or_else(|| { + proto_error(format!( + "physical_plan::from_proto() Unexpected sort expr {:?}", + self + )) + })? + .as_ref(); + Ok(PhysicalSortExpr { + expr: parse_physical_expr(expr,registry, input.schema().as_ref())?, + options: SortOptions { + descending: !sort_expr.asc, + nulls_first: sort_expr.nulls_first, + }, + }) + } else { + Err(DataFusionError::Internal(format!( + "physical_plan::from_proto() {:?}", + self + ))) + } + }) + .collect::, _>>()?; + let fetch = if sort.fetch < 0 { + None + } else { + Some(sort.fetch as usize) + }; + Ok(Arc::new(SortExec::try_new(exprs, input, fetch)?)) + } + PhysicalPlanType::SortPreservingMerge(sort) => { + let input: Arc = + into_physical_plan!(sort.input, registry, runtime, extension_codec)?; + let exprs = sort + .expr + .iter() + .map(|expr| { + let expr = expr.expr_type.as_ref().ok_or_else(|| { + proto_error(format!( + "physical_plan::from_proto() Unexpected expr {:?}", + self + )) + })?; + if let protobuf::physical_expr_node::ExprType::Sort(sort_expr) = expr { + let expr = sort_expr + .expr + .as_ref() + .ok_or_else(|| { + proto_error(format!( + "physical_plan::from_proto() Unexpected sort expr {:?}", + self + )) + })? + .as_ref(); + Ok(PhysicalSortExpr { + expr: parse_physical_expr(expr,registry, input.schema().as_ref())?, + options: SortOptions { + descending: !sort_expr.asc, + nulls_first: sort_expr.nulls_first, + }, + }) + } else { + Err(DataFusionError::Internal(format!( + "physical_plan::from_proto() {:?}", + self + ))) + } + }) + .collect::, _>>()?; + Ok(Arc::new(SortPreservingMergeExec::new(exprs, input))) + } + PhysicalPlanType::Extension(extension) => { + let inputs: Vec> = extension + .inputs + .iter() + .map(|i| i.try_into_physical_plan(registry, runtime, extension_codec)) + .collect::>()?; + + let extension_node = extension_codec.try_decode( + extension.node.as_slice(), + &inputs, + registry, + )?; + + Ok(extension_node) + } + } + } + + fn try_from_physical_plan( + plan: Arc, + extension_codec: &dyn PhysicalExtensionCodec, + ) -> Result + where + Self: Sized, + { + let plan_clone = plan.clone(); + let plan = plan.as_any(); + + if let Some(exec) = plan.downcast_ref::() { + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Explain( + protobuf::ExplainExecNode { + schema: Some(exec.schema().as_ref().try_into()?), + stringified_plans: exec + .stringified_plans() + .iter() + .map(|plan| plan.into()) + .collect(), + verbose: exec.verbose(), + }, + )), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.input().to_owned(), + extension_codec, + )?; + let expr = exec + .expr() + .iter() + .map(|expr| expr.0.clone().try_into()) + .collect::, DataFusionError>>()?; + let expr_name = exec.expr().iter().map(|expr| expr.1.clone()).collect(); + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Projection(Box::new( + protobuf::ProjectionExecNode { + input: Some(Box::new(input)), + expr, + expr_name, + }, + ))), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.input().to_owned(), + extension_codec, + )?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Filter(Box::new( + protobuf::FilterExecNode { + input: Some(Box::new(input)), + expr: Some(exec.predicate().clone().try_into()?), + }, + ))), + }) + } else if let Some(limit) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + limit.input().to_owned(), + extension_codec, + )?; + + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::GlobalLimit(Box::new( + protobuf::GlobalLimitExecNode { + input: Some(Box::new(input)), + skip: limit.skip() as u32, + fetch: match limit.fetch() { + Some(n) => *n as i64, + _ => -1, // no limit + }, + }, + ))), + }) + } else if let Some(limit) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + limit.input().to_owned(), + extension_codec, + )?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::LocalLimit(Box::new( + protobuf::LocalLimitExecNode { + input: Some(Box::new(input)), + fetch: limit.fetch() as u32, + }, + ))), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let left = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.left().to_owned(), + extension_codec, + )?; + let right = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.right().to_owned(), + extension_codec, + )?; + let on: Vec = exec + .on() + .iter() + .map(|tuple| protobuf::JoinOn { + left: Some(protobuf::PhysicalColumn { + name: tuple.0.name().to_string(), + index: tuple.0.index() as u32, + }), + right: Some(protobuf::PhysicalColumn { + name: tuple.1.name().to_string(), + index: tuple.1.index() as u32, + }), + }) + .collect(); + let join_type: protobuf::JoinType = exec.join_type().to_owned().into(); + let filter = exec + .filter() + .as_ref() + .map(|f| { + let expression = f.expression().to_owned().try_into()?; + let column_indices = f + .column_indices() + .iter() + .map(|i| { + let side: protobuf::JoinSide = i.side.to_owned().into(); + protobuf::ColumnIndex { + index: i.index as u32, + side: side.into(), + } + }) + .collect(); + let schema = f.schema().try_into()?; + Ok(protobuf::JoinFilter { + expression: Some(expression), + column_indices, + schema: Some(schema), + }) + }) + .map_or( + Ok(None), + |v: Result| v.map(Some), + )?; + + let partition_mode = match exec.partition_mode() { + PartitionMode::CollectLeft => protobuf::PartitionMode::CollectLeft, + PartitionMode::Partitioned => protobuf::PartitionMode::Partitioned, + }; + + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::HashJoin(Box::new( + protobuf::HashJoinExecNode { + left: Some(Box::new(left)), + right: Some(Box::new(right)), + on, + join_type: join_type.into(), + partition_mode: partition_mode.into(), + null_equals_null: *exec.null_equals_null(), + filter, + }, + ))), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let left = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.left().to_owned(), + extension_codec, + )?; + let right = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.right().to_owned(), + extension_codec, + )?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::CrossJoin(Box::new( + protobuf::CrossJoinExecNode { + left: Some(Box::new(left)), + right: Some(Box::new(right)), + }, + ))), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let groups: Vec = exec + .group_expr() + .groups() + .iter() + .flatten() + .copied() + .collect(); + + let group_names = exec + .group_expr() + .expr() + .iter() + .map(|expr| expr.1.to_owned()) + .collect(); + + let agg = exec + .aggr_expr() + .iter() + .map(|expr| expr.to_owned().try_into()) + .collect::, DataFusionError>>()?; + let agg_names = exec + .aggr_expr() + .iter() + .map(|expr| match expr.field() { + Ok(field) => Ok(field.name().clone()), + Err(e) => Err(e), + }) + .collect::>()?; + + let agg_mode = match exec.mode() { + AggregateMode::Partial => protobuf::AggregateMode::Partial, + AggregateMode::Final => protobuf::AggregateMode::Final, + AggregateMode::FinalPartitioned => { + protobuf::AggregateMode::FinalPartitioned + } + }; + let input_schema = exec.input_schema(); + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.input().to_owned(), + extension_codec, + )?; + + let null_expr = exec + .group_expr() + .null_expr() + .iter() + .map(|expr| expr.0.to_owned().try_into()) + .collect::, DataFusionError>>()?; + + let group_expr = exec + .group_expr() + .expr() + .iter() + .map(|expr| expr.0.to_owned().try_into()) + .collect::, DataFusionError>>()?; + + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Aggregate(Box::new( + protobuf::AggregateExecNode { + group_expr, + group_expr_name: group_names, + aggr_expr: agg, + aggr_expr_name: agg_names, + mode: agg_mode as i32, + input: Some(Box::new(input)), + input_schema: Some(input_schema.as_ref().try_into()?), + null_expr, + groups, + }, + ))), + }) + } else if let Some(empty) = plan.downcast_ref::() { + let schema = empty.schema().as_ref().try_into()?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Empty( + protobuf::EmptyExecNode { + produce_one_row: empty.produce_one_row(), + schema: Some(schema), + }, + )), + }) + } else if let Some(coalesce_batches) = plan.downcast_ref::() + { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + coalesce_batches.input().to_owned(), + extension_codec, + )?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::CoalesceBatches(Box::new( + protobuf::CoalesceBatchesExecNode { + input: Some(Box::new(input)), + target_batch_size: coalesce_batches.target_batch_size() as u32, + }, + ))), + }) + } else if let Some(exec) = plan.downcast_ref::() { + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::CsvScan( + protobuf::CsvScanExecNode { + base_conf: Some(exec.base_config().try_into()?), + has_header: exec.has_header(), + delimiter: byte_to_string(exec.delimiter())?, + }, + )), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let pruning_expr = exec + .pruning_predicate() + .map(|pred| pred.logical_expr().try_into()) + .transpose()?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::ParquetScan( + protobuf::ParquetScanExecNode { + base_conf: Some(exec.base_config().try_into()?), + pruning_predicate: pruning_expr, + }, + )), + }) + } else if let Some(exec) = plan.downcast_ref::() { + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::AvroScan( + protobuf::AvroScanExecNode { + base_conf: Some(exec.base_config().try_into()?), + }, + )), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.input().to_owned(), + extension_codec, + )?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Merge(Box::new( + protobuf::CoalescePartitionsExecNode { + input: Some(Box::new(input)), + }, + ))), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.input().to_owned(), + extension_codec, + )?; + + let pb_partition_method = match exec.partitioning() { + Partitioning::Hash(exprs, partition_count) => { + PartitionMethod::Hash(protobuf::PhysicalHashRepartition { + hash_expr: exprs + .iter() + .map(|expr| expr.clone().try_into()) + .collect::, DataFusionError>>()?, + partition_count: *partition_count as u64, + }) + } + Partitioning::RoundRobinBatch(partition_count) => { + PartitionMethod::RoundRobin(*partition_count as u64) + } + Partitioning::UnknownPartitioning(partition_count) => { + PartitionMethod::Unknown(*partition_count as u64) + } + }; + + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Repartition(Box::new( + protobuf::RepartitionExecNode { + input: Some(Box::new(input)), + partition_method: Some(pb_partition_method), + }, + ))), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.input().to_owned(), + extension_codec, + )?; + let expr = exec + .expr() + .iter() + .map(|expr| { + let sort_expr = Box::new(protobuf::PhysicalSortExprNode { + expr: Some(Box::new(expr.expr.to_owned().try_into()?)), + asc: !expr.options.descending, + nulls_first: expr.options.nulls_first, + }); + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::Sort( + sort_expr, + )), + }) + }) + .collect::, DataFusionError>>()?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Sort(Box::new( + protobuf::SortExecNode { + input: Some(Box::new(input)), + expr, + fetch: match exec.fetch() { + Some(n) => n as i64, + _ => -1, + }, + }, + ))), + }) + } else if let Some(union) = plan.downcast_ref::() { + let mut inputs: Vec = vec![]; + for input in union.inputs() { + inputs.push(protobuf::PhysicalPlanNode::try_from_physical_plan( + input.to_owned(), + extension_codec, + )?); + } + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Union( + protobuf::UnionExecNode { inputs }, + )), + }) + } else if let Some(exec) = plan.downcast_ref::() { + let input = protobuf::PhysicalPlanNode::try_from_physical_plan( + exec.input().to_owned(), + extension_codec, + )?; + let expr = exec + .expr() + .iter() + .map(|expr| { + let sort_expr = Box::new(protobuf::PhysicalSortExprNode { + expr: Some(Box::new(expr.expr.to_owned().try_into()?)), + asc: !expr.options.descending, + nulls_first: expr.options.nulls_first, + }); + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::Sort( + sort_expr, + )), + }) + }) + .collect::, DataFusionError>>()?; + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::SortPreservingMerge( + Box::new(protobuf::SortPreservingMergeExecNode { + input: Some(Box::new(input)), + expr, + }), + )), + }) + } else { + let mut buf: Vec = vec![]; + match extension_codec.try_encode(plan_clone.clone(), &mut buf) { + Ok(_) => { + let inputs: Vec = plan_clone + .children() + .into_iter() + .map(|i| { + protobuf::PhysicalPlanNode::try_from_physical_plan( + i, + extension_codec, + ) + }) + .collect::>()?; + + Ok(protobuf::PhysicalPlanNode { + physical_plan_type: Some(PhysicalPlanType::Extension( + protobuf::PhysicalExtensionNode { node: buf, inputs }, + )), + }) + } + Err(e) => Err(DataFusionError::Internal(format!( + "Unsupported plan and extension codec failed with [{}]. Plan: {:?}", + e, plan_clone + ))), + } + } + } +} + +fn decode_scan_config( + proto: &protobuf::FileScanExecConf, +) -> Result { + let schema = Arc::new(convert_required!(proto.schema)?); + let projection = proto + .projection + .iter() + .map(|i| *i as usize) + .collect::>(); + let projection = if projection.is_empty() { + None + } else { + Some(projection) + }; + let statistics = convert_required!(proto.statistics)?; + + let file_groups: Vec> = proto + .file_groups + .iter() + .map(|f| f.try_into()) + .collect::, _>>()?; + + let object_store_url = match proto.object_store_url.is_empty() { + false => ObjectStoreUrl::parse(&proto.object_store_url)?, + true => ObjectStoreUrl::local_filesystem(), + }; + + Ok(FileScanConfig { + config_options: Arc::new(RwLock::new(ConfigOptions::new())), // TODO add serde + object_store_url, + file_schema: schema, + file_groups, + statistics, + projection, + limit: proto.limit.as_ref().map(|sl| sl.limit as usize), + table_partition_cols: vec![], + output_ordering: None, + }) +} + +pub trait AsExecutionPlan: Debug + Send + Sync + Clone { + fn try_decode(buf: &[u8]) -> Result + where + Self: Sized; + + fn try_encode(&self, buf: &mut B) -> Result<(), DataFusionError> + where + B: BufMut, + Self: Sized; + + fn try_into_physical_plan( + &self, + registry: &dyn FunctionRegistry, + runtime: &RuntimeEnv, + extension_codec: &dyn PhysicalExtensionCodec, + ) -> Result, DataFusionError>; + + fn try_from_physical_plan( + plan: Arc, + extension_codec: &dyn PhysicalExtensionCodec, + ) -> Result + where + Self: Sized; +} + +pub trait PhysicalExtensionCodec: Debug + Send + Sync { + fn try_decode( + &self, + buf: &[u8], + inputs: &[Arc], + registry: &dyn FunctionRegistry, + ) -> Result, DataFusionError>; + + fn try_encode( + &self, + node: Arc, + buf: &mut Vec, + ) -> Result<(), DataFusionError>; +} + +#[macro_export] +macro_rules! into_physical_plan { + ($PB:expr, $REG:expr, $RUNTIME:expr, $CODEC:expr) => {{ + if let Some(field) = $PB.as_ref() { + field + .as_ref() + .try_into_physical_plan($REG, $RUNTIME, $CODEC) + } else { + Err(proto_error("Missing required field in protobuf")) + } + }}; +} + +#[cfg(test)] +mod roundtrip_tests { + use std::ops::Deref; + use std::sync::Arc; + + use super::super::protobuf; + use crate::bytes::DefaultPhysicalExtensionCodec; + use crate::physical_plan::AsExecutionPlan; + use datafusion::arrow::array::ArrayRef; + use datafusion::arrow::datatypes::IntervalUnit; + use datafusion::config::ConfigOptions; + use datafusion::datasource::object_store::ObjectStoreUrl; + use datafusion::execution::context::ExecutionProps; + use datafusion::logical_expr::create_udf; + use datafusion::logical_expr::{BuiltinScalarFunction, Volatility}; + use datafusion::physical_expr::expressions::DateTimeIntervalExpr; + use datafusion::physical_expr::ScalarFunctionExpr; + use datafusion::physical_plan::aggregates::PhysicalGroupBy; + use datafusion::physical_plan::functions; + use datafusion::physical_plan::functions::make_scalar_function; + use datafusion::physical_plan::projection::ProjectionExec; + use datafusion::{ + arrow::{ + compute::kernels::sort::SortOptions, + datatypes::{DataType, Field, Schema}, + }, + datasource::listing::PartitionedFile, + logical_expr::{JoinType, Operator}, + physical_plan::{ + aggregates::{AggregateExec, AggregateMode}, + empty::EmptyExec, + expressions::{binary, col, lit, InListExpr, NotExpr}, + expressions::{Avg, Column, DistinctCount, PhysicalSortExpr}, + file_format::{FileScanConfig, ParquetExec}, + filter::FilterExec, + joins::{HashJoinExec, PartitionMode}, + limit::{GlobalLimitExec, LocalLimitExec}, + sorts::sort::SortExec, + AggregateExpr, ExecutionPlan, Partitioning, PhysicalExpr, Statistics, + }, + prelude::SessionContext, + scalar::ScalarValue, + }; + use datafusion_common::Result; + use parking_lot::RwLock; + + fn roundtrip_test(exec_plan: Arc) -> Result<()> { + let ctx = SessionContext::new(); + let codec = DefaultPhysicalExtensionCodec {}; + let proto: protobuf::PhysicalPlanNode = + protobuf::PhysicalPlanNode::try_from_physical_plan(exec_plan.clone(), &codec) + .expect("to proto"); + let runtime = ctx.runtime_env(); + let result_exec_plan: Arc = proto + .try_into_physical_plan(&ctx, runtime.deref(), &codec) + .expect("from proto"); + assert_eq!( + format!("{:?}", exec_plan), + format!("{:?}", result_exec_plan) + ); + Ok(()) + } + + fn roundtrip_test_with_context( + exec_plan: Arc, + ctx: SessionContext, + ) -> Result<()> { + let codec = DefaultPhysicalExtensionCodec {}; + let proto: protobuf::PhysicalPlanNode = + protobuf::PhysicalPlanNode::try_from_physical_plan(exec_plan.clone(), &codec) + .expect("to proto"); + let runtime = ctx.runtime_env(); + let result_exec_plan: Arc = proto + .try_into_physical_plan(&ctx, runtime.deref(), &codec) + .expect("from proto"); + assert_eq!( + format!("{:?}", exec_plan), + format!("{:?}", result_exec_plan) + ); + Ok(()) + } + + #[test] + fn roundtrip_empty() -> Result<()> { + roundtrip_test(Arc::new(EmptyExec::new(false, Arc::new(Schema::empty())))) + } + + #[test] + fn roundtrip_date_time_interval() -> Result<()> { + let schema = Schema::new(vec![ + Field::new("some_date", DataType::Date32, false), + Field::new( + "some_interval", + DataType::Interval(IntervalUnit::DayTime), + false, + ), + ]); + let input = Arc::new(EmptyExec::new(false, Arc::new(schema.clone()))); + let date_expr = col("some_date", &schema)?; + let literal_expr = col("some_interval", &schema)?; + let date_time_interval_expr = Arc::new(DateTimeIntervalExpr::try_new( + date_expr, + Operator::Plus, + literal_expr, + &schema, + )?); + let plan = Arc::new(ProjectionExec::try_new( + vec![(date_time_interval_expr, "result".to_string())], + input, + )?); + roundtrip_test(plan) + } + + #[test] + fn roundtrip_local_limit() -> Result<()> { + roundtrip_test(Arc::new(LocalLimitExec::new( + Arc::new(EmptyExec::new(false, Arc::new(Schema::empty()))), + 25, + ))) + } + + #[test] + fn roundtrip_global_limit() -> Result<()> { + roundtrip_test(Arc::new(GlobalLimitExec::new( + Arc::new(EmptyExec::new(false, Arc::new(Schema::empty()))), + 0, + Some(25), + ))) + } + + #[test] + fn roundtrip_global_skip_no_limit() -> Result<()> { + roundtrip_test(Arc::new(GlobalLimitExec::new( + Arc::new(EmptyExec::new(false, Arc::new(Schema::empty()))), + 10, + None, // no limit + ))) + } + + #[test] + fn roundtrip_hash_join() -> Result<()> { + let field_a = Field::new("col", DataType::Int64, false); + let schema_left = Schema::new(vec![field_a.clone()]); + let schema_right = Schema::new(vec![field_a]); + let on = vec![( + Column::new("col", schema_left.index_of("col")?), + Column::new("col", schema_right.index_of("col")?), + )]; + + let schema_left = Arc::new(schema_left); + let schema_right = Arc::new(schema_right); + for join_type in &[ + JoinType::Inner, + JoinType::Left, + JoinType::Right, + JoinType::Full, + JoinType::LeftAnti, + JoinType::RightAnti, + JoinType::LeftSemi, + JoinType::RightSemi, + ] { + for partition_mode in + &[PartitionMode::Partitioned, PartitionMode::CollectLeft] + { + roundtrip_test(Arc::new(HashJoinExec::try_new( + Arc::new(EmptyExec::new(false, schema_left.clone())), + Arc::new(EmptyExec::new(false, schema_right.clone())), + on.clone(), + None, + join_type, + *partition_mode, + &false, + )?))?; + } + } + Ok(()) + } + + #[test] + fn rountrip_aggregate() -> Result<()> { + let field_a = Field::new("a", DataType::Int64, false); + let field_b = Field::new("b", DataType::Int64, false); + let schema = Arc::new(Schema::new(vec![field_a, field_b])); + + let groups: Vec<(Arc, String)> = + vec![(col("a", &schema)?, "unused".to_string())]; + + let aggregates: Vec> = vec![Arc::new(Avg::new( + col("b", &schema)?, + "AVG(b)".to_string(), + DataType::Float64, + ))]; + + roundtrip_test(Arc::new(AggregateExec::try_new( + AggregateMode::Final, + PhysicalGroupBy::new_single(groups.clone()), + aggregates.clone(), + Arc::new(EmptyExec::new(false, schema.clone())), + schema, + )?)) + } + + #[test] + fn roundtrip_filter_with_not_and_in_list() -> Result<()> { + let field_a = Field::new("a", DataType::Boolean, false); + let field_b = Field::new("b", DataType::Int64, false); + let field_c = Field::new("c", DataType::Int64, false); + let schema = Arc::new(Schema::new(vec![field_a, field_b, field_c])); + let not = Arc::new(NotExpr::new(col("a", &schema)?)); + let in_list = Arc::new(InListExpr::new( + col("b", &schema)?, + vec![ + lit(ScalarValue::Int64(Some(1))), + lit(ScalarValue::Int64(Some(2))), + ], + false, + schema.as_ref(), + )); + let and = binary(not, Operator::And, in_list, &schema)?; + roundtrip_test(Arc::new(FilterExec::try_new( + and, + Arc::new(EmptyExec::new(false, schema.clone())), + )?)) + } + + #[test] + fn roundtrip_sort() -> Result<()> { + let field_a = Field::new("a", DataType::Boolean, false); + let field_b = Field::new("b", DataType::Int64, false); + let schema = Arc::new(Schema::new(vec![field_a, field_b])); + let sort_exprs = vec![ + PhysicalSortExpr { + expr: col("a", &schema)?, + options: SortOptions { + descending: true, + nulls_first: false, + }, + }, + PhysicalSortExpr { + expr: col("b", &schema)?, + options: SortOptions { + descending: false, + nulls_first: true, + }, + }, + ]; + roundtrip_test(Arc::new(SortExec::try_new( + sort_exprs, + Arc::new(EmptyExec::new(false, schema)), + None, + )?)) + } + + #[test] + fn roundtrip_parquet_exec_with_pruning_predicate() -> Result<()> { + let scan_config = FileScanConfig { + config_options: Arc::new(RwLock::new(ConfigOptions::new())), // TODO add serde + object_store_url: ObjectStoreUrl::local_filesystem(), + file_schema: Arc::new(Schema::new(vec![Field::new( + "col", + DataType::Utf8, + false, + )])), + file_groups: vec![vec![PartitionedFile::new( + "/path/to/file.parquet".to_string(), + 1024, + )]], + statistics: Statistics { + num_rows: Some(100), + total_byte_size: Some(1024), + column_statistics: None, + is_exact: false, + }, + projection: None, + limit: None, + table_partition_cols: vec![], + output_ordering: None, + }; + + let predicate = datafusion::prelude::col("col").eq(datafusion::prelude::lit("1")); + roundtrip_test(Arc::new(ParquetExec::new( + scan_config, + Some(predicate), + None, + ))) + } + + #[test] + fn roundtrip_builtin_scalar_function() -> Result<()> { + let field_a = Field::new("a", DataType::Int64, false); + let field_b = Field::new("b", DataType::Int64, false); + let schema = Arc::new(Schema::new(vec![field_a, field_b])); + + let input = Arc::new(EmptyExec::new(false, schema.clone())); + + let execution_props = ExecutionProps::new(); + + let fun_expr = functions::create_physical_fun( + &BuiltinScalarFunction::Abs, + &execution_props, + )?; + + let expr = ScalarFunctionExpr::new( + "abs", + fun_expr, + vec![col("a", &schema)?], + &DataType::Int64, + ); + + let project = + ProjectionExec::try_new(vec![(Arc::new(expr), "a".to_string())], input)?; + + roundtrip_test(Arc::new(project)) + } + + #[test] + fn roundtrip_scalar_udf() -> Result<()> { + let field_a = Field::new("a", DataType::Int64, false); + let field_b = Field::new("b", DataType::Int64, false); + let schema = Arc::new(Schema::new(vec![field_a, field_b])); + + let input = Arc::new(EmptyExec::new(false, schema.clone())); + + let fn_impl = |args: &[ArrayRef]| Ok(Arc::new(args[0].clone()) as ArrayRef); + + let scalar_fn = make_scalar_function(fn_impl); + + let udf = create_udf( + "dummy", + vec![DataType::Int64], + Arc::new(DataType::Int64), + Volatility::Immutable, + scalar_fn.clone(), + ); + + let expr = ScalarFunctionExpr::new( + "dummy", + scalar_fn, + vec![col("a", &schema)?], + &DataType::Int64, + ); + + let project = + ProjectionExec::try_new(vec![(Arc::new(expr), "a".to_string())], input)?; + + let mut ctx = SessionContext::new(); + + ctx.register_udf(udf); + + roundtrip_test_with_context(Arc::new(project), ctx) + } + + #[test] + fn roundtrip_distinct_count() -> Result<()> { + let field_a = Field::new("a", DataType::Int64, false); + let field_b = Field::new("b", DataType::Int64, false); + let schema = Arc::new(Schema::new(vec![field_a, field_b])); + + let aggregates: Vec> = vec![Arc::new(DistinctCount::new( + vec![DataType::Int64], + vec![col("b", &schema)?], + "COUNT(DISTINCT b)".to_string(), + DataType::Int64, + ))]; + + let groups: Vec<(Arc, String)> = + vec![(col("a", &schema)?, "unused".to_string())]; + + roundtrip_test(Arc::new(AggregateExec::try_new( + AggregateMode::Final, + PhysicalGroupBy::new_single(groups), + aggregates.clone(), + Arc::new(EmptyExec::new(false, schema.clone())), + schema, + )?)) + } +} diff --git a/datafusion/proto/src/physical_plan/to_proto.rs b/datafusion/proto/src/physical_plan/to_proto.rs new file mode 100644 index 000000000000..88d0299c2154 --- /dev/null +++ b/datafusion/proto/src/physical_plan/to_proto.rs @@ -0,0 +1,472 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License.language governing permissions and +// limitations under the License. + +use std::{ + convert::{TryFrom, TryInto}, + str::FromStr, + sync::Arc, +}; + +use datafusion::physical_plan::expressions::{CastExpr, TryCastExpr}; +use datafusion::physical_plan::ColumnStatistics; +use datafusion::physical_plan::{ + expressions::{ + CaseExpr, InListExpr, IsNotNullExpr, IsNullExpr, NegativeExpr, NotExpr, + }, + Statistics, +}; + +use datafusion::datasource::listing::{FileRange, PartitionedFile}; +use datafusion::physical_plan::file_format::FileScanConfig; + +use datafusion::physical_plan::expressions::{Count, DistinctCount, Literal}; + +use datafusion::physical_plan::expressions::{Avg, BinaryExpr, Column, Max, Min, Sum}; +use datafusion::physical_plan::{AggregateExpr, PhysicalExpr}; + +use crate::protobuf; +use datafusion::logical_expr::BuiltinScalarFunction; +use datafusion::physical_expr::expressions::DateTimeIntervalExpr; +use datafusion::physical_expr::ScalarFunctionExpr; +use datafusion_common::DataFusionError; + +impl TryInto for Arc { + type Error = DataFusionError; + + fn try_into(self) -> Result { + use datafusion::physical_plan::expressions; + use protobuf::AggregateFunction; + + let mut distinct = false; + let aggr_function = if self.as_any().downcast_ref::().is_some() { + Ok(AggregateFunction::Avg.into()) + } else if self.as_any().downcast_ref::().is_some() { + Ok(AggregateFunction::Sum.into()) + } else if self.as_any().downcast_ref::().is_some() { + Ok(AggregateFunction::Count.into()) + } else if self.as_any().downcast_ref::().is_some() { + distinct = true; + Ok(AggregateFunction::Count.into()) + } else if self.as_any().downcast_ref::().is_some() { + Ok(AggregateFunction::Min.into()) + } else if self.as_any().downcast_ref::().is_some() { + Ok(AggregateFunction::Max.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::ApproxDistinct.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::ArrayAgg.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::Variance.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::VariancePop.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::Covariance.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::CovariancePop.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::Stddev.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::StddevPop.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::Correlation.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::ApproxPercentileCont.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::ApproxPercentileContWithWeight.into()) + } else if self + .as_any() + .downcast_ref::() + .is_some() + { + Ok(AggregateFunction::ApproxMedian.into()) + } else { + Err(DataFusionError::NotImplemented(format!( + "Aggregate function not supported: {:?}", + self + ))) + }?; + let expressions: Vec = self + .expressions() + .iter() + .map(|e| e.clone().try_into()) + .collect::, DataFusionError>>()?; + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::AggregateExpr( + protobuf::PhysicalAggregateExprNode { + aggr_function, + expr: expressions, + distinct, + }, + )), + }) + } +} + +impl TryFrom> for protobuf::PhysicalExprNode { + type Error = DataFusionError; + + fn try_from(value: Arc) -> Result { + let expr = value.as_any(); + + if let Some(expr) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::Column( + protobuf::PhysicalColumn { + name: expr.name().to_string(), + index: expr.index() as u32, + }, + )), + }) + } else if let Some(expr) = expr.downcast_ref::() { + let binary_expr = Box::new(protobuf::PhysicalBinaryExprNode { + l: Some(Box::new(expr.left().to_owned().try_into()?)), + r: Some(Box::new(expr.right().to_owned().try_into()?)), + op: format!("{:?}", expr.op()), + }); + + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::BinaryExpr( + binary_expr, + )), + }) + } else if let Some(expr) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some( + protobuf::physical_expr_node::ExprType::Case( + Box::new( + protobuf::PhysicalCaseNode { + expr: expr + .expr() + .as_ref() + .map(|exp| exp.clone().try_into().map(Box::new)) + .transpose()?, + when_then_expr: expr + .when_then_expr() + .iter() + .map(|(when_expr, then_expr)| { + try_parse_when_then_expr(when_expr, then_expr) + }) + .collect::, + Self::Error, + >>()?, + else_expr: expr + .else_expr() + .map(|a| a.clone().try_into().map(Box::new)) + .transpose()?, + }, + ), + ), + ), + }) + } else if let Some(expr) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::NotExpr( + Box::new(protobuf::PhysicalNot { + expr: Some(Box::new(expr.arg().to_owned().try_into()?)), + }), + )), + }) + } else if let Some(expr) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::IsNullExpr( + Box::new(protobuf::PhysicalIsNull { + expr: Some(Box::new(expr.arg().to_owned().try_into()?)), + }), + )), + }) + } else if let Some(expr) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::IsNotNullExpr( + Box::new(protobuf::PhysicalIsNotNull { + expr: Some(Box::new(expr.arg().to_owned().try_into()?)), + }), + )), + }) + } else if let Some(expr) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some( + protobuf::physical_expr_node::ExprType::InList( + Box::new( + protobuf::PhysicalInListNode { + expr: Some(Box::new(expr.expr().to_owned().try_into()?)), + list: expr + .list() + .iter() + .map(|a| a.clone().try_into()) + .collect::, + Self::Error, + >>()?, + negated: expr.negated(), + }, + ), + ), + ), + }) + } else if let Some(expr) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::Negative( + Box::new(protobuf::PhysicalNegativeNode { + expr: Some(Box::new(expr.arg().to_owned().try_into()?)), + }), + )), + }) + } else if let Some(lit) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::Literal( + lit.value().try_into()?, + )), + }) + } else if let Some(cast) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::Cast(Box::new( + protobuf::PhysicalCastNode { + expr: Some(Box::new(cast.expr().clone().try_into()?)), + arrow_type: Some(cast.cast_type().try_into()?), + }, + ))), + }) + } else if let Some(cast) = expr.downcast_ref::() { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::TryCast( + Box::new(protobuf::PhysicalTryCastNode { + expr: Some(Box::new(cast.expr().clone().try_into()?)), + arrow_type: Some(cast.cast_type().try_into()?), + }), + )), + }) + } else if let Some(expr) = expr.downcast_ref::() { + let args: Vec = expr + .args() + .iter() + .map(|e| e.to_owned().try_into()) + .collect::, _>>()?; + if let Ok(fun) = BuiltinScalarFunction::from_str(expr.name()) { + let fun: protobuf::ScalarFunction = (&fun).try_into()?; + + Ok(protobuf::PhysicalExprNode { + expr_type: Some( + protobuf::physical_expr_node::ExprType::ScalarFunction( + protobuf::PhysicalScalarFunctionNode { + name: expr.name().to_string(), + fun: fun.into(), + args, + return_type: Some(expr.return_type().try_into()?), + }, + ), + ), + }) + } else { + Ok(protobuf::PhysicalExprNode { + expr_type: Some(protobuf::physical_expr_node::ExprType::ScalarUdf( + protobuf::PhysicalScalarUdfNode { + name: expr.name().to_string(), + args, + return_type: Some(expr.return_type().try_into()?), + }, + )), + }) + } + } else if let Some(expr) = expr.downcast_ref::() { + let dti_expr = Box::new(protobuf::PhysicalDateTimeIntervalExprNode { + l: Some(Box::new(expr.lhs().to_owned().try_into()?)), + r: Some(Box::new(expr.rhs().to_owned().try_into()?)), + op: format!("{:?}", expr.op()), + }); + + Ok(protobuf::PhysicalExprNode { + expr_type: Some( + protobuf::physical_expr_node::ExprType::DateTimeIntervalExpr( + dti_expr, + ), + ), + }) + } else { + Err(DataFusionError::Internal(format!( + "physical_plan::to_proto() unsupported expression {:?}", + value + ))) + } + } +} + +fn try_parse_when_then_expr( + when_expr: &Arc, + then_expr: &Arc, +) -> Result { + Ok(protobuf::PhysicalWhenThen { + when_expr: Some(when_expr.clone().try_into()?), + then_expr: Some(then_expr.clone().try_into()?), + }) +} + +impl TryFrom<&PartitionedFile> for protobuf::PartitionedFile { + type Error = DataFusionError; + + fn try_from(pf: &PartitionedFile) -> Result { + Ok(protobuf::PartitionedFile { + path: pf.object_meta.location.as_ref().to_owned(), + size: pf.object_meta.size as u64, + last_modified_ns: pf.object_meta.last_modified.timestamp_nanos() as u64, + partition_values: pf + .partition_values + .iter() + .map(|v| v.try_into()) + .collect::, _>>()?, + range: pf.range.as_ref().map(|r| r.try_into()).transpose()?, + }) + } +} + +impl TryFrom<&FileRange> for protobuf::FileRange { + type Error = DataFusionError; + + fn try_from(value: &FileRange) -> Result { + Ok(protobuf::FileRange { + start: value.start, + end: value.end, + }) + } +} + +impl TryFrom<&[PartitionedFile]> for protobuf::FileGroup { + type Error = DataFusionError; + + fn try_from(gr: &[PartitionedFile]) -> Result { + Ok(protobuf::FileGroup { + files: gr + .iter() + .map(|f| f.try_into()) + .collect::, _>>()?, + }) + } +} + +impl From<&ColumnStatistics> for protobuf::ColumnStats { + fn from(cs: &ColumnStatistics) -> protobuf::ColumnStats { + protobuf::ColumnStats { + min_value: cs.min_value.as_ref().map(|m| m.try_into().unwrap()), + max_value: cs.max_value.as_ref().map(|m| m.try_into().unwrap()), + null_count: cs.null_count.map(|n| n as u32).unwrap_or(0), + distinct_count: cs.distinct_count.map(|n| n as u32).unwrap_or(0), + } + } +} + +impl From<&Statistics> for protobuf::Statistics { + fn from(s: &Statistics) -> protobuf::Statistics { + let none_value = -1_i64; + let column_stats = match &s.column_statistics { + None => vec![], + Some(column_stats) => column_stats.iter().map(|s| s.into()).collect(), + }; + protobuf::Statistics { + num_rows: s.num_rows.map(|n| n as i64).unwrap_or(none_value), + total_byte_size: s.total_byte_size.map(|n| n as i64).unwrap_or(none_value), + column_stats, + is_exact: s.is_exact, + } + } +} + +impl TryFrom<&FileScanConfig> for protobuf::FileScanExecConf { + type Error = DataFusionError; + fn try_from( + conf: &FileScanConfig, + ) -> Result { + let file_groups = conf + .file_groups + .iter() + .map(|p| p.as_slice().try_into()) + .collect::, _>>()?; + + Ok(protobuf::FileScanExecConf { + file_groups, + statistics: Some((&conf.statistics).into()), + limit: conf.limit.map(|l| protobuf::ScanLimit { limit: l as u32 }), + projection: conf + .projection + .as_ref() + .unwrap_or(&vec![]) + .iter() + .map(|n| *n as u32) + .collect(), + schema: Some(conf.file_schema.as_ref().try_into()?), + table_partition_cols: conf.table_partition_cols.to_vec(), + object_store_url: conf.object_store_url.to_string(), + }) + } +} + +impl From for protobuf::JoinSide { + fn from(t: datafusion::physical_plan::joins::utils::JoinSide) -> Self { + match t { + datafusion::physical_plan::joins::utils::JoinSide::Left => { + protobuf::JoinSide::LeftSide + } + datafusion::physical_plan::joins::utils::JoinSide::Right => { + protobuf::JoinSide::RightSide + } + } + } +} From e8afa7a0acf2d71af83f1972c39cb20d096f135b Mon Sep 17 00:00:00 2001 From: kikkon Date: Sun, 27 Nov 2022 18:04:18 +0800 Subject: [PATCH 02/10] add license --- datafusion/proto/README.md | 1 - datafusion/proto/src/common.rs | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/datafusion/proto/README.md b/datafusion/proto/README.md index 6995710c40a4..e99efab68cc4 100644 --- a/datafusion/proto/README.md +++ b/datafusion/proto/README.md @@ -94,5 +94,4 @@ async fn main() -> Result<()> { ``` - [df]: https://crates.io/crates/datafusion diff --git a/datafusion/proto/src/common.rs b/datafusion/proto/src/common.rs index c6a12da872b8..a818159ec90d 100644 --- a/datafusion/proto/src/common.rs +++ b/datafusion/proto/src/common.rs @@ -1,3 +1,20 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + use datafusion_common::DataFusionError; pub fn byte_to_string(b: u8) -> Result { From 9d299e0d93a5d5fb1aab2f3f2f82710046b97b8e Mon Sep 17 00:00:00 2001 From: kikkon Date: Sun, 27 Nov 2022 21:31:46 +0800 Subject: [PATCH 03/10] rebase master --- datafusion/proto/proto/datafusion.proto | 1 + datafusion/proto/src/generated/pbjson.rs | 71 ++++++++++--------- datafusion/proto/src/generated/prost.rs | 2 + datafusion/proto/src/physical_plan/mod.rs | 2 + .../proto/src/physical_plan/to_proto.rs | 6 +- 5 files changed, 47 insertions(+), 35 deletions(-) diff --git a/datafusion/proto/proto/datafusion.proto b/datafusion/proto/proto/datafusion.proto index d416dd28ac03..081494ec975f 100644 --- a/datafusion/proto/proto/datafusion.proto +++ b/datafusion/proto/proto/datafusion.proto @@ -1129,6 +1129,7 @@ message AvroScanExecNode { enum PartitionMode { COLLECT_LEFT = 0; PARTITIONED = 1; + AUTO = 2; } message HashJoinExecNode { diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs index f7c817acf00f..14483689106e 100644 --- a/datafusion/proto/src/generated/pbjson.rs +++ b/datafusion/proto/src/generated/pbjson.rs @@ -2399,7 +2399,7 @@ impl<'de> serde::Deserialize<'de> for CoalesceBatchesExecNode { if target_batch_size__.is_some() { return Err(serde::de::Error::duplicate_field("targetBatchSize")); } - target_batch_size__ = + target_batch_size__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -2704,7 +2704,7 @@ impl<'de> serde::Deserialize<'de> for ColumnIndex { if index__.is_some() { return Err(serde::de::Error::duplicate_field("index")); } - index__ = + index__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -2941,7 +2941,7 @@ impl<'de> serde::Deserialize<'de> for ColumnStats { if null_count__.is_some() { return Err(serde::de::Error::duplicate_field("nullCount")); } - null_count__ = + null_count__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -2949,7 +2949,7 @@ impl<'de> serde::Deserialize<'de> for ColumnStats { if distinct_count__.is_some() { return Err(serde::de::Error::duplicate_field("distinctCount")); } - distinct_count__ = + distinct_count__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -5458,7 +5458,7 @@ impl<'de> serde::Deserialize<'de> for ExecutorHeartbeat { if timestamp__.is_some() { return Err(serde::de::Error::duplicate_field("timestamp")); } - timestamp__ = + timestamp__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -5619,7 +5619,7 @@ impl<'de> serde::Deserialize<'de> for ExecutorMetadata { if port__.is_some() { return Err(serde::de::Error::duplicate_field("port")); } - port__ = + port__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -5627,7 +5627,7 @@ impl<'de> serde::Deserialize<'de> for ExecutorMetadata { if grpc_port__.is_some() { return Err(serde::de::Error::duplicate_field("grpcPort")); } - grpc_port__ = + grpc_port__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -5877,7 +5877,7 @@ impl<'de> serde::Deserialize<'de> for ExecutorRegistration { if port__.is_some() { return Err(serde::de::Error::duplicate_field("port")); } - port__ = + port__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -5885,7 +5885,7 @@ impl<'de> serde::Deserialize<'de> for ExecutorRegistration { if grpc_port__.is_some() { return Err(serde::de::Error::duplicate_field("grpcPort")); } - grpc_port__ = + grpc_port__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -6778,7 +6778,7 @@ impl<'de> serde::Deserialize<'de> for FileRange { if start__.is_some() { return Err(serde::de::Error::duplicate_field("start")); } - start__ = + start__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -6786,7 +6786,7 @@ impl<'de> serde::Deserialize<'de> for FileRange { if end__.is_some() { return Err(serde::de::Error::duplicate_field("end")); } - end__ = + end__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -6955,7 +6955,7 @@ impl<'de> serde::Deserialize<'de> for FileScanExecConf { if projection__.is_some() { return Err(serde::de::Error::duplicate_field("projection")); } - projection__ = + projection__ = Some(map.next_value::>>()? .into_iter().map(|x| x.0).collect()) ; @@ -7526,7 +7526,7 @@ impl<'de> serde::Deserialize<'de> for GlobalLimitExecNode { if skip__.is_some() { return Err(serde::de::Error::duplicate_field("skip")); } - skip__ = + skip__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -7534,7 +7534,7 @@ impl<'de> serde::Deserialize<'de> for GlobalLimitExecNode { if fetch__.is_some() { return Err(serde::de::Error::duplicate_field("fetch")); } - fetch__ = + fetch__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -10605,7 +10605,7 @@ impl<'de> serde::Deserialize<'de> for LocalLimitExecNode { if fetch__.is_some() { return Err(serde::de::Error::duplicate_field("fetch")); } - fetch__ = + fetch__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12434,7 +12434,7 @@ impl<'de> serde::Deserialize<'de> for PartitionId { if stage_id__.is_some() { return Err(serde::de::Error::duplicate_field("stageId")); } - stage_id__ = + stage_id__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12442,7 +12442,7 @@ impl<'de> serde::Deserialize<'de> for PartitionId { if partition_id__.is_some() { return Err(serde::de::Error::duplicate_field("partitionId")); } - partition_id__ = + partition_id__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12581,7 +12581,7 @@ impl<'de> serde::Deserialize<'de> for PartitionLocation { if map_partition_id__.is_some() { return Err(serde::de::Error::duplicate_field("mapPartitionId")); } - map_partition_id__ = + map_partition_id__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12632,6 +12632,7 @@ impl serde::Serialize for PartitionMode { let variant = match self { Self::CollectLeft => "COLLECT_LEFT", Self::Partitioned => "PARTITIONED", + Self::Auto => "AUTO", }; serializer.serialize_str(variant) } @@ -12645,6 +12646,7 @@ impl<'de> serde::Deserialize<'de> for PartitionMode { const FIELDS: &[&str] = &[ "COLLECT_LEFT", "PARTITIONED", + "AUTO", ]; struct GeneratedVisitor; @@ -12689,6 +12691,7 @@ impl<'de> serde::Deserialize<'de> for PartitionMode { match value { "COLLECT_LEFT" => Ok(PartitionMode::CollectLeft), "PARTITIONED" => Ok(PartitionMode::Partitioned), + "AUTO" => Ok(PartitionMode::Auto), _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), } } @@ -12809,7 +12812,7 @@ impl<'de> serde::Deserialize<'de> for PartitionStats { if num_rows__.is_some() { return Err(serde::de::Error::duplicate_field("numRows")); } - num_rows__ = + num_rows__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12817,7 +12820,7 @@ impl<'de> serde::Deserialize<'de> for PartitionStats { if num_batches__.is_some() { return Err(serde::de::Error::duplicate_field("numBatches")); } - num_batches__ = + num_batches__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12825,7 +12828,7 @@ impl<'de> serde::Deserialize<'de> for PartitionStats { if num_bytes__.is_some() { return Err(serde::de::Error::duplicate_field("numBytes")); } - num_bytes__ = + num_bytes__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12975,7 +12978,7 @@ impl<'de> serde::Deserialize<'de> for PartitionedFile { if size__.is_some() { return Err(serde::de::Error::duplicate_field("size")); } - size__ = + size__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -12983,7 +12986,7 @@ impl<'de> serde::Deserialize<'de> for PartitionedFile { if last_modified_ns__.is_some() { return Err(serde::de::Error::duplicate_field("lastModifiedNs")); } - last_modified_ns__ = + last_modified_ns__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -13705,7 +13708,7 @@ impl<'de> serde::Deserialize<'de> for PhysicalColumn { if index__.is_some() { return Err(serde::de::Error::duplicate_field("index")); } - index__ = + index__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -14250,7 +14253,7 @@ impl<'de> serde::Deserialize<'de> for PhysicalExtensionNode { if node__.is_some() { return Err(serde::de::Error::duplicate_field("node")); } - node__ = + node__ = Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) ; } @@ -14368,7 +14371,7 @@ impl<'de> serde::Deserialize<'de> for PhysicalHashRepartition { if partition_count__.is_some() { return Err(serde::de::Error::duplicate_field("partitionCount")); } - partition_count__ = + partition_count__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -18603,7 +18606,7 @@ impl<'de> serde::Deserialize<'de> for ScanLimit { if limit__.is_some() { return Err(serde::de::Error::duplicate_field("limit")); } - limit__ = + limit__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -19025,7 +19028,7 @@ impl<'de> serde::Deserialize<'de> for ShuffleWriterExecNode { if stage_id__.is_some() { return Err(serde::de::Error::duplicate_field("stageId")); } - stage_id__ = + stage_id__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -19308,7 +19311,7 @@ impl<'de> serde::Deserialize<'de> for SortExecNode { if fetch__.is_some() { return Err(serde::de::Error::duplicate_field("fetch")); } - fetch__ = + fetch__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -19798,7 +19801,7 @@ impl<'de> serde::Deserialize<'de> for Statistics { if num_rows__.is_some() { return Err(serde::de::Error::duplicate_field("numRows")); } - num_rows__ = + num_rows__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -19806,7 +19809,7 @@ impl<'de> serde::Deserialize<'de> for Statistics { if total_byte_size__.is_some() { return Err(serde::de::Error::duplicate_field("totalByteSize")); } - total_byte_size__ = + total_byte_size__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -21052,7 +21055,7 @@ impl<'de> serde::Deserialize<'de> for UnresolvedShuffleExecNode { if stage_id__.is_some() { return Err(serde::de::Error::duplicate_field("stageId")); } - stage_id__ = + stage_id__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -21066,7 +21069,7 @@ impl<'de> serde::Deserialize<'de> for UnresolvedShuffleExecNode { if input_partition_count__.is_some() { return Err(serde::de::Error::duplicate_field("inputPartitionCount")); } - input_partition_count__ = + input_partition_count__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -21074,7 +21077,7 @@ impl<'de> serde::Deserialize<'de> for UnresolvedShuffleExecNode { if output_partition_count__.is_some() { return Err(serde::de::Error::duplicate_field("outputPartitionCount")); } - output_partition_count__ = + output_partition_count__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs index 9555e50b262d..d361281fdce5 100644 --- a/datafusion/proto/src/generated/prost.rs +++ b/datafusion/proto/src/generated/prost.rs @@ -2289,6 +2289,7 @@ impl UnionMode { pub enum PartitionMode { CollectLeft = 0, Partitioned = 1, + Auto = 2, } impl PartitionMode { /// String value of the enum field names used in the ProtoBuf definition. @@ -2299,6 +2300,7 @@ impl PartitionMode { match self { PartitionMode::CollectLeft => "COLLECT_LEFT", PartitionMode::Partitioned => "PARTITIONED", + PartitionMode::Auto => "AUTO", } } } diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs index c9db1f3bf248..baba06b8cf6d 100644 --- a/datafusion/proto/src/physical_plan/mod.rs +++ b/datafusion/proto/src/physical_plan/mod.rs @@ -521,6 +521,7 @@ impl AsExecutionPlan for PhysicalPlanNode { let partition_mode = match partition_mode { protobuf::PartitionMode::CollectLeft => PartitionMode::CollectLeft, protobuf::PartitionMode::Partitioned => PartitionMode::Partitioned, + protobuf::PartitionMode::Auto => PartitionMode::Auto, }; Ok(Arc::new(HashJoinExec::try_new( left, @@ -810,6 +811,7 @@ impl AsExecutionPlan for PhysicalPlanNode { let partition_mode = match exec.partition_mode() { PartitionMode::CollectLeft => protobuf::PartitionMode::CollectLeft, PartitionMode::Partitioned => protobuf::PartitionMode::Partitioned, + PartitionMode::Auto => protobuf::PartitionMode::Auto, }; Ok(protobuf::PhysicalPlanNode { diff --git a/datafusion/proto/src/physical_plan/to_proto.rs b/datafusion/proto/src/physical_plan/to_proto.rs index 88d0299c2154..cce992192c80 100644 --- a/datafusion/proto/src/physical_plan/to_proto.rs +++ b/datafusion/proto/src/physical_plan/to_proto.rs @@ -452,7 +452,11 @@ impl TryFrom<&FileScanConfig> for protobuf::FileScanExecConf { .map(|n| *n as u32) .collect(), schema: Some(conf.file_schema.as_ref().try_into()?), - table_partition_cols: conf.table_partition_cols.to_vec(), + table_partition_cols: conf + .table_partition_cols + .iter() + .map(|x| x.0.clone()) + .collect::>(), object_store_url: conf.object_store_url.to_string(), }) } From 494548762b2b3ad2092f25ed12e6759b592c0ef5 Mon Sep 17 00:00:00 2001 From: kikkon Date: Sun, 27 Nov 2022 21:46:53 +0800 Subject: [PATCH 04/10] fix --- datafusion/proto/src/bytes/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/datafusion/proto/src/bytes/mod.rs b/datafusion/proto/src/bytes/mod.rs index dd9f1467a28f..944221fdef85 100644 --- a/datafusion/proto/src/bytes/mod.rs +++ b/datafusion/proto/src/bytes/mod.rs @@ -248,7 +248,7 @@ pub fn physical_plan_from_json( let back: protobuf::PhysicalPlanNode = serde_json::from_str(json) .map_err(|e| DataFusionError::Plan(format!("Error serializing plan: {}", e)))?; let extension_codec = DefaultPhysicalExtensionCodec {}; - back.try_into_physical_plan(ctx, ctx.runtime_env(), &extension_codec) + back.try_into_physical_plan(ctx, &ctx.runtime_env(), &extension_codec) } /// Deserialize a PhysicalPlan from bytes From 3d905abe7a6cc46249bde6c4ff3b33282a23a4f8 Mon Sep 17 00:00:00 2001 From: kikkon Date: Sun, 27 Nov 2022 22:06:43 +0800 Subject: [PATCH 05/10] cargo check again --- datafusion/proto/src/bytes/mod.rs | 4 ++-- datafusion/proto/src/physical_plan/mod.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/datafusion/proto/src/bytes/mod.rs b/datafusion/proto/src/bytes/mod.rs index 944221fdef85..005b76a567b8 100644 --- a/datafusion/proto/src/bytes/mod.rs +++ b/datafusion/proto/src/bytes/mod.rs @@ -215,9 +215,9 @@ pub fn physical_plan_to_bytes(plan: Arc) -> Result { /// Serialize a PhysicalPlan as json #[cfg(feature = "json")] pub fn physical_plan_to_json(plan: Arc) -> Result { - let extension_codec = DefaultLogicalExtensionCodec {}; + let extension_codec = DefaultPhysicalExtensionCodec {}; let protobuf = - protobuf::LogicalPlanNode::try_from_physical_plan(plan, &extension_codec) + protobuf::PhysicalPlanNode::try_from_physical_plan(plan, &extension_codec) .map_err(|e| { DataFusionError::Plan(format!("Error serializing plan: {}", e)) })?; diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs index baba06b8cf6d..54ece7259325 100644 --- a/datafusion/proto/src/physical_plan/mod.rs +++ b/datafusion/proto/src/physical_plan/mod.rs @@ -1251,7 +1251,7 @@ mod roundtrip_tests { joins::{HashJoinExec, PartitionMode}, limit::{GlobalLimitExec, LocalLimitExec}, sorts::sort::SortExec, - AggregateExpr, ExecutionPlan, Partitioning, PhysicalExpr, Statistics, + AggregateExpr, ExecutionPlan, PhysicalExpr, Statistics, }, prelude::SessionContext, scalar::ScalarValue, From 7326d1cb05afb092c25189b39e708584540bbbaf Mon Sep 17 00:00:00 2001 From: kikkon Date: Sun, 27 Nov 2022 22:28:40 +0800 Subject: [PATCH 06/10] tomlfmt --- datafusion/proto/Cargo.toml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/datafusion/proto/Cargo.toml b/datafusion/proto/Cargo.toml index df11d9072c7b..7cb5daf33fcb 100644 --- a/datafusion/proto/Cargo.toml +++ b/datafusion/proto/Cargo.toml @@ -41,17 +41,18 @@ json = ["pbjson", "serde", "serde_json"] [dependencies] arrow = "28.0.0" +chrono = { version = "0.4", default-features = false } datafusion = { path = "../core", version = "14.0.0" } datafusion-common = { path = "../common", version = "14.0.0" } datafusion-expr = { path = "../expr", version = "14.0.0" } +object_store = { version = "0.5.0" } +parking_lot = { version = "0.12" } pbjson = { version = "0.5", optional = true } pbjson-types = { version = "0.5", optional = true } prost = "0.11.0" serde = { version = "1.0", optional = true } serde_json = { version = "1.0", optional = true } -chrono = { version = "0.4", default-features = false } -parking_lot = "0.12" -object_store = "0.5.0" + [dev-dependencies] doc-comment = "0.3" tokio = "1.18" From dac598ee2739040ead04ac7322284a70274e60ae Mon Sep 17 00:00:00 2001 From: kikkon Date: Tue, 29 Nov 2022 15:04:19 +0800 Subject: [PATCH 07/10] remove ballista --- datafusion/proto/proto/datafusion.proto | 16 -- datafusion/proto/src/generated/pbjson.rs | 298 ----------------------- datafusion/proto/src/generated/prost.rs | 24 -- 3 files changed, 338 deletions(-) diff --git a/datafusion/proto/proto/datafusion.proto b/datafusion/proto/proto/datafusion.proto index 081494ec975f..9ec28f223ef5 100644 --- a/datafusion/proto/proto/datafusion.proto +++ b/datafusion/proto/proto/datafusion.proto @@ -1080,13 +1080,6 @@ message PhysicalNegativeNode { PhysicalExprNode expr = 1; } -message UnresolvedShuffleExecNode { - uint32 stage_id = 1; - datafusion.Schema schema = 2; - uint32 input_partition_count = 3; - uint32 output_partition_count = 4; -} - message FilterExecNode { PhysicalPlanNode input = 1; PhysicalExprNode expr = 2; @@ -1204,15 +1197,6 @@ message AggregateExecNode { repeated bool groups = 9; } -message ShuffleWriterExecNode { - //TODO it seems redundant to provide job and stage id here since we also have them - // in the TaskDefinition that wraps this plan - string job_id = 1; - uint32 stage_id = 2; - PhysicalPlanNode input = 3; - PhysicalHashRepartition output_partitioning = 4; -} - message GlobalLimitExecNode { PhysicalPlanNode input = 1; // The number of rows to skip before fetch diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs index 14483689106e..105f05ab6b3a 100644 --- a/datafusion/proto/src/generated/pbjson.rs +++ b/datafusion/proto/src/generated/pbjson.rs @@ -18910,153 +18910,6 @@ impl<'de> serde::Deserialize<'de> for SelectionNode { deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for ShuffleWriterExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.job_id.is_empty() { - len += 1; - } - if self.stage_id != 0 { - len += 1; - } - if self.input.is_some() { - len += 1; - } - if self.output_partitioning.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ShuffleWriterExecNode", len)?; - if !self.job_id.is_empty() { - struct_ser.serialize_field("jobId", &self.job_id)?; - } - if self.stage_id != 0 { - struct_ser.serialize_field("stageId", &self.stage_id)?; - } - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.output_partitioning.as_ref() { - struct_ser.serialize_field("outputPartitioning", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ShuffleWriterExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "job_id", - "jobId", - "stage_id", - "stageId", - "input", - "output_partitioning", - "outputPartitioning", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - JobId, - StageId, - Input, - OutputPartitioning, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "jobId" | "job_id" => Ok(GeneratedField::JobId), - "stageId" | "stage_id" => Ok(GeneratedField::StageId), - "input" => Ok(GeneratedField::Input), - "outputPartitioning" | "output_partitioning" => Ok(GeneratedField::OutputPartitioning), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ShuffleWriterExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ShuffleWriterExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut job_id__ = None; - let mut stage_id__ = None; - let mut input__ = None; - let mut output_partitioning__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::JobId => { - if job_id__.is_some() { - return Err(serde::de::Error::duplicate_field("jobId")); - } - job_id__ = Some(map.next_value()?); - } - GeneratedField::StageId => { - if stage_id__.is_some() { - return Err(serde::de::Error::duplicate_field("stageId")); - } - stage_id__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::OutputPartitioning => { - if output_partitioning__.is_some() { - return Err(serde::de::Error::duplicate_field("outputPartitioning")); - } - output_partitioning__ = map.next_value()?; - } - } - } - Ok(ShuffleWriterExecNode { - job_id: job_id__.unwrap_or_default(), - stage_id: stage_id__.unwrap_or_default(), - input: input__, - output_partitioning: output_partitioning__, - }) - } - } - deserializer.deserialize_struct("datafusion.ShuffleWriterExecNode", FIELDS, GeneratedVisitor) - } -} impl serde::Serialize for SimilarToNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result @@ -20943,157 +20796,6 @@ impl<'de> serde::Deserialize<'de> for UnionNode { deserializer.deserialize_struct("datafusion.UnionNode", FIELDS, GeneratedVisitor) } } -impl serde::Serialize for UnresolvedShuffleExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.stage_id != 0 { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if self.input_partition_count != 0 { - len += 1; - } - if self.output_partition_count != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.UnresolvedShuffleExecNode", len)?; - if self.stage_id != 0 { - struct_ser.serialize_field("stageId", &self.stage_id)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if self.input_partition_count != 0 { - struct_ser.serialize_field("inputPartitionCount", &self.input_partition_count)?; - } - if self.output_partition_count != 0 { - struct_ser.serialize_field("outputPartitionCount", &self.output_partition_count)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for UnresolvedShuffleExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "stage_id", - "stageId", - "schema", - "input_partition_count", - "inputPartitionCount", - "output_partition_count", - "outputPartitionCount", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - StageId, - Schema, - InputPartitionCount, - OutputPartitionCount, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "stageId" | "stage_id" => Ok(GeneratedField::StageId), - "schema" => Ok(GeneratedField::Schema), - "inputPartitionCount" | "input_partition_count" => Ok(GeneratedField::InputPartitionCount), - "outputPartitionCount" | "output_partition_count" => Ok(GeneratedField::OutputPartitionCount), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UnresolvedShuffleExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.UnresolvedShuffleExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut stage_id__ = None; - let mut schema__ = None; - let mut input_partition_count__ = None; - let mut output_partition_count__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::StageId => { - if stage_id__.is_some() { - return Err(serde::de::Error::duplicate_field("stageId")); - } - stage_id__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::InputPartitionCount => { - if input_partition_count__.is_some() { - return Err(serde::de::Error::duplicate_field("inputPartitionCount")); - } - input_partition_count__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::OutputPartitionCount => { - if output_partition_count__.is_some() { - return Err(serde::de::Error::duplicate_field("outputPartitionCount")); - } - output_partition_count__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(UnresolvedShuffleExecNode { - stage_id: stage_id__.unwrap_or_default(), - schema: schema__, - input_partition_count: input_partition_count__.unwrap_or_default(), - output_partition_count: output_partition_count__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.UnresolvedShuffleExecNode", FIELDS, GeneratedVisitor) - } -} impl serde::Serialize for ValuesNode { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result diff --git a/datafusion/proto/src/generated/prost.rs b/datafusion/proto/src/generated/prost.rs index d361281fdce5..6350e20dc720 100644 --- a/datafusion/proto/src/generated/prost.rs +++ b/datafusion/proto/src/generated/prost.rs @@ -1417,17 +1417,6 @@ pub struct PhysicalNegativeNode { pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, } #[derive(Clone, PartialEq, ::prost::Message)] -pub struct UnresolvedShuffleExecNode { - #[prost(uint32, tag = "1")] - pub stage_id: u32, - #[prost(message, optional, tag = "2")] - pub schema: ::core::option::Option, - #[prost(uint32, tag = "3")] - pub input_partition_count: u32, - #[prost(uint32, tag = "4")] - pub output_partition_count: u32, -} -#[derive(Clone, PartialEq, ::prost::Message)] pub struct FilterExecNode { #[prost(message, optional, boxed, tag = "1")] pub input: ::core::option::Option<::prost::alloc::boxed::Box>, @@ -1585,19 +1574,6 @@ pub struct AggregateExecNode { pub groups: ::prost::alloc::vec::Vec, } #[derive(Clone, PartialEq, ::prost::Message)] -pub struct ShuffleWriterExecNode { - /// TODO it seems redundant to provide job and stage id here since we also have them - /// in the TaskDefinition that wraps this plan - #[prost(string, tag = "1")] - pub job_id: ::prost::alloc::string::String, - #[prost(uint32, tag = "2")] - pub stage_id: u32, - #[prost(message, optional, tag = "3")] - pub input: ::core::option::Option, - #[prost(message, optional, tag = "4")] - pub output_partitioning: ::core::option::Option, -} -#[derive(Clone, PartialEq, ::prost::Message)] pub struct GlobalLimitExecNode { #[prost(message, optional, boxed, tag = "1")] pub input: ::core::option::Option<::prost::alloc::boxed::Box>, From 47cf9098f9bb44a2b83914e2cb9850535715f914 Mon Sep 17 00:00:00 2001 From: kikkon Date: Tue, 29 Nov 2022 15:37:09 +0800 Subject: [PATCH 08/10] remove ballista --- datafusion/proto/src/physical_plan/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs index 54ece7259325..e6e0e5b3d347 100644 --- a/datafusion/proto/src/physical_plan/mod.rs +++ b/datafusion/proto/src/physical_plan/mod.rs @@ -737,7 +737,7 @@ impl AsExecutionPlan for PhysicalPlanNode { input: Some(Box::new(input)), skip: limit.skip() as u32, fetch: match limit.fetch() { - Some(n) => *n as i64, + Some(n) => n as i64, _ => -1, // no limit }, }, From ed329634fe3c2de18c7d2b4b6b92d05348461ebf Mon Sep 17 00:00:00 2001 From: Kikkon Date: Wed, 30 Nov 2022 13:01:54 +0800 Subject: [PATCH 09/10] resolve comment --- datafusion/proto/src/common.rs | 2 +- datafusion/proto/src/physical_plan/from_proto.rs | 6 +++--- datafusion/proto/src/physical_plan/mod.rs | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/datafusion/proto/src/common.rs b/datafusion/proto/src/common.rs index a818159ec90d..9388f2e51d36 100644 --- a/datafusion/proto/src/common.rs +++ b/datafusion/proto/src/common.rs @@ -17,7 +17,7 @@ use datafusion_common::DataFusionError; -pub fn byte_to_string(b: u8) -> Result { +pub fn csv_delimiter_to_string(b: u8) -> Result { let b = &[b]; let b = std::str::from_utf8(b) .map_err(|_| DataFusionError::Internal("Invalid CSV delimiter".to_owned()))?; diff --git a/datafusion/proto/src/physical_plan/from_proto.rs b/datafusion/proto/src/physical_plan/from_proto.rs index 43cc228957c7..c61339a31877 100644 --- a/datafusion/proto/src/physical_plan/from_proto.rs +++ b/datafusion/proto/src/physical_plan/from_proto.rs @@ -96,17 +96,17 @@ pub(crate) fn parse_physical_expr( input_schema, )?), ExprType::AggregateExpr(_) => { - return Err(DataFusionError::Internal( + return Err(DataFusionError::NotImplemented( "Cannot convert aggregate expr node to physical expression".to_owned(), )); } ExprType::WindowExpr(_) => { - return Err(DataFusionError::Internal( + return Err(DataFusionError::NotImplemented( "Cannot convert window expr node to physical expression".to_owned(), )); } ExprType::Sort(_) => { - return Err(DataFusionError::Internal( + return Err(DataFusionError::NotImplemented( "Cannot convert sort expr node to physical expression".to_owned(), )); } diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs index e6e0e5b3d347..34db3c3cd05d 100644 --- a/datafusion/proto/src/physical_plan/mod.rs +++ b/datafusion/proto/src/physical_plan/mod.rs @@ -58,7 +58,7 @@ use prost::bytes::BufMut; use prost::Message; use crate::common::proto_error; -use crate::common::{byte_to_string, str_to_byte}; +use crate::common::{csv_delimiter_to_string, str_to_byte}; use crate::from_proto::parse_expr; use crate::physical_plan::from_proto::parse_physical_expr; use crate::protobuf::physical_expr_node::ExprType; @@ -946,7 +946,7 @@ impl AsExecutionPlan for PhysicalPlanNode { protobuf::CsvScanExecNode { base_conf: Some(exec.base_config().try_into()?), has_header: exec.has_header(), - delimiter: byte_to_string(exec.delimiter())?, + delimiter: csv_delimiter_to_string(exec.delimiter())?, }, )), }) From f7f4b2ccf0ede35414990e1803588495ee184fa9 Mon Sep 17 00:00:00 2001 From: kikkon Date: Wed, 30 Nov 2022 23:48:47 +0800 Subject: [PATCH 10/10] remove ballista --- datafusion/proto/src/generated/pbjson.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/datafusion/proto/src/generated/pbjson.rs b/datafusion/proto/src/generated/pbjson.rs index 105f05ab6b3a..22964281a6dc 100644 --- a/datafusion/proto/src/generated/pbjson.rs +++ b/datafusion/proto/src/generated/pbjson.rs @@ -4499,7 +4499,7 @@ impl<'de> serde::Deserialize<'de> for Decimal { if precision__.is_some() { return Err(serde::de::Error::duplicate_field("precision")); } - precision__ = + precision__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; } @@ -4507,7 +4507,7 @@ impl<'de> serde::Deserialize<'de> for Decimal { if scale__.is_some() { return Err(serde::de::Error::duplicate_field("scale")); } - scale__ = + scale__ = Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) ; }