From cca2012f1c319e9a613ae972f6dc56926f75dba7 Mon Sep 17 00:00:00 2001 From: Jiayu Liu Date: Sat, 26 Feb 2022 15:16:07 +0800 Subject: [PATCH 1/2] move expr --- .../src}/expressions/approx_distinct.rs | 0 .../src}/expressions/approx_median.rs | 0 .../src}/expressions/approx_percentile_cont.rs | 0 .../src}/expressions/array_agg.rs | 0 .../src}/expressions/average.rs | 0 .../src}/expressions/binary.rs | 0 .../src}/expressions/case.rs | 0 .../src}/expressions/cast.rs | 0 .../src}/expressions/column.rs | 0 .../src}/expressions/correlation.rs | 0 .../src}/expressions/count.rs | 0 .../src}/expressions/covariance.rs | 0 .../src}/expressions/cume_dist.rs | 4 ++-- .../src}/expressions/distinct_expressions.rs | 0 .../src}/expressions/get_indexed_field.rs | 0 .../src}/expressions/in_list.rs | 0 .../src}/expressions/is_not_null.rs | 0 .../src}/expressions/is_null.rs | 0 .../src}/expressions/lead_lag.rs | 4 ++-- .../src}/expressions/literal.rs | 0 .../src}/expressions/min_max.rs | 0 .../src}/expressions/mod.rs | 2 +- .../src}/expressions/negative.rs | 0 .../src}/expressions/not.rs | 0 .../src}/expressions/nth_value.rs | 4 ++-- .../src}/expressions/nullif.rs | 0 .../src}/expressions/rank.rs | 4 ++-- .../src}/expressions/row_number.rs | 4 ++-- .../src}/expressions/stats.rs | 0 .../src}/expressions/stddev.rs | 0 .../src}/expressions/sum.rs | 0 .../src}/expressions/try_cast.rs | 0 .../src}/expressions/variance.rs | 0 datafusion-physical-expr/src/lib.rs | 1 + datafusion/src/physical_plan/mod.rs | 2 +- 35 files changed, 13 insertions(+), 12 deletions(-) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/approx_distinct.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/approx_median.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/approx_percentile_cont.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/array_agg.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/average.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/binary.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/case.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/cast.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/column.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/correlation.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/count.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/covariance.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/cume_dist.rs (97%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/distinct_expressions.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/get_indexed_field.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/in_list.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/is_not_null.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/is_null.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/lead_lag.rs (98%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/literal.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/min_max.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/mod.rs (99%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/negative.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/not.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/nth_value.rs (98%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/nullif.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/rank.rs (98%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/row_number.rs (97%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/stats.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/stddev.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/sum.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/try_cast.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/expressions/variance.rs (100%) diff --git a/datafusion/src/physical_plan/expressions/approx_distinct.rs b/datafusion-physical-expr/src/expressions/approx_distinct.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/approx_distinct.rs rename to datafusion-physical-expr/src/expressions/approx_distinct.rs diff --git a/datafusion/src/physical_plan/expressions/approx_median.rs b/datafusion-physical-expr/src/expressions/approx_median.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/approx_median.rs rename to datafusion-physical-expr/src/expressions/approx_median.rs diff --git a/datafusion/src/physical_plan/expressions/approx_percentile_cont.rs b/datafusion-physical-expr/src/expressions/approx_percentile_cont.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/approx_percentile_cont.rs rename to datafusion-physical-expr/src/expressions/approx_percentile_cont.rs diff --git a/datafusion/src/physical_plan/expressions/array_agg.rs b/datafusion-physical-expr/src/expressions/array_agg.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/array_agg.rs rename to datafusion-physical-expr/src/expressions/array_agg.rs diff --git a/datafusion/src/physical_plan/expressions/average.rs b/datafusion-physical-expr/src/expressions/average.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/average.rs rename to datafusion-physical-expr/src/expressions/average.rs diff --git a/datafusion/src/physical_plan/expressions/binary.rs b/datafusion-physical-expr/src/expressions/binary.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/binary.rs rename to datafusion-physical-expr/src/expressions/binary.rs diff --git a/datafusion/src/physical_plan/expressions/case.rs b/datafusion-physical-expr/src/expressions/case.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/case.rs rename to datafusion-physical-expr/src/expressions/case.rs diff --git a/datafusion/src/physical_plan/expressions/cast.rs b/datafusion-physical-expr/src/expressions/cast.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/cast.rs rename to datafusion-physical-expr/src/expressions/cast.rs diff --git a/datafusion/src/physical_plan/expressions/column.rs b/datafusion-physical-expr/src/expressions/column.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/column.rs rename to datafusion-physical-expr/src/expressions/column.rs diff --git a/datafusion/src/physical_plan/expressions/correlation.rs b/datafusion-physical-expr/src/expressions/correlation.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/correlation.rs rename to datafusion-physical-expr/src/expressions/correlation.rs diff --git a/datafusion/src/physical_plan/expressions/count.rs b/datafusion-physical-expr/src/expressions/count.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/count.rs rename to datafusion-physical-expr/src/expressions/count.rs diff --git a/datafusion/src/physical_plan/expressions/covariance.rs b/datafusion-physical-expr/src/expressions/covariance.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/covariance.rs rename to datafusion-physical-expr/src/expressions/covariance.rs diff --git a/datafusion/src/physical_plan/expressions/cume_dist.rs b/datafusion-physical-expr/src/expressions/cume_dist.rs similarity index 97% rename from datafusion/src/physical_plan/expressions/cume_dist.rs rename to datafusion-physical-expr/src/expressions/cume_dist.rs index 6f24d8226d502..fd2ce20e231c7 100644 --- a/datafusion/src/physical_plan/expressions/cume_dist.rs +++ b/datafusion-physical-expr/src/expressions/cume_dist.rs @@ -20,12 +20,12 @@ use crate::error::Result; use crate::physical_plan::PhysicalExpr; +use crate::window::BuiltInWindowFunctionExpr; +use crate::window::PartitionEvaluator; use arrow::array::ArrayRef; use arrow::array::Float64Array; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; -use datafusion_physical_expr::window::BuiltInWindowFunctionExpr; -use datafusion_physical_expr::window::PartitionEvaluator; use std::any::Any; use std::iter; use std::ops::Range; diff --git a/datafusion/src/physical_plan/expressions/distinct_expressions.rs b/datafusion-physical-expr/src/expressions/distinct_expressions.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/distinct_expressions.rs rename to datafusion-physical-expr/src/expressions/distinct_expressions.rs diff --git a/datafusion/src/physical_plan/expressions/get_indexed_field.rs b/datafusion-physical-expr/src/expressions/get_indexed_field.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/get_indexed_field.rs rename to datafusion-physical-expr/src/expressions/get_indexed_field.rs diff --git a/datafusion/src/physical_plan/expressions/in_list.rs b/datafusion-physical-expr/src/expressions/in_list.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/in_list.rs rename to datafusion-physical-expr/src/expressions/in_list.rs diff --git a/datafusion/src/physical_plan/expressions/is_not_null.rs b/datafusion-physical-expr/src/expressions/is_not_null.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/is_not_null.rs rename to datafusion-physical-expr/src/expressions/is_not_null.rs diff --git a/datafusion/src/physical_plan/expressions/is_null.rs b/datafusion-physical-expr/src/expressions/is_null.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/is_null.rs rename to datafusion-physical-expr/src/expressions/is_null.rs diff --git a/datafusion/src/physical_plan/expressions/lead_lag.rs b/datafusion-physical-expr/src/expressions/lead_lag.rs similarity index 98% rename from datafusion/src/physical_plan/expressions/lead_lag.rs rename to datafusion-physical-expr/src/expressions/lead_lag.rs index fef5bad2a926d..b9180e3baaef4 100644 --- a/datafusion/src/physical_plan/expressions/lead_lag.rs +++ b/datafusion-physical-expr/src/expressions/lead_lag.rs @@ -21,12 +21,12 @@ use crate::error::{DataFusionError, Result}; use crate::physical_plan::PhysicalExpr; use crate::scalar::ScalarValue; +use crate::window::BuiltInWindowFunctionExpr; +use crate::window::PartitionEvaluator; use arrow::array::ArrayRef; use arrow::compute::cast; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; -use datafusion_physical_expr::window::BuiltInWindowFunctionExpr; -use datafusion_physical_expr::window::PartitionEvaluator; use std::any::Any; use std::ops::Neg; use std::ops::Range; diff --git a/datafusion/src/physical_plan/expressions/literal.rs b/datafusion-physical-expr/src/expressions/literal.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/literal.rs rename to datafusion-physical-expr/src/expressions/literal.rs diff --git a/datafusion/src/physical_plan/expressions/min_max.rs b/datafusion-physical-expr/src/expressions/min_max.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/min_max.rs rename to datafusion-physical-expr/src/expressions/min_max.rs diff --git a/datafusion/src/physical_plan/expressions/mod.rs b/datafusion-physical-expr/src/expressions/mod.rs similarity index 99% rename from datafusion/src/physical_plan/expressions/mod.rs rename to datafusion-physical-expr/src/expressions/mod.rs index 567e87c1d36d4..ff9f019b34d27 100644 --- a/datafusion/src/physical_plan/expressions/mod.rs +++ b/datafusion-physical-expr/src/expressions/mod.rs @@ -112,7 +112,7 @@ pub fn format_state_name(name: &str, state_name: &str) -> String { format!("{}[{}]", name, state_name) } -pub use datafusion_physical_expr::PhysicalSortExpr; +pub use crate::PhysicalSortExpr; #[cfg(test)] mod tests { diff --git a/datafusion/src/physical_plan/expressions/negative.rs b/datafusion-physical-expr/src/expressions/negative.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/negative.rs rename to datafusion-physical-expr/src/expressions/negative.rs diff --git a/datafusion/src/physical_plan/expressions/not.rs b/datafusion-physical-expr/src/expressions/not.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/not.rs rename to datafusion-physical-expr/src/expressions/not.rs diff --git a/datafusion/src/physical_plan/expressions/nth_value.rs b/datafusion-physical-expr/src/expressions/nth_value.rs similarity index 98% rename from datafusion/src/physical_plan/expressions/nth_value.rs rename to datafusion-physical-expr/src/expressions/nth_value.rs index 895a8b95a045a..52cc4db2a0168 100644 --- a/datafusion/src/physical_plan/expressions/nth_value.rs +++ b/datafusion-physical-expr/src/expressions/nth_value.rs @@ -21,12 +21,12 @@ use crate::error::{DataFusionError, Result}; use crate::physical_plan::PhysicalExpr; use crate::scalar::ScalarValue; +use crate::window::BuiltInWindowFunctionExpr; +use crate::window::PartitionEvaluator; use arrow::array::{new_null_array, ArrayRef}; use arrow::compute::kernels::window::shift; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; -use datafusion_physical_expr::window::BuiltInWindowFunctionExpr; -use datafusion_physical_expr::window::PartitionEvaluator; use std::any::Any; use std::iter; use std::ops::Range; diff --git a/datafusion/src/physical_plan/expressions/nullif.rs b/datafusion-physical-expr/src/expressions/nullif.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/nullif.rs rename to datafusion-physical-expr/src/expressions/nullif.rs diff --git a/datafusion/src/physical_plan/expressions/rank.rs b/datafusion-physical-expr/src/expressions/rank.rs similarity index 98% rename from datafusion/src/physical_plan/expressions/rank.rs rename to datafusion-physical-expr/src/expressions/rank.rs index 66697a052b3e2..04340f70b1548 100644 --- a/datafusion/src/physical_plan/expressions/rank.rs +++ b/datafusion-physical-expr/src/expressions/rank.rs @@ -20,12 +20,12 @@ use crate::error::Result; use crate::physical_plan::PhysicalExpr; +use crate::window::BuiltInWindowFunctionExpr; +use crate::window::PartitionEvaluator; use arrow::array::ArrayRef; use arrow::array::{Float64Array, UInt64Array}; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; -use datafusion_physical_expr::window::BuiltInWindowFunctionExpr; -use datafusion_physical_expr::window::PartitionEvaluator; use std::any::Any; use std::iter; use std::ops::Range; diff --git a/datafusion/src/physical_plan/expressions/row_number.rs b/datafusion-physical-expr/src/expressions/row_number.rs similarity index 97% rename from datafusion/src/physical_plan/expressions/row_number.rs rename to datafusion-physical-expr/src/expressions/row_number.rs index 4c349c141fd87..5d765235d6bfa 100644 --- a/datafusion/src/physical_plan/expressions/row_number.rs +++ b/datafusion-physical-expr/src/expressions/row_number.rs @@ -19,11 +19,11 @@ use crate::error::Result; use crate::physical_plan::PhysicalExpr; +use crate::window::BuiltInWindowFunctionExpr; +use crate::window::PartitionEvaluator; use arrow::array::{ArrayRef, UInt64Array}; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; -use datafusion_physical_expr::window::BuiltInWindowFunctionExpr; -use datafusion_physical_expr::window::PartitionEvaluator; use std::any::Any; use std::ops::Range; use std::sync::Arc; diff --git a/datafusion/src/physical_plan/expressions/stats.rs b/datafusion-physical-expr/src/expressions/stats.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/stats.rs rename to datafusion-physical-expr/src/expressions/stats.rs diff --git a/datafusion/src/physical_plan/expressions/stddev.rs b/datafusion-physical-expr/src/expressions/stddev.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/stddev.rs rename to datafusion-physical-expr/src/expressions/stddev.rs diff --git a/datafusion/src/physical_plan/expressions/sum.rs b/datafusion-physical-expr/src/expressions/sum.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/sum.rs rename to datafusion-physical-expr/src/expressions/sum.rs diff --git a/datafusion/src/physical_plan/expressions/try_cast.rs b/datafusion-physical-expr/src/expressions/try_cast.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/try_cast.rs rename to datafusion-physical-expr/src/expressions/try_cast.rs diff --git a/datafusion/src/physical_plan/expressions/variance.rs b/datafusion-physical-expr/src/expressions/variance.rs similarity index 100% rename from datafusion/src/physical_plan/expressions/variance.rs rename to datafusion-physical-expr/src/expressions/variance.rs diff --git a/datafusion-physical-expr/src/lib.rs b/datafusion-physical-expr/src/lib.rs index 6beffd18d015f..0c505b35d1a01 100644 --- a/datafusion-physical-expr/src/lib.rs +++ b/datafusion-physical-expr/src/lib.rs @@ -16,6 +16,7 @@ // under the License. mod aggregate_expr; +pub mod expressions; mod physical_expr; mod sort_expr; pub mod window; diff --git a/datafusion/src/physical_plan/mod.rs b/datafusion/src/physical_plan/mod.rs index 32f2d5b53087a..9c51d4a1fc1f2 100644 --- a/datafusion/src/physical_plan/mod.rs +++ b/datafusion/src/physical_plan/mod.rs @@ -526,7 +526,7 @@ pub mod datetime_expressions; pub mod display; pub mod empty; pub mod explain; -pub mod expressions; +pub use datafusion_physical_expr::expressions; pub mod file_format; pub mod filter; pub mod functions; From ad41b2aa4450073ec09b0474f485b3517bec5ff2 Mon Sep 17 00:00:00 2001 From: Jiayu Liu Date: Sat, 26 Feb 2022 15:18:38 +0800 Subject: [PATCH 2/2] move more expressions to datafusion-physical-expr --- datafusion-physical-expr/Cargo.toml | 3 + .../src}/coercion_rule/binary_rule.rs | 12 +-- .../src}/coercion_rule/mod.rs | 3 +- .../src/expressions/approx_distinct.rs | 9 +-- .../src/expressions/approx_median.rs | 8 +- .../src/expressions/approx_percentile_cont.rs | 19 ++--- .../src/expressions/array_agg.rs | 17 +++-- .../src/expressions/average.rs | 36 +++++---- .../src/expressions/binary.rs | 56 +++++++------- .../src/expressions/case.rs | 16 ++-- .../src/expressions/cast.rs | 15 ++-- .../src/expressions/column.rs | 5 +- .../src/expressions/correlation.rs | 60 +++++++-------- .../src/expressions/count.rs | 24 +++--- .../src/expressions/covariance.rs | 57 +++++++------- .../src/expressions/cume_dist.rs | 4 +- .../src/expressions/distinct_expressions.rs | 24 +++--- .../src/expressions/get_indexed_field.rs | 30 ++++---- .../src/expressions/in_list.rs | 11 +-- .../src/expressions/is_not_null.rs | 12 +-- .../src/expressions/is_null.rs | 11 +-- .../src/expressions/lead_lag.rs | 14 ++-- .../src/expressions/literal.rs | 8 +- .../src/expressions/min_max.rs | 74 +++++++++---------- .../src/expressions/mod.rs | 26 +++---- .../src/expressions/negative.rs | 7 +- .../src/expressions/not.rs | 12 +-- .../src/expressions/nth_value.rs | 14 ++-- .../src/expressions/nullif.rs | 13 ++-- .../src/expressions/rank.rs | 4 +- .../src/expressions/row_number.rs | 9 +-- .../src/expressions/stddev.rs | 52 ++++++------- .../src/expressions/sum.rs | 36 +++++---- .../src/expressions/try_cast.rs | 12 +-- .../src/expressions/variance.rs | 53 ++++++------- .../src/field_util.rs | 5 +- .../src}/hyperloglog/mod.rs | 0 datafusion-physical-expr/src/lib.rs | 4 + .../src}/tdigest/mod.rs | 42 +++++------ datafusion/src/lib.rs | 1 - datafusion/src/logical_plan/expr_schema.rs | 2 +- .../{coercion_rule => }/aggregate_rule.rs | 26 +++---- datafusion/src/physical_plan/aggregates.rs | 5 +- datafusion/src/physical_plan/mod.rs | 4 +- 44 files changed, 411 insertions(+), 444 deletions(-) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/coercion_rule/binary_rule.rs (98%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/coercion_rule/mod.rs (93%) rename {datafusion => datafusion-physical-expr}/src/field_util.rs (96%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/hyperloglog/mod.rs (100%) rename {datafusion/src/physical_plan => datafusion-physical-expr/src}/tdigest/mod.rs (95%) rename datafusion/src/physical_plan/{coercion_rule => }/aggregate_rule.rs (96%) diff --git a/datafusion-physical-expr/Cargo.toml b/datafusion-physical-expr/Cargo.toml index ba12b586354e4..5c437caf5257d 100644 --- a/datafusion-physical-expr/Cargo.toml +++ b/datafusion-physical-expr/Cargo.toml @@ -38,3 +38,6 @@ path = "src/lib.rs" datafusion-common = { path = "../datafusion-common", version = "7.0.0" } datafusion-expr = { path = "../datafusion-expr", version = "7.0.0" } arrow = { version = "9.0.0", features = ["prettyprint"] } +paste = "^1.0" +ahash = { version = "0.7", default-features = false } +ordered-float = "2.10" diff --git a/datafusion/src/physical_plan/coercion_rule/binary_rule.rs b/datafusion-physical-expr/src/coercion_rule/binary_rule.rs similarity index 98% rename from datafusion/src/physical_plan/coercion_rule/binary_rule.rs rename to datafusion-physical-expr/src/coercion_rule/binary_rule.rs index 7d4dd55bf605f..67a052b86de27 100644 --- a/datafusion/src/physical_plan/coercion_rule/binary_rule.rs +++ b/datafusion-physical-expr/src/coercion_rule/binary_rule.rs @@ -17,9 +17,10 @@ //! Coercion rules for matching argument types for binary operators -use crate::arrow::datatypes::DataType; -use crate::error::{DataFusionError, Result}; -use crate::scalar::{MAX_PRECISION_FOR_DECIMAL128, MAX_SCALE_FOR_DECIMAL128}; +use arrow::datatypes::DataType; +use datafusion_common::DataFusionError; +use datafusion_common::Result; +use datafusion_common::{MAX_PRECISION_FOR_DECIMAL128, MAX_SCALE_FOR_DECIMAL128}; use datafusion_expr::Operator; /// Coercion rules for all binary operators. Returns the output type @@ -492,8 +493,9 @@ fn eq_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option { #[cfg(test)] mod tests { use super::*; - use crate::arrow::datatypes::DataType; - use crate::error::{DataFusionError, Result}; + use arrow::datatypes::DataType; + use datafusion_common::DataFusionError; + use datafusion_common::Result; use datafusion_expr::Operator; #[test] diff --git a/datafusion/src/physical_plan/coercion_rule/mod.rs b/datafusion-physical-expr/src/coercion_rule/mod.rs similarity index 93% rename from datafusion/src/physical_plan/coercion_rule/mod.rs rename to datafusion-physical-expr/src/coercion_rule/mod.rs index 83e091aa5e91c..a98154867f5a1 100644 --- a/datafusion/src/physical_plan/coercion_rule/mod.rs +++ b/datafusion-physical-expr/src/coercion_rule/mod.rs @@ -20,5 +20,4 @@ //! Aggregate function rule //! Binary operation rule -pub(crate) mod aggregate_rule; -pub(crate) mod binary_rule; +pub mod binary_rule; diff --git a/datafusion-physical-expr/src/expressions/approx_distinct.rs b/datafusion-physical-expr/src/expressions/approx_distinct.rs index 9900780ce0d35..610f381bb5dc5 100644 --- a/datafusion-physical-expr/src/expressions/approx_distinct.rs +++ b/datafusion-physical-expr/src/expressions/approx_distinct.rs @@ -18,11 +18,7 @@ //! Defines physical expressions that can evaluated at runtime during query execution use super::format_state_name; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{ - hyperloglog::HyperLogLog, Accumulator, AggregateExpr, PhysicalExpr, -}; -use crate::scalar::ScalarValue; +use crate::{hyperloglog::HyperLogLog, AggregateExpr, PhysicalExpr}; use arrow::array::{ ArrayRef, BinaryArray, BinaryOffsetSizeTrait, GenericBinaryArray, GenericStringArray, PrimitiveArray, StringOffsetSizeTrait, @@ -31,6 +27,9 @@ use arrow::datatypes::{ ArrowPrimitiveType, DataType, Field, Int16Type, Int32Type, Int64Type, Int8Type, UInt16Type, UInt32Type, UInt64Type, UInt8Type, }; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; use std::any::type_name; use std::any::Any; use std::convert::TryFrom; diff --git a/datafusion-physical-expr/src/expressions/approx_median.rs b/datafusion-physical-expr/src/expressions/approx_median.rs index 2ca585759c6b4..651ccbdb7277b 100644 --- a/datafusion-physical-expr/src/expressions/approx_median.rs +++ b/datafusion-physical-expr/src/expressions/approx_median.rs @@ -17,13 +17,13 @@ //! Defines physical expressions for APPROX_MEDIAN that can be evaluated MEDIAN at runtime during query execution +use crate::{AggregateExpr, PhysicalExpr}; +use arrow::{datatypes::DataType, datatypes::Field}; +use datafusion_common::Result; +use datafusion_expr::Accumulator; use std::any::Any; use std::sync::Arc; -use crate::error::Result; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use arrow::{datatypes::DataType, datatypes::Field}; - /// MEDIAN aggregate expression #[derive(Debug)] pub struct ApproxMedian { diff --git a/datafusion-physical-expr/src/expressions/approx_percentile_cont.rs b/datafusion-physical-expr/src/expressions/approx_percentile_cont.rs index 0e419751659e0..77d82cf49af1f 100644 --- a/datafusion-physical-expr/src/expressions/approx_percentile_cont.rs +++ b/datafusion-physical-expr/src/expressions/approx_percentile_cont.rs @@ -15,8 +15,8 @@ // specific language governing permissions and limitations // under the License. -use std::{any::Any, iter, sync::Arc}; - +use super::{format_state_name, Literal}; +use crate::{tdigest::TDigest, AggregateExpr, PhysicalExpr}; use arrow::{ array::{ ArrayRef, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array, @@ -24,16 +24,11 @@ use arrow::{ }, datatypes::{DataType, Field}, }; - -use crate::{ - error::DataFusionError, - physical_plan::{tdigest::TDigest, Accumulator, AggregateExpr, PhysicalExpr}, - scalar::ScalarValue, -}; - -use crate::error::Result; - -use super::{format_state_name, Literal}; +use datafusion_common::DataFusionError; +use datafusion_common::Result; +use datafusion_common::ScalarValue; +use datafusion_expr::Accumulator; +use std::{any::Any, iter, sync::Arc}; /// Return `true` if `arg_type` is of a [`DataType`] that the /// [`ApproxPercentileCont`] aggregation can operate on. diff --git a/datafusion-physical-expr/src/expressions/array_agg.rs b/datafusion-physical-expr/src/expressions/array_agg.rs index 5a86edd59e400..e187930f3703d 100644 --- a/datafusion-physical-expr/src/expressions/array_agg.rs +++ b/datafusion-physical-expr/src/expressions/array_agg.rs @@ -18,11 +18,12 @@ //! Defines physical expressions that can evaluated at runtime during query execution use super::format_state_name; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::{AggregateExpr, PhysicalExpr}; use arrow::array::ArrayRef; use arrow::datatypes::{DataType, Field}; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; use std::any::Any; use std::sync::Arc; @@ -157,18 +158,18 @@ impl Accumulator for ArrayAggAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::physical_plan::expressions::tests::aggregate; - use crate::{error::Result, generic_test_op}; + use crate::expressions::col; + use crate::expressions::tests::aggregate; + use crate::generic_test_op; use arrow::array::ArrayRef; use arrow::array::Int32Array; use arrow::datatypes::*; use arrow::record_batch::RecordBatch; + use datafusion_common::Result; #[test] fn array_agg_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); let list = ScalarValue::List( Some(Box::new(vec![ diff --git a/datafusion-physical-expr/src/expressions/average.rs b/datafusion-physical-expr/src/expressions/average.rs index 2b9fa9d9ba162..acdbf8b72cb1b 100644 --- a/datafusion-physical-expr/src/expressions/average.rs +++ b/datafusion-physical-expr/src/expressions/average.rs @@ -21,17 +21,18 @@ use std::any::Any; use std::convert::TryFrom; use std::sync::Arc; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::{ - ScalarValue, MAX_PRECISION_FOR_DECIMAL128, MAX_SCALE_FOR_DECIMAL128, -}; +use crate::{AggregateExpr, PhysicalExpr}; use arrow::compute; use arrow::datatypes::DataType; use arrow::{ array::{ArrayRef, UInt64Array}, datatypes::Field, }; +use datafusion_common::{DataFusionError, Result}; +use datafusion_common::{ + ScalarValue, MAX_PRECISION_FOR_DECIMAL128, MAX_SCALE_FOR_DECIMAL128, +}; +use datafusion_expr::Accumulator; use super::{format_state_name, sum}; @@ -70,7 +71,7 @@ pub fn avg_return_type(arg_type: &DataType) -> Result { } } -pub(crate) fn is_avg_support_arg_type(arg_type: &DataType) -> bool { +pub fn is_avg_support_arg_type(arg_type: &DataType) -> bool { matches!( arg_type, DataType::UInt8 @@ -215,11 +216,11 @@ impl Accumulator for AvgAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::{error::Result, generic_test_op}; + use crate::expressions::col; + use crate::generic_test_op; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; #[test] fn test_avg_return_data_type() -> Result<()> { @@ -290,7 +291,7 @@ mod tests { #[test] fn avg_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -332,9 +333,8 @@ mod tests { #[test] fn avg_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ - 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, - ])); + let a: ArrayRef = + Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); generic_test_op!( a, DataType::UInt32, @@ -346,9 +346,8 @@ mod tests { #[test] fn avg_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ - 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, - ])); + let a: ArrayRef = + Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); generic_test_op!( a, DataType::Float32, @@ -360,9 +359,8 @@ mod tests { #[test] fn avg_f64() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a: ArrayRef = + Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); generic_test_op!( a, DataType::Float64, diff --git a/datafusion-physical-expr/src/expressions/binary.rs b/datafusion-physical-expr/src/expressions/binary.rs index 6f9084ac18f20..09990773b9a9d 100644 --- a/datafusion-physical-expr/src/expressions/binary.rs +++ b/datafusion-physical-expr/src/expressions/binary.rs @@ -54,11 +54,12 @@ use arrow::datatypes::{ArrowNumericType, DataType, Schema, TimeUnit}; use arrow::error::ArrowError::DivideByZero; use arrow::record_batch::RecordBatch; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::coercion_rule::binary_rule::coerce_types; -use crate::physical_plan::expressions::try_cast; -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::coercion_rule::binary_rule::coerce_types; +use crate::expressions::try_cast; +use crate::PhysicalExpr; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; use datafusion_expr::Operator; // TODO move to arrow_rs @@ -1375,11 +1376,10 @@ pub fn binary( #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::{col, lit}; + use crate::expressions::{col, lit}; use arrow::datatypes::{ArrowNumericType, Field, Int32Type, SchemaRef}; use arrow::util::display::array_value_to_string; + use datafusion_common::Result; // Create a binary expression without coercion. Used here when we do not want to coerce the expressions // to valid types. Usage can result in an execution (after plan) error. @@ -1398,8 +1398,8 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ]); - let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]); - let b = Int32Array::from_slice(&[1, 2, 4, 8, 16]); + let a = Int32Array::from(vec![1, 2, 3, 4, 5]); + let b = Int32Array::from(vec![1, 2, 4, 8, 16]); // expression: "a < b" let lt = binary_simple( @@ -1432,8 +1432,8 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ]); - let a = Int32Array::from_slice(&[2, 4, 6, 8, 10]); - let b = Int32Array::from_slice(&[2, 5, 4, 8, 8]); + let a = Int32Array::from(vec![2, 4, 6, 8, 10]); + let b = Int32Array::from(vec![2, 5, 4, 8, 8]); // expression: "a < b OR a == b" let expr = binary_simple( @@ -1831,14 +1831,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ]); - let a = Int32Array::from_slice(&[1, 2, 3, 4, 5]); - let b = Int32Array::from_slice(&[1, 2, 4, 8, 16]); + let a = Int32Array::from(vec![1, 2, 3, 4, 5]); + let b = Int32Array::from(vec![1, 2, 4, 8, 16]); apply_arithmetic::( Arc::new(schema), vec![Arc::new(a), Arc::new(b)], Operator::Plus, - Int32Array::from_slice(&[2, 4, 7, 12, 21]), + Int32Array::from(vec![2, 4, 7, 12, 21]), )?; Ok(()) @@ -1850,14 +1850,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from_slice(&[1, 2, 4, 8, 16])); - let b = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a = Arc::new(Int32Array::from(vec![1, 2, 4, 8, 16])); + let b = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); apply_arithmetic::( schema.clone(), vec![a.clone(), b.clone()], Operator::Minus, - Int32Array::from_slice(&[0, 0, 1, 4, 11]), + Int32Array::from(vec![0, 0, 1, 4, 11]), )?; // should handle have negative values in result (for signed) @@ -1865,7 +1865,7 @@ mod tests { schema, vec![b, a], Operator::Minus, - Int32Array::from_slice(&[0, 0, -1, -4, -11]), + Int32Array::from(vec![0, 0, -1, -4, -11]), )?; Ok(()) @@ -1877,14 +1877,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from_slice(&[4, 8, 16, 32, 64])); - let b = Arc::new(Int32Array::from_slice(&[2, 4, 8, 16, 32])); + let a = Arc::new(Int32Array::from(vec![4, 8, 16, 32, 64])); + let b = Arc::new(Int32Array::from(vec![2, 4, 8, 16, 32])); apply_arithmetic::( schema, vec![a, b], Operator::Multiply, - Int32Array::from_slice(&[8, 32, 128, 512, 2048]), + Int32Array::from(vec![8, 32, 128, 512, 2048]), )?; Ok(()) @@ -1896,14 +1896,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from_slice(&[8, 32, 128, 512, 2048])); - let b = Arc::new(Int32Array::from_slice(&[2, 4, 8, 16, 32])); + let a = Arc::new(Int32Array::from(vec![8, 32, 128, 512, 2048])); + let b = Arc::new(Int32Array::from(vec![2, 4, 8, 16, 32])); apply_arithmetic::( schema, vec![a, b], Operator::Divide, - Int32Array::from_slice(&[4, 8, 16, 32, 64]), + Int32Array::from(vec![4, 8, 16, 32, 64]), )?; Ok(()) @@ -1915,14 +1915,14 @@ mod tests { Field::new("a", DataType::Int32, false), Field::new("b", DataType::Int32, false), ])); - let a = Arc::new(Int32Array::from_slice(&[8, 32, 128, 512, 2048])); - let b = Arc::new(Int32Array::from_slice(&[2, 4, 7, 14, 32])); + let a = Arc::new(Int32Array::from(vec![8, 32, 128, 512, 2048])); + let b = Arc::new(Int32Array::from(vec![2, 4, 7, 14, 32])); apply_arithmetic::( schema, vec![a, b], Operator::Modulo, - Int32Array::from_slice(&[0, 0, 2, 8, 0]), + Int32Array::from(vec![0, 0, 2, 8, 0]), )?; Ok(()) diff --git a/datafusion-physical-expr/src/expressions/case.rs b/datafusion-physical-expr/src/expressions/case.rs index d990d744ef051..3bcb78a97745c 100644 --- a/datafusion-physical-expr/src/expressions/case.rs +++ b/datafusion-physical-expr/src/expressions/case.rs @@ -17,13 +17,14 @@ use std::{any::Any, sync::Arc}; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::expressions::try_cast; -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; +use crate::expressions::try_cast; +use crate::PhysicalExpr; use arrow::array::{self, *}; use arrow::compute::{eq, eq_utf8}; use arrow::datatypes::{DataType, Schema}; use arrow::record_batch::RecordBatch; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; type WhenThen = (Arc, Arc); @@ -454,13 +455,12 @@ pub fn case( #[cfg(test)] mod tests { use super::*; - use crate::{ - error::Result, - physical_plan::expressions::{binary, col, lit}, - scalar::ScalarValue, - }; + use crate::expressions::binary; + use crate::expressions::col; + use crate::expressions::lit; use arrow::array::StringArray; use arrow::datatypes::*; + use datafusion_common::ScalarValue; use datafusion_expr::Operator; #[test] diff --git a/datafusion-physical-expr/src/expressions/cast.rs b/datafusion-physical-expr/src/expressions/cast.rs index c1c3fee514935..1b157e36d1899 100644 --- a/datafusion-physical-expr/src/expressions/cast.rs +++ b/datafusion-physical-expr/src/expressions/cast.rs @@ -19,16 +19,16 @@ use std::any::Any; use std::fmt; use std::sync::Arc; -use super::ColumnarValue; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::PhysicalExpr; -use crate::scalar::ScalarValue; +use crate::PhysicalExpr; use arrow::compute; use arrow::compute::kernels; use arrow::compute::CastOptions; use arrow::datatypes::{DataType, Schema}; use arrow::record_batch::RecordBatch; use compute::can_cast_types; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; /// provide Datafusion default cast options pub const DEFAULT_DATAFUSION_CAST_OPTIONS: CastOptions = CastOptions { safe: false }; @@ -158,9 +158,7 @@ pub fn cast( #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; + use crate::expressions::col; use arrow::{ array::{ Array, DecimalArray, DecimalBuilder, Float32Array, Float64Array, Int16Array, @@ -169,6 +167,7 @@ mod tests { }, datatypes::*, }; + use datafusion_common::Result; // runs an end-to-end test of physical type cast // 1. construct a record batch with a column "a" of type A @@ -621,7 +620,7 @@ mod tests { fn invalid_cast_with_options_error() -> Result<()> { // Ensure a useful error happens at plan time if invalid casts are used let schema = Schema::new(vec![Field::new("a", DataType::Utf8, false)]); - let a = StringArray::from_slice(&["9.1"]); + let a = StringArray::from(vec!["9.1"]); let batch = RecordBatch::try_new(Arc::new(schema.clone()), vec![Arc::new(a)])?; let expression = cast_with_options( col("a", &schema)?, diff --git a/datafusion-physical-expr/src/expressions/column.rs b/datafusion-physical-expr/src/expressions/column.rs index d6eafbb05384a..3def89f785016 100644 --- a/datafusion-physical-expr/src/expressions/column.rs +++ b/datafusion-physical-expr/src/expressions/column.rs @@ -24,8 +24,9 @@ use arrow::{ record_batch::RecordBatch, }; -use crate::error::Result; -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; +use crate::PhysicalExpr; +use datafusion_common::Result; +use datafusion_expr::ColumnarValue; /// Represents the column at a given index in a RecordBatch #[derive(Debug, Hash, PartialEq, Eq, Clone)] diff --git a/datafusion-physical-expr/src/expressions/correlation.rs b/datafusion-physical-expr/src/expressions/correlation.rs index 598e0314a4902..3f7b28a902995 100644 --- a/datafusion-physical-expr/src/expressions/correlation.rs +++ b/datafusion-physical-expr/src/expressions/correlation.rs @@ -17,16 +17,16 @@ //! Defines physical expressions that can evaluated at runtime during query execution -use std::any::Any; -use std::sync::Arc; - -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{ +use crate::{ expressions::{covariance::CovarianceAccumulator, stddev::StddevAccumulator}, - Accumulator, AggregateExpr, PhysicalExpr, + AggregateExpr, PhysicalExpr, }; -use crate::scalar::ScalarValue; use arrow::{array::ArrayRef, datatypes::DataType, datatypes::Field}; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; +use std::any::Any; +use std::sync::Arc; use super::{format_state_name, StatsType}; @@ -39,7 +39,7 @@ pub struct Correlation { } /// function return type of correlation -pub(crate) fn correlation_return_type(arg_type: &DataType) -> Result { +pub fn correlation_return_type(arg_type: &DataType) -> Result { match arg_type { DataType::Int8 | DataType::Int16 @@ -58,7 +58,7 @@ pub(crate) fn correlation_return_type(arg_type: &DataType) -> Result { } } -pub(crate) fn is_correlation_support_arg_type(arg_type: &DataType) -> bool { +pub fn is_correlation_support_arg_type(arg_type: &DataType) -> bool { matches!( arg_type, DataType::UInt8 @@ -228,16 +228,16 @@ impl Accumulator for CorrelationAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::{error::Result, generic_test_op2}; + use crate::expressions::col; + use crate::generic_test_op2; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; #[test] fn correlation_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 7_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 7_f64])); generic_test_op2!( a, @@ -252,8 +252,8 @@ mod tests { #[test] fn correlation_f64_2() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, -5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, -5_f64, 6_f64])); generic_test_op2!( a, @@ -268,8 +268,8 @@ mod tests { #[test] fn correlation_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4.1_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from(vec![4.1_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -304,8 +304,8 @@ mod tests { #[test] fn correlation_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3])); - let b: ArrayRef = Arc::new(Int32Array::from_slice(&[4, 5, 6])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3])); + let b: ArrayRef = Arc::new(Int32Array::from(vec![4, 5, 6])); generic_test_op2!( a, @@ -320,8 +320,8 @@ mod tests { #[test] fn correlation_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[1_u32, 2_u32, 3_u32])); - let b: ArrayRef = Arc::new(UInt32Array::from_slice(&[4_u32, 5_u32, 6_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32])); + let b: ArrayRef = Arc::new(UInt32Array::from(vec![4_u32, 5_u32, 6_u32])); generic_test_op2!( a, b, @@ -335,8 +335,8 @@ mod tests { #[test] fn correlation_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[1_f32, 2_f32, 3_f32])); - let b: ArrayRef = Arc::new(Float32Array::from_slice(&[4_f32, 5_f32, 6_f32])); + let a: ArrayRef = Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32])); + let b: ArrayRef = Arc::new(Float32Array::from(vec![4_f32, 5_f32, 6_f32])); generic_test_op2!( a, b, @@ -425,10 +425,10 @@ mod tests { #[test] fn correlation_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); - let c = Arc::new(Float64Array::from_slice(&[1.1_f64, 2.2_f64, 3.3_f64])); - let d = Arc::new(Float64Array::from_slice(&[4.4_f64, 5.5_f64, 9.9_f64])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); + let c = Arc::new(Float64Array::from(vec![1.1_f64, 2.2_f64, 3.3_f64])); + let d = Arc::new(Float64Array::from(vec![4.4_f64, 5.5_f64, 9.9_f64])); let schema = Schema::new(vec![ Field::new("a", DataType::Float64, false), @@ -460,8 +460,8 @@ mod tests { #[test] fn correlation_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); let c = Arc::new(Float64Array::from(vec![None])); let d = Arc::new(Float64Array::from(vec![None])); diff --git a/datafusion-physical-expr/src/expressions/count.rs b/datafusion-physical-expr/src/expressions/count.rs index 830cbf3d09d32..ccc5a8ebdaf69 100644 --- a/datafusion-physical-expr/src/expressions/count.rs +++ b/datafusion-physical-expr/src/expressions/count.rs @@ -20,15 +20,16 @@ use std::any::Any; use std::sync::Arc; -use crate::error::Result; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::{AggregateExpr, PhysicalExpr}; use arrow::compute; use arrow::datatypes::DataType; use arrow::{ array::{ArrayRef, UInt64Array}, datatypes::Field, }; +use datafusion_common::Result; +use datafusion_common::ScalarValue; +use datafusion_expr::Accumulator; use super::format_state_name; @@ -133,16 +134,16 @@ impl Accumulator for CountAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::physical_plan::expressions::tests::aggregate; - use crate::{error::Result, generic_test_op}; + use crate::expressions::col; + use crate::expressions::tests::aggregate; + use crate::generic_test_op; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; #[test] fn count_elements() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -201,7 +202,7 @@ mod tests { #[test] fn count_utf8() -> Result<()> { let a: ArrayRef = - Arc::new(StringArray::from_slice(&["a", "bb", "ccc", "dddd", "ad"])); + Arc::new(StringArray::from(vec!["a", "bb", "ccc", "dddd", "ad"])); generic_test_op!( a, DataType::Utf8, @@ -213,9 +214,8 @@ mod tests { #[test] fn count_large_utf8() -> Result<()> { - let a: ArrayRef = Arc::new(LargeStringArray::from_slice(&[ - "a", "bb", "ccc", "dddd", "ad", - ])); + let a: ArrayRef = + Arc::new(LargeStringArray::from(vec!["a", "bb", "ccc", "dddd", "ad"])); generic_test_op!( a, DataType::LargeUtf8, diff --git a/datafusion-physical-expr/src/expressions/covariance.rs b/datafusion-physical-expr/src/expressions/covariance.rs index f26406222c5d5..539a869be9efe 100644 --- a/datafusion-physical-expr/src/expressions/covariance.rs +++ b/datafusion-physical-expr/src/expressions/covariance.rs @@ -20,9 +20,7 @@ use std::any::Any; use std::sync::Arc; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::{AggregateExpr, PhysicalExpr}; use arrow::array::Float64Array; use arrow::{ array::{ArrayRef, UInt64Array}, @@ -30,6 +28,9 @@ use arrow::{ datatypes::DataType, datatypes::Field, }; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; use super::{format_state_name, StatsType}; @@ -50,7 +51,7 @@ pub struct CovariancePop { } /// function return type of covariance -pub(crate) fn covariance_return_type(arg_type: &DataType) -> Result { +pub fn covariance_return_type(arg_type: &DataType) -> Result { match arg_type { DataType::Int8 | DataType::Int16 @@ -69,7 +70,7 @@ pub(crate) fn covariance_return_type(arg_type: &DataType) -> Result { } } -pub(crate) fn is_covariance_support_arg_type(arg_type: &DataType) -> bool { +pub fn is_covariance_support_arg_type(arg_type: &DataType) -> bool { matches!( arg_type, DataType::UInt8 @@ -386,16 +387,16 @@ impl Accumulator for CovarianceAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::{error::Result, generic_test_op2}; + use crate::expressions::col; + use crate::generic_test_op2; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; #[test] fn covariance_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -410,8 +411,8 @@ mod tests { #[test] fn covariance_f64_2() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -426,8 +427,8 @@ mod tests { #[test] fn covariance_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4.1_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from(vec![4.1_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -442,8 +443,8 @@ mod tests { #[test] fn covariance_f64_5() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); - let b: ArrayRef = Arc::new(Float64Array::from_slice(&[4.1_f64, 5_f64, 6_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); + let b: ArrayRef = Arc::new(Float64Array::from(vec![4.1_f64, 5_f64, 6_f64])); generic_test_op2!( a, @@ -478,8 +479,8 @@ mod tests { #[test] fn covariance_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3])); - let b: ArrayRef = Arc::new(Int32Array::from_slice(&[4, 5, 6])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3])); + let b: ArrayRef = Arc::new(Int32Array::from(vec![4, 5, 6])); generic_test_op2!( a, @@ -494,8 +495,8 @@ mod tests { #[test] fn covariance_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[1_u32, 2_u32, 3_u32])); - let b: ArrayRef = Arc::new(UInt32Array::from_slice(&[4_u32, 5_u32, 6_u32])); + let a: ArrayRef = Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32])); + let b: ArrayRef = Arc::new(UInt32Array::from(vec![4_u32, 5_u32, 6_u32])); generic_test_op2!( a, b, @@ -509,8 +510,8 @@ mod tests { #[test] fn covariance_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[1_f32, 2_f32, 3_f32])); - let b: ArrayRef = Arc::new(Float32Array::from_slice(&[4_f32, 5_f32, 6_f32])); + let a: ArrayRef = Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32])); + let b: ArrayRef = Arc::new(Float32Array::from(vec![4_f32, 5_f32, 6_f32])); generic_test_op2!( a, b, @@ -597,10 +598,10 @@ mod tests { #[test] fn covariance_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); - let c = Arc::new(Float64Array::from_slice(&[1.1_f64, 2.2_f64, 3.3_f64])); - let d = Arc::new(Float64Array::from_slice(&[4.4_f64, 5.5_f64, 6.6_f64])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); + let c = Arc::new(Float64Array::from(vec![1.1_f64, 2.2_f64, 3.3_f64])); + let d = Arc::new(Float64Array::from(vec![4.4_f64, 5.5_f64, 6.6_f64])); let schema = Schema::new(vec![ Field::new("a", DataType::Float64, false), @@ -632,8 +633,8 @@ mod tests { #[test] fn covariance_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64, 6_f64])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64, 6_f64])); let c = Arc::new(Float64Array::from(vec![None])); let d = Arc::new(Float64Array::from(vec![None])); diff --git a/datafusion-physical-expr/src/expressions/cume_dist.rs b/datafusion-physical-expr/src/expressions/cume_dist.rs index fd2ce20e231c7..7376f37b9b5fe 100644 --- a/datafusion-physical-expr/src/expressions/cume_dist.rs +++ b/datafusion-physical-expr/src/expressions/cume_dist.rs @@ -18,14 +18,14 @@ //! Defines physical expression for `cume_dist` that can evaluated //! at runtime during query execution -use crate::error::Result; -use crate::physical_plan::PhysicalExpr; use crate::window::BuiltInWindowFunctionExpr; use crate::window::PartitionEvaluator; +use crate::PhysicalExpr; use arrow::array::ArrayRef; use arrow::array::Float64Array; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; +use datafusion_common::Result; use std::any::Any; use std::iter; use std::ops::Range; diff --git a/datafusion-physical-expr/src/expressions/distinct_expressions.rs b/datafusion-physical-expr/src/expressions/distinct_expressions.rs index bdbd82d1b0260..c249ca8d74ee3 100644 --- a/datafusion-physical-expr/src/expressions/distinct_expressions.rs +++ b/datafusion-physical-expr/src/expressions/distinct_expressions.rs @@ -27,9 +27,10 @@ use ahash::RandomState; use arrow::array::{Array, ArrayRef}; use std::collections::HashSet; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::{AggregateExpr, PhysicalExpr}; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; #[derive(Debug, PartialEq, Eq, Hash, Clone)] struct DistinctScalarValues(Vec); @@ -362,10 +363,8 @@ impl Accumulator for DistinctArrayAggAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::physical_plan::expressions::tests::aggregate; - + use crate::expressions::col; + use crate::expressions::tests::aggregate; use arrow::array::{ ArrayRef, BooleanArray, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array, Int8Array, ListArray, UInt16Array, UInt32Array, UInt64Array, @@ -680,12 +679,11 @@ mod tests { let zero_count_values = BooleanArray::from(Vec::::new()); - let one_count_values = BooleanArray::from_slice(&[false, false]); + let one_count_values = BooleanArray::from(vec![false, false]); let one_count_values_with_null = BooleanArray::from(vec![Some(true), Some(true), None, None]); - let two_count_values = - BooleanArray::from_slice(&[true, false, true, false, true]); + let two_count_values = BooleanArray::from(vec![true, false, true, false, true]); let two_count_values_with_null = BooleanArray::from(vec![ Some(true), Some(false), @@ -732,7 +730,7 @@ mod tests { #[test] fn count_distinct_update_batch_empty() -> Result<()> { - let arrays = vec![Arc::new(Int32Array::from_slice(&[])) as ArrayRef]; + let arrays = vec![Arc::new(Int32Array::from(vec![0_i32; 0])) as ArrayRef]; let (states, result) = run_update_batch(&arrays)?; @@ -745,8 +743,8 @@ mod tests { #[test] fn count_distinct_update_batch_multiple_columns() -> Result<()> { - let array_int8: ArrayRef = Arc::new(Int8Array::from_slice(&[1, 1, 2])); - let array_int16: ArrayRef = Arc::new(Int16Array::from_slice(&[3, 3, 4])); + let array_int8: ArrayRef = Arc::new(Int8Array::from(vec![1, 1, 2])); + let array_int16: ArrayRef = Arc::new(Int16Array::from(vec![3, 3, 4])); let arrays = vec![array_int8, array_int16]; let (states, result) = run_update_batch(&arrays)?; diff --git a/datafusion-physical-expr/src/expressions/get_indexed_field.rs b/datafusion-physical-expr/src/expressions/get_indexed_field.rs index 7e60698aa3112..26a5cf2034a04 100644 --- a/datafusion-physical-expr/src/expressions/get_indexed_field.rs +++ b/datafusion-physical-expr/src/expressions/get_indexed_field.rs @@ -17,25 +17,21 @@ //! get field of a `ListArray` -use std::convert::TryInto; -use std::{any::Any, sync::Arc}; - +use crate::{field_util::get_indexed_field as get_data_type_field, PhysicalExpr}; +use arrow::array::Array; +use arrow::array::{ListArray, StructArray}; +use arrow::compute::concat; use arrow::{ datatypes::{DataType, Schema}, record_batch::RecordBatch, }; - -use crate::arrow::array::Array; -use crate::arrow::compute::concat; -use crate::scalar::ScalarValue; -use crate::{ - error::DataFusionError, - error::Result, - field_util::get_indexed_field as get_data_type_field, - physical_plan::{ColumnarValue, PhysicalExpr}, -}; -use arrow::array::{ListArray, StructArray}; +use datafusion_common::DataFusionError; +use datafusion_common::Result; +use datafusion_common::ScalarValue; +use datafusion_expr::ColumnarValue; +use std::convert::TryInto; use std::fmt::Debug; +use std::{any::Any, sync::Arc}; /// expression to get a field of a struct array. #[derive(Debug)] @@ -119,13 +115,13 @@ impl PhysicalExpr for GetIndexedFieldExpr { #[cfg(test)] mod tests { use super::*; - use crate::arrow::array::GenericListArray; - use crate::error::Result; - use crate::physical_plan::expressions::{col, lit}; + use crate::expressions::{col, lit}; + use arrow::array::GenericListArray; use arrow::array::{ Int64Array, Int64Builder, ListBuilder, StringBuilder, StructArray, StructBuilder, }; use arrow::{array::StringArray, datatypes::Field}; + use datafusion_common::Result; fn build_utf8_lists(list_of_lists: Vec>>) -> GenericListArray { let builder = StringBuilder::new(list_of_lists.len()); diff --git a/datafusion-physical-expr/src/expressions/in_list.rs b/datafusion-physical-expr/src/expressions/in_list.rs index 826ffa87ae835..2aee0d87dbde3 100644 --- a/datafusion-physical-expr/src/expressions/in_list.rs +++ b/datafusion-physical-expr/src/expressions/in_list.rs @@ -32,11 +32,12 @@ use arrow::{ record_batch::RecordBatch, }; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::PhysicalExpr; use arrow::array::*; use arrow::buffer::{Buffer, MutableBuffer}; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; macro_rules! compare_op_scalar { ($left: expr, $right:expr, $op:expr) => {{ @@ -472,8 +473,8 @@ mod tests { use arrow::{array::StringArray, datatypes::Field}; use super::*; - use crate::error::Result; - use crate::physical_plan::expressions::{col, lit}; + use crate::expressions::{col, lit}; + use datafusion_common::Result; // applies the in_list expr to an input batch and list macro_rules! in_list { diff --git a/datafusion-physical-expr/src/expressions/is_not_null.rs b/datafusion-physical-expr/src/expressions/is_not_null.rs index da4fc9a9b1a5e..6b614f3d98ca1 100644 --- a/datafusion-physical-expr/src/expressions/is_not_null.rs +++ b/datafusion-physical-expr/src/expressions/is_not_null.rs @@ -19,14 +19,15 @@ use std::{any::Any, sync::Arc}; +use crate::PhysicalExpr; use arrow::compute; use arrow::{ datatypes::{DataType, Schema}, record_batch::RecordBatch, }; - -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; -use crate::{error::Result, scalar::ScalarValue}; +use datafusion_common::Result; +use datafusion_common::ScalarValue; +use datafusion_expr::ColumnarValue; /// IS NOT NULL expression #[derive(Debug)] @@ -88,8 +89,7 @@ pub fn is_not_null(arg: Arc) -> Result> #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; + use crate::expressions::col; use arrow::{ array::{BooleanArray, StringArray}, datatypes::*, @@ -111,7 +111,7 @@ mod tests { .downcast_ref::() .expect("failed to downcast to BooleanArray"); - let expected = &BooleanArray::from_slice(&[true, false]); + let expected = &BooleanArray::from(vec![true, false]); assert_eq!(expected, result); diff --git a/datafusion-physical-expr/src/expressions/is_null.rs b/datafusion-physical-expr/src/expressions/is_null.rs index 15a04a7c9fc71..e5dbfbdc74819 100644 --- a/datafusion-physical-expr/src/expressions/is_null.rs +++ b/datafusion-physical-expr/src/expressions/is_null.rs @@ -25,8 +25,10 @@ use arrow::{ record_batch::RecordBatch, }; -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; -use crate::{error::Result, scalar::ScalarValue}; +use crate::PhysicalExpr; +use datafusion_common::Result; +use datafusion_common::ScalarValue; +use datafusion_expr::ColumnarValue; /// IS NULL expression #[derive(Debug)] @@ -88,8 +90,7 @@ pub fn is_null(arg: Arc) -> Result> { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; + use crate::expressions::col; use arrow::{ array::{BooleanArray, StringArray}, datatypes::*, @@ -112,7 +113,7 @@ mod tests { .downcast_ref::() .expect("failed to downcast to BooleanArray"); - let expected = &BooleanArray::from_slice(&[false, true]); + let expected = &BooleanArray::from(vec![false, true]); assert_eq!(expected, result); diff --git a/datafusion-physical-expr/src/expressions/lead_lag.rs b/datafusion-physical-expr/src/expressions/lead_lag.rs index b9180e3baaef4..333810711b7fc 100644 --- a/datafusion-physical-expr/src/expressions/lead_lag.rs +++ b/datafusion-physical-expr/src/expressions/lead_lag.rs @@ -18,15 +18,15 @@ //! Defines physical expression for `lead` and `lag` that can evaluated //! at runtime during query execution -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::PhysicalExpr; -use crate::scalar::ScalarValue; use crate::window::BuiltInWindowFunctionExpr; use crate::window::PartitionEvaluator; +use crate::PhysicalExpr; use arrow::array::ArrayRef; use arrow::compute::cast; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; use std::any::Any; use std::ops::Neg; use std::ops::Range; @@ -179,15 +179,13 @@ impl PartitionEvaluator for WindowShiftEvaluator { #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::Column; + use crate::expressions::Column; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; fn test_i32_result(expr: WindowShift, expected: Int32Array) -> Result<()> { - let arr: ArrayRef = - Arc::new(Int32Array::from_slice(&[1, -2, 3, -4, 5, -6, 7, 8])); + let arr: ArrayRef = Arc::new(Int32Array::from(vec![1, -2, 3, -4, 5, -6, 7, 8])); let values = vec![arr]; let schema = Schema::new(vec![Field::new("arr", DataType::Int32, false)]); let batch = RecordBatch::try_new(Arc::new(schema), values.clone())?; diff --git a/datafusion-physical-expr/src/expressions/literal.rs b/datafusion-physical-expr/src/expressions/literal.rs index 3110d39c87e0b..6fff67e0e2840 100644 --- a/datafusion-physical-expr/src/expressions/literal.rs +++ b/datafusion-physical-expr/src/expressions/literal.rs @@ -25,8 +25,10 @@ use arrow::{ record_batch::RecordBatch, }; -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; -use crate::{error::Result, scalar::ScalarValue}; +use crate::PhysicalExpr; +use datafusion_common::Result; +use datafusion_common::ScalarValue; +use datafusion_expr::ColumnarValue; /// Represents a literal value #[derive(Debug)] @@ -79,9 +81,9 @@ pub fn lit(value: ScalarValue) -> Arc { #[cfg(test)] mod tests { use super::*; - use crate::error::Result; use arrow::array::Int32Array; use arrow::datatypes::*; + use datafusion_common::Result; #[test] fn literal_i32() -> Result<()> { diff --git a/datafusion-physical-expr/src/expressions/min_max.rs b/datafusion-physical-expr/src/expressions/min_max.rs index 125f2cbc0dc68..be3ea95004c6f 100644 --- a/datafusion-physical-expr/src/expressions/min_max.rs +++ b/datafusion-physical-expr/src/expressions/min_max.rs @@ -21,9 +21,7 @@ use std::any::Any; use std::convert::TryFrom; use std::sync::Arc; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::{AggregateExpr, PhysicalExpr}; use arrow::compute; use arrow::datatypes::{DataType, TimeUnit}; use arrow::{ @@ -35,9 +33,12 @@ use arrow::{ }, datatypes::Field, }; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; use super::format_state_name; -use crate::arrow::array::Array; +use arrow::array::Array; use arrow::array::DecimalArray; // Min/max aggregation can take Dictionary encode input but always produces unpacked @@ -419,7 +420,7 @@ pub fn max(lhs: &ScalarValue, rhs: &ScalarValue) -> Result { /// An accumulator to compute the maximum value #[derive(Debug)] -pub(crate) struct MaxAccumulator { +pub struct MaxAccumulator { max: ScalarValue, } @@ -515,7 +516,7 @@ impl AggregateExpr for Min { /// An accumulator to compute the minimum value #[derive(Debug)] -pub(crate) struct MinAccumulator { +pub struct MinAccumulator { min: ScalarValue, } @@ -552,14 +553,15 @@ impl Accumulator for MinAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::physical_plan::expressions::tests::aggregate; - use crate::scalar::ScalarValue::Decimal128; - use crate::{error::Result, generic_test_op}; + use crate::expressions::col; + use crate::expressions::tests::aggregate; + use crate::generic_test_op; use arrow::array::DecimalBuilder; use arrow::datatypes::*; use arrow::record_batch::RecordBatch; + use datafusion_common::Result; + use datafusion_common::ScalarValue; + use datafusion_common::ScalarValue::Decimal128; #[test] fn min_decimal() -> Result<()> { @@ -731,7 +733,7 @@ mod tests { #[test] fn max_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -743,7 +745,7 @@ mod tests { #[test] fn min_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -755,7 +757,7 @@ mod tests { #[test] fn max_utf8() -> Result<()> { - let a: ArrayRef = Arc::new(StringArray::from_slice(&["d", "a", "c", "b"])); + let a: ArrayRef = Arc::new(StringArray::from(vec!["d", "a", "c", "b"])); generic_test_op!( a, DataType::Utf8, @@ -767,7 +769,7 @@ mod tests { #[test] fn max_large_utf8() -> Result<()> { - let a: ArrayRef = Arc::new(LargeStringArray::from_slice(&["d", "a", "c", "b"])); + let a: ArrayRef = Arc::new(LargeStringArray::from(vec!["d", "a", "c", "b"])); generic_test_op!( a, DataType::LargeUtf8, @@ -779,7 +781,7 @@ mod tests { #[test] fn min_utf8() -> Result<()> { - let a: ArrayRef = Arc::new(StringArray::from_slice(&["d", "a", "c", "b"])); + let a: ArrayRef = Arc::new(StringArray::from(vec!["d", "a", "c", "b"])); generic_test_op!( a, DataType::Utf8, @@ -791,7 +793,7 @@ mod tests { #[test] fn min_large_utf8() -> Result<()> { - let a: ArrayRef = Arc::new(LargeStringArray::from_slice(&["d", "a", "c", "b"])); + let a: ArrayRef = Arc::new(LargeStringArray::from(vec!["d", "a", "c", "b"])); generic_test_op!( a, DataType::LargeUtf8, @@ -863,9 +865,8 @@ mod tests { #[test] fn max_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ - 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, - ])); + let a: ArrayRef = + Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); generic_test_op!( a, DataType::UInt32, @@ -877,9 +878,8 @@ mod tests { #[test] fn min_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ - 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, - ])); + let a: ArrayRef = + Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); generic_test_op!( a, DataType::UInt32, @@ -891,9 +891,8 @@ mod tests { #[test] fn max_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ - 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, - ])); + let a: ArrayRef = + Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); generic_test_op!( a, DataType::Float32, @@ -905,9 +904,8 @@ mod tests { #[test] fn min_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ - 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, - ])); + let a: ArrayRef = + Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); generic_test_op!( a, DataType::Float32, @@ -919,9 +917,8 @@ mod tests { #[test] fn max_f64() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a: ArrayRef = + Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); generic_test_op!( a, DataType::Float64, @@ -933,9 +930,8 @@ mod tests { #[test] fn min_f64() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a: ArrayRef = + Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); generic_test_op!( a, DataType::Float64, @@ -947,7 +943,7 @@ mod tests { #[test] fn min_date32() -> Result<()> { - let a: ArrayRef = Arc::new(Date32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date32, @@ -959,7 +955,7 @@ mod tests { #[test] fn min_date64() -> Result<()> { - let a: ArrayRef = Arc::new(Date64Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date64Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date64, @@ -971,7 +967,7 @@ mod tests { #[test] fn max_date32() -> Result<()> { - let a: ArrayRef = Arc::new(Date32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date32, @@ -983,7 +979,7 @@ mod tests { #[test] fn max_date64() -> Result<()> { - let a: ArrayRef = Arc::new(Date64Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Date64Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Date64, diff --git a/datafusion-physical-expr/src/expressions/mod.rs b/datafusion-physical-expr/src/expressions/mod.rs index ff9f019b34d27..dd0b01129e8e6 100644 --- a/datafusion-physical-expr/src/expressions/mod.rs +++ b/datafusion-physical-expr/src/expressions/mod.rs @@ -17,8 +17,6 @@ //! Defines physical expressions that can evaluated at runtime during query execution -use datafusion_expr::ColumnarValue; - mod approx_distinct; mod approx_percentile_cont; mod array_agg; @@ -60,12 +58,12 @@ pub mod helpers { } pub use approx_distinct::ApproxDistinct; -pub(crate) use approx_median::ApproxMedian; +pub use approx_median::ApproxMedian; pub use approx_percentile_cont::{ is_approx_percentile_cont_supported_arg_type, ApproxPercentileCont, }; pub use array_agg::ArrayAgg; -pub(crate) use average::is_avg_support_arg_type; +pub use average::is_avg_support_arg_type; pub use average::{avg_return_type, Avg, AvgAccumulator}; pub use binary::{binary, binary_operator_data_type, BinaryExpr}; pub use case::{case, CaseExpr}; @@ -73,14 +71,15 @@ pub use cast::{ cast, cast_column, cast_with_options, CastExpr, DEFAULT_DATAFUSION_CAST_OPTIONS, }; pub use column::{col, Column}; -pub(crate) use correlation::{ +pub use correlation::{ correlation_return_type, is_correlation_support_arg_type, Correlation, }; pub use count::Count; -pub(crate) use covariance::{ +pub use covariance::{ covariance_return_type, is_covariance_support_arg_type, Covariance, CovariancePop, }; pub use cume_dist::cume_dist; + pub use distinct_expressions::{DistinctArrayAgg, DistinctCount}; pub use get_indexed_field::GetIndexedFieldExpr; pub use in_list::{in_list, InListExpr}; @@ -89,7 +88,7 @@ pub use is_null::{is_null, IsNullExpr}; pub use lead_lag::{lag, lead}; pub use literal::{lit, Literal}; pub use min_max::{Max, Min}; -pub(crate) use min_max::{MaxAccumulator, MinAccumulator}; +pub use min_max::{MaxAccumulator, MinAccumulator}; pub use negative::{negative, NegativeExpr}; pub use not::{not, NotExpr}; pub use nth_value::NthValue; @@ -97,13 +96,11 @@ pub use nullif::{nullif_func, SUPPORTED_NULLIF_TYPES}; pub use rank::{dense_rank, percent_rank, rank}; pub use row_number::RowNumber; pub use stats::StatsType; -pub(crate) use stddev::{ - is_stddev_support_arg_type, stddev_return_type, Stddev, StddevPop, -}; -pub(crate) use sum::is_sum_support_arg_type; +pub use stddev::{is_stddev_support_arg_type, stddev_return_type, Stddev, StddevPop}; +pub use sum::is_sum_support_arg_type; pub use sum::{sum_return_type, Sum}; pub use try_cast::{try_cast, TryCastExpr}; -pub(crate) use variance::{ +pub use variance::{ is_variance_support_arg_type, variance_return_type, Variance, VariancePop, }; @@ -111,13 +108,14 @@ pub(crate) use variance::{ pub fn format_state_name(name: &str, state_name: &str) -> String { format!("{}[{}]", name, state_name) } - pub use crate::PhysicalSortExpr; #[cfg(test)] mod tests { - use crate::{error::Result, physical_plan::AggregateExpr, scalar::ScalarValue}; + use crate::AggregateExpr; use arrow::record_batch::RecordBatch; + use datafusion_common::Result; + use datafusion_common::ScalarValue; use std::sync::Arc; /// macro to perform an aggregation and verify the result. diff --git a/datafusion-physical-expr/src/expressions/negative.rs b/datafusion-physical-expr/src/expressions/negative.rs index 1877cb584ea19..4974bdb329206 100644 --- a/datafusion-physical-expr/src/expressions/negative.rs +++ b/datafusion-physical-expr/src/expressions/negative.rs @@ -28,9 +28,10 @@ use arrow::{ record_batch::RecordBatch, }; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::coercion_rule::binary_rule::is_signed_numeric; -use crate::physical_plan::{ColumnarValue, PhysicalExpr}; +use crate::coercion_rule::binary_rule::is_signed_numeric; +use crate::PhysicalExpr; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; /// Invoke a compute kernel on array(s) macro_rules! compute_op { diff --git a/datafusion-physical-expr/src/expressions/not.rs b/datafusion-physical-expr/src/expressions/not.rs index d94e78fb8d824..fd0fbd1c65d26 100644 --- a/datafusion-physical-expr/src/expressions/not.rs +++ b/datafusion-physical-expr/src/expressions/not.rs @@ -21,13 +21,13 @@ use std::any::Any; use std::fmt; use std::sync::Arc; -use super::ColumnarValue; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::PhysicalExpr; -use crate::scalar::ScalarValue; +use crate::PhysicalExpr; use arrow::array::BooleanArray; use arrow::datatypes::{DataType, Schema}; use arrow::record_batch::RecordBatch; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; /// Not expression #[derive(Debug)] @@ -118,9 +118,9 @@ pub fn not( #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::physical_plan::expressions::col; + use crate::expressions::col; use arrow::datatypes::*; + use datafusion_common::Result; #[test] fn neg_op() -> Result<()> { diff --git a/datafusion-physical-expr/src/expressions/nth_value.rs b/datafusion-physical-expr/src/expressions/nth_value.rs index 52cc4db2a0168..21df07aa0fa74 100644 --- a/datafusion-physical-expr/src/expressions/nth_value.rs +++ b/datafusion-physical-expr/src/expressions/nth_value.rs @@ -18,15 +18,15 @@ //! Defines physical expressions for `first_value`, `last_value`, and `nth_value` //! that can evaluated at runtime during query execution -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::PhysicalExpr; -use crate::scalar::ScalarValue; use crate::window::BuiltInWindowFunctionExpr; use crate::window::PartitionEvaluator; +use crate::PhysicalExpr; use arrow::array::{new_null_array, ArrayRef}; use arrow::compute::kernels::window::shift; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; use std::any::Any; use std::iter; use std::ops::Range; @@ -198,15 +198,13 @@ impl PartitionEvaluator for NthValueEvaluator { #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::Column; + use crate::expressions::Column; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; fn test_i32_result(expr: NthValue, expected: Int32Array) -> Result<()> { - let arr: ArrayRef = - Arc::new(Int32Array::from_slice(&[1, -2, 3, -4, 5, -6, 7, 8])); + let arr: ArrayRef = Arc::new(Int32Array::from(vec![1, -2, 3, -4, 5, -6, 7, 8])); let values = vec![arr]; let schema = Schema::new(vec![Field::new("arr", DataType::Int32, false)]); let batch = RecordBatch::try_new(Arc::new(schema), values.clone())?; diff --git a/datafusion-physical-expr/src/expressions/nullif.rs b/datafusion-physical-expr/src/expressions/nullif.rs index 7b121bfd74af4..a078e2228ea64 100644 --- a/datafusion-physical-expr/src/expressions/nullif.rs +++ b/datafusion-physical-expr/src/expressions/nullif.rs @@ -17,10 +17,7 @@ use std::sync::Arc; -use super::ColumnarValue; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::expressions::binary::{eq_decimal, eq_decimal_scalar}; -use crate::scalar::ScalarValue; +use crate::expressions::binary::{eq_decimal, eq_decimal_scalar}; use arrow::array::Array; use arrow::array::*; use arrow::compute::kernels::boolean::nullif; @@ -28,6 +25,9 @@ use arrow::compute::kernels::comparison::{ eq, eq_bool, eq_bool_scalar, eq_scalar, eq_utf8, eq_utf8_scalar, }; use arrow::datatypes::{DataType, TimeUnit}; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; /// Invoke a compute kernel on a primitive array and a Boolean Array macro_rules! compute_bool_array_op { @@ -122,8 +122,7 @@ pub static SUPPORTED_NULLIF_TYPES: &[DataType] = &[ #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::from_slice::FromSlice; + use datafusion_common::Result; #[test] fn nullif_int32() -> Result<()> { @@ -163,7 +162,7 @@ mod tests { #[test] // Ensure that arrays with no nulls can also invoke NULLIF() correctly fn nullif_int32_nonulls() -> Result<()> { - let a = Int32Array::from_slice(&[1, 3, 10, 7, 8, 1, 2, 4, 5]); + let a = Int32Array::from(vec![1, 3, 10, 7, 8, 1, 2, 4, 5]); let a = ColumnarValue::Array(Arc::new(a)); let lit_array = ColumnarValue::Scalar(ScalarValue::Int32(Some(1i32))); diff --git a/datafusion-physical-expr/src/expressions/rank.rs b/datafusion-physical-expr/src/expressions/rank.rs index 04340f70b1548..f3f1143c83790 100644 --- a/datafusion-physical-expr/src/expressions/rank.rs +++ b/datafusion-physical-expr/src/expressions/rank.rs @@ -18,14 +18,14 @@ //! Defines physical expression for `rank`, `dense_rank`, and `percent_rank` that can evaluated //! at runtime during query execution -use crate::error::Result; -use crate::physical_plan::PhysicalExpr; use crate::window::BuiltInWindowFunctionExpr; use crate::window::PartitionEvaluator; +use crate::PhysicalExpr; use arrow::array::ArrayRef; use arrow::array::{Float64Array, UInt64Array}; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; +use datafusion_common::Result; use std::any::Any; use std::iter; use std::ops::Range; diff --git a/datafusion-physical-expr/src/expressions/row_number.rs b/datafusion-physical-expr/src/expressions/row_number.rs index 5d765235d6bfa..f9dccee5023ab 100644 --- a/datafusion-physical-expr/src/expressions/row_number.rs +++ b/datafusion-physical-expr/src/expressions/row_number.rs @@ -17,13 +17,13 @@ //! Defines physical expression for `row_number` that can evaluated at runtime during query execution -use crate::error::Result; -use crate::physical_plan::PhysicalExpr; use crate::window::BuiltInWindowFunctionExpr; use crate::window::PartitionEvaluator; +use crate::PhysicalExpr; use arrow::array::{ArrayRef, UInt64Array}; use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; +use datafusion_common::Result; use std::any::Any; use std::ops::Range; use std::sync::Arc; @@ -84,10 +84,9 @@ impl PartitionEvaluator for NumRowsEvaluator { #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::from_slice::FromSlice; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; #[test] fn row_number_all_null() -> Result<()> { @@ -107,7 +106,7 @@ mod tests { #[test] fn row_number_all_values() -> Result<()> { - let arr: ArrayRef = Arc::new(BooleanArray::from_slice(&[ + let arr: ArrayRef = Arc::new(BooleanArray::from(vec![ true, false, true, false, false, true, false, true, ])); let schema = Schema::new(vec![Field::new("arr", DataType::Boolean, false)]); diff --git a/datafusion-physical-expr/src/expressions/stddev.rs b/datafusion-physical-expr/src/expressions/stddev.rs index b9af721ade81f..8a5d4e8861660 100644 --- a/datafusion-physical-expr/src/expressions/stddev.rs +++ b/datafusion-physical-expr/src/expressions/stddev.rs @@ -20,12 +20,11 @@ use std::any::Any; use std::sync::Arc; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{ - expressions::variance::VarianceAccumulator, Accumulator, AggregateExpr, PhysicalExpr, -}; -use crate::scalar::ScalarValue; +use crate::{expressions::variance::VarianceAccumulator, AggregateExpr, PhysicalExpr}; use arrow::{array::ArrayRef, datatypes::DataType, datatypes::Field}; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; use super::{format_state_name, StatsType}; @@ -44,7 +43,7 @@ pub struct StddevPop { } /// function return type of standard deviation -pub(crate) fn stddev_return_type(arg_type: &DataType) -> Result { +pub fn stddev_return_type(arg_type: &DataType) -> Result { match arg_type { DataType::Int8 | DataType::Int16 @@ -63,7 +62,7 @@ pub(crate) fn stddev_return_type(arg_type: &DataType) -> Result { } } -pub(crate) fn is_stddev_support_arg_type(arg_type: &DataType) -> bool { +pub fn is_stddev_support_arg_type(arg_type: &DataType) -> bool { matches!( arg_type, DataType::UInt8 @@ -252,15 +251,15 @@ impl Accumulator for StddevAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::{error::Result, generic_test_op}; + use crate::expressions::col; + use crate::generic_test_op; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; #[test] fn stddev_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64])); generic_test_op!( a, DataType::Float64, @@ -272,7 +271,7 @@ mod tests { #[test] fn stddev_f64_2() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); generic_test_op!( a, DataType::Float64, @@ -284,9 +283,8 @@ mod tests { #[test] fn stddev_f64_3() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a: ArrayRef = + Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); generic_test_op!( a, DataType::Float64, @@ -298,7 +296,7 @@ mod tests { #[test] fn stddev_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); generic_test_op!( a, DataType::Float64, @@ -310,7 +308,7 @@ mod tests { #[test] fn stddev_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -322,9 +320,8 @@ mod tests { #[test] fn stddev_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ - 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, - ])); + let a: ArrayRef = + Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); generic_test_op!( a, DataType::UInt32, @@ -336,9 +333,8 @@ mod tests { #[test] fn stddev_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ - 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, - ])); + let a: ArrayRef = + Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); generic_test_op!( a, DataType::Float32, @@ -361,7 +357,7 @@ mod tests { #[test] fn test_stddev_1_input() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); let batch = RecordBatch::try_new(Arc::new(schema.clone()), vec![a])?; @@ -413,8 +409,8 @@ mod tests { #[test] fn stddev_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); @@ -441,9 +437,7 @@ mod tests { #[test] fn stddev_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); let b = Arc::new(Float64Array::from(vec![None])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); diff --git a/datafusion-physical-expr/src/expressions/sum.rs b/datafusion-physical-expr/src/expressions/sum.rs index e8f4420bd5ef6..f2c19f56e3352 100644 --- a/datafusion-physical-expr/src/expressions/sum.rs +++ b/datafusion-physical-expr/src/expressions/sum.rs @@ -21,9 +21,7 @@ use std::any::Any; use std::convert::TryFrom; use std::sync::Arc; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::{ScalarValue, MAX_PRECISION_FOR_DECIMAL128}; +use crate::{AggregateExpr, PhysicalExpr}; use arrow::compute; use arrow::datatypes::DataType; use arrow::{ @@ -33,9 +31,12 @@ use arrow::{ }, datatypes::Field, }; +use datafusion_common::{DataFusionError, Result}; +use datafusion_common::{ScalarValue, MAX_PRECISION_FOR_DECIMAL128}; +use datafusion_expr::Accumulator; use super::format_state_name; -use crate::arrow::array::Array; +use arrow::array::Array; use arrow::array::DecimalArray; /// SUM aggregate expression @@ -72,7 +73,7 @@ pub fn sum_return_type(arg_type: &DataType) -> Result { } } -pub(crate) fn is_sum_support_arg_type(arg_type: &DataType) -> bool { +pub fn is_sum_support_arg_type(arg_type: &DataType) -> bool { matches!( arg_type, DataType::UInt8 @@ -374,12 +375,12 @@ impl Accumulator for SumAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::arrow::array::DecimalBuilder; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::{error::Result, generic_test_op}; + use crate::expressions::col; + use crate::generic_test_op; + use arrow::array::DecimalBuilder; use arrow::datatypes::*; use arrow::record_batch::RecordBatch; + use datafusion_common::Result; #[test] fn test_sum_return_data_type() -> Result<()> { @@ -516,7 +517,7 @@ mod tests { #[test] fn sum_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -558,9 +559,8 @@ mod tests { #[test] fn sum_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ - 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, - ])); + let a: ArrayRef = + Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); generic_test_op!( a, DataType::UInt32, @@ -572,9 +572,8 @@ mod tests { #[test] fn sum_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ - 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, - ])); + let a: ArrayRef = + Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); generic_test_op!( a, DataType::Float32, @@ -586,9 +585,8 @@ mod tests { #[test] fn sum_f64() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a: ArrayRef = + Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); generic_test_op!( a, DataType::Float64, diff --git a/datafusion-physical-expr/src/expressions/try_cast.rs b/datafusion-physical-expr/src/expressions/try_cast.rs index 00060a90d7229..6b0d3e1b13847 100644 --- a/datafusion-physical-expr/src/expressions/try_cast.rs +++ b/datafusion-physical-expr/src/expressions/try_cast.rs @@ -19,15 +19,15 @@ use std::any::Any; use std::fmt; use std::sync::Arc; -use super::ColumnarValue; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::PhysicalExpr; -use crate::scalar::ScalarValue; +use crate::PhysicalExpr; use arrow::compute; use arrow::compute::kernels; use arrow::datatypes::{DataType, Schema}; use arrow::record_batch::RecordBatch; use compute::can_cast_types; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::ColumnarValue; /// TRY_CAST expression casts an expression to a specific data type and retuns NULL on invalid cast #[derive(Debug)] @@ -117,8 +117,7 @@ pub fn try_cast( #[cfg(test)] mod tests { use super::*; - use crate::error::Result; - use crate::physical_plan::expressions::col; + use crate::expressions::col; use arrow::array::{ DecimalArray, DecimalBuilder, StringArray, Time64NanosecondArray, }; @@ -129,6 +128,7 @@ mod tests { }, datatypes::*, }; + use datafusion_common::Result; // runs an end-to-end test of physical type cast // 1. construct a record batch with a column "a" of type A diff --git a/datafusion-physical-expr/src/expressions/variance.rs b/datafusion-physical-expr/src/expressions/variance.rs index 38ee3d7aad359..70f25ce53f900 100644 --- a/datafusion-physical-expr/src/expressions/variance.rs +++ b/datafusion-physical-expr/src/expressions/variance.rs @@ -20,9 +20,7 @@ use std::any::Any; use std::sync::Arc; -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::{Accumulator, AggregateExpr, PhysicalExpr}; -use crate::scalar::ScalarValue; +use crate::{AggregateExpr, PhysicalExpr}; use arrow::array::Float64Array; use arrow::{ array::{ArrayRef, UInt64Array}, @@ -30,6 +28,9 @@ use arrow::{ datatypes::DataType, datatypes::Field, }; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::Accumulator; use super::{format_state_name, StatsType}; @@ -48,7 +49,7 @@ pub struct VariancePop { } /// function return type of variance -pub(crate) fn variance_return_type(arg_type: &DataType) -> Result { +pub fn variance_return_type(arg_type: &DataType) -> Result { match arg_type { DataType::Int8 | DataType::Int16 @@ -67,7 +68,7 @@ pub(crate) fn variance_return_type(arg_type: &DataType) -> Result { } } -pub(crate) fn is_variance_support_arg_type(arg_type: &DataType) -> bool { +pub fn is_variance_support_arg_type(arg_type: &DataType) -> bool { matches!( arg_type, DataType::UInt8 @@ -331,15 +332,15 @@ impl Accumulator for VarianceAccumulator { #[cfg(test)] mod tests { use super::*; - use crate::from_slice::FromSlice; - use crate::physical_plan::expressions::col; - use crate::{error::Result, generic_test_op}; + use crate::expressions::col; + use crate::generic_test_op; use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; + use datafusion_common::Result; #[test] fn variance_f64_1() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64, 2_f64])); generic_test_op!( a, DataType::Float64, @@ -351,9 +352,8 @@ mod tests { #[test] fn variance_f64_2() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a: ArrayRef = + Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); generic_test_op!( a, DataType::Float64, @@ -365,9 +365,8 @@ mod tests { #[test] fn variance_f64_3() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a: ArrayRef = + Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); generic_test_op!( a, DataType::Float64, @@ -379,7 +378,7 @@ mod tests { #[test] fn variance_f64_4() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1.1_f64, 2_f64, 3_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1.1_f64, 2_f64, 3_f64])); generic_test_op!( a, DataType::Float64, @@ -391,7 +390,7 @@ mod tests { #[test] fn variance_i32() -> Result<()> { - let a: ArrayRef = Arc::new(Int32Array::from_slice(&[1, 2, 3, 4, 5])); + let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])); generic_test_op!( a, DataType::Int32, @@ -403,9 +402,8 @@ mod tests { #[test] fn variance_u32() -> Result<()> { - let a: ArrayRef = Arc::new(UInt32Array::from_slice(&[ - 1_u32, 2_u32, 3_u32, 4_u32, 5_u32, - ])); + let a: ArrayRef = + Arc::new(UInt32Array::from(vec![1_u32, 2_u32, 3_u32, 4_u32, 5_u32])); generic_test_op!( a, DataType::UInt32, @@ -417,9 +415,8 @@ mod tests { #[test] fn variance_f32() -> Result<()> { - let a: ArrayRef = Arc::new(Float32Array::from_slice(&[ - 1_f32, 2_f32, 3_f32, 4_f32, 5_f32, - ])); + let a: ArrayRef = + Arc::new(Float32Array::from(vec![1_f32, 2_f32, 3_f32, 4_f32, 5_f32])); generic_test_op!( a, DataType::Float32, @@ -442,7 +439,7 @@ mod tests { #[test] fn test_variance_1_input() -> Result<()> { - let a: ArrayRef = Arc::new(Float64Array::from_slice(&[1_f64])); + let a: ArrayRef = Arc::new(Float64Array::from(vec![1_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); let batch = RecordBatch::try_new(Arc::new(schema.clone()), vec![a])?; @@ -494,8 +491,8 @@ mod tests { #[test] fn variance_f64_merge_1() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[1_f64, 2_f64, 3_f64])); - let b = Arc::new(Float64Array::from_slice(&[4_f64, 5_f64])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64])); + let b = Arc::new(Float64Array::from(vec![4_f64, 5_f64])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); @@ -522,9 +519,7 @@ mod tests { #[test] fn variance_f64_merge_2() -> Result<()> { - let a = Arc::new(Float64Array::from_slice(&[ - 1_f64, 2_f64, 3_f64, 4_f64, 5_f64, - ])); + let a = Arc::new(Float64Array::from(vec![1_f64, 2_f64, 3_f64, 4_f64, 5_f64])); let b = Arc::new(Float64Array::from(vec![None])); let schema = Schema::new(vec![Field::new("a", DataType::Float64, false)]); diff --git a/datafusion/src/field_util.rs b/datafusion-physical-expr/src/field_util.rs similarity index 96% rename from datafusion/src/field_util.rs rename to datafusion-physical-expr/src/field_util.rs index 272c17b60887b..2c9411e875d46 100644 --- a/datafusion/src/field_util.rs +++ b/datafusion-physical-expr/src/field_util.rs @@ -18,9 +18,8 @@ //! Utility functions for complex field access use arrow::datatypes::{DataType, Field}; - -use crate::error::{DataFusionError, Result}; -use crate::scalar::ScalarValue; +use datafusion_common::ScalarValue; +use datafusion_common::{DataFusionError, Result}; /// Returns the field access indexed by `key` from a [`DataType::List`] or [`DataType::Struct`] /// # Error diff --git a/datafusion/src/physical_plan/hyperloglog/mod.rs b/datafusion-physical-expr/src/hyperloglog/mod.rs similarity index 100% rename from datafusion/src/physical_plan/hyperloglog/mod.rs rename to datafusion-physical-expr/src/hyperloglog/mod.rs diff --git a/datafusion-physical-expr/src/lib.rs b/datafusion-physical-expr/src/lib.rs index 0c505b35d1a01..ead338fc2ebd3 100644 --- a/datafusion-physical-expr/src/lib.rs +++ b/datafusion-physical-expr/src/lib.rs @@ -16,9 +16,13 @@ // under the License. mod aggregate_expr; +pub mod coercion_rule; pub mod expressions; +pub mod field_util; +mod hyperloglog; mod physical_expr; mod sort_expr; +mod tdigest; pub mod window; pub use aggregate_expr::AggregateExpr; diff --git a/datafusion/src/physical_plan/tdigest/mod.rs b/datafusion-physical-expr/src/tdigest/mod.rs similarity index 95% rename from datafusion/src/physical_plan/tdigest/mod.rs rename to datafusion-physical-expr/src/tdigest/mod.rs index 5bd8b9e35fb08..e0c5767b51e0f 100644 --- a/datafusion/src/physical_plan/tdigest/mod.rs +++ b/datafusion-physical-expr/src/tdigest/mod.rs @@ -28,14 +28,12 @@ //! [Facebook's Folly TDigest]: https://github.com/facebook/folly/blob/main/folly/stats/TDigest.h use arrow::datatypes::DataType; +use datafusion_common::DataFusionError; +use datafusion_common::Result; +use datafusion_common::ScalarValue; use ordered_float::OrderedFloat; use std::cmp::Ordering; -use crate::{ - error::{DataFusionError, Result}, - scalar::ScalarValue, -}; - // Cast a non-null [`ScalarValue::Float64`] to an [`OrderedFloat`], or // panic. macro_rules! cast_scalar_f64 { @@ -582,23 +580,23 @@ impl TDigest { /// ┌────────┬────────┬────────┬───────┬────────┬────────┐ /// │max_size│ sum │ count │ max │ min │centroid│ /// └────────┴────────┴────────┴───────┴────────┴────────┘ - /// │ - /// ┌─────────────────────┘ - /// ▼ - /// ┌ List ───┐ - /// │┌ ─ ─ ─ ┐│ - /// │ mean │ - /// │├ ─ ─ ─ ┼│─ ─ Centroid 1 - /// │ weight │ - /// │└ ─ ─ ─ ┘│ - /// │ │ - /// │┌ ─ ─ ─ ┐│ - /// │ mean │ - /// │├ ─ ─ ─ ┼│─ ─ Centroid 2 - /// │ weight │ - /// │└ ─ ─ ─ ┘│ - /// │ │ - /// ... + /// │ + /// ┌─────────────────────┘ + /// ▼ + /// ┌ List ───┐ + /// │┌ ─ ─ ─ ┐│ + /// │ mean │ + /// │├ ─ ─ ─ ┼│─ ─ Centroid 1 + /// │ weight │ + /// │└ ─ ─ ─ ┘│ + /// │ │ + /// │┌ ─ ─ ─ ┐│ + /// │ mean │ + /// │├ ─ ─ ─ ┼│─ ─ Centroid 2 + /// │ weight │ + /// │└ ─ ─ ─ ┘│ + /// │ │ + /// ... /// /// ``` /// diff --git a/datafusion/src/lib.rs b/datafusion/src/lib.rs index 0ce6e91e8ad08..0f2fb1418e7b5 100644 --- a/datafusion/src/lib.rs +++ b/datafusion/src/lib.rs @@ -225,7 +225,6 @@ pub mod variable; pub use arrow; pub use parquet; -pub(crate) mod field_util; #[cfg(feature = "row")] pub mod row; diff --git a/datafusion/src/logical_plan/expr_schema.rs b/datafusion/src/logical_plan/expr_schema.rs index 2e44c72415c96..347dcd3deec43 100644 --- a/datafusion/src/logical_plan/expr_schema.rs +++ b/datafusion/src/logical_plan/expr_schema.rs @@ -16,13 +16,13 @@ // under the License. use super::Expr; -use crate::field_util::get_indexed_field; use crate::physical_plan::{ aggregates, expressions::binary_operator_data_type, functions, window_functions, }; use arrow::compute::can_cast_types; use arrow::datatypes::DataType; use datafusion_common::{DFField, DFSchema, DataFusionError, ExprSchema, Result}; +use datafusion_physical_expr::field_util::get_indexed_field; /// trait to allow expr to typable with respect to a schema pub trait ExprSchemable { diff --git a/datafusion/src/physical_plan/coercion_rule/aggregate_rule.rs b/datafusion/src/physical_plan/aggregate_rule.rs similarity index 96% rename from datafusion/src/physical_plan/coercion_rule/aggregate_rule.rs rename to datafusion/src/physical_plan/aggregate_rule.rs index 47d406579241b..2e510129a1d23 100644 --- a/datafusion/src/physical_plan/coercion_rule/aggregate_rule.rs +++ b/datafusion/src/physical_plan/aggregate_rule.rs @@ -17,26 +17,24 @@ //! Support the coercion rule for aggregate function. -use crate::error::{DataFusionError, Result}; -use crate::physical_plan::aggregates::AggregateFunction; -use crate::physical_plan::expressions::{ +use arrow::datatypes::DataType; +use arrow::datatypes::Schema; +use datafusion_common::{DataFusionError, Result}; +use datafusion_expr::AggregateFunction; +use datafusion_expr::{Signature, TypeSignature}; +use datafusion_physical_expr::expressions::is_approx_percentile_cont_supported_arg_type; +use datafusion_physical_expr::expressions::{ is_avg_support_arg_type, is_correlation_support_arg_type, is_covariance_support_arg_type, is_stddev_support_arg_type, is_sum_support_arg_type, is_variance_support_arg_type, try_cast, }; -use crate::physical_plan::functions::{Signature, TypeSignature}; -use crate::physical_plan::PhysicalExpr; -use crate::{ - arrow::datatypes::Schema, - physical_plan::expressions::is_approx_percentile_cont_supported_arg_type, -}; -use arrow::datatypes::DataType; +use datafusion_physical_expr::PhysicalExpr; use std::ops::Deref; use std::sync::Arc; /// Returns the coerced data type for each `input_types`. /// Different aggregate function with different input data type will get corresponding coerced data type. -pub(crate) fn coerce_types( +pub fn coerce_types( agg_fun: &AggregateFunction, input_types: &[DataType], signature: &Signature, @@ -238,7 +236,7 @@ fn get_min_max_result_type(input_types: &[DataType]) -> Result> { /// Returns the coerced exprs for each `input_exprs`. /// Get the coerced data type from `aggregate_rule::coerce_types` and add `try_cast` if the /// data type of `input_exprs` need to be coerced. -pub(crate) fn coerce_exprs( +pub fn coerce_exprs( agg_fun: &AggregateFunction, input_exprs: &[Arc], schema: &Schema, @@ -265,10 +263,10 @@ pub(crate) fn coerce_exprs( #[cfg(test)] mod tests { + use super::*; use crate::physical_plan::aggregates; - use crate::physical_plan::aggregates::AggregateFunction; - use crate::physical_plan::coercion_rule::aggregate_rule::coerce_types; use arrow::datatypes::DataType; + use datafusion_expr::AggregateFunction; #[test] fn test_aggregate_coerce_types() { diff --git a/datafusion/src/physical_plan/aggregates.rs b/datafusion/src/physical_plan/aggregates.rs index cdf5cf9875521..ab114643feb10 100644 --- a/datafusion/src/physical_plan/aggregates.rs +++ b/datafusion/src/physical_plan/aggregates.rs @@ -26,22 +26,21 @@ //! * Signature: see `Signature` //! * Return type: a function `(arg_types) -> return_type`. E.g. for min, ([f32]) -> f32, ([f64]) -> f64. +use super::aggregate_rule::{coerce_exprs, coerce_types}; use super::{ functions::{Signature, TypeSignature, Volatility}, AggregateExpr, PhysicalExpr, }; use crate::error::{DataFusionError, Result}; -use crate::physical_plan::coercion_rule::aggregate_rule::{coerce_exprs, coerce_types}; use crate::physical_plan::expressions; use arrow::datatypes::{DataType, Field, Schema, TimeUnit}; +pub use datafusion_expr::AggregateFunction; use expressions::{ avg_return_type, correlation_return_type, covariance_return_type, stddev_return_type, sum_return_type, variance_return_type, }; use std::sync::Arc; -pub use datafusion_expr::AggregateFunction; - /// Returns the datatype of the aggregate function. /// This is used to get the returned data type for aggregate expr. pub fn return_type( diff --git a/datafusion/src/physical_plan/mod.rs b/datafusion/src/physical_plan/mod.rs index 9c51d4a1fc1f2..7d2599958c85d 100644 --- a/datafusion/src/physical_plan/mod.rs +++ b/datafusion/src/physical_plan/mod.rs @@ -517,7 +517,6 @@ pub mod analyze; pub mod array_expressions; pub mod coalesce_batches; pub mod coalesce_partitions; -mod coercion_rule; pub mod common; pub mod cross_join; #[cfg(feature = "crypto_expressions")] @@ -527,13 +526,13 @@ pub mod display; pub mod empty; pub mod explain; pub use datafusion_physical_expr::expressions; +pub mod aggregate_rule; pub mod file_format; pub mod filter; pub mod functions; pub mod hash_aggregate; pub mod hash_join; pub mod hash_utils; -pub(crate) mod hyperloglog; pub mod join_utils; pub mod limit; pub mod math_expressions; @@ -547,7 +546,6 @@ pub mod repartition; pub mod sorts; pub mod stream; pub mod string_expressions; -pub(crate) mod tdigest; pub mod type_coercion; pub mod udaf; pub mod udf;