Apache DataFusion SQL Query Engine
Update 5 crates to rust 2024 edition (#19091)
Tim Saucer998f534aafbf
diff --git a/datafusion/functions-aggregate/Cargo.toml b/datafusion/functions-aggregate/Cargo.tomlindex 8f8697fef0..1d07c1f8a0 100644--- a/datafusion/functions-aggregate/Cargo.toml+++ b/datafusion/functions-aggregate/Cargo.toml@@ -21,7 +21,7 @@ description = "Traits and types for logical plans and expressions for DataFusionkeywords = ["datafusion", "logical", "plan", "expressions"]readme = "README.md"version = { workspace = true }-edition = { workspace = true }+edition = "2024"homepage = { workspace = true }repository = { workspace = true }license = { workspace = true }diff --git a/datafusion/functions-aggregate/benches/array_agg.rs b/datafusion/functions-aggregate/benches/array_agg.rsindex ac1b44c4e8..d7f6873863 100644--- a/datafusion/functions-aggregate/benches/array_agg.rs+++ b/datafusion/functions-aggregate/benches/array_agg.rs@@ -23,15 +23,15 @@ use arrow::array::{PrimitiveArray,};use arrow::datatypes::{Field, Int64Type};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_expr::Accumulator;use datafusion_functions_aggregate::array_agg::ArrayAggAccumulator;use arrow::buffer::OffsetBuffer;-use rand::distr::{Distribution, StandardUniform};-use rand::prelude::StdRng;use rand::Rng;use rand::SeedableRng;+use rand::distr::{Distribution, StandardUniform};+use rand::prelude::StdRng;/// Returns fixed seedable RNGpub fn seedable_rng() -> StdRng {diff --git a/datafusion/functions-aggregate/benches/count.rs b/datafusion/functions-aggregate/benches/count.rsindex 5299f6c70b..711bbe5a3c 100644--- a/datafusion/functions-aggregate/benches/count.rs+++ b/datafusion/functions-aggregate/benches/count.rs@@ -30,7 +30,7 @@ use datafusion_expr::{Accumulator, AggregateUDFImpl, GroupsAccumulator};use datafusion_functions_aggregate::count::Count;use datafusion_physical_expr::expressions::col;-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};fn prepare_group_accumulator() -> Box<dyn GroupsAccumulator> {let schema = Arc::new(Schema::new(vec![Field::new("f", DataType::Int32, true)]));diff --git a/datafusion/functions-aggregate/benches/min_max_bytes.rs b/datafusion/functions-aggregate/benches/min_max_bytes.rsindex 6d76ff2d03..9f4eb0f0c6 100644--- a/datafusion/functions-aggregate/benches/min_max_bytes.rs+++ b/datafusion/functions-aggregate/benches/min_max_bytes.rs@@ -29,8 +29,8 @@ use arrow::{array::{ArrayRef, StringArray},datatypes::{DataType, Field, Schema},};-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};-use datafusion_expr::{function::AccumulatorArgs, GroupsAccumulator};+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};+use datafusion_expr::{GroupsAccumulator, function::AccumulatorArgs};use datafusion_functions_aggregate::min_max;use datafusion_physical_expr::expressions::col;diff --git a/datafusion/functions-aggregate/benches/sum.rs b/datafusion/functions-aggregate/benches/sum.rsindex 48f2f4d835..5299817902 100644--- a/datafusion/functions-aggregate/benches/sum.rs+++ b/datafusion/functions-aggregate/benches/sum.rs@@ -22,11 +22,11 @@ use arrow::array::{ArrayRef, BooleanArray};use arrow::datatypes::{DataType, Field, Int64Type, Schema};use arrow::util::bench_util::{create_boolean_array, create_primitive_array};-use datafusion_expr::{function::AccumulatorArgs, AggregateUDFImpl, GroupsAccumulator};+use datafusion_expr::{AggregateUDFImpl, GroupsAccumulator, function::AccumulatorArgs};use datafusion_functions_aggregate::sum::Sum;use datafusion_physical_expr::expressions::col;-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};fn prepare_accumulator(data_type: &DataType) -> Box<dyn GroupsAccumulator> {let field = Field::new("f", data_type.clone(), true).into();diff --git a/datafusion/functions-aggregate/src/approx_distinct.rs b/datafusion/functions-aggregate/src/approx_distinct.rsindex 58c2a5489d..3c9692d29c 100644--- a/datafusion/functions-aggregate/src/approx_distinct.rs+++ b/datafusion/functions-aggregate/src/approx_distinct.rs@@ -23,17 +23,17 @@ use arrow::array::{GenericBinaryArray, GenericStringArray, OffsetSizeTrait, PrimitiveArray,};use arrow::datatypes::{- ArrowPrimitiveType, Date32Type, Date64Type, FieldRef, Int16Type, Int32Type,- Int64Type, Int8Type, Time32MillisecondType, Time32SecondType, Time64MicrosecondType,+ ArrowPrimitiveType, Date32Type, Date64Type, FieldRef, Int8Type, Int16Type, Int32Type,+ Int64Type, Time32MillisecondType, Time32SecondType, Time64MicrosecondType,Time64NanosecondType, TimeUnit, TimestampMicrosecondType, TimestampMillisecondType,- TimestampNanosecondType, TimestampSecondType, UInt16Type, UInt32Type, UInt64Type,- UInt8Type,+ TimestampNanosecondType, TimestampSecondType, UInt8Type, UInt16Type, UInt32Type,+ UInt64Type,};use arrow::{array::ArrayRef, datatypes::DataType, datatypes::Field};use datafusion_common::ScalarValue;use datafusion_common::{- downcast_value, internal_datafusion_err, internal_err, not_impl_err, DataFusionError,- Result,+ DataFusionError, Result, downcast_value, internal_datafusion_err, internal_err,+ not_impl_err,};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::utils::format_state_name;@@ -328,19 +328,23 @@ impl AggregateUDFImpl for ApproxDistinct {fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {if args.input_fields[0].data_type().is_null() {- Ok(vec![Field::new(- format_state_name(args.name, self.name()),- DataType::Null,- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, self.name()),+ DataType::Null,+ true,+ )+ .into(),+ ])} else {- Ok(vec![Field::new(- format_state_name(args.name, "hll_registers"),- DataType::Binary,- false,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, "hll_registers"),+ DataType::Binary,+ false,+ )+ .into(),+ ])}}@@ -395,8 +399,8 @@ impl AggregateUDFImpl for ApproxDistinct {}other => {return not_impl_err!(- "Support for 'approx_distinct' for data type {other} is not implemented"- )+ "Support for 'approx_distinct' for data type {other} is not implemented"+ );}};Ok(accumulator)diff --git a/datafusion/functions-aggregate/src/approx_median.rs b/datafusion/functions-aggregate/src/approx_median.rsindex 1d0d7a318a..739e333b54 100644--- a/datafusion/functions-aggregate/src/approx_median.rs+++ b/datafusion/functions-aggregate/src/approx_median.rs@@ -25,7 +25,7 @@ use std::any::Any;use std::fmt::Debug;use std::sync::Arc;-use datafusion_common::{not_impl_err, Result};+use datafusion_common::{Result, not_impl_err};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::utils::format_state_name;use datafusion_expr::{@@ -98,12 +98,14 @@ impl AggregateUDFImpl for ApproxMedian {fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {if args.input_fields[0].data_type().is_null() {- Ok(vec![Field::new(- format_state_name(args.name, self.name()),- DataType::Null,- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, self.name()),+ DataType::Null,+ true,+ )+ .into(),+ ])} else {Ok(vec![Field::new(format_state_name(args.name, "max_size"), UInt64, false),diff --git a/datafusion/functions-aggregate/src/approx_percentile_cont.rs b/datafusion/functions-aggregate/src/approx_percentile_cont.rsindex b09d43bd8f..b1e649ec02 100644--- a/datafusion/functions-aggregate/src/approx_percentile_cont.rs+++ b/datafusion/functions-aggregate/src/approx_percentile_cont.rs@@ -25,14 +25,14 @@ use arrow::compute::{filter, is_not_null};use arrow::datatypes::FieldRef;use arrow::{array::{- ArrayRef, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array,- Int8Array, UInt16Array, UInt32Array, UInt64Array, UInt8Array,+ ArrayRef, Float32Array, Float64Array, Int8Array, Int16Array, Int32Array,+ Int64Array, UInt8Array, UInt16Array, UInt32Array, UInt64Array,},datatypes::{DataType, Field},};use datafusion_common::{- downcast_value, internal_err, not_impl_err, plan_err, DataFusionError, Result,- ScalarValue,+ DataFusionError, Result, ScalarValue, downcast_value, internal_err, not_impl_err,+ plan_err,};use datafusion_expr::expr::{AggregateFunction, Sort};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};@@ -42,7 +42,7 @@ use datafusion_expr::{Accumulator, AggregateUDFImpl, Documentation, Expr, Signature, TypeSignature,Volatility,};-use datafusion_functions_aggregate_common::tdigest::{TDigest, DEFAULT_MAX_SIZE};+use datafusion_functions_aggregate_common::tdigest::{DEFAULT_MAX_SIZE, TDigest};use datafusion_macros::user_doc;use datafusion_physical_expr_common::physical_expr::PhysicalExpr;@@ -190,7 +190,11 @@ impl ApproxPercentileCont {| DataType::Float32| DataType::Float64 => {if let Some(max_size) = tdigest_max_size {- ApproxPercentileAccumulator::new_with_max_size(percentile, data_type.clone(), max_size)+ ApproxPercentileAccumulator::new_with_max_size(+ percentile,+ data_type.clone(),+ max_size,+ )} else {ApproxPercentileAccumulator::new(percentile, data_type.clone())}@@ -198,7 +202,7 @@ impl ApproxPercentileCont {other => {return not_impl_err!("Support for 'APPROX_PERCENTILE_CONT' for data type {other} is not implemented"- )+ );}};@@ -227,8 +231,8 @@ fn validate_input_max_size_expr(expr: &Arc<dyn PhysicalExpr>) -> Result<usize> {return plan_err!("Tdigest max_size value for 'APPROX_PERCENTILE_CONT' must be UInt > 0 literal (got data type {}).",sv.data_type()- )- },+ );+ }};Ok(max_size)diff --git a/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rs b/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rsindex 6a86ef2262..ff7762e816 100644--- a/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rs+++ b/datafusion/functions-aggregate/src/approx_percentile_cont_with_weight.rs@@ -25,11 +25,11 @@ use arrow::compute::{and, filter, is_not_null};use arrow::datatypes::FieldRef;use arrow::{array::ArrayRef, datatypes::DataType};use datafusion_common::ScalarValue;-use datafusion_common::{not_impl_err, plan_err, Result};+use datafusion_common::{Result, not_impl_err, plan_err};+use datafusion_expr::Volatility::Immutable;use datafusion_expr::expr::{AggregateFunction, Sort};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::type_coercion::aggregates::{INTEGERS, NUMERICS};-use datafusion_expr::Volatility::Immutable;use datafusion_expr::{Accumulator, AggregateUDFImpl, Documentation, Expr, Signature, TypeSignature,};@@ -184,7 +184,9 @@ impl AggregateUDFImpl for ApproxPercentileContWithWeight {);}if arg_types[2] != DataType::Float64 {- return plan_err!("approx_percentile_cont_with_weight requires float64 percentile input types");+ return plan_err!(+ "approx_percentile_cont_with_weight requires float64 percentile input types"+ );}if arg_types.len() == 4 && !arg_types[3].is_integer() {return plan_err!(diff --git a/datafusion/functions-aggregate/src/array_agg.rs b/datafusion/functions-aggregate/src/array_agg.rsindex 4f5797c308..8491062124 100644--- a/datafusion/functions-aggregate/src/array_agg.rs+++ b/datafusion/functions-aggregate/src/array_agg.rs@@ -23,16 +23,16 @@ use std::mem::{size_of, size_of_val, take};use std::sync::Arc;use arrow::array::{- new_empty_array, Array, ArrayRef, AsArray, BooleanArray, ListArray, StructArray,+ Array, ArrayRef, AsArray, BooleanArray, ListArray, StructArray, new_empty_array,};-use arrow::compute::{filter, SortOptions};+use arrow::compute::{SortOptions, filter};use arrow::datatypes::{DataType, Field, FieldRef, Fields};use datafusion_common::cast::as_list_array;use datafusion_common::utils::{- compare_rows, get_row_at_idx, take_function_args, SingleRowListArrayBuilder,+ SingleRowListArrayBuilder, compare_rows, get_row_at_idx, take_function_args,};-use datafusion_common::{assert_eq_or_internal_err, exec_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, assert_eq_or_internal_err, exec_err};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::utils::format_state_name;use datafusion_expr::{@@ -113,22 +113,26 @@ impl AggregateUDFImpl for ArrayAgg {fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {if args.is_distinct {- return Ok(vec![Field::new_list(- format_state_name(args.name, "distinct_array_agg"),+ return Ok(vec![+ Field::new_list(+ format_state_name(args.name, "distinct_array_agg"),+ // See COMMENTS.md to understand why nullable is set to true+ Field::new_list_field(args.input_fields[0].data_type().clone(), true),+ true,+ )+ .into(),+ ]);+ }++ let mut fields = vec![+ Field::new_list(+ format_state_name(args.name, "array_agg"),// See COMMENTS.md to understand why nullable is set to trueField::new_list_field(args.input_fields[0].data_type().clone(), true),true,)- .into()]);- }-- let mut fields = vec![Field::new_list(- format_state_name(args.name, "array_agg"),- // See COMMENTS.md to understand why nullable is set to true- Field::new_list_field(args.input_fields[0].data_type().clone(), true),- true,- )- .into()];+ .into(),+ ];if args.ordering_fields.is_empty() {return Ok(fields);@@ -799,8 +803,8 @@ mod tests {use arrow::datatypes::{FieldRef, Schema};use datafusion_common::cast::as_generic_string_array;use datafusion_common::internal_err;- use datafusion_physical_expr::expressions::Column;use datafusion_physical_expr::PhysicalExpr;+ use datafusion_physical_expr::expressions::Column;use datafusion_physical_expr_common::sort_expr::PhysicalSortExpr;use std::sync::Arc;diff --git a/datafusion/functions-aggregate/src/average.rs b/datafusion/functions-aggregate/src/average.rsindex f4b3e598c3..46a8dbf954 100644--- a/datafusion/functions-aggregate/src/average.rs+++ b/datafusion/functions-aggregate/src/average.rs@@ -24,15 +24,15 @@ use arrow::array::{use arrow::compute::sum;use arrow::datatypes::{- i256, ArrowNativeType, DataType, Decimal128Type, Decimal256Type, Decimal32Type,- Decimal64Type, DecimalType, DurationMicrosecondType, DurationMillisecondType,- DurationNanosecondType, DurationSecondType, Field, FieldRef, Float64Type, TimeUnit,- UInt64Type, DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION,- DECIMAL256_MAX_SCALE, DECIMAL32_MAX_PRECISION, DECIMAL32_MAX_SCALE,- DECIMAL64_MAX_PRECISION, DECIMAL64_MAX_SCALE,+ ArrowNativeType, DECIMAL32_MAX_PRECISION, DECIMAL32_MAX_SCALE,+ DECIMAL64_MAX_PRECISION, DECIMAL64_MAX_SCALE, DECIMAL128_MAX_PRECISION,+ DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION, DECIMAL256_MAX_SCALE, DataType,+ Decimal32Type, Decimal64Type, Decimal128Type, Decimal256Type, DecimalType,+ DurationMicrosecondType, DurationMillisecondType, DurationNanosecondType,+ DurationSecondType, Field, FieldRef, Float64Type, TimeUnit, UInt64Type, i256,};-use datafusion_common::types::{logical_float64, NativeType};-use datafusion_common::{exec_err, not_impl_err, Result, ScalarValue};+use datafusion_common::types::{NativeType, logical_float64};+use datafusion_common::{Result, ScalarValue, exec_err, not_impl_err};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::utils::format_state_name;use datafusion_expr::{@@ -310,12 +310,14 @@ impl AggregateUDFImpl for Avg {};// Similar to datafusion_functions_aggregate::sum::Sum::state_fields// since the accumulator uses DistinctSumAccumulator internally.- Ok(vec![Field::new_list(- format_state_name(args.name, "avg distinct"),- Field::new_list_field(dt, true),- false,- )- .into()])+ Ok(vec![+ Field::new_list(+ format_state_name(args.name, "avg distinct"),+ Field::new_list_field(dt, true),+ false,+ )+ .into(),+ ])} else {Ok(vec![Field::new(diff --git a/datafusion/functions-aggregate/src/bit_and_or_xor.rs b/datafusion/functions-aggregate/src/bit_and_or_xor.rsindex 28e5f7e375..734a916e2a 100644--- a/datafusion/functions-aggregate/src/bit_and_or_xor.rs+++ b/datafusion/functions-aggregate/src/bit_and_or_xor.rs@@ -24,14 +24,14 @@ use std::hash::Hash;use std::mem::{size_of, size_of_val};use ahash::RandomState;-use arrow::array::{downcast_integer, Array, ArrayRef, AsArray};+use arrow::array::{Array, ArrayRef, AsArray, downcast_integer};use arrow::datatypes::{- ArrowNativeType, ArrowNumericType, DataType, Field, FieldRef, Int16Type, Int32Type,- Int64Type, Int8Type, UInt16Type, UInt32Type, UInt64Type, UInt8Type,+ ArrowNativeType, ArrowNumericType, DataType, Field, FieldRef, Int8Type, Int16Type,+ Int32Type, Int64Type, UInt8Type, UInt16Type, UInt32Type, UInt64Type,};use datafusion_common::cast::as_list_array;-use datafusion_common::{not_impl_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, not_impl_err};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::utils::format_state_name;use datafusion_expr::{@@ -262,30 +262,36 @@ impl AggregateUDFImpl for BitwiseOperation {fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {if args.input_fields[0].data_type().is_null() {- Ok(vec![Field::new(- format_state_name(args.name, self.name()),- DataType::Null,- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, self.name()),+ DataType::Null,+ true,+ )+ .into(),+ ])} else if self.operation == BitwiseOperationType::Xor && args.is_distinct {- Ok(vec![Field::new_list(- format_state_name(- args.name,- format!("{} distinct", self.name()).as_str(),- ),- // See COMMENTS.md to understand why nullable is set to true- Field::new_list_field(args.return_type().clone(), true),- false,- )- .into()])+ Ok(vec![+ Field::new_list(+ format_state_name(+ args.name,+ format!("{} distinct", self.name()).as_str(),+ ),+ // See COMMENTS.md to understand why nullable is set to true+ Field::new_list_field(args.return_type().clone(), true),+ false,+ )+ .into(),+ ])} else {- Ok(vec![Field::new(- format_state_name(args.name, self.name()),- args.return_field.data_type().clone(),- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, self.name()),+ args.return_field.data_type().clone(),+ true,+ )+ .into(),+ ])}}diff --git a/datafusion/functions-aggregate/src/bool_and_or.rs b/datafusion/functions-aggregate/src/bool_and_or.rsindex ff389bb419..a107024e2f 100644--- a/datafusion/functions-aggregate/src/bool_and_or.rs+++ b/datafusion/functions-aggregate/src/bool_and_or.rs@@ -28,10 +28,10 @@ use arrow::datatypes::Field;use arrow::datatypes::{DataType, FieldRef};use datafusion_common::internal_err;-use datafusion_common::{downcast_value, not_impl_err};use datafusion_common::{Result, ScalarValue};+use datafusion_common::{downcast_value, not_impl_err};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};-use datafusion_expr::utils::{format_state_name, AggregateOrderSensitivity};+use datafusion_expr::utils::{AggregateOrderSensitivity, format_state_name};use datafusion_expr::{Accumulator, AggregateUDFImpl, Documentation, GroupsAccumulator, ReversedUDAF,Signature, Volatility,@@ -151,12 +151,14 @@ impl AggregateUDFImpl for BoolAnd {}fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {- Ok(vec![Field::new(- format_state_name(args.name, self.name()),- DataType::Boolean,- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, self.name()),+ DataType::Boolean,+ true,+ )+ .into(),+ ])}fn groups_accumulator_supported(&self, _args: AccumulatorArgs) -> bool {@@ -286,12 +288,14 @@ impl AggregateUDFImpl for BoolOr {}fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {- Ok(vec![Field::new(- format_state_name(args.name, self.name()),- DataType::Boolean,- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, self.name()),+ DataType::Boolean,+ true,+ )+ .into(),+ ])}fn groups_accumulator_supported(&self, _args: AccumulatorArgs) -> bool {diff --git a/datafusion/functions-aggregate/src/correlation.rs b/datafusion/functions-aggregate/src/correlation.rsindex 4cac159ebb..538311dfa2 100644--- a/datafusion/functions-aggregate/src/correlation.rs+++ b/datafusion/functions-aggregate/src/correlation.rs@@ -23,8 +23,8 @@ use std::mem::size_of_val;use std::sync::Arc;use arrow::array::{- downcast_array, Array, AsArray, BooleanArray, Float64Array, NullBufferBuilder,- UInt64Array,+ Array, AsArray, BooleanArray, Float64Array, NullBufferBuilder, UInt64Array,+ downcast_array,};use arrow::compute::{and, filter, is_not_null};use arrow::datatypes::{FieldRef, Float64Type, UInt64Type};@@ -40,9 +40,9 @@ use crate::covariance::CovarianceAccumulator;use crate::stddev::StddevAccumulator;use datafusion_common::{Result, ScalarValue};use datafusion_expr::{+ Accumulator, AggregateUDFImpl, Documentation, Signature, Volatility,function::{AccumulatorArgs, StateFieldsArgs},utils::format_state_name,- Accumulator, AggregateUDFImpl, Documentation, Signature, Volatility,};use datafusion_functions_aggregate_common::stats::StatsType;use datafusion_macros::user_doc;@@ -214,15 +214,14 @@ impl Accumulator for CorrelationAccumulator {return Ok(ScalarValue::Float64(None));}- if let ScalarValue::Float64(Some(c)) = covar {- if let ScalarValue::Float64(Some(s1)) = stddev1 {- if let ScalarValue::Float64(Some(s2)) = stddev2 {- if s1 == 0_f64 || s2 == 0_f64 {- return Ok(ScalarValue::Float64(None));- } else {- return Ok(ScalarValue::Float64(Some(c / s1 / s2)));- }- }+ if let ScalarValue::Float64(Some(c)) = covar+ && let ScalarValue::Float64(Some(s1)) = stddev1+ && let ScalarValue::Float64(Some(s2)) = stddev2+ {+ if s1 == 0_f64 || s2 == 0_f64 {+ return Ok(ScalarValue::Float64(None));+ } else {+ return Ok(ScalarValue::Float64(Some(c / s1 / s2)));}}@@ -509,7 +508,10 @@ impl GroupsAccumulator for CorrelationGroupsAccumulator {let partial_sum_xx = values[4].as_primitive::<Float64Type>();let partial_sum_yy = values[5].as_primitive::<Float64Type>();- assert!(opt_filter.is_none(), "aggregate filter should be applied in partial stage, there should be no filter in final stage");+ assert!(+ opt_filter.is_none(),+ "aggregate filter should be applied in partial stage, there should be no filter in final stage"+ );accumulate_correlation_states(group_indices,diff --git a/datafusion/functions-aggregate/src/count.rs b/datafusion/functions-aggregate/src/count.rsindex a291e8e21e..a7c819acaf 100644--- a/datafusion/functions-aggregate/src/count.rs+++ b/datafusion/functions-aggregate/src/count.rs@@ -22,24 +22,24 @@ use arrow::{compute,datatypes::{DataType, Date32Type, Date64Type, Decimal128Type, Decimal256Type, Field,- FieldRef, Float16Type, Float32Type, Float64Type, Int16Type, Int32Type, Int64Type,- Int8Type, Time32MillisecondType, Time32SecondType, Time64MicrosecondType,+ FieldRef, Float16Type, Float32Type, Float64Type, Int8Type, Int16Type, Int32Type,+ Int64Type, Time32MillisecondType, Time32SecondType, Time64MicrosecondType,Time64NanosecondType, TimeUnit, TimestampMicrosecondType,TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType,- UInt16Type, UInt32Type, UInt64Type, UInt8Type,+ UInt8Type, UInt16Type, UInt32Type, UInt64Type,},};use datafusion_common::{- downcast_value, internal_err, not_impl_err, stats::Precision,- utils::expr::COUNT_STAR_EXPANSION, HashMap, Result, ScalarValue,+ HashMap, Result, ScalarValue, downcast_value, internal_err, not_impl_err,+ stats::Precision, utils::expr::COUNT_STAR_EXPANSION,};use datafusion_expr::{- expr::WindowFunction,- function::{AccumulatorArgs, StateFieldsArgs},- utils::format_state_name,Accumulator, AggregateUDFImpl, Documentation, EmitTo, Expr, GroupsAccumulator,ReversedUDAF, SetMonotonicity, Signature, StatisticsArgs, TypeSignature, Volatility,WindowFunctionDefinition,+ expr::WindowFunction,+ function::{AccumulatorArgs, StateFieldsArgs},+ utils::format_state_name,};use datafusion_functions_aggregate_common::aggregate::{count_distinct::BytesDistinctCountAccumulator,@@ -307,20 +307,24 @@ impl AggregateUDFImpl for Count {&dtype => dtype.clone(),};- Ok(vec![Field::new_list(- format_state_name(args.name, "count distinct"),- // See COMMENTS.md to understand why nullable is set to true- Field::new_list_field(dtype, true),- false,- )- .into()])+ Ok(vec![+ Field::new_list(+ format_state_name(args.name, "count distinct"),+ // See COMMENTS.md to understand why nullable is set to true+ Field::new_list_field(dtype, true),+ false,+ )+ .into(),+ ])} else {- Ok(vec![Field::new(- format_state_name(args.name, "count"),- DataType::Int64,- false,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, "count"),+ DataType::Int64,+ false,+ )+ .into(),+ ])}}@@ -373,27 +377,26 @@ impl AggregateUDFImpl for Count {if statistics_args.is_distinct {return None;}- if let Precision::Exact(num_rows) = statistics_args.statistics.num_rows {- if statistics_args.exprs.len() == 1 {- // TODO optimize with exprs other than Column- if let Some(col_expr) = statistics_args.exprs[0]- .as_any()- .downcast_ref::<expressions::Column>()- {- let current_val = &statistics_args.statistics.column_statistics- [col_expr.index()]- .null_count;- if let &Precision::Exact(val) = current_val {- return Some(ScalarValue::Int64(Some((num_rows - val) as i64)));- }- } else if let Some(lit_expr) = statistics_args.exprs[0]- .as_any()- .downcast_ref::<expressions::Literal>()- {- if lit_expr.value() == &COUNT_STAR_EXPANSION {- return Some(ScalarValue::Int64(Some(num_rows as i64)));- }+ if let Precision::Exact(num_rows) = statistics_args.statistics.num_rows+ && statistics_args.exprs.len() == 1+ {+ // TODO optimize with exprs other than Column+ if let Some(col_expr) = statistics_args.exprs[0]+ .as_any()+ .downcast_ref::<expressions::Column>()+ {+ let current_val = &statistics_args.statistics.column_statistics+ [col_expr.index()]+ .null_count;+ if let &Precision::Exact(val) = current_val {+ return Some(ScalarValue::Int64(Some((num_rows - val) as i64)));}+ } else if let Some(lit_expr) = statistics_args.exprs[0]+ .as_any()+ .downcast_ref::<expressions::Literal>()+ && lit_expr.value() == &COUNT_STAR_EXPANSION+ {+ return Some(ScalarValue::Int64(Some(num_rows as i64)));}}None@@ -466,12 +469,12 @@ impl Accumulator for SlidingDistinctCountAccumulator {let arr = &values[0];for i in 0..arr.len() {let v = ScalarValue::try_from_array(arr, i)?;- if !v.is_null() {- if let Some(cnt) = self.counts.get_mut(&v) {- *cnt -= 1;- if *cnt == 0 {- self.counts.remove(&v);- }+ if !v.is_null()+ && let Some(cnt) = self.counts.get_mut(&v)+ {+ *cnt -= 1;+ if *cnt == 0 {+ self.counts.remove(&v);}}}@@ -854,7 +857,7 @@ mod tests {datatypes::{DataType, Field, Int32Type, Schema},};use datafusion_expr::function::AccumulatorArgs;- use datafusion_physical_expr::{expressions::Column, PhysicalExpr};+ use datafusion_physical_expr::{PhysicalExpr, expressions::Column};use std::sync::Arc;/// Helper function to create a dictionary array with non-null keys but some null values/// Returns a dictionary array where:diff --git a/datafusion/functions-aggregate/src/covariance.rs b/datafusion/functions-aggregate/src/covariance.rsindex 7e34ffbaad..e86d742db3 100644--- a/datafusion/functions-aggregate/src/covariance.rs+++ b/datafusion/functions-aggregate/src/covariance.rs@@ -24,13 +24,13 @@ use arrow::{datatypes::{DataType, Field},};use datafusion_common::{- downcast_value, plan_err, unwrap_or_internal_err, Result, ScalarValue,+ Result, ScalarValue, downcast_value, plan_err, unwrap_or_internal_err,};use datafusion_expr::{+ Accumulator, AggregateUDFImpl, Documentation, Signature, Volatility,function::{AccumulatorArgs, StateFieldsArgs},type_coercion::aggregates::NUMERICS,utils::format_state_name,- Accumulator, AggregateUDFImpl, Documentation, Signature, Volatility,};use datafusion_functions_aggregate_common::stats::StatsType;use datafusion_macros::user_doc;diff --git a/datafusion/functions-aggregate/src/first_last.rs b/datafusion/functions-aggregate/src/first_last.rsindex bedf124d30..51bc1b6de2 100644--- a/datafusion/functions-aggregate/src/first_last.rs+++ b/datafusion/functions-aggregate/src/first_last.rs@@ -30,20 +30,20 @@ use arrow::array::{use arrow::buffer::{BooleanBuffer, NullBuffer};use arrow::compute::{self, LexicographicalComparator, SortColumn, SortOptions};use arrow::datatypes::{- DataType, Date32Type, Date64Type, Decimal128Type, Decimal256Type, Decimal32Type,- Decimal64Type, Field, FieldRef, Float16Type, Float32Type, Float64Type, Int16Type,- Int32Type, Int64Type, Int8Type, Time32MillisecondType, Time32SecondType,+ DataType, Date32Type, Date64Type, Decimal32Type, Decimal64Type, Decimal128Type,+ Decimal256Type, Field, FieldRef, Float16Type, Float32Type, Float64Type, Int8Type,+ Int16Type, Int32Type, Int64Type, Time32MillisecondType, Time32SecondType,Time64MicrosecondType, Time64NanosecondType, TimeUnit, TimestampMicrosecondType,- TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType, UInt16Type,- UInt32Type, UInt64Type, UInt8Type,+ TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType, UInt8Type,+ UInt16Type, UInt32Type, UInt64Type,};use datafusion_common::cast::as_boolean_array;use datafusion_common::utils::{compare_rows, extract_row_at_idx_to_buf, get_row_at_idx};use datafusion_common::{- arrow_datafusion_err, internal_err, DataFusionError, Result, ScalarValue,+ DataFusionError, Result, ScalarValue, arrow_datafusion_err, internal_err,};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};-use datafusion_expr::utils::{format_state_name, AggregateOrderSensitivity};+use datafusion_expr::utils::{AggregateOrderSensitivity, format_state_name};use datafusion_expr::{Accumulator, AggregateUDFImpl, Documentation, EmitTo, Expr, ExprFunctionExt,GroupsAccumulator, ReversedUDAF, Signature, SortExpr, Volatility,@@ -159,12 +159,14 @@ impl AggregateUDFImpl for FirstValue {}fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {- let mut fields = vec![Field::new(- format_state_name(args.name, "first_value"),- args.return_type().clone(),- true,- )- .into()];+ let mut fields = vec![+ Field::new(+ format_state_name(args.name, "first_value"),+ args.return_type().clone(),+ true,+ )+ .into(),+ ];fields.extend(args.ordering_fields.iter().cloned());fields.push(Field::new(@@ -825,11 +827,11 @@ impl Accumulator for TrivialFirstValueAccumulator {let filtered_states =filter_states_according_to_is_set(&states[0..1], flags)?;- if let Some(first) = filtered_states.first() {- if !first.is_empty() {- self.first = ScalarValue::try_from_array(first, 0)?;- self.is_set = true;- }+ if let Some(first) = filtered_states.first()+ && !first.is_empty()+ {+ self.first = ScalarValue::try_from_array(first, 0)?;+ self.is_set = true;}}Ok(())@@ -1095,12 +1097,14 @@ impl AggregateUDFImpl for LastValue {}fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {- let mut fields = vec![Field::new(- format_state_name(args.name, "last_value"),- args.return_field.data_type().clone(),- true,- )- .into()];+ let mut fields = vec![+ Field::new(+ format_state_name(args.name, "last_value"),+ args.return_field.data_type().clone(),+ true,+ )+ .into(),+ ];fields.extend(args.ordering_fields.iter().cloned());fields.push(Field::new(@@ -1314,11 +1318,11 @@ impl Accumulator for TrivialLastValueAccumulator {validate_is_set_flags(flags, "last_value")?;let filtered_states = filter_states_according_to_is_set(&states[0..1], flags)?;- if let Some(last) = filtered_states.last() {- if !last.is_empty() {- self.last = ScalarValue::try_from_array(last, 0)?;- self.is_set = true;- }+ if let Some(last) = filtered_states.last()+ && !last.is_empty()+ {+ self.last = ScalarValue::try_from_array(last, 0)?;+ self.is_set = true;}Ok(())}@@ -1545,7 +1549,7 @@ mod tests {compute::SortOptions,datatypes::Schema,};- use datafusion_physical_expr::{expressions::col, PhysicalSortExpr};+ use datafusion_physical_expr::{PhysicalSortExpr, expressions::col};use super::*;@@ -1967,10 +1971,12 @@ mod tests {let trivial_states = vec![Arc::clone(&value), Arc::clone(&corrupted_flag)];let result = trivial_accumulator.merge_batch(&trivial_states);assert!(result.is_err());- assert!(result- .unwrap_err()- .to_string()- .contains("is_set flags contain nulls"));+ assert!(+ result+ .unwrap_err()+ .to_string()+ .contains("is_set flags contain nulls")+ );// Test FirstValueAccumulator (with ordering)let schema = Schema::new(vec![Field::new("ordering", DataType::Int64, false)]);@@ -1990,10 +1996,12 @@ mod tests {let ordered_states = vec![value, ordering, corrupted_flag];let result = ordered_accumulator.merge_batch(&ordered_states);assert!(result.is_err());- assert!(result- .unwrap_err()- .to_string()- .contains("is_set flags contain nulls"));+ assert!(+ result+ .unwrap_err()+ .to_string()+ .contains("is_set flags contain nulls")+ );Ok(())}@@ -2010,10 +2018,12 @@ mod tests {let trivial_states = vec![Arc::clone(&value), Arc::clone(&corrupted_flag)];let result = trivial_accumulator.merge_batch(&trivial_states);assert!(result.is_err());- assert!(result- .unwrap_err()- .to_string()- .contains("is_set flags contain nulls"));+ assert!(+ result+ .unwrap_err()+ .to_string()+ .contains("is_set flags contain nulls")+ );// Test LastValueAccumulator (with ordering)let schema = Schema::new(vec![Field::new("ordering", DataType::Int64, false)]);@@ -2033,10 +2043,12 @@ mod tests {let ordered_states = vec![value, ordering, corrupted_flag];let result = ordered_accumulator.merge_batch(&ordered_states);assert!(result.is_err());- assert!(result- .unwrap_err()- .to_string()- .contains("is_set flags contain nulls"));+ assert!(+ result+ .unwrap_err()+ .to_string()+ .contains("is_set flags contain nulls")+ );Ok(())}diff --git a/datafusion/functions-aggregate/src/grouping.rs b/datafusion/functions-aggregate/src/grouping.rsindex 4d1da1dad5..43218b1147 100644--- a/datafusion/functions-aggregate/src/grouping.rs+++ b/datafusion/functions-aggregate/src/grouping.rs@@ -22,7 +22,7 @@ use std::fmt;use arrow::datatypes::Field;use arrow::datatypes::{DataType, FieldRef};-use datafusion_common::{not_impl_err, Result};+use datafusion_common::{Result, not_impl_err};use datafusion_expr::function::AccumulatorArgs;use datafusion_expr::function::StateFieldsArgs;use datafusion_expr::utils::format_state_name;@@ -107,12 +107,14 @@ impl AggregateUDFImpl for Grouping {}fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {- Ok(vec![Field::new(- format_state_name(args.name, "grouping"),- DataType::Int32,- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, "grouping"),+ DataType::Int32,+ true,+ )+ .into(),+ ])}fn accumulator(&self, _acc_args: AccumulatorArgs) -> Result<Box<dyn Accumulator>> {diff --git a/datafusion/functions-aggregate/src/median.rs b/datafusion/functions-aggregate/src/median.rsindex ef76d1e6ea..f09c544628 100644--- a/datafusion/functions-aggregate/src/median.rs+++ b/datafusion/functions-aggregate/src/median.rs@@ -21,8 +21,8 @@ use std::mem::{size_of, size_of_val};use std::sync::Arc;use arrow::array::{- downcast_integer, ArrowNumericType, BooleanArray, ListArray, PrimitiveArray,- PrimitiveBuilder,+ ArrowNumericType, BooleanArray, ListArray, PrimitiveArray, PrimitiveBuilder,+ downcast_integer,};use arrow::buffer::{OffsetBuffer, ScalarBuffer};use arrow::{@@ -40,13 +40,13 @@ use arrow::datatypes::{};use datafusion_common::{- assert_eq_or_internal_err, internal_datafusion_err, DataFusionError, Result,- ScalarValue,+ DataFusionError, Result, ScalarValue, assert_eq_or_internal_err,+ internal_datafusion_err,};use datafusion_expr::function::StateFieldsArgs;use datafusion_expr::{- function::AccumulatorArgs, utils::format_state_name, Accumulator, AggregateUDFImpl,- Documentation, Signature, Volatility,+ Accumulator, AggregateUDFImpl, Documentation, Signature, Volatility,+ function::AccumulatorArgs, utils::format_state_name,};use datafusion_expr::{EmitTo, GroupsAccumulator};use datafusion_functions_aggregate_common::aggregate::groups_accumulator::accumulate::accumulate;@@ -138,12 +138,14 @@ impl AggregateUDFImpl for Median {"median"};- Ok(vec![Field::new(- format_state_name(args.name, state_name),- DataType::List(Arc::new(field)),- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, state_name),+ DataType::List(Arc::new(field)),+ true,+ )+ .into(),+ ])}fn accumulator(&self, acc_args: AccumulatorArgs) -> Result<Box<dyn Accumulator>> {diff --git a/datafusion/functions-aggregate/src/min_max.rs b/datafusion/functions-aggregate/src/min_max.rsindex 1a46afefff..0eebad9e3a 100644--- a/datafusion/functions-aggregate/src/min_max.rs+++ b/datafusion/functions-aggregate/src/min_max.rs@@ -23,13 +23,13 @@ mod min_max_struct;use arrow::array::ArrayRef;use arrow::datatypes::{- DataType, Decimal128Type, Decimal256Type, Decimal32Type, Decimal64Type,+ DataType, Decimal32Type, Decimal64Type, Decimal128Type, Decimal256Type,DurationMicrosecondType, DurationMillisecondType, DurationNanosecondType,- DurationSecondType, Float16Type, Float32Type, Float64Type, Int16Type, Int32Type,- Int64Type, Int8Type, UInt16Type, UInt32Type, UInt64Type, UInt8Type,+ DurationSecondType, Float16Type, Float32Type, Float64Type, Int8Type, Int16Type,+ Int32Type, Int64Type, UInt8Type, UInt16Type, UInt32Type, UInt64Type,};use datafusion_common::stats::Precision;-use datafusion_common::{exec_err, internal_err, ColumnStatistics, Result};+use datafusion_common::{ColumnStatistics, Result, exec_err, internal_err};use datafusion_functions_aggregate_common::aggregate::groups_accumulator::prim_op::PrimitiveGroupsAccumulator;use datafusion_physical_expr::expressions;use std::cmp::Ordering;@@ -46,8 +46,8 @@ use crate::min_max::min_max_bytes::MinMaxBytesAccumulator;use crate::min_max::min_max_struct::MinMaxStructAccumulator;use datafusion_common::ScalarValue;use datafusion_expr::{- function::AccumulatorArgs, Accumulator, AggregateUDFImpl, Documentation,- SetMonotonicity, Signature, Volatility,+ Accumulator, AggregateUDFImpl, Documentation, SetMonotonicity, Signature, Volatility,+ function::AccumulatorArgs,};use datafusion_expr::{GroupsAccumulator, StatisticsArgs};use datafusion_macros::user_doc;@@ -193,10 +193,10 @@ impl FromColumnStatistics for Max {&self,col_stats: &ColumnStatistics,) -> Option<ScalarValue> {- if let Precision::Exact(ref val) = col_stats.max_value {- if !val.is_null() {- return Some(val.clone());- }+ if let Precision::Exact(ref val) = col_stats.max_value+ && !val.is_null()+ {+ return Some(val.clone());}None}@@ -480,10 +480,10 @@ impl FromColumnStatistics for Min {&self,col_stats: &ColumnStatistics,) -> Option<ScalarValue> {- if let Precision::Exact(ref val) = col_stats.min_value {- if !val.is_null() {- return Some(val.clone());- }+ if let Precision::Exact(ref val) = col_stats.min_value+ && !val.is_null()+ {+ return Some(val.clone());}None}diff --git a/datafusion/functions-aggregate/src/min_max/min_max_bytes.rs b/datafusion/functions-aggregate/src/min_max/min_max_bytes.rsindex 30b2739c08..e4ac7eccf5 100644--- a/datafusion/functions-aggregate/src/min_max/min_max_bytes.rs+++ b/datafusion/functions-aggregate/src/min_max/min_max_bytes.rs@@ -21,7 +21,7 @@ use arrow::array::{};use arrow::datatypes::DataType;use datafusion_common::hash_map::Entry;-use datafusion_common::{internal_err, HashMap, Result};+use datafusion_common::{HashMap, Result, internal_err};use datafusion_expr::{EmitTo, GroupsAccumulator};use datafusion_functions_aggregate_common::aggregate::groups_accumulator::nulls::apply_filter_as_nulls;use std::mem::size_of;diff --git a/datafusion/functions-aggregate/src/min_max/min_max_struct.rs b/datafusion/functions-aggregate/src/min_max/min_max_struct.rsindex 8038f2f01d..796fd586ca 100644--- a/datafusion/functions-aggregate/src/min_max/min_max_struct.rs+++ b/datafusion/functions-aggregate/src/min_max/min_max_struct.rs@@ -24,9 +24,8 @@ use arrow::{datatypes::DataType,};use datafusion_common::{- internal_err,+ Result, internal_err,scalar::{copy_array_data, partial_cmp_struct},- Result,};use datafusion_expr::{EmitTo, GroupsAccumulator};use datafusion_functions_aggregate_common::aggregate::groups_accumulator::nulls::apply_filter_as_nulls;diff --git a/datafusion/functions-aggregate/src/nth_value.rs b/datafusion/functions-aggregate/src/nth_value.rsindex 05026940fe..bc343a1969 100644--- a/datafusion/functions-aggregate/src/nth_value.rs+++ b/datafusion/functions-aggregate/src/nth_value.rs@@ -23,18 +23,18 @@ use std::collections::VecDeque;use std::mem::{size_of, size_of_val};use std::sync::Arc;-use arrow::array::{new_empty_array, ArrayRef, AsArray, StructArray};+use arrow::array::{ArrayRef, AsArray, StructArray, new_empty_array};use arrow::datatypes::{DataType, Field, FieldRef, Fields};-use datafusion_common::utils::{get_row_at_idx, SingleRowListArrayBuilder};+use datafusion_common::utils::{SingleRowListArrayBuilder, get_row_at_idx};use datafusion_common::{- assert_or_internal_err, exec_err, not_impl_err, Result, ScalarValue,+ Result, ScalarValue, assert_or_internal_err, exec_err, not_impl_err,};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::utils::format_state_name;use datafusion_expr::{- lit, Accumulator, AggregateUDFImpl, Documentation, ExprFunctionExt, ReversedUDAF,- Signature, SortExpr, Volatility,+ Accumulator, AggregateUDFImpl, Documentation, ExprFunctionExt, ReversedUDAF,+ Signature, SortExpr, Volatility, lit,};use datafusion_functions_aggregate_common::merge_arrays::merge_ordered_arrays;use datafusion_functions_aggregate_common::utils::ordering_fields;@@ -146,7 +146,7 @@ impl AggregateUDFImpl for NthValueAgg {"{} not supported for n: {}",self.name(),&acc_args.exprs[1]- )+ );}};diff --git a/datafusion/functions-aggregate/src/percentile_cont.rs b/datafusion/functions-aggregate/src/percentile_cont.rsindex 1ea896d4b3..d6c8eabb45 100644--- a/datafusion/functions-aggregate/src/percentile_cont.rs+++ b/datafusion/functions-aggregate/src/percentile_cont.rs@@ -26,8 +26,8 @@ use arrow::buffer::{OffsetBuffer, ScalarBuffer};use arrow::{array::{Array, ArrayRef, AsArray},datatypes::{- ArrowNativeType, DataType, Decimal128Type, Decimal256Type, Decimal32Type,- Decimal64Type, Field, FieldRef, Float16Type, Float32Type, Float64Type,+ ArrowNativeType, DataType, Decimal32Type, Decimal64Type, Decimal128Type,+ Decimal256Type, Field, FieldRef, Float16Type, Float32Type, Float64Type,},};@@ -35,21 +35,21 @@ use arrow::array::ArrowNativeTypeOp;use crate::min_max::{max_udaf, min_udaf};use datafusion_common::{- assert_eq_or_internal_err, internal_datafusion_err, plan_err,- utils::take_function_args, DataFusionError, Result, ScalarValue,+ DataFusionError, Result, ScalarValue, assert_eq_or_internal_err,+ internal_datafusion_err, plan_err, utils::take_function_args,};use datafusion_expr::type_coercion::aggregates::NUMERICS;use datafusion_expr::utils::format_state_name;-use datafusion_expr::{- expr::{AggregateFunction, Cast, Sort},- function::{AccumulatorArgs, AggregateFunctionSimplification, StateFieldsArgs},- simplify::SimplifyInfo,-};use datafusion_expr::{Accumulator, AggregateUDFImpl, Documentation, Expr, Signature, TypeSignature,Volatility,};use datafusion_expr::{EmitTo, GroupsAccumulator};+use datafusion_expr::{+ expr::{AggregateFunction, Cast, Sort},+ function::{AccumulatorArgs, AggregateFunctionSimplification, StateFieldsArgs},+ simplify::SimplifyInfo,+};use datafusion_functions_aggregate_common::aggregate::groups_accumulator::accumulate::accumulate;use datafusion_functions_aggregate_common::aggregate::groups_accumulator::nulls::filtered_null_mask;use datafusion_functions_aggregate_common::utils::GenericDistinctBuffer;@@ -287,12 +287,14 @@ impl AggregateUDFImpl for PercentileCont {"percentile_cont"};- Ok(vec![Field::new(- format_state_name(args.name, state_name),- DataType::List(Arc::new(field)),- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, state_name),+ DataType::List(Arc::new(field)),+ true,+ )+ .into(),+ ])}fn accumulator(&self, acc_args: AccumulatorArgs) -> Result<Box<dyn Accumulator>> {diff --git a/datafusion/functions-aggregate/src/planner.rs b/datafusion/functions-aggregate/src/planner.rsindex f0e37f6b1d..8a6d9b9bb1 100644--- a/datafusion/functions-aggregate/src/planner.rs+++ b/datafusion/functions-aggregate/src/planner.rs@@ -19,11 +19,11 @@use datafusion_common::Result;use datafusion_expr::{+ Expr,expr::{AggregateFunction, AggregateFunctionParams},expr_rewriter::NamePreserver,planner::{ExprPlanner, PlannerResult, RawAggregateExpr},utils::COUNT_STAR_EXPANSION,- Expr,};#[derive(Debug)]diff --git a/datafusion/functions-aggregate/src/regr.rs b/datafusion/functions-aggregate/src/regr.rsindex 8d2a68a0ad..bbc5567dab 100644--- a/datafusion/functions-aggregate/src/regr.rs+++ b/datafusion/functions-aggregate/src/regr.rs@@ -26,7 +26,7 @@ use arrow::{datatypes::Field,};use datafusion_common::{- downcast_value, plan_err, unwrap_or_internal_err, HashMap, Result, ScalarValue,+ HashMap, Result, ScalarValue, downcast_value, plan_err, unwrap_or_internal_err,};use datafusion_doc::aggregate_doc_sections::DOC_SECTION_STATISTICAL;use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};diff --git a/datafusion/functions-aggregate/src/stddev.rs b/datafusion/functions-aggregate/src/stddev.rsindex 782524aa4d..13eb5e1660 100644--- a/datafusion/functions-aggregate/src/stddev.rs+++ b/datafusion/functions-aggregate/src/stddev.rs@@ -26,8 +26,8 @@ use std::sync::Arc;use arrow::array::Float64Array;use arrow::datatypes::FieldRef;use arrow::{array::ArrayRef, datatypes::DataType, datatypes::Field};-use datafusion_common::{internal_err, not_impl_err, Result};-use datafusion_common::{plan_err, ScalarValue};+use datafusion_common::{Result, internal_err, not_impl_err};+use datafusion_common::{ScalarValue, plan_err};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};use datafusion_expr::utils::format_state_name;use datafusion_expr::{@@ -473,12 +473,16 @@ mod tests {let mut accum1 = agg1.accumulator(args1)?;let mut accum2 = agg2.accumulator(args2)?;- let value1 = vec![col("a", schema)?- .evaluate(batch1)- .and_then(|v| v.into_array(batch1.num_rows()))?];- let value2 = vec![col("a", schema)?- .evaluate(batch2)- .and_then(|v| v.into_array(batch2.num_rows()))?];+ let value1 = vec![+ col("a", schema)?+ .evaluate(batch1)+ .and_then(|v| v.into_array(batch1.num_rows()))?,+ ];+ let value2 = vec![+ col("a", schema)?+ .evaluate(batch2)+ .and_then(|v| v.into_array(batch2.num_rows()))?,+ ];accum1.update_batch(&value1)?;accum2.update_batch(&value2)?;diff --git a/datafusion/functions-aggregate/src/string_agg.rs b/datafusion/functions-aggregate/src/string_agg.rsindex 4a040df7b4..77e9f60afd 100644--- a/datafusion/functions-aggregate/src/string_agg.rs+++ b/datafusion/functions-aggregate/src/string_agg.rs@@ -29,7 +29,7 @@ use datafusion_common::cast::{as_generic_string_array, as_string_array, as_string_view_array,};use datafusion_common::{- internal_datafusion_err, internal_err, not_impl_err, Result, ScalarValue,+ Result, ScalarValue, internal_datafusion_err, internal_err, not_impl_err,};use datafusion_expr::function::AccumulatorArgs;use datafusion_expr::utils::format_state_name;@@ -150,12 +150,14 @@ impl AggregateUDFImpl for StringAgg {(args.ordering_fields.is_empty()) && (!args.is_distinct);if no_order_no_distinct {// Case `SimpleStringAggAccumulator`- Ok(vec![Field::new(- format_state_name(args.name, "string_agg"),- DataType::LargeUtf8,- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, "string_agg"),+ DataType::LargeUtf8,+ true,+ )+ .into(),+ ])} else {// Case `StringAggAccumulator`self.array_agg.state_fields(args)@@ -252,7 +254,10 @@ impl Accumulator for StringAggAccumulator {let scalar = self.array_agg_acc.evaluate()?;let ScalarValue::List(list) = scalar else {- return internal_err!("Expected a DataType::List while evaluating underlying ArrayAggAccumulator, but got {}", scalar.data_type());+ return internal_err!(+ "Expected a DataType::List while evaluating underlying ArrayAggAccumulator, but got {}",+ scalar.data_type()+ );};let string_arr: Vec<_> = match list.value_type() {@@ -272,7 +277,7 @@ impl Accumulator for StringAggAccumulator {return internal_err!("Expected elements to of type Utf8 or LargeUtf8, but got {}",list.value_type()- )+ );}};diff --git a/datafusion/functions-aggregate/src/sum.rs b/datafusion/functions-aggregate/src/sum.rsindex d40709a467..198ba54adf 100644--- a/datafusion/functions-aggregate/src/sum.rs+++ b/datafusion/functions-aggregate/src/sum.rs@@ -21,19 +21,19 @@ use ahash::RandomState;use arrow::array::{Array, ArrayRef, ArrowNativeTypeOp, ArrowNumericType, AsArray};use arrow::datatypes::Field;use arrow::datatypes::{- ArrowNativeType, DataType, Decimal128Type, Decimal256Type, Decimal32Type,- Decimal64Type, DurationMicrosecondType, DurationMillisecondType,- DurationNanosecondType, DurationSecondType, FieldRef, Float64Type, Int64Type,- TimeUnit, UInt64Type, DECIMAL128_MAX_PRECISION, DECIMAL256_MAX_PRECISION,- DECIMAL32_MAX_PRECISION, DECIMAL64_MAX_PRECISION,+ ArrowNativeType, DECIMAL32_MAX_PRECISION, DECIMAL64_MAX_PRECISION,+ DECIMAL128_MAX_PRECISION, DECIMAL256_MAX_PRECISION, DataType, Decimal32Type,+ Decimal64Type, Decimal128Type, Decimal256Type, DurationMicrosecondType,+ DurationMillisecondType, DurationNanosecondType, DurationSecondType, FieldRef,+ Float64Type, Int64Type, TimeUnit, UInt64Type,};use datafusion_common::types::{- logical_float64, logical_int16, logical_int32, logical_int64, logical_int8,- logical_uint16, logical_uint32, logical_uint64, logical_uint8, NativeType,+ NativeType, logical_float64, logical_int8, logical_int16, logical_int32,+ logical_int64, logical_uint8, logical_uint16, logical_uint32, logical_uint64,};-use datafusion_common::{exec_err, not_impl_err, HashMap, Result, ScalarValue};+use datafusion_common::{HashMap, Result, ScalarValue, exec_err, not_impl_err};use datafusion_expr::function::{AccumulatorArgs, StateFieldsArgs};-use datafusion_expr::utils::{format_state_name, AggregateOrderSensitivity};+use datafusion_expr::utils::{AggregateOrderSensitivity, format_state_name};use datafusion_expr::{Accumulator, AggregateUDFImpl, Coercion, Documentation, Expr, GroupsAccumulator,ReversedUDAF, SetMonotonicity, Signature, TypeSignature, TypeSignatureClass,@@ -260,20 +260,24 @@ impl AggregateUDFImpl for Sum {fn state_fields(&self, args: StateFieldsArgs) -> Result<Vec<FieldRef>> {if args.is_distinct {- Ok(vec![Field::new_list(- format_state_name(args.name, "sum distinct"),- // See COMMENTS.md to understand why nullable is set to true- Field::new_list_field(args.return_type().clone(), true),- false,- )- .into()])+ Ok(vec![+ Field::new_list(+ format_state_name(args.name, "sum distinct"),+ // See COMMENTS.md to understand why nullable is set to true+ Field::new_list_field(args.return_type().clone(), true),+ false,+ )+ .into(),+ ])} else {- Ok(vec![Field::new(- format_state_name(args.name, "sum"),- args.return_type().clone(),- true,- )- .into()])+ Ok(vec![+ Field::new(+ format_state_name(args.name, "sum"),+ args.return_type().clone(),+ true,+ )+ .into(),+ ])}}diff --git a/datafusion/functions-aggregate/src/utils.rs b/datafusion/functions-aggregate/src/utils.rsindex c058b64f95..5e1925fcdb 100644--- a/datafusion/functions-aggregate/src/utils.rs+++ b/datafusion/functions-aggregate/src/utils.rs@@ -19,7 +19,7 @@ use std::sync::Arc;use arrow::array::RecordBatch;use arrow::datatypes::Schema;-use datafusion_common::{internal_err, plan_err, DataFusionError, Result, ScalarValue};+use datafusion_common::{DataFusionError, Result, ScalarValue, internal_err, plan_err};use datafusion_expr::ColumnarValue;use datafusion_physical_expr_common::physical_expr::PhysicalExpr;@@ -58,7 +58,7 @@ pub(crate) fn validate_percentile_expr(return plan_err!("Percentile value for '{fn_name}' must be Float32 or Float64 literal (got data type {})",sv.data_type()- )+ );}};diff --git a/datafusion/functions-aggregate/src/variance.rs b/datafusion/functions-aggregate/src/variance.rsindex 846c145cb1..e6978c15d0 100644--- a/datafusion/functions-aggregate/src/variance.rs+++ b/datafusion/functions-aggregate/src/variance.rs@@ -25,12 +25,12 @@ use arrow::{compute::kernels::cast,datatypes::{DataType, Field},};-use datafusion_common::{downcast_value, not_impl_err, plan_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, downcast_value, not_impl_err, plan_err};use datafusion_expr::{- function::{AccumulatorArgs, StateFieldsArgs},- utils::format_state_name,Accumulator, AggregateUDFImpl, Documentation, GroupsAccumulator, Signature,Volatility,+ function::{AccumulatorArgs, StateFieldsArgs},+ utils::format_state_name,};use datafusion_functions_aggregate_common::{aggregate::groups_accumulator::accumulate::accumulate, stats::StatsType,diff --git a/datafusion/functions-window/Cargo.toml b/datafusion/functions-window/Cargo.tomlindex 42690907ae..fbe6a34f29 100644--- a/datafusion/functions-window/Cargo.toml+++ b/datafusion/functions-window/Cargo.toml@@ -21,7 +21,7 @@ description = "Window function packages for the DataFusion query engine"keywords = ["datafusion", "logical", "plan", "expressions"]readme = "README.md"version = { workspace = true }-edition = { workspace = true }+edition = "2024"homepage = { workspace = true }repository = { workspace = true }license = { workspace = true }diff --git a/datafusion/functions-window/src/cume_dist.rs b/datafusion/functions-window/src/cume_dist.rsindex 536526e784..dccb9148d2 100644--- a/datafusion/functions-window/src/cume_dist.rs+++ b/datafusion/functions-window/src/cume_dist.rs@@ -18,10 +18,10 @@//! `cume_dist` window function implementationuse arrow::datatypes::FieldRef;+use datafusion_common::Result;use datafusion_common::arrow::array::{ArrayRef, Float64Array};use datafusion_common::arrow::datatypes::DataType;use datafusion_common::arrow::datatypes::Field;-use datafusion_common::Result;use datafusion_expr::{Documentation, LimitEffect, PartitionEvaluator, Signature, Volatility, WindowUDFImpl,};diff --git a/datafusion/functions-window/src/lead_lag.rs b/datafusion/functions-window/src/lead_lag.rsindex b3d8a55065..7569dac9ac 100644--- a/datafusion/functions-window/src/lead_lag.rs+++ b/datafusion/functions-window/src/lead_lag.rs@@ -22,7 +22,7 @@ use arrow::datatypes::FieldRef;use datafusion_common::arrow::array::ArrayRef;use datafusion_common::arrow::datatypes::DataType;use datafusion_common::arrow::datatypes::Field;-use datafusion_common::{arrow_datafusion_err, DataFusionError, Result, ScalarValue};+use datafusion_common::{DataFusionError, Result, ScalarValue, arrow_datafusion_err};use datafusion_doc::window_doc_sections::DOC_SECTION_ANALYTICAL;use datafusion_expr::{Documentation, LimitEffect, Literal, PartitionEvaluator, ReversedUDWF, Signature,diff --git a/datafusion/functions-window/src/lib.rs b/datafusion/functions-window/src/lib.rsindex 89a54bd866..3003133873 100644--- a/datafusion/functions-window/src/lib.rs+++ b/datafusion/functions-window/src/lib.rs@@ -38,8 +38,8 @@ use std::sync::Arc;use log::debug;-use datafusion_expr::registry::FunctionRegistry;use datafusion_expr::WindowUDF;+use datafusion_expr::registry::FunctionRegistry;#[macro_use]pub mod macros;diff --git a/datafusion/functions-window/src/nth_value.rs b/datafusion/functions-window/src/nth_value.rsindex 82492de2e1..be08f25ec4 100644--- a/datafusion/functions-window/src/nth_value.rs+++ b/datafusion/functions-window/src/nth_value.rs@@ -22,7 +22,7 @@ use crate::utils::{get_scalar_value_from_args, get_signed_integer};use arrow::datatypes::FieldRef;use datafusion_common::arrow::array::ArrayRef;use datafusion_common::arrow::datatypes::{DataType, Field};-use datafusion_common::{exec_datafusion_err, exec_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_datafusion_err, exec_err};use datafusion_doc::window_doc_sections::DOC_SECTION_ANALYTICAL;use datafusion_expr::window_state::WindowAggState;use datafusion_expr::{@@ -276,27 +276,30 @@ impl WindowUDFImpl for NthValue {}));}- let n =- match get_scalar_value_from_args(partition_evaluator_args.input_exprs(), 1)- .map_err(|_e| {- exec_datafusion_err!(- "Expected a signed integer literal for the second argument of nth_value")- })?- .map(|v| get_signed_integer(&v))- {- Some(Ok(n)) => {- if partition_evaluator_args.is_reversed() {- -n- } else {- n- }- }- _ => {- return exec_err!(+ let n = match get_scalar_value_from_args(+ partition_evaluator_args.input_exprs(),+ 1,+ )+ .map_err(|_e| {+ exec_datafusion_err!("Expected a signed integer literal for the second argument of nth_value")+ })?+ .map(|v| get_signed_integer(&v))+ {+ Some(Ok(n)) => {+ if partition_evaluator_args.is_reversed() {+ -n+ } else {+ n}- };+ }+ _ => {+ return exec_err!(+ "Expected a signed integer literal for the second argument of nth_value"+ );+ }+ };Ok(Box::new(NthValueEvaluator {state,diff --git a/datafusion/functions-window/src/ntile.rs b/datafusion/functions-window/src/ntile.rsindex df0a168f2a..21ce2795b4 100644--- a/datafusion/functions-window/src/ntile.rs+++ b/datafusion/functions-window/src/ntile.rs@@ -23,7 +23,7 @@ use crate::utils::{use arrow::datatypes::FieldRef;use datafusion_common::arrow::array::{ArrayRef, UInt64Array};use datafusion_common::arrow::datatypes::{DataType, Field};-use datafusion_common::{exec_datafusion_err, exec_err, Result};+use datafusion_common::{Result, exec_datafusion_err, exec_err};use datafusion_expr::{Documentation, LimitEffect, PartitionEvaluator, Signature, Volatility, WindowUDFImpl,};diff --git a/datafusion/functions-window/src/planner.rs b/datafusion/functions-window/src/planner.rsindex 84836ad569..6f4eb2051f 100644--- a/datafusion/functions-window/src/planner.rs+++ b/datafusion/functions-window/src/planner.rs@@ -19,11 +19,11 @@use datafusion_common::Result;use datafusion_expr::{+ Expr,expr::{WindowFunction, WindowFunctionParams},expr_rewriter::NamePreserver,planner::{ExprPlanner, PlannerResult, RawWindowExpr},utils::COUNT_STAR_EXPANSION,- Expr,};#[derive(Debug)]diff --git a/datafusion/functions-window/src/rank.rs b/datafusion/functions-window/src/rank.rsindex 2d6ad6cbc0..9d5af64eb9 100644--- a/datafusion/functions-window/src/rank.rs+++ b/datafusion/functions-window/src/rank.rs@@ -25,7 +25,7 @@ use datafusion_common::arrow::compute::SortOptions;use datafusion_common::arrow::datatypes::DataType;use datafusion_common::arrow::datatypes::Field;use datafusion_common::utils::get_row_at_idx;-use datafusion_common::{exec_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err};use datafusion_doc::window_doc_sections::DOC_SECTION_RANKING;use datafusion_expr::{Documentation, LimitEffect, PartitionEvaluator, Signature, Volatility, WindowUDFImpl,diff --git a/datafusion/functions-window/src/utils.rs b/datafusion/functions-window/src/utils.rsindex ee4813e046..4d0c4d181a 100644--- a/datafusion/functions-window/src/utils.rs+++ b/datafusion/functions-window/src/utils.rs@@ -16,7 +16,7 @@// under the License.use datafusion_common::arrow::datatypes::DataType;-use datafusion_common::{exec_err, DataFusionError, Result, ScalarValue};+use datafusion_common::{DataFusionError, Result, ScalarValue, exec_err};use datafusion_physical_expr::expressions::Literal;use datafusion_physical_expr_common::physical_expr::PhysicalExpr;use std::sync::Arc;diff --git a/datafusion/functions/Cargo.toml b/datafusion/functions/Cargo.tomlindex a384e5635d..ebb71861d1 100644--- a/datafusion/functions/Cargo.toml+++ b/datafusion/functions/Cargo.toml@@ -21,7 +21,7 @@ description = "Function packages for the DataFusion query engine"keywords = ["datafusion", "logical", "plan", "expressions"]readme = "README.md"version = { workspace = true }-edition = { workspace = true }+edition = "2024"homepage = { workspace = true }repository = { workspace = true }license = { workspace = true }diff --git a/datafusion/functions/benches/ascii.rs b/datafusion/functions/benches/ascii.rsindex 03d25e9c3d..66d81261bf 100644--- a/datafusion/functions/benches/ascii.rs+++ b/datafusion/functions/benches/ascii.rs@@ -19,7 +19,7 @@ extern crate criterion;mod helper;use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::ScalarFunctionArgs;use helper::gen_string_array;diff --git a/datafusion/functions/benches/character_length.rs b/datafusion/functions/benches/character_length.rsindex 4a1a63d627..35a0cf886b 100644--- a/datafusion/functions/benches/character_length.rs+++ b/datafusion/functions/benches/character_length.rs@@ -18,7 +18,7 @@extern crate criterion;use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::ScalarFunctionArgs;use helper::gen_string_array;diff --git a/datafusion/functions/benches/chr.rs b/datafusion/functions/benches/chr.rsindex 8356cf7c31..9a6342ca40 100644--- a/datafusion/functions/benches/chr.rs+++ b/datafusion/functions/benches/chr.rs@@ -18,7 +18,7 @@extern crate criterion;use arrow::{array::PrimitiveArray, datatypes::Int64Type};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::string::chr;use rand::{Rng, SeedableRng};diff --git a/datafusion/functions/benches/concat.rs b/datafusion/functions/benches/concat.rsindex 09200139a2..f7ef978920 100644--- a/datafusion/functions/benches/concat.rs+++ b/datafusion/functions/benches/concat.rs@@ -18,9 +18,9 @@use arrow::array::ArrayRef;use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::create_string_array_with_len;-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};-use datafusion_common::config::ConfigOptions;+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::string::concat;use std::hint::black_box;diff --git a/datafusion/functions/benches/cot.rs b/datafusion/functions/benches/cot.rsindex 97f21ccd6d..c47198d4a6 100644--- a/datafusion/functions/benches/cot.rs+++ b/datafusion/functions/benches/cot.rs@@ -21,7 +21,7 @@ use arrow::{datatypes::{Float32Type, Float64Type},util::bench_util::create_primitive_array,};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::math::cot;use std::hint::black_box;diff --git a/datafusion/functions/benches/date_bin.rs b/datafusion/functions/benches/date_bin.rsindex 74390491d5..eb4e960d83 100644--- a/datafusion/functions/benches/date_bin.rs+++ b/datafusion/functions/benches/date_bin.rs@@ -22,13 +22,13 @@ use std::sync::Arc;use arrow::array::{Array, ArrayRef, TimestampSecondArray};use arrow::datatypes::Field;-use criterion::{criterion_group, criterion_main, Criterion};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::datetime::date_bin;-use rand::rngs::ThreadRng;use rand::Rng;+use rand::rngs::ThreadRng;fn timestamps(rng: &mut ThreadRng) -> TimestampSecondArray {let mut seconds = vec![];diff --git a/datafusion/functions/benches/date_trunc.rs b/datafusion/functions/benches/date_trunc.rsindex 498a3e63ef..f5c8ceb5fe 100644--- a/datafusion/functions/benches/date_trunc.rs+++ b/datafusion/functions/benches/date_trunc.rs@@ -22,13 +22,13 @@ use std::sync::Arc;use arrow::array::{Array, ArrayRef, TimestampSecondArray};use arrow::datatypes::Field;-use criterion::{criterion_group, criterion_main, Criterion};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::datetime::date_trunc;-use rand::rngs::ThreadRng;use rand::Rng;+use rand::rngs::ThreadRng;fn timestamps(rng: &mut ThreadRng) -> TimestampSecondArray {let mut seconds = vec![];diff --git a/datafusion/functions/benches/encoding.rs b/datafusion/functions/benches/encoding.rsindex 98faee91e1..8a7c2b7b66 100644--- a/datafusion/functions/benches/encoding.rs+++ b/datafusion/functions/benches/encoding.rs@@ -20,7 +20,7 @@ extern crate criterion;use arrow::array::Array;use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::create_string_array_with_len;-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::encoding;diff --git a/datafusion/functions/benches/find_in_set.rs b/datafusion/functions/benches/find_in_set.rsindex a928f56558..e207c1fa48 100644--- a/datafusion/functions/benches/find_in_set.rs+++ b/datafusion/functions/benches/find_in_set.rs@@ -22,9 +22,9 @@ use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::{create_string_array_with_len, create_string_view_array_with_len,};-use criterion::{criterion_group, criterion_main, Criterion, SamplingMode};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, SamplingMode, criterion_group, criterion_main};use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use rand::distr::Alphanumeric;use rand::prelude::StdRng;diff --git a/datafusion/functions/benches/gcd.rs b/datafusion/functions/benches/gcd.rsindex 19e196d9a3..9705af8a2f 100644--- a/datafusion/functions/benches/gcd.rs+++ b/datafusion/functions/benches/gcd.rs@@ -22,9 +22,9 @@ use arrow::{array::{ArrayRef, Int64Array},datatypes::DataType,};-use criterion::{criterion_group, criterion_main, Criterion};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::math::gcd;use rand::Rng;diff --git a/datafusion/functions/benches/helper.rs b/datafusion/functions/benches/helper.rsindex a2b110ae4d..d6d6afd48f 100644--- a/datafusion/functions/benches/helper.rs+++ b/datafusion/functions/benches/helper.rs@@ -18,7 +18,7 @@use arrow::array::{StringArray, StringViewArray};use datafusion_expr::ColumnarValue;use rand::distr::Alphanumeric;-use rand::{rngs::StdRng, Rng, SeedableRng};+use rand::{Rng, SeedableRng, rngs::StdRng};use std::sync::Arc;/// gen_arr(4096, 128, 0.1, 0.1, true) will generate a StringViewArray withdiff --git a/datafusion/functions/benches/initcap.rs b/datafusion/functions/benches/initcap.rsindex 50aee8dbb9..ba055d58f5 100644--- a/datafusion/functions/benches/initcap.rs+++ b/datafusion/functions/benches/initcap.rs@@ -22,7 +22,7 @@ use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::{create_string_array_with_len, create_string_view_array_with_len,};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::unicode;diff --git a/datafusion/functions/benches/isnan.rs b/datafusion/functions/benches/isnan.rsindex 4a90d45d66..d4e41e882f 100644--- a/datafusion/functions/benches/isnan.rs+++ b/datafusion/functions/benches/isnan.rs@@ -22,7 +22,7 @@ use arrow::{datatypes::{Float32Type, Float64Type},util::bench_util::create_primitive_array,};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::math::isnan;diff --git a/datafusion/functions/benches/iszero.rs b/datafusion/functions/benches/iszero.rsindex 961cba7200..53e38745af 100644--- a/datafusion/functions/benches/iszero.rs+++ b/datafusion/functions/benches/iszero.rs@@ -22,7 +22,7 @@ use arrow::{datatypes::{Float32Type, Float64Type},util::bench_util::create_primitive_array,};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::math::iszero;diff --git a/datafusion/functions/benches/lower.rs b/datafusion/functions/benches/lower.rsindex 6a5178b87f..333dca3900 100644--- a/datafusion/functions/benches/lower.rs+++ b/datafusion/functions/benches/lower.rs@@ -22,7 +22,7 @@ use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::{create_string_array_with_len, create_string_view_array_with_len,};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::string;diff --git a/datafusion/functions/benches/ltrim.rs b/datafusion/functions/benches/ltrim.rsindex 4458af6143..3fce426a91 100644--- a/datafusion/functions/benches/ltrim.rs+++ b/datafusion/functions/benches/ltrim.rs@@ -20,14 +20,14 @@ extern crate criterion;use arrow::array::{ArrayRef, LargeStringArray, StringArray, StringViewArray};use arrow::datatypes::{DataType, Field};use criterion::{- criterion_group, criterion_main, measurement::Measurement, BenchmarkGroup, Criterion,- SamplingMode,+ BenchmarkGroup, Criterion, SamplingMode, criterion_group, criterion_main,+ measurement::Measurement,};-use datafusion_common::config::ConfigOptions;use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDF};use datafusion_functions::string;-use rand::{distr::Alphanumeric, rngs::StdRng, Rng, SeedableRng};+use rand::{Rng, SeedableRng, distr::Alphanumeric, rngs::StdRng};use std::hint::black_box;use std::{fmt, sync::Arc};diff --git a/datafusion/functions/benches/make_date.rs b/datafusion/functions/benches/make_date.rsindex 15a895468d..8b1b32edfc 100644--- a/datafusion/functions/benches/make_date.rs+++ b/datafusion/functions/benches/make_date.rs@@ -22,13 +22,13 @@ use std::sync::Arc;use arrow::array::{Array, ArrayRef, Int32Array};use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::datetime::make_date;-use rand::rngs::ThreadRng;use rand::Rng;+use rand::rngs::ThreadRng;fn years(rng: &mut ThreadRng) -> Int32Array {let mut years = vec![];diff --git a/datafusion/functions/benches/nullif.rs b/datafusion/functions/benches/nullif.rsindex d649697cc5..f937d19421 100644--- a/datafusion/functions/benches/nullif.rs+++ b/datafusion/functions/benches/nullif.rs@@ -19,9 +19,9 @@ extern crate criterion;use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::create_string_array_with_len;-use criterion::{criterion_group, criterion_main, Criterion};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::core::nullif;use std::hint::black_box;diff --git a/datafusion/functions/benches/pad.rs b/datafusion/functions/benches/pad.rsindex bdd1d3c367..c9220d8d3f 100644--- a/datafusion/functions/benches/pad.rs+++ b/datafusion/functions/benches/pad.rs@@ -20,13 +20,13 @@ use arrow::datatypes::{DataType, Field, Int64Type};use arrow::util::bench_util::{create_string_array_with_len, create_string_view_array_with_len,};-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};-use datafusion_common::config::ConfigOptions;+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};use datafusion_common::DataFusionError;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::unicode::{lpad, rpad};-use rand::distr::{Distribution, Uniform};use rand::Rng;+use rand::distr::{Distribution, Uniform};use std::hint::black_box;use std::sync::Arc;diff --git a/datafusion/functions/benches/random.rs b/datafusion/functions/benches/random.rsindex 88efb2d1b5..3d8631140c 100644--- a/datafusion/functions/benches/random.rs+++ b/datafusion/functions/benches/random.rs@@ -18,7 +18,7 @@extern crate criterion;use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl};use datafusion_functions::math::random::RandomFunc;diff --git a/datafusion/functions/benches/regx.rs b/datafusion/functions/benches/regx.rsindex a415330245..32378ccd12 100644--- a/datafusion/functions/benches/regx.rs+++ b/datafusion/functions/benches/regx.rs@@ -21,16 +21,16 @@ use arrow::array::builder::StringBuilder;use arrow::array::{ArrayRef, AsArray, Int64Array, StringArray, StringViewArray};use arrow::compute::cast;use arrow::datatypes::DataType;-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_functions::regex::regexpcount::regexp_count_func;use datafusion_functions::regex::regexpinstr::regexp_instr_func;use datafusion_functions::regex::regexplike::regexp_like;use datafusion_functions::regex::regexpmatch::regexp_match;use datafusion_functions::regex::regexpreplace::regexp_replace;+use rand::Rng;use rand::distr::Alphanumeric;use rand::prelude::IndexedRandom;use rand::rngs::ThreadRng;-use rand::Rng;use std::hint::black_box;use std::iter;use std::sync::Arc;diff --git a/datafusion/functions/benches/repeat.rs b/datafusion/functions/benches/repeat.rsindex 80ffa8ee38..304739b42f 100644--- a/datafusion/functions/benches/repeat.rs+++ b/datafusion/functions/benches/repeat.rs@@ -22,9 +22,9 @@ use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::{create_string_array_with_len, create_string_view_array_with_len,};-use criterion::{criterion_group, criterion_main, Criterion, SamplingMode};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, SamplingMode, criterion_group, criterion_main};use datafusion_common::DataFusionError;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::string;use std::hint::black_box;diff --git a/datafusion/functions/benches/reverse.rs b/datafusion/functions/benches/reverse.rsindex b1eca654fb..73f5be5b45 100644--- a/datafusion/functions/benches/reverse.rs+++ b/datafusion/functions/benches/reverse.rs@@ -19,7 +19,7 @@ extern crate criterion;mod helper;use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::ScalarFunctionArgs;use helper::gen_string_array;diff --git a/datafusion/functions/benches/signum.rs b/datafusion/functions/benches/signum.rsindex 24b8861e4d..08a197a60e 100644--- a/datafusion/functions/benches/signum.rs+++ b/datafusion/functions/benches/signum.rs@@ -22,7 +22,7 @@ use arrow::{datatypes::{Field, Float32Type, Float64Type},util::bench_util::create_primitive_array,};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::math::signum;diff --git a/datafusion/functions/benches/strpos.rs b/datafusion/functions/benches/strpos.rsindex 18a99e44bf..9babf1d05c 100644--- a/datafusion/functions/benches/strpos.rs+++ b/datafusion/functions/benches/strpos.rs@@ -19,7 +19,7 @@ extern crate criterion;use arrow::array::{StringArray, StringViewArray};use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use rand::distr::Alphanumeric;diff --git a/datafusion/functions/benches/substr.rs b/datafusion/functions/benches/substr.rsindex 542c013465..a6989c1bca 100644--- a/datafusion/functions/benches/substr.rs+++ b/datafusion/functions/benches/substr.rs@@ -22,9 +22,9 @@ use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::{create_string_array_with_len, create_string_view_array_with_len,};-use criterion::{criterion_group, criterion_main, Criterion, SamplingMode};-use datafusion_common::config::ConfigOptions;+use criterion::{Criterion, SamplingMode, criterion_group, criterion_main};use datafusion_common::DataFusionError;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::unicode;use std::hint::black_box;diff --git a/datafusion/functions/benches/substr_index.rs b/datafusion/functions/benches/substr_index.rsindex d0941d9bae..88600317c9 100644--- a/datafusion/functions/benches/substr_index.rs+++ b/datafusion/functions/benches/substr_index.rs@@ -22,13 +22,13 @@ use std::sync::Arc;use arrow::array::{ArrayRef, Int64Array, StringArray};use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::unicode::substr_index;+use rand::Rng;use rand::distr::{Alphanumeric, Uniform};use rand::prelude::Distribution;-use rand::Rng;struct Filter<Dist, Test> {dist: Dist,diff --git a/datafusion/functions/benches/to_char.rs b/datafusion/functions/benches/to_char.rsindex 945508aec7..ac5b5dc7e0 100644--- a/datafusion/functions/benches/to_char.rs+++ b/datafusion/functions/benches/to_char.rs@@ -22,17 +22,17 @@ use std::sync::Arc;use arrow::array::{ArrayRef, Date32Array, StringArray};use arrow::datatypes::{DataType, Field};-use chrono::prelude::*;use chrono::TimeDelta;-use criterion::{criterion_group, criterion_main, Criterion};-use datafusion_common::config::ConfigOptions;+use chrono::prelude::*;+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;use datafusion_common::ScalarValue::TimestampNanosecond;+use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::datetime::to_char;+use rand::Rng;use rand::prelude::IndexedRandom;use rand::rngs::ThreadRng;-use rand::Rng;fn pick_date_in_range(rng: &mut ThreadRng,diff --git a/datafusion/functions/benches/to_hex.rs b/datafusion/functions/benches/to_hex.rsindex a75ed92587..7346b89847 100644--- a/datafusion/functions/benches/to_hex.rs+++ b/datafusion/functions/benches/to_hex.rs@@ -19,7 +19,7 @@ extern crate criterion;use arrow::datatypes::{DataType, Field, Int32Type, Int64Type};use arrow::util::bench_util::create_primitive_array;-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::string;diff --git a/datafusion/functions/benches/to_timestamp.rs b/datafusion/functions/benches/to_timestamp.rsindex a8f5c5816d..d95a197872 100644--- a/datafusion/functions/benches/to_timestamp.rs+++ b/datafusion/functions/benches/to_timestamp.rs@@ -24,7 +24,7 @@ use arrow::array::builder::StringBuilder;use arrow::array::{Array, ArrayRef, StringArray};use arrow::compute::cast;use arrow::datatypes::{DataType, Field, TimeUnit};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::datetime::to_timestamp;diff --git a/datafusion/functions/benches/trunc.rs b/datafusion/functions/benches/trunc.rsindex 6e225e0e70..d0a6e2be75 100644--- a/datafusion/functions/benches/trunc.rs+++ b/datafusion/functions/benches/trunc.rs@@ -21,7 +21,7 @@ use arrow::{datatypes::{Field, Float32Type, Float64Type},util::bench_util::create_primitive_array,};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::math::trunc;use std::hint::black_box;diff --git a/datafusion/functions/benches/upper.rs b/datafusion/functions/benches/upper.rsindex 7328b32574..51ce1da0fa 100644--- a/datafusion/functions/benches/upper.rs+++ b/datafusion/functions/benches/upper.rs@@ -19,7 +19,7 @@ extern crate criterion;use arrow::datatypes::{DataType, Field};use arrow::util::bench_util::create_string_array_with_len;-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_functions::string;diff --git a/datafusion/functions/benches/uuid.rs b/datafusion/functions/benches/uuid.rsindex 1368e2f2af..df9b2bed4b 100644--- a/datafusion/functions/benches/uuid.rs+++ b/datafusion/functions/benches/uuid.rs@@ -18,7 +18,7 @@extern crate criterion;use arrow::datatypes::{DataType, Field};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::config::ConfigOptions;use datafusion_expr::ScalarFunctionArgs;use datafusion_functions::string;diff --git a/datafusion/functions/src/core/arrow_cast.rs b/datafusion/functions/src/core/arrow_cast.rsindex 29d5d31328..a0101dc09d 100644--- a/datafusion/functions/src/core/arrow_cast.rs+++ b/datafusion/functions/src/core/arrow_cast.rs@@ -20,7 +20,7 @@use arrow::datatypes::{DataType, Field, FieldRef};use arrow::error::ArrowError;use datafusion_common::{- arrow_datafusion_err, exec_err, internal_err, Result, ScalarValue,+ Result, ScalarValue, arrow_datafusion_err, exec_err, internal_err,};use datafusion_common::{exec_datafusion_err, utils::take_function_args};use std::any::Any;diff --git a/datafusion/functions/src/core/arrowtypeof.rs b/datafusion/functions/src/core/arrowtypeof.rsindex f178890f93..f34a2abafd 100644--- a/datafusion/functions/src/core/arrowtypeof.rs+++ b/datafusion/functions/src/core/arrowtypeof.rs@@ -16,7 +16,7 @@// under the License.use arrow::datatypes::DataType;-use datafusion_common::{utils::take_function_args, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, utils::take_function_args};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;diff --git a/datafusion/functions/src/core/coalesce.rs b/datafusion/functions/src/core/coalesce.rsindex aab1f445d5..1404f68570 100644--- a/datafusion/functions/src/core/coalesce.rs+++ b/datafusion/functions/src/core/coalesce.rs@@ -16,7 +16,7 @@// under the License.use arrow::datatypes::{DataType, Field, FieldRef};-use datafusion_common::{exec_err, internal_err, plan_err, Result};+use datafusion_common::{Result, exec_err, internal_err, plan_err};use datafusion_expr::binary::try_type_union_resolution;use datafusion_expr::conditional_expressions::CaseBuilder;use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};diff --git a/datafusion/functions/src/core/getfield.rs b/datafusion/functions/src/core/getfield.rsindex 1194d11ba5..a1b4167d69 100644--- a/datafusion/functions/src/core/getfield.rs+++ b/datafusion/functions/src/core/getfield.rs@@ -16,16 +16,16 @@// under the License.use arrow::array::{- make_array, make_comparator, Array, BooleanArray, Capacities, MutableArrayData,- Scalar,+ Array, BooleanArray, Capacities, MutableArrayData, Scalar, make_array,+ make_comparator,};use arrow::compute::SortOptions;use arrow::datatypes::{DataType, Field, FieldRef};use arrow_buffer::NullBuffer;use datafusion_common::cast::{as_map_array, as_struct_array};use datafusion_common::{- exec_err, internal_err, plan_datafusion_err, utils::take_function_args, Result,- ScalarValue,+ Result, ScalarValue, exec_err, internal_err, plan_datafusion_err,+ utils::take_function_args,};use datafusion_expr::{ColumnarValue, Documentation, Expr, ReturnFieldArgs, ScalarFunctionArgs,@@ -137,7 +137,10 @@ impl ScalarUDFImpl for GetFieldFunc {// Length check handled in the signaturedebug_assert_eq!(args.scalar_arguments.len(), 2);- match (&args.arg_fields[0].data_type(), args.scalar_arguments[1].as_ref()) {+ match (+ &args.arg_fields[0].data_type(),+ args.scalar_arguments[1].as_ref(),+ ) {(DataType::Map(fields, _), _) => {match fields.data_type() {DataType::Struct(fields) if fields.len() == 2 => {@@ -145,35 +148,48 @@ impl ScalarUDFImpl for GetFieldFunc {// often named "key", and "value", but we don't require any specific naming here;// instead, we assume that the second column is the "value" column both here and in// execution.- let value_field = fields.get(1).expect("fields should have exactly two members");+ let value_field = fields+ .get(1)+ .expect("fields should have exactly two members");Ok(value_field.as_ref().clone().with_nullable(true).into())- },- _ => exec_err!("Map fields must contain a Struct with exactly 2 fields"),+ }+ _ => exec_err!(+ "Map fields must contain a Struct with exactly 2 fields"+ ),}}- (DataType::Struct(fields),sv) => {+ (DataType::Struct(fields), sv) => {sv.and_then(|sv| sv.try_as_str().flatten().filter(|s| !s.is_empty()))- .map_or_else(- || exec_err!("Field name must be a non-empty string"),- |field_name| {- fields.iter().find(|f| f.name() == field_name)- .ok_or(plan_datafusion_err!("Field {field_name} not found in struct"))- .map(|f| {- let mut child_field = f.as_ref().clone();-- // If the parent is nullable, then getting the child must be nullable,- // so potentially override the return value-- if args.arg_fields[0].is_nullable() {- child_field = child_field.with_nullable(true);- }- Arc::new(child_field)- })- })- },- (DataType::Null, _) => Ok(Field::new(self.name(), DataType::Null, true).into()),- (other, _) => exec_err!("The expression to get an indexed field is only valid for `Struct`, `Map` or `Null` types, got {other}"),+ .map_or_else(+ || exec_err!("Field name must be a non-empty string"),+ |field_name| {+ fields+ .iter()+ .find(|f| f.name() == field_name)+ .ok_or(plan_datafusion_err!(+ "Field {field_name} not found in struct"+ ))+ .map(|f| {+ let mut child_field = f.as_ref().clone();++ // If the parent is nullable, then getting the child must be nullable,+ // so potentially override the return value++ if args.arg_fields[0].is_nullable() {+ child_field = child_field.with_nullable(true);+ }+ Arc::new(child_field)+ })+ },+ )+ }+ (DataType::Null, _) => {+ Ok(Field::new(self.name(), DataType::Null, true).into())+ }+ (other, _) => exec_err!(+ "The expression to get an indexed field is only valid for `Struct`, `Map` or `Null` types, got {other}"+ ),}}diff --git a/datafusion/functions/src/core/greatest.rs b/datafusion/functions/src/core/greatest.rsindex 95fd8e64d7..fb7592c629 100644--- a/datafusion/functions/src/core/greatest.rs+++ b/datafusion/functions/src/core/greatest.rs@@ -16,12 +16,12 @@// under the License.use crate::core::greatest_least_utils::GreatestLeastOperator;-use arrow::array::{make_comparator, Array, BooleanArray};+use arrow::array::{Array, BooleanArray, make_comparator};use arrow::buffer::BooleanBuffer;-use arrow::compute::kernels::cmp;use arrow::compute::SortOptions;+use arrow::compute::kernels::cmp;use arrow::datatypes::DataType;-use datafusion_common::{assert_eq_or_internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, assert_eq_or_internal_err};use datafusion_doc::Documentation;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};@@ -90,11 +90,7 @@ impl GreatestLeastOperator for GreatestFunc {SORT_OPTIONS,)?;- if cmp(0, 0).is_ge() {- Ok(lhs)- } else {- Ok(rhs)- }+ if cmp(0, 0).is_ge() { Ok(lhs) } else { Ok(rhs) }}/// Return boolean array where `arr[i] = lhs[i] >= rhs[i]` for all i, where `arr` is the result arraydiff --git a/datafusion/functions/src/core/greatest_least_utils.rs b/datafusion/functions/src/core/greatest_least_utils.rsindex 78c6864d8c..5f8b4a5118 100644--- a/datafusion/functions/src/core/greatest_least_utils.rs+++ b/datafusion/functions/src/core/greatest_least_utils.rs@@ -18,7 +18,7 @@use arrow::array::{Array, ArrayRef, BooleanArray};use arrow::compute::kernels::zip::zip;use arrow::datatypes::DataType;-use datafusion_common::{assert_or_internal_err, plan_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, assert_or_internal_err, plan_err};use datafusion_expr_common::columnar_value::ColumnarValue;use datafusion_expr_common::type_coercion::binary::type_union_resolution;use std::sync::Arc;diff --git a/datafusion/functions/src/core/least.rs b/datafusion/functions/src/core/least.rsindex 602cd4169a..fc67924888 100644--- a/datafusion/functions/src/core/least.rs+++ b/datafusion/functions/src/core/least.rs@@ -16,12 +16,12 @@// under the License.use crate::core::greatest_least_utils::GreatestLeastOperator;-use arrow::array::{make_comparator, Array, BooleanArray};+use arrow::array::{Array, BooleanArray, make_comparator};use arrow::buffer::BooleanBuffer;-use arrow::compute::kernels::cmp;use arrow::compute::SortOptions;+use arrow::compute::kernels::cmp;use arrow::datatypes::DataType;-use datafusion_common::{assert_eq_or_internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, assert_eq_or_internal_err};use datafusion_doc::Documentation;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};@@ -103,11 +103,7 @@ impl GreatestLeastOperator for LeastFunc {SORT_OPTIONS,)?;- if cmp(0, 0).is_le() {- Ok(lhs)- } else {- Ok(rhs)- }+ if cmp(0, 0).is_le() { Ok(lhs) } else { Ok(rhs) }}/// Return boolean array where `arr[i] = lhs[i] <= rhs[i]` for all i, where `arr` is the result arraydiff --git a/datafusion/functions/src/core/named_struct.rs b/datafusion/functions/src/core/named_struct.rsindex 1da5148474..933151fcbd 100644--- a/datafusion/functions/src/core/named_struct.rs+++ b/datafusion/functions/src/core/named_struct.rs@@ -17,7 +17,7 @@use arrow::array::StructArray;use arrow::datatypes::{DataType, Field, FieldRef, Fields};-use datafusion_common::{exec_err, internal_err, Result};+use datafusion_common::{Result, exec_err, internal_err};use datafusion_expr::{ColumnarValue, Documentation, ReturnFieldArgs, ScalarFunctionArgs,};diff --git a/datafusion/functions/src/core/nullif.rs b/datafusion/functions/src/core/nullif.rsindex 69d86360cb..a8a512d35a 100644--- a/datafusion/functions/src/core/nullif.rs+++ b/datafusion/functions/src/core/nullif.rs@@ -20,7 +20,7 @@ use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs};use arrow::compute::kernels::cmp::eq;use arrow::compute::kernels::nullif::nullif;-use datafusion_common::{utils::take_function_args, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, utils::take_function_args};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;use std::any::Any;diff --git a/datafusion/functions/src/core/nvl2.rs b/datafusion/functions/src/core/nvl2.rsindex 45cb6760d0..eda59fe07f 100644--- a/datafusion/functions/src/core/nvl2.rs+++ b/datafusion/functions/src/core/nvl2.rs@@ -16,13 +16,13 @@// under the License.use arrow::datatypes::{DataType, Field, FieldRef};-use datafusion_common::{internal_err, utils::take_function_args, Result};+use datafusion_common::{Result, internal_err, utils::take_function_args};use datafusion_expr::{+ ColumnarValue, Documentation, Expr, ReturnFieldArgs, ScalarFunctionArgs,+ ScalarUDFImpl, Signature, Volatility,conditional_expressions::CaseBuilder,simplify::{ExprSimplifyResult, SimplifyInfo},type_coercion::binary::comparison_coercion,- ColumnarValue, Documentation, Expr, ReturnFieldArgs, ScalarFunctionArgs,- ScalarUDFImpl, Signature, Volatility,};use datafusion_macros::user_doc;diff --git a/datafusion/functions/src/core/overlay.rs b/datafusion/functions/src/core/overlay.rsindex 0b3bb2ce74..179ad9a460 100644--- a/datafusion/functions/src/core/overlay.rs+++ b/datafusion/functions/src/core/overlay.rs@@ -25,7 +25,7 @@ use crate::utils::{make_scalar_function, utf8_to_str_type};use datafusion_common::cast::{as_generic_string_array, as_int64_array, as_string_view_array,};-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, Documentation, TypeSignature, Volatility};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};use datafusion_macros::user_doc;diff --git a/datafusion/functions/src/core/planner.rs b/datafusion/functions/src/core/planner.rsindex 227e401156..4d6b744b3e 100644--- a/datafusion/functions/src/core/planner.rs+++ b/datafusion/functions/src/core/planner.rs@@ -20,7 +20,7 @@ use datafusion_common::Result;use datafusion_common::{Column, DFSchema, ScalarValue, TableReference};use datafusion_expr::expr::ScalarFunction;use datafusion_expr::planner::{ExprPlanner, PlannerResult, RawDictionaryExpr};-use datafusion_expr::{lit, Expr};+use datafusion_expr::{Expr, lit};use super::named_struct;diff --git a/datafusion/functions/src/core/struct.rs b/datafusion/functions/src/core/struct.rsindex 32c7af80e3..352f258643 100644--- a/datafusion/functions/src/core/struct.rs+++ b/datafusion/functions/src/core/struct.rs@@ -17,7 +17,7 @@use arrow::array::StructArray;use arrow::datatypes::{DataType, Field};-use datafusion_common::{exec_err, internal_err, Result};+use datafusion_common::{Result, exec_err, internal_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;diff --git a/datafusion/functions/src/core/union_extract.rs b/datafusion/functions/src/core/union_extract.rsindex a71e2e8738..56d4f23cc4 100644--- a/datafusion/functions/src/core/union_extract.rs+++ b/datafusion/functions/src/core/union_extract.rs@@ -20,7 +20,7 @@ use arrow::datatypes::{DataType, Field, FieldRef, UnionFields};use datafusion_common::cast::as_union_array;use datafusion_common::utils::take_function_args;use datafusion_common::{- exec_datafusion_err, exec_err, internal_err, Result, ScalarValue,+ Result, ScalarValue, exec_datafusion_err, exec_err, internal_err,};use datafusion_doc::Documentation;use datafusion_expr::{ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs};@@ -117,9 +117,16 @@ impl ScalarUDFImpl for UnionExtractFun {let [array, target_name] = take_function_args("union_extract", args.args)?;let target_name = match target_name {- ColumnarValue::Scalar(ScalarValue::Utf8(Some(target_name))) => Ok(target_name),- ColumnarValue::Scalar(ScalarValue::Utf8(None)) => exec_err!("union_extract second argument must be a non-null string literal, got a null instead"),- _ => exec_err!("union_extract second argument must be a non-null string literal, got {} instead", target_name.data_type()),+ ColumnarValue::Scalar(ScalarValue::Utf8(Some(target_name))) => {+ Ok(target_name)+ }+ ColumnarValue::Scalar(ScalarValue::Utf8(None)) => exec_err!(+ "union_extract second argument must be a non-null string literal, got a null instead"+ ),+ _ => exec_err!(+ "union_extract second argument must be a non-null string literal, got {} instead",+ target_name.data_type()+ ),}?;match array {diff --git a/datafusion/functions/src/core/union_tag.rs b/datafusion/functions/src/core/union_tag.rsindex aeadb8292b..809679dea6 100644--- a/datafusion/functions/src/core/union_tag.rs+++ b/datafusion/functions/src/core/union_tag.rs@@ -18,7 +18,7 @@use arrow::array::{Array, AsArray, DictionaryArray, Int8Array, StringArray};use arrow::datatypes::DataType;use datafusion_common::utils::take_function_args;-use datafusion_common::{exec_datafusion_err, exec_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_datafusion_err, exec_err};use datafusion_doc::Documentation;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};@@ -156,8 +156,8 @@ impl ScalarUDFImpl for UnionTagFunc {mod tests {use super::UnionTagFunc;use arrow::datatypes::{DataType, Field, UnionFields, UnionMode};- use datafusion_common::config::ConfigOptions;use datafusion_common::ScalarValue;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl};use std::sync::Arc;diff --git a/datafusion/functions/src/core/version.rs b/datafusion/functions/src/core/version.rsindex 006da4b132..436551184f 100644--- a/datafusion/functions/src/core/version.rs+++ b/datafusion/functions/src/core/version.rs@@ -18,7 +18,7 @@//! [`VersionFunc`]: Implementation of the `version` function.use arrow::datatypes::DataType;-use datafusion_common::{utils::take_function_args, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, utils::take_function_args};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,Volatility,diff --git a/datafusion/functions/src/crypto/basic.rs b/datafusion/functions/src/crypto/basic.rsindex 664bb94b70..3cb53d3b60 100644--- a/datafusion/functions/src/crypto/basic.rs+++ b/datafusion/functions/src/crypto/basic.rs@@ -27,8 +27,8 @@ use datafusion_common::cast::as_binary_array;use arrow::compute::StringArrayType;use datafusion_common::{- exec_err, internal_err, plan_err, utils::take_function_args, DataFusionError, Result,- ScalarValue,+ DataFusionError, Result, ScalarValue, exec_err, internal_err, plan_err,+ utils::take_function_args,};use datafusion_expr::ColumnarValue;use md5::Md5;@@ -305,7 +305,7 @@ pub fn digest_process(other => {return exec_err!("Unsupported data type {other:?} for function {digest_algorithm}"- )+ );}};Ok(ColumnarValue::Array(output))diff --git a/datafusion/functions/src/crypto/digest.rs b/datafusion/functions/src/crypto/digest.rsindex ccc8e72bfb..4d3ff06777 100644--- a/datafusion/functions/src/crypto/digest.rs+++ b/datafusion/functions/src/crypto/digest.rs@@ -15,14 +15,13 @@// specific language governing permissions and limitations// under the License.-use crate::crypto::basic::{digest_process, DigestAlgorithm};+use crate::crypto::basic::{DigestAlgorithm, digest_process};use arrow::datatypes::DataType;use datafusion_common::{- exec_err, not_impl_err,+ Result, exec_err, not_impl_err,types::{logical_binary, logical_string},utils::take_function_args,- Result,};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/crypto/md5.rs b/datafusion/functions/src/crypto/md5.rsindex 325d2d00a5..728e0d4a33 100644--- a/datafusion/functions/src/crypto/md5.rs+++ b/datafusion/functions/src/crypto/md5.rs@@ -18,8 +18,8 @@use crate::crypto::basic::md5;use arrow::datatypes::DataType;use datafusion_common::{- types::{logical_binary, logical_string},Result,+ types::{logical_binary, logical_string},};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/crypto/sha.rs b/datafusion/functions/src/crypto/sha.rsindex e7b1cef3ce..9199cf57c7 100644--- a/datafusion/functions/src/crypto/sha.rs+++ b/datafusion/functions/src/crypto/sha.rs@@ -15,13 +15,13 @@// specific language governing permissions and limitations// under the License.-use crate::crypto::basic::{digest_process, DigestAlgorithm};+use crate::crypto::basic::{DigestAlgorithm, digest_process};use arrow::datatypes::DataType;use datafusion_common::{+ Result,types::{logical_binary, logical_string},utils::take_function_args,- Result,};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/datetime/common.rs b/datafusion/functions/src/datetime/common.rsindex a0daab66c7..5b152081b6 100644--- a/datafusion/functions/src/datetime/common.rs+++ b/datafusion/functions/src/datetime/common.rs@@ -23,14 +23,14 @@ use arrow::array::{};use arrow::compute::kernels::cast_utils::string_to_timestamp_nanos;use arrow::datatypes::DataType;-use chrono::format::{parse, Parsed, StrftimeItems};use chrono::LocalResult::Single;+use chrono::format::{Parsed, StrftimeItems, parse};use chrono::{DateTime, TimeZone, Utc};use datafusion_common::cast::as_generic_string_array;use datafusion_common::{- exec_datafusion_err, exec_err, unwrap_or_internal_err, DataFusionError, Result,- ScalarType, ScalarValue,+ DataFusionError, Result, ScalarType, ScalarValue, exec_datafusion_err, exec_err,+ unwrap_or_internal_err,};use datafusion_expr::ColumnarValue;@@ -243,14 +243,24 @@ whereDataType::Utf8View | DataType::LargeUtf8 | DataType::Utf8 => {// all good}- other => return exec_err!("Unsupported data type {other:?} for function {name}, arg # {pos}"),+ other => {+ return exec_err!(+ "Unsupported data type {other:?} for function {name}, arg # {pos}"+ );+ }},ColumnarValue::Scalar(arg) => {match arg.data_type() {- DataType::Utf8View| DataType::LargeUtf8 | DataType::Utf8 => {+ DataType::Utf8View+ | DataType::LargeUtf8+ | DataType::Utf8 => {// all good}- other => return exec_err!("Unsupported data type {other:?} for function {name}, arg # {pos}"),+ other => {+ return exec_err!(+ "Unsupported data type {other:?} for function {name}, arg # {pos}"+ );+ }}}}@@ -280,7 +290,9 @@ where| ScalarValue::Utf8(x),) = velse {- return exec_err!("Unsupported data type {v:?} for function {name}, arg # {pos}");+ return exec_err!(+ "Unsupported data type {v:?} for function {name}, arg # {pos}"+ );};if let Some(s) = x {diff --git a/datafusion/functions/src/datetime/current_date.rs b/datafusion/functions/src/datetime/current_date.rsindex da690b4e6b..7edc1a58d9 100644--- a/datafusion/functions/src/datetime/current_date.rs+++ b/datafusion/functions/src/datetime/current_date.rs@@ -22,7 +22,7 @@ use arrow::datatypes::DataType;use arrow::datatypes::DataType::Date32;use chrono::{Datelike, NaiveDate, TimeZone};-use datafusion_common::{internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};use datafusion_expr::{ColumnarValue, Documentation, Expr, ScalarUDFImpl, Signature, Volatility,diff --git a/datafusion/functions/src/datetime/current_time.rs b/datafusion/functions/src/datetime/current_time.rsindex 9f3456b877..2c9bcdfe49 100644--- a/datafusion/functions/src/datetime/current_time.rs+++ b/datafusion/functions/src/datetime/current_time.rs@@ -21,7 +21,7 @@ use arrow::datatypes::DataType::Time64;use arrow::datatypes::TimeUnit::Nanosecond;use chrono::TimeZone;use chrono::Timelike;-use datafusion_common::{internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};use datafusion_expr::{ColumnarValue, Documentation, Expr, ScalarUDFImpl, Signature, Volatility,@@ -225,6 +225,9 @@ mod tests {// 10 hours in nanosecondslet expected_offset = 10i64 * 3600 * 1_000_000_000;- assert_eq!(difference, expected_offset, "Expected 10-hour offset difference in nanoseconds between UTC+05:00 and UTC-05:00");+ assert_eq!(+ difference, expected_offset,+ "Expected 10-hour offset difference in nanoseconds between UTC+05:00 and UTC-05:00"+ );}}diff --git a/datafusion/functions/src/datetime/date_bin.rs b/datafusion/functions/src/datetime/date_bin.rsindex 92af123dba..3fd2fd3fe2 100644--- a/datafusion/functions/src/datetime/date_bin.rs+++ b/datafusion/functions/src/datetime/date_bin.rs@@ -31,11 +31,11 @@ use arrow::datatypes::TimeUnit::{Microsecond, Millisecond, Nanosecond, Second};use arrow::datatypes::{DataType, TimeUnit};use datafusion_common::cast::as_primitive_array;-use datafusion_common::{exec_err, not_impl_err, plan_err, Result, ScalarValue};-use datafusion_expr::sort_properties::{ExprProperties, SortProperties};+use datafusion_common::{Result, ScalarValue, exec_err, not_impl_err, plan_err};use datafusion_expr::TypeSignature::Exact;+use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{- ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility, TIMEZONE_WILDCARD,+ ColumnarValue, Documentation, ScalarUDFImpl, Signature, TIMEZONE_WILDCARD, Volatility,};use datafusion_macros::user_doc;@@ -365,8 +365,8 @@ fn date_bin_impl(}ColumnarValue::Array(_) => {return not_impl_err!(- "DATE_BIN only supports literal values for the stride argument, not arrays"- );+ "DATE_BIN only supports literal values for the stride argument, not arrays"+ );}};@@ -380,8 +380,8 @@ fn date_bin_impl(}ColumnarValue::Array(_) => {return not_impl_err!(- "DATE_BIN only supports literal values for the origin argument, not arrays"- );+ "DATE_BIN only supports literal values for the origin argument, not arrays"+ );}};@@ -501,7 +501,7 @@ fn date_bin_impl(mod tests {use std::sync::Arc;- use crate::datetime::date_bin::{date_bin_nanos_interval, DateBinFunc};+ use crate::datetime::date_bin::{DateBinFunc, date_bin_nanos_interval};use arrow::array::types::TimestampNanosecondType;use arrow::array::{Array, IntervalDayTimeArray, TimestampNanosecondArray};use arrow::compute::kernels::cast_utils::string_to_timestamp_nanos;diff --git a/datafusion/functions/src/datetime/date_part.rs b/datafusion/functions/src/datetime/date_part.rsindex aa23a5028d..375200d072 100644--- a/datafusion/functions/src/datetime/date_part.rs+++ b/datafusion/functions/src/datetime/date_part.rs@@ -21,15 +21,16 @@ use std::sync::Arc;use arrow::array::{Array, ArrayRef, Float64Array, Int32Array};use arrow::compute::kernels::cast_utils::IntervalUnit;-use arrow::compute::{binary, date_part, DatePart};+use arrow::compute::{DatePart, binary, date_part};use arrow::datatypes::DataType::{Date32, Date64, Duration, Interval, Time32, Time64, Timestamp,};use arrow::datatypes::TimeUnit::{Microsecond, Millisecond, Nanosecond, Second};use arrow::datatypes::{DataType, Field, FieldRef, TimeUnit};-use datafusion_common::types::{logical_date, NativeType};+use datafusion_common::types::{NativeType, logical_date};use datafusion_common::{+ Result, ScalarValue,cast::{as_date32_array, as_date64_array, as_int32_array, as_time32_millisecond_array,as_time32_second_array, as_time64_microsecond_array, as_time64_nanosecond_array,@@ -39,7 +40,6 @@ use datafusion_common::{exec_err, internal_err, not_impl_err,types::logical_string,utils::take_function_args,- Result, ScalarValue,};use datafusion_expr::{ColumnarValue, Documentation, ReturnFieldArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/datetime/date_trunc.rs b/datafusion/functions/src/datetime/date_trunc.rsindex c8376cf844..aca1d24c31 100644--- a/datafusion/functions/src/datetime/date_trunc.rs+++ b/datafusion/functions/src/datetime/date_trunc.rs@@ -34,12 +34,12 @@ use arrow::datatypes::DataType::{self, Null, Timestamp, Utf8, Utf8View};use arrow::datatypes::TimeUnit::{self, Microsecond, Millisecond, Nanosecond, Second};use datafusion_common::cast::as_primitive_array;use datafusion_common::{- exec_datafusion_err, exec_err, plan_err, DataFusionError, Result, ScalarValue,+ DataFusionError, Result, ScalarValue, exec_datafusion_err, exec_err, plan_err,};-use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::TypeSignature::Exact;+use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{- ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility, TIMEZONE_WILDCARD,+ ColumnarValue, Documentation, ScalarUDFImpl, Signature, TIMEZONE_WILDCARD, Volatility,};use datafusion_macros::user_doc;@@ -341,7 +341,9 @@ impl ScalarUDFImpl for DateTruncFunc {)?,}} else {- return exec_err!("second argument of `date_trunc` is an unsupported array type: {array_type}");+ return exec_err!(+ "second argument of `date_trunc` is an unsupported array type: {array_type}"+ );}}_ => {@@ -629,7 +631,7 @@ mod tests {use std::sync::Arc;use crate::datetime::date_trunc::{- date_trunc_coarse, DateTruncFunc, DateTruncGranularity,+ DateTruncFunc, DateTruncGranularity, date_trunc_coarse,};use arrow::array::cast::as_primitive_array;@@ -637,8 +639,8 @@ mod tests {use arrow::array::{Array, TimestampNanosecondArray};use arrow::compute::kernels::cast_utils::string_to_timestamp_nanos;use arrow::datatypes::{DataType, Field, TimeUnit};- use datafusion_common::config::ConfigOptions;use datafusion_common::ScalarValue;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarUDFImpl};#[test]diff --git a/datafusion/functions/src/datetime/from_unixtime.rs b/datafusion/functions/src/datetime/from_unixtime.rsindex 5d6adfb6f1..574564dd45 100644--- a/datafusion/functions/src/datetime/from_unixtime.rs+++ b/datafusion/functions/src/datetime/from_unixtime.rs@@ -21,7 +21,7 @@ use std::sync::Arc;use arrow::datatypes::DataType::{Int64, Timestamp, Utf8};use arrow::datatypes::TimeUnit::Second;use arrow::datatypes::{DataType, Field, FieldRef};-use datafusion_common::{exec_err, internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, internal_err};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ReturnFieldArgs, ScalarUDFImpl, Signature, Volatility,@@ -164,9 +164,9 @@ mod test {use crate::datetime::from_unixtime::FromUnixtimeFunc;use arrow::datatypes::TimeUnit::Second;use arrow::datatypes::{DataType, Field};- use datafusion_common::config::ConfigOptions;use datafusion_common::ScalarValue;use datafusion_common::ScalarValue::Int64;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarUDFImpl};use std::sync::Arc;diff --git a/datafusion/functions/src/datetime/make_date.rs b/datafusion/functions/src/datetime/make_date.rsindex 8699e85b93..fbe28b8c23 100644--- a/datafusion/functions/src/datetime/make_date.rs+++ b/datafusion/functions/src/datetime/make_date.rs@@ -18,15 +18,15 @@use std::any::Any;use std::sync::Arc;+use arrow::array::PrimitiveArray;use arrow::array::builder::PrimitiveBuilder;use arrow::array::cast::AsArray;use arrow::array::types::{Date32Type, Int32Type};-use arrow::array::PrimitiveArray;use arrow::datatypes::DataType;use arrow::datatypes::DataType::{Date32, Int32, Int64, UInt32, UInt64, Utf8, Utf8View};use chrono::prelude::*;-use datafusion_common::{exec_err, utils::take_function_args, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, utils::take_function_args};use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,};diff --git a/datafusion/functions/src/datetime/now.rs b/datafusion/functions/src/datetime/now.rsindex 65f0b8e19b..b804efe591 100644--- a/datafusion/functions/src/datetime/now.rs+++ b/datafusion/functions/src/datetime/now.rs@@ -22,7 +22,7 @@ use std::any::Any;use std::sync::Arc;use datafusion_common::config::ConfigOptions;-use datafusion_common::{internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};use datafusion_expr::{ColumnarValue, Documentation, Expr, ReturnFieldArgs, ScalarUDF, ScalarUDFImpl,diff --git a/datafusion/functions/src/datetime/planner.rs b/datafusion/functions/src/datetime/planner.rsindex f4b64c3711..f2b8ef9d1d 100644--- a/datafusion/functions/src/datetime/planner.rs+++ b/datafusion/functions/src/datetime/planner.rs@@ -16,9 +16,9 @@// under the License.//! SQL planning extensions like [`DatetimeFunctionPlanner`]+use datafusion_expr::Expr;use datafusion_expr::expr::ScalarFunction;use datafusion_expr::planner::{ExprPlanner, PlannerResult};-use datafusion_expr::Expr;#[derive(Default, Debug)]pub struct DatetimeFunctionPlanner;diff --git a/datafusion/functions/src/datetime/to_char.rs b/datafusion/functions/src/datetime/to_char.rsindex cff096dc92..8d0c47cfe6 100644--- a/datafusion/functions/src/datetime/to_char.rs+++ b/datafusion/functions/src/datetime/to_char.rs@@ -19,7 +19,7 @@ use std::any::Any;use std::sync::Arc;use arrow::array::cast::AsArray;-use arrow::array::{new_null_array, Array, ArrayRef, StringArray};+use arrow::array::{Array, ArrayRef, StringArray, new_null_array};use arrow::compute::cast;use arrow::datatypes::DataType;use arrow::datatypes::DataType::{@@ -28,10 +28,10 @@ use arrow::datatypes::DataType::{use arrow::datatypes::TimeUnit::{Microsecond, Millisecond, Nanosecond, Second};use arrow::error::ArrowError;use arrow::util::display::{ArrayFormatter, DurationFormat, FormatOptions};-use datafusion_common::{exec_err, utils::take_function_args, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, utils::take_function_args};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{- ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility, TIMEZONE_WILDCARD,+ ColumnarValue, Documentation, ScalarUDFImpl, Signature, TIMEZONE_WILDCARD, Volatility,};use datafusion_macros::user_doc;@@ -343,8 +343,8 @@ mod tests {};use arrow::datatypes::{DataType, Field, TimeUnit};use chrono::{NaiveDateTime, Timelike};- use datafusion_common::config::ConfigOptions;use datafusion_common::ScalarValue;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarUDFImpl};use std::sync::Arc;diff --git a/datafusion/functions/src/datetime/to_date.rs b/datafusion/functions/src/datetime/to_date.rsindex a216e8e5b7..ac95bbd0d0 100644--- a/datafusion/functions/src/datetime/to_date.rs+++ b/datafusion/functions/src/datetime/to_date.rs@@ -20,7 +20,7 @@ use arrow::datatypes::DataType;use arrow::datatypes::DataType::*;use arrow::error::ArrowError::ParseError;use arrow::{array::types::Date32Type, compute::kernels::cast_utils::Parser};-use datafusion_common::{arrow_err, exec_err, internal_datafusion_err, Result};+use datafusion_common::{Result, arrow_err, exec_err, internal_datafusion_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,};@@ -351,7 +351,11 @@ mod tests {match to_date_result {Ok(ColumnarValue::Scalar(ScalarValue::Date32(date_val))) => {let expected = Date32Type::parse_formatted(tc.date_str, "%Y-%m-%d");- assert_eq!(date_val, expected, "{}: to_date created wrong value for date '{}' with format string '{}'", tc.name, tc.formatted_date, tc.format_str);+ assert_eq!(+ date_val, expected,+ "{}: to_date created wrong value for date '{}' with format string '{}'",+ tc.name, tc.formatted_date, tc.format_str+ );}_ => panic!("Could not convert '{}' with format string '{}'to Date",@@ -385,7 +389,8 @@ mod tests {builder.append_value(expected.unwrap());assert_eq!(- &builder.finish() as &dyn Array, a.as_ref(),+ &builder.finish() as &dyn Array,+ a.as_ref(),"{}: to_date created wrong value for date '{}' with format string '{}'",tc.name,tc.formatted_date,diff --git a/datafusion/functions/src/datetime/to_local_time.rs b/datafusion/functions/src/datetime/to_local_time.rsindex 0495a4841f..86c949711d 100644--- a/datafusion/functions/src/datetime/to_local_time.rs+++ b/datafusion/functions/src/datetime/to_local_time.rs@@ -31,8 +31,8 @@ use chrono::{DateTime, MappedLocalTime, Offset, TimeDelta, TimeZone, Utc};use datafusion_common::cast::as_primitive_array;use datafusion_common::{- exec_err, internal_datafusion_err, internal_err, utils::take_function_args, Result,- ScalarValue,+ Result, ScalarValue, exec_err, internal_datafusion_err, internal_err,+ utils::take_function_args,};use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarUDFImpl, Signature, TypeSignatureClass,@@ -192,7 +192,7 @@ fn to_local_time(time_value: &ColumnarValue) -> Result<ColumnarValue> {dt => {return internal_err!("to_local_time function requires timestamp argument, got {dt}"- )+ );}};@@ -378,15 +378,15 @@ fn adjust_to_local_time<T: ArrowTimestampType>(ts: i64, tz: Tz) -> Result<i64> {mod tests {use std::sync::Arc;- use arrow::array::{types::TimestampNanosecondType, Array, TimestampNanosecondArray};+ use arrow::array::{Array, TimestampNanosecondArray, types::TimestampNanosecondType};use arrow::compute::kernels::cast_utils::string_to_timestamp_nanos;use arrow::datatypes::{DataType, Field, TimeUnit};use chrono::NaiveDateTime;- use datafusion_common::config::ConfigOptions;use datafusion_common::ScalarValue;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl};- use super::{adjust_to_local_time, ToLocalTimeFunc};+ use super::{ToLocalTimeFunc, adjust_to_local_time};#[test]fn test_adjust_to_local_time() {diff --git a/datafusion/functions/src/datetime/to_timestamp.rs b/datafusion/functions/src/datetime/to_timestamp.rsindex cf6c342938..fdaf8a764a 100644--- a/datafusion/functions/src/datetime/to_timestamp.rs+++ b/datafusion/functions/src/datetime/to_timestamp.rs@@ -27,7 +27,7 @@ use arrow::datatypes::{TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType,};use datafusion_common::format::DEFAULT_CAST_OPTIONS;-use datafusion_common::{exec_err, Result, ScalarType, ScalarValue};+use datafusion_common::{Result, ScalarType, ScalarValue, exec_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,};@@ -654,7 +654,7 @@ mod tests {use arrow::datatypes::{Field, TimeUnit};use chrono::Utc;use datafusion_common::config::ConfigOptions;- use datafusion_common::{assert_contains, DataFusionError, ScalarValue};+ use datafusion_common::{DataFusionError, ScalarValue, assert_contains};use datafusion_expr::ScalarFunctionImplementation;use super::*;@@ -811,8 +811,7 @@ mod tests {let string_array =ColumnarValue::Array(Arc::new(date_string_builder.finish()) as ArrayRef);- let expected_err =- "Arrow error: Parser error: Error parsing timestamp from '2020-09-08 - 13:42:29.19085Z': error parsing time";+ let expected_err = "Arrow error: Parser error: Error parsing timestamp from '2020-09-08 - 13:42:29.19085Z': error parsing time";match to_timestamp(&[string_array]) {Ok(_) => panic!("Expected error but got success"),Err(e) => {@@ -836,8 +835,7 @@ mod tests {let string_array =ColumnarValue::Array(Arc::new(date_string_builder.finish()) as ArrayRef);- let expected_err =- "Arrow error: Parser error: Invalid timezone \"ZZ\": failed to parse timezone";+ let expected_err = "Arrow error: Parser error: Invalid timezone \"ZZ\": failed to parse timezone";match to_timestamp(&[string_array]) {Ok(_) => panic!("Expected error but got success"),Err(e) => {@@ -874,8 +872,7 @@ mod tests {ColumnarValue::Array(Arc::new(format3_builder.finish()) as ArrayRef),];- let expected_err =- "Execution error: Error parsing timestamp from '2020-09-08T13:42:29.19085Z' using format '%H:%M:%S': input contains invalid characters";+ let expected_err = "Execution error: Error parsing timestamp from '2020-09-08T13:42:29.19085Z' using format '%H:%M:%S': input contains invalid characters";match to_timestamp(&string_array) {Ok(_) => panic!("Expected error but got success"),Err(e) => {@@ -950,7 +947,9 @@ mod tests {];for (s, f, ctx) in cases {- let expected = format!("Execution error: Error parsing timestamp from '{s}' using format '{f}': {ctx}");+ let expected = format!(+ "Execution error: Error parsing timestamp from '{s}' using format '{f}': {ctx}"+ );let actual = string_to_datetime_formatted(&Utc, s, f).unwrap_err().strip_backtrace();@@ -978,7 +977,9 @@ mod tests {];for (s, f, ctx) in cases {- let expected = format!("Execution error: Error parsing timestamp from '{s}' using format '{f}': {ctx}");+ let expected = format!(+ "Execution error: Error parsing timestamp from '{s}' using format '{f}': {ctx}"+ );let actual = string_to_datetime_formatted(&Utc, s, f).unwrap_err().strip_backtrace();diff --git a/datafusion/functions/src/datetime/to_unixtime.rs b/datafusion/functions/src/datetime/to_unixtime.rsindex 42651cd537..a62ace9ccb 100644--- a/datafusion/functions/src/datetime/to_unixtime.rs+++ b/datafusion/functions/src/datetime/to_unixtime.rs@@ -18,7 +18,7 @@use super::to_timestamp::ToTimestampSecondsFunc;use crate::datetime::common::*;use arrow::datatypes::{DataType, TimeUnit};-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,};diff --git a/datafusion/functions/src/encoding/inner.rs b/datafusion/functions/src/encoding/inner.rsindex e5314ad220..cb3f45b60a 100644--- a/datafusion/functions/src/encoding/inner.rs+++ b/datafusion/functions/src/encoding/inner.rs@@ -25,16 +25,16 @@ use arrow::{};use arrow_buffer::{Buffer, OffsetBufferBuilder};use base64::{- engine::{DecodePaddingMode, GeneralPurpose, GeneralPurposeConfig},Engine as _,+ engine::{DecodePaddingMode, GeneralPurpose, GeneralPurposeConfig},};+use datafusion_common::{DataFusionError, Result};+use datafusion_common::{ScalarValue, exec_err, internal_datafusion_err};use datafusion_common::{cast::{as_generic_binary_array, as_generic_string_array},not_impl_err, plan_err,utils::take_function_args,};-use datafusion_common::{exec_err, internal_datafusion_err, ScalarValue};-use datafusion_common::{DataFusionError, Result};use datafusion_expr::{ColumnarValue, Documentation};use std::sync::Arc;use std::{fmt, str::FromStr};@@ -542,7 +542,7 @@ fn decode(args: &[ColumnarValue]) -> Result<ColumnarValue> {let encoding = match format {ColumnarValue::Scalar(scalar) => match scalar.try_as_str() {- Some(Some(method))=> method.parse::<Encoding>(),+ Some(Some(method)) => method.parse::<Encoding>(),_ => not_impl_err!("Second argument to decode must be a non null constant string: Decode using dynamically decided method is not yet supported. Got {scalar:?}"),diff --git a/datafusion/functions/src/macros.rs b/datafusion/functions/src/macros.rsindex f0f3f9efa3..3d728a1784 100644--- a/datafusion/functions/src/macros.rs+++ b/datafusion/functions/src/macros.rs@@ -166,9 +166,7 @@ macro_rules! downcast_named_arg {/// $ARRAY_TYPE: the type of array to cast the argument to#[macro_export]macro_rules! downcast_arg {- ($ARG:expr, $ARRAY_TYPE:ident) => {{- $crate::downcast_named_arg!($ARG, "", $ARRAY_TYPE)- }};+ ($ARG:expr, $ARRAY_TYPE:ident) => {{ $crate::downcast_named_arg!($ARG, "", $ARRAY_TYPE) }};}/// Macro to create a unary math UDF.@@ -191,7 +189,7 @@ macro_rules! make_math_unary_udf {use arrow::array::{ArrayRef, AsArray};use arrow::datatypes::{DataType, Float32Type, Float64Type};- use datafusion_common::{exec_err, Result};+ use datafusion_common::{Result, exec_err};use datafusion_expr::interval_arithmetic::Interval;use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{@@ -270,7 +268,7 @@ macro_rules! make_math_unary_udf {return exec_err!("Unsupported data type {other:?} for function {}",self.name()- )+ );}};@@ -305,9 +303,9 @@ macro_rules! make_math_binary_udf {use arrow::array::{ArrayRef, AsArray};use arrow::datatypes::{DataType, Float32Type, Float64Type};- use datafusion_common::{exec_err, Result};- use datafusion_expr::sort_properties::{ExprProperties, SortProperties};+ use datafusion_common::{Result, exec_err};use datafusion_expr::TypeSignature;+ use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl,Signature, Volatility,@@ -392,7 +390,7 @@ macro_rules! make_math_binary_udf {return exec_err!("Unsupported data type {other:?} for function {}",self.name()- )+ );}};diff --git a/datafusion/functions/src/math/abs.rs b/datafusion/functions/src/math/abs.rsindex 35d0f3eccf..081668f766 100644--- a/datafusion/functions/src/math/abs.rs+++ b/datafusion/functions/src/math/abs.rs@@ -21,13 +21,13 @@ use std::any::Any;use std::sync::Arc;use arrow::array::{- ArrayRef, Decimal128Array, Decimal256Array, Decimal32Array, Decimal64Array,- Float16Array, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array,- Int8Array,+ ArrayRef, Decimal32Array, Decimal64Array, Decimal128Array, Decimal256Array,+ Float16Array, Float32Array, Float64Array, Int8Array, Int16Array, Int32Array,+ Int64Array,};use arrow::datatypes::DataType;use arrow::error::ArrowError;-use datafusion_common::{not_impl_err, utils::take_function_args, Result};+use datafusion_common::{Result, not_impl_err, utils::take_function_args};use datafusion_expr::interval_arithmetic::Interval;use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{diff --git a/datafusion/functions/src/math/cot.rs b/datafusion/functions/src/math/cot.rsindex 43f2012d07..a0d7b02b68 100644--- a/datafusion/functions/src/math/cot.rs+++ b/datafusion/functions/src/math/cot.rs@@ -23,7 +23,7 @@ use arrow::datatypes::DataType::{Float32, Float64};use arrow::datatypes::{DataType, Float32Type, Float64Type};use crate::utils::make_scalar_function;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;diff --git a/datafusion/functions/src/math/factorial.rs b/datafusion/functions/src/math/factorial.rsindex c9980bb6aa..4d651cf77d 100644--- a/datafusion/functions/src/math/factorial.rs+++ b/datafusion/functions/src/math/factorial.rs@@ -26,7 +26,7 @@ use arrow::datatypes::DataType;use arrow::datatypes::DataType::Int64;use crate::utils::make_scalar_function;-use datafusion_common::{arrow_datafusion_err, exec_err, Result};+use datafusion_common::{Result, arrow_datafusion_err, exec_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,Volatility,diff --git a/datafusion/functions/src/math/gcd.rs b/datafusion/functions/src/math/gcd.rsindex 0b85e7b54a..baf52d7806 100644--- a/datafusion/functions/src/math/gcd.rs+++ b/datafusion/functions/src/math/gcd.rs@@ -15,7 +15,7 @@// specific language governing permissions and limitations// under the License.-use arrow::array::{new_null_array, ArrayRef, AsArray, Int64Array, PrimitiveArray};+use arrow::array::{ArrayRef, AsArray, Int64Array, PrimitiveArray, new_null_array};use arrow::compute::try_binary;use arrow::datatypes::{DataType, Int64Type};use arrow::error::ArrowError;@@ -23,7 +23,7 @@ use std::any::Any;use std::mem::swap;use std::sync::Arc;-use datafusion_common::{exec_err, internal_datafusion_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, internal_datafusion_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,Volatility,@@ -94,20 +94,23 @@ impl ScalarUDFImpl for GcdFunc {[ColumnarValue::Array(a), ColumnarValue::Array(b)] => {compute_gcd_for_arrays(&a, &b)}- [ColumnarValue::Scalar(ScalarValue::Int64(a)), ColumnarValue::Scalar(ScalarValue::Int64(b))] => {- match (a, b) {- (Some(a), Some(b)) => Ok(ColumnarValue::Scalar(ScalarValue::Int64(- Some(compute_gcd(a, b)?),- ))),- _ => Ok(ColumnarValue::Scalar(ScalarValue::Int64(None))),- }- }- [ColumnarValue::Array(a), ColumnarValue::Scalar(ScalarValue::Int64(b))] => {- compute_gcd_with_scalar(&a, b)- }- [ColumnarValue::Scalar(ScalarValue::Int64(a)), ColumnarValue::Array(b)] => {- compute_gcd_with_scalar(&b, a)- }+ [+ ColumnarValue::Scalar(ScalarValue::Int64(a)),+ ColumnarValue::Scalar(ScalarValue::Int64(b)),+ ] => match (a, b) {+ (Some(a), Some(b)) => Ok(ColumnarValue::Scalar(ScalarValue::Int64(+ Some(compute_gcd(a, b)?),+ ))),+ _ => Ok(ColumnarValue::Scalar(ScalarValue::Int64(None))),+ },+ [+ ColumnarValue::Array(a),+ ColumnarValue::Scalar(ScalarValue::Int64(b)),+ ] => compute_gcd_with_scalar(&a, b),+ [+ ColumnarValue::Scalar(ScalarValue::Int64(a)),+ ColumnarValue::Array(b),+ ] => compute_gcd_with_scalar(&b, a),_ => exec_err!("Unsupported argument types for function gcd"),}}diff --git a/datafusion/functions/src/math/iszero.rs b/datafusion/functions/src/math/iszero.rsindex f053256a48..6349551ca0 100644--- a/datafusion/functions/src/math/iszero.rs+++ b/datafusion/functions/src/math/iszero.rs@@ -22,7 +22,7 @@ use arrow::array::{ArrayRef, AsArray, BooleanArray};use arrow::datatypes::DataType::{Boolean, Float32, Float64};use arrow::datatypes::{DataType, Float32Type, Float64Type};-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/math/lcm.rs b/datafusion/functions/src/math/lcm.rsindex 6d42ce6202..58934e137b 100644--- a/datafusion/functions/src/math/lcm.rs+++ b/datafusion/functions/src/math/lcm.rs@@ -23,7 +23,7 @@ use arrow::datatypes::DataType;use arrow::datatypes::DataType::Int64;use arrow::error::ArrowError;-use datafusion_common::{arrow_datafusion_err, exec_err, Result};+use datafusion_common::{Result, arrow_datafusion_err, exec_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,Volatility,diff --git a/datafusion/functions/src/math/log.rs b/datafusion/functions/src/math/log.rsindex 24000a3876..72a9cf4555 100644--- a/datafusion/functions/src/math/log.rs+++ b/datafusion/functions/src/math/log.rs@@ -31,14 +31,14 @@ use arrow::error::ArrowError;use arrow_buffer::i256;use datafusion_common::types::NativeType;use datafusion_common::{- exec_err, internal_err, plan_datafusion_err, plan_err, Result, ScalarValue,+ Result, ScalarValue, exec_err, internal_err, plan_datafusion_err, plan_err,};use datafusion_expr::expr::ScalarFunction;use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{- lit, Coercion, ColumnarValue, Documentation, Expr, ScalarFunctionArgs, ScalarUDF,- TypeSignature, TypeSignatureClass,+ Coercion, ColumnarValue, Documentation, Expr, ScalarFunctionArgs, ScalarUDF,+ TypeSignature, TypeSignatureClass, lit,};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;@@ -249,7 +249,7 @@ impl ScalarUDFImpl for LogFunc {)?}other => {- return exec_err!("Unsupported data type {other:?} for function log")+ return exec_err!("Unsupported data type {other:?} for function log");}};@@ -324,7 +324,7 @@ impl ScalarUDFImpl for LogFunc {_ => {return internal_err!("Unexpected number of arguments in log::simplify"- )+ );}};Ok(ExprSimplifyResult::Original(args))@@ -350,10 +350,10 @@ mod tests {Date32Array, Decimal128Array, Decimal256Array, Float32Array, Float64Array,};use arrow::compute::SortOptions;- use arrow::datatypes::{Field, DECIMAL256_MAX_PRECISION};+ use arrow::datatypes::{DECIMAL256_MAX_PRECISION, Field};+ use datafusion_common::DFSchema;use datafusion_common::cast::{as_float32_array, as_float64_array};use datafusion_common::config::ConfigOptions;- use datafusion_common::DFSchema;use datafusion_expr::execution_props::ExecutionProps;use datafusion_expr::simplify::SimplifyContext;@@ -1120,7 +1120,8 @@ mod tests {};let result = LogFunc::new().invoke_with_args(args);assert!(result.is_err());- assert_eq!(result.unwrap_err().to_string().lines().next().unwrap(),+ assert_eq!(+ result.unwrap_err().to_string().lines().next().unwrap(),"Arrow error: Not yet implemented: Log of Decimal256 larger than Decimal128 is not yet supported: 170141183460469231731687303715884106727");}diff --git a/datafusion/functions/src/math/monotonicity.rs b/datafusion/functions/src/math/monotonicity.rsindex ffb3df4196..76539b9b5c 100644--- a/datafusion/functions/src/math/monotonicity.rs+++ b/datafusion/functions/src/math/monotonicity.rs@@ -17,11 +17,11 @@use std::sync::LazyLock;-use datafusion_common::{exec_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err};use datafusion_doc::scalar_doc_sections::DOC_SECTION_MATH;+use datafusion_expr::Documentation;use datafusion_expr::interval_arithmetic::Interval;use datafusion_expr::sort_properties::{ExprProperties, SortProperties};-use datafusion_expr::Documentation;/// Non-increasing on the interval \[−1, 1\], undefined otherwise.pub fn acos_order(input: &[ExprProperties]) -> Result<SortProperties> {diff --git a/datafusion/functions/src/math/nans.rs b/datafusion/functions/src/math/nans.rsindex 759b0f5fd5..be21cfde0a 100644--- a/datafusion/functions/src/math/nans.rs+++ b/datafusion/functions/src/math/nans.rs@@ -18,7 +18,7 @@//! Math function: `isnan()`.use arrow::datatypes::{DataType, Float32Type, Float64Type};-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, TypeSignature};use arrow::array::{ArrayRef, AsArray, BooleanArray};@@ -100,7 +100,7 @@ impl ScalarUDFImpl for IsNanFunc {return exec_err!("Unsupported data type {other:?} for function {}",self.name()- )+ );}};Ok(ColumnarValue::Array(arr))diff --git a/datafusion/functions/src/math/nanvl.rs b/datafusion/functions/src/math/nanvl.rsindex f0835b4d48..345b1a5b71 100644--- a/datafusion/functions/src/math/nanvl.rs+++ b/datafusion/functions/src/math/nanvl.rs@@ -23,7 +23,7 @@ use crate::utils::make_scalar_function;use arrow::array::{ArrayRef, AsArray, Float32Array, Float64Array};use arrow::datatypes::DataType::{Float32, Float64};use arrow::datatypes::{DataType, Float32Type, Float64Type};-use datafusion_common::{exec_err, DataFusionError, Result};+use datafusion_common::{DataFusionError, Result, exec_err};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,@@ -110,11 +110,7 @@ fn nanvl(args: &[ArrayRef]) -> Result<ArrayRef> {match args[0].data_type() {Float64 => {let compute_nanvl = |x: f64, y: f64| {- if x.is_nan() {- y- } else {- x- }+ if x.is_nan() { y } else { x }};let x = args[0].as_primitive() as &Float64Array;@@ -125,11 +121,7 @@ fn nanvl(args: &[ArrayRef]) -> Result<ArrayRef> {}Float32 => {let compute_nanvl = |x: f32, y: f32| {- if x.is_nan() {- y- } else {- x- }+ if x.is_nan() { y } else { x }};let x = args[0].as_primitive() as &Float32Array;diff --git a/datafusion/functions/src/math/pi.rs b/datafusion/functions/src/math/pi.rsindex 92a27932e1..574928a097 100644--- a/datafusion/functions/src/math/pi.rs+++ b/datafusion/functions/src/math/pi.rs@@ -19,7 +19,7 @@ use std::any::Any;use arrow::datatypes::DataType;use arrow::datatypes::DataType::Float64;-use datafusion_common::{assert_or_internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, assert_or_internal_err};use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/math/power.rs b/datafusion/functions/src/math/power.rsindex 5d6a8bcfde..3fb48c392c 100644--- a/datafusion/functions/src/math/power.rs+++ b/datafusion/functions/src/math/power.rs@@ -23,12 +23,12 @@ use super::log::LogFunc;use crate::utils::{calculate_binary_decimal_math, calculate_binary_math};use arrow::array::{Array, ArrayRef};use arrow::datatypes::{- ArrowNativeTypeOp, DataType, Decimal128Type, Decimal256Type, Decimal32Type,- Decimal64Type, Float64Type, Int64Type,+ ArrowNativeTypeOp, DataType, Decimal32Type, Decimal64Type, Decimal128Type,+ Decimal256Type, Float64Type, Int64Type,};use arrow::error::ArrowError;use datafusion_common::utils::take_function_args;-use datafusion_common::{exec_err, plan_datafusion_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, plan_datafusion_err};use datafusion_expr::expr::ScalarFunction;use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};use datafusion_expr::type_coercion::is_decimal;@@ -226,81 +226,113 @@ impl ScalarUDFImpl for PowerFunc {},)?}- (DataType::Decimal32(precision, scale), DataType::Int64) =>- calculate_binary_decimal_math::<Decimal32Type, Int64Type, Decimal32Type, _>(- &base,- exponent,- |b, e| pow_decimal_int(b, *scale, e),+ (DataType::Decimal32(precision, scale), DataType::Int64) => {+ calculate_binary_decimal_math::<Decimal32Type, Int64Type, Decimal32Type, _>(+ &base,+ exponent,+ |b, e| pow_decimal_int(b, *scale, e),*precision,*scale,- )?,- (DataType::Decimal32(precision, scale), DataType::Float64) =>- calculate_binary_decimal_math::<Decimal32Type, Float64Type, Decimal32Type, _>(- &base,- exponent,- |b, e| pow_decimal_float(b, *scale, e),+ )?+ }+ (DataType::Decimal32(precision, scale), DataType::Float64) => {+ calculate_binary_decimal_math::<+ Decimal32Type,+ Float64Type,+ Decimal32Type,+ _,+ >(+ &base,+ exponent,+ |b, e| pow_decimal_float(b, *scale, e),*precision,*scale,- )?,- (DataType::Decimal64(precision, scale), DataType::Int64) =>- calculate_binary_decimal_math::<Decimal64Type, Int64Type, Decimal64Type, _>(- &base,- exponent,- |b, e| pow_decimal_int(b, *scale, e),+ )?+ }+ (DataType::Decimal64(precision, scale), DataType::Int64) => {+ calculate_binary_decimal_math::<Decimal64Type, Int64Type, Decimal64Type, _>(+ &base,+ exponent,+ |b, e| pow_decimal_int(b, *scale, e),*precision,*scale,- )?,- (DataType::Decimal64(precision, scale), DataType::Float64) =>- calculate_binary_decimal_math::<Decimal64Type, Float64Type, Decimal64Type, _>(- &base,- exponent,- |b, e| pow_decimal_float(b, *scale, e),+ )?+ }+ (DataType::Decimal64(precision, scale), DataType::Float64) => {+ calculate_binary_decimal_math::<+ Decimal64Type,+ Float64Type,+ Decimal64Type,+ _,+ >(+ &base,+ exponent,+ |b, e| pow_decimal_float(b, *scale, e),*precision,*scale,- )?,- (DataType::Decimal128(precision, scale), DataType::Int64) =>- calculate_binary_decimal_math::<Decimal128Type, Int64Type, Decimal128Type, _>(- &base,- exponent,- |b, e| pow_decimal_int(b, *scale, e),+ )?+ }+ (DataType::Decimal128(precision, scale), DataType::Int64) => {+ calculate_binary_decimal_math::<+ Decimal128Type,+ Int64Type,+ Decimal128Type,+ _,+ >(+ &base,+ exponent,+ |b, e| pow_decimal_int(b, *scale, e),*precision,*scale,- )?,- (DataType::Decimal128(precision, scale), DataType::Float64) =>- calculate_binary_decimal_math::<- Decimal128Type,- Float64Type,- Decimal128Type,- _,- >(&base, exponent, |b, e|- pow_decimal_float(b, *scale, e),+ )?+ }+ (DataType::Decimal128(precision, scale), DataType::Float64) => {+ calculate_binary_decimal_math::<+ Decimal128Type,+ Float64Type,+ Decimal128Type,+ _,+ >(+ &base,+ exponent,+ |b, e| pow_decimal_float(b, *scale, e),*precision,*scale,- )?,- (DataType::Decimal256(precision, scale),DataType::Int64) =>- calculate_binary_decimal_math::<Decimal256Type, Int64Type, Decimal256Type, _>(- &base,- exponent,- |b, e| pow_decimal_int(b, *scale, e),+ )?+ }+ (DataType::Decimal256(precision, scale), DataType::Int64) => {+ calculate_binary_decimal_math::<+ Decimal256Type,+ Int64Type,+ Decimal256Type,+ _,+ >(+ &base,+ exponent,+ |b, e| pow_decimal_int(b, *scale, e),*precision,*scale,- )?,- (DataType::Decimal256(precision, scale), DataType::Float64) =>- calculate_binary_decimal_math::<- Decimal256Type,- Float64Type,- Decimal256Type,- _,- >(&base, exponent, |b, e|- pow_decimal_float(b, *scale, e) ,- *precision,+ )?+ }+ (DataType::Decimal256(precision, scale), DataType::Float64) => {+ calculate_binary_decimal_math::<+ Decimal256Type,+ Float64Type,+ Decimal256Type,+ _,+ >(+ &base,+ exponent,+ |b, e| pow_decimal_float(b, *scale, e),+ *precision,*scale,- )?,+ )?+ }(base_type, exp_type) => {return exec_err!("Unsupported data types for base {base_type:?} and exponent {exp_type:?} for function {}",self.name()- )+ );}};Ok(ColumnarValue::Array(arr))@@ -359,7 +391,7 @@ fn is_log(func: &ScalarUDF) -> bool {mod tests {use super::*;use arrow::array::{Array, Decimal128Array, Float64Array, Int64Array};- use arrow::datatypes::{Field, DECIMAL128_MAX_SCALE};+ use arrow::datatypes::{DECIMAL128_MAX_SCALE, Field};use arrow_buffer::NullBuffer;use datafusion_common::cast::{as_decimal128_array, as_float64_array, as_int64_array,diff --git a/datafusion/functions/src/math/random.rs b/datafusion/functions/src/math/random.rsindex 4270eff665..78932873b4 100644--- a/datafusion/functions/src/math/random.rs+++ b/datafusion/functions/src/math/random.rs@@ -21,9 +21,9 @@ use std::sync::Arc;use arrow::array::Float64Array;use arrow::datatypes::DataType;use arrow::datatypes::DataType::Float64;-use rand::{rng, Rng};+use rand::{Rng, rng};-use datafusion_common::{assert_or_internal_err, Result};+use datafusion_common::{Result, assert_or_internal_err};use datafusion_expr::{ColumnarValue, ScalarFunctionArgs};use datafusion_expr::{Documentation, ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;diff --git a/datafusion/functions/src/math/round.rs b/datafusion/functions/src/math/round.rsindex 5f9b1eb6ad..7d5b6f9172 100644--- a/datafusion/functions/src/math/round.rs+++ b/datafusion/functions/src/math/round.rs@@ -21,12 +21,12 @@ use std::sync::Arc;use crate::utils::make_scalar_function;use arrow::array::{ArrayRef, AsArray, PrimitiveArray};-use arrow::compute::{cast_with_options, CastOptions};+use arrow::compute::{CastOptions, cast_with_options};use arrow::datatypes::DataType::{Float32, Float64, Int32};use arrow::datatypes::{DataType, Float32Type, Float64Type, Int32Type};-use datafusion_common::{exec_datafusion_err, exec_err, Result, ScalarValue};-use datafusion_expr::sort_properties::{ExprProperties, SortProperties};+use datafusion_common::{Result, ScalarValue, exec_datafusion_err, exec_err};use datafusion_expr::TypeSignature::Exact;+use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,Volatility,@@ -234,8 +234,8 @@ mod test {use crate::math::round::round;use arrow::array::{ArrayRef, Float32Array, Float64Array, Int64Array};- use datafusion_common::cast::{as_float32_array, as_float64_array};use datafusion_common::DataFusionError;+ use datafusion_common::cast::{as_float32_array, as_float64_array};#[test]fn test_round_f32() {diff --git a/datafusion/functions/src/math/signum.rs b/datafusion/functions/src/math/signum.rsindex 2e616fe0fe..e217088c64 100644--- a/datafusion/functions/src/math/signum.rs+++ b/datafusion/functions/src/math/signum.rs@@ -22,7 +22,7 @@ use arrow::array::{ArrayRef, AsArray};use arrow::datatypes::DataType::{Float32, Float64};use arrow::datatypes::{DataType, Float32Type, Float64Type};-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,@@ -114,11 +114,7 @@ fn signum(args: &[ArrayRef]) -> Result<ArrayRef> {.as_primitive::<Float64Type>().unary::<_, Float64Type>(|x: f64| {- if x == 0_f64 {- 0_f64- } else {- x.signum()- }+ if x == 0_f64 { 0_f64 } else { x.signum() }},),) as ArrayRef),@@ -128,11 +124,7 @@ fn signum(args: &[ArrayRef]) -> Result<ArrayRef> {.as_primitive::<Float32Type>().unary::<_, Float32Type>(|x: f32| {- if x == 0_f32 {- 0_f32- } else {- x.signum()- }+ if x == 0_f32 { 0_f32 } else { x.signum() }},),) as ArrayRef),diff --git a/datafusion/functions/src/math/trunc.rs b/datafusion/functions/src/math/trunc.rsindex 9d1b4336f6..6727ba8fbd 100644--- a/datafusion/functions/src/math/trunc.rs+++ b/datafusion/functions/src/math/trunc.rs@@ -24,9 +24,9 @@ use arrow::array::{ArrayRef, AsArray, PrimitiveArray};use arrow::datatypes::DataType::{Float32, Float64};use arrow::datatypes::{DataType, Float32Type, Float64Type, Int64Type};use datafusion_common::ScalarValue::Int64;-use datafusion_common::{exec_err, Result};-use datafusion_expr::sort_properties::{ExprProperties, SortProperties};+use datafusion_common::{Result, exec_err};use datafusion_expr::TypeSignature::Exact;+use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,Volatility,@@ -158,11 +158,7 @@ fn trunc(args: &[ArrayRef]) -> Result<ArrayRef> {args[0].as_primitive::<Float64Type>().unary::<_, Float64Type>(|x: f64| {- if x == 0_f64 {- 0_f64- } else {- x.trunc()- }+ if x == 0_f64 { 0_f64 } else { x.trunc() }}),) as ArrayRef)}@@ -184,11 +180,7 @@ fn trunc(args: &[ArrayRef]) -> Result<ArrayRef> {args[0].as_primitive::<Float32Type>().unary::<_, Float32Type>(|x: f32| {- if x == 0_f32 {- 0_f32- } else {- x.trunc()- }+ if x == 0_f32 { 0_f32 } else { x.trunc() }}),) as ArrayRef)}diff --git a/datafusion/functions/src/planner.rs b/datafusion/functions/src/planner.rsindex ccd1679970..9854326945 100644--- a/datafusion/functions/src/planner.rs+++ b/datafusion/functions/src/planner.rs@@ -19,9 +19,9 @@use datafusion_common::Result;use datafusion_expr::{+ Expr,expr::ScalarFunction,planner::{ExprPlanner, PlannerResult},- Expr,};#[deprecated(diff --git a/datafusion/functions/src/regex/mod.rs b/datafusion/functions/src/regex/mod.rsindex da4e23f91d..75cc5d9514 100644--- a/datafusion/functions/src/regex/mod.rs+++ b/datafusion/functions/src/regex/mod.rs@@ -19,8 +19,8 @@use arrow::error::ArrowError;use regex::Regex;-use std::collections::hash_map::Entry;use std::collections::HashMap;+use std::collections::hash_map::Entry;use std::sync::Arc;pub mod regexpcount;pub mod regexpinstr;diff --git a/datafusion/functions/src/regex/regexpcount.rs b/datafusion/functions/src/regex/regexpcount.rsindex ae08ca3e92..de4c657dd0 100644--- a/datafusion/functions/src/regex/regexpcount.rs+++ b/datafusion/functions/src/regex/regexpcount.rs@@ -22,7 +22,7 @@ use arrow::datatypes::{DataType::Int64, DataType::LargeUtf8, DataType::Utf8, DataType::Utf8View,};use arrow::error::ArrowError;-use datafusion_common::{exec_err, internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, internal_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, TypeSignature::Exact,TypeSignature::Uniform, Volatility,@@ -146,7 +146,9 @@ impl ScalarUDFImpl for RegexpCountFunc {pub fn regexp_count_func(args: &[ArrayRef]) -> Result<ArrayRef> {let args_len = args.len();if !(2..=4).contains(&args_len) {- return exec_err!("regexp_count was called with {args_len} arguments. It requires at least 2 and at most 4.");+ return exec_err!(+ "regexp_count was called with {args_len} arguments. It requires at least 2 and at most 4."+ );}let values = &args[0];@@ -306,7 +308,7 @@ where(true, true, true) => {let regex = match regex_scalar {None | Some("") => {- return Ok(Arc::new(Int64Array::from(vec![0; values.len()])))+ return Ok(Arc::new(Int64Array::from(vec![0; values.len()])));}Some(regex) => regex,};@@ -323,7 +325,7 @@ where(true, true, false) => {let regex = match regex_scalar {None | Some("") => {- return Ok(Arc::new(Int64Array::from(vec![0; values.len()])))+ return Ok(Arc::new(Int64Array::from(vec![0; values.len()])));}Some(regex) => regex,};@@ -352,7 +354,7 @@ where(true, false, true) => {let regex = match regex_scalar {None | Some("") => {- return Ok(Arc::new(Int64Array::from(vec![0; values.len()])))+ return Ok(Arc::new(Int64Array::from(vec![0; values.len()])));}Some(regex) => regex,};@@ -372,7 +374,7 @@ where(true, false, false) => {let regex = match regex_scalar {None | Some("") => {- return Ok(Arc::new(Int64Array::from(vec![0; values.len()])))+ return Ok(Arc::new(Int64Array::from(vec![0; values.len()])));}Some(regex) => regex,};diff --git a/datafusion/functions/src/regex/regexpinstr.rs b/datafusion/functions/src/regex/regexpinstr.rsindex cb32007924..dce689a0c2 100644--- a/datafusion/functions/src/regex/regexpinstr.rs+++ b/datafusion/functions/src/regex/regexpinstr.rs@@ -23,7 +23,7 @@ use arrow::datatypes::{DataType::Int64, DataType::LargeUtf8, DataType::Utf8, DataType::Utf8View,};use arrow::error::ArrowError;-use datafusion_common::{exec_err, internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, internal_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, TypeSignature::Exact,TypeSignature::Uniform, Volatility,@@ -163,7 +163,9 @@ impl ScalarUDFImpl for RegexpInstrFunc {pub fn regexp_instr_func(args: &[ArrayRef]) -> Result<ArrayRef> {let args_len = args.len();if !(2..=6).contains(&args_len) {- return exec_err!("regexp_instr was called with {args_len} arguments. It requires at least 2 and at most 6.");+ return exec_err!(+ "regexp_instr was called with {args_len} arguments. It requires at least 2 and at most 6."+ );}let values = &args[0];@@ -356,14 +358,14 @@ fn handle_subexp(value: &str,byte_start_offset: usize,) -> Result<Option<i64>, ArrowError> {- if let Some(captures) = pattern.captures(search_slice) {- if let Some(matched) = captures.get(subexpr as usize) {- // Convert byte offset relative to search_slice back to 1-based character offset- // relative to the original `value` string.- let start_char_offset =- value[..byte_start_offset + matched.start()].chars().count() as i64 + 1;- return Ok(Some(start_char_offset));- }+ if let Some(captures) = pattern.captures(search_slice)+ && let Some(matched) = captures.get(subexpr as usize)+ {+ // Convert byte offset relative to search_slice back to 1-based character offset+ // relative to the original `value` string.+ let start_char_offset =+ value[..byte_start_offset + matched.start()].chars().count() as i64 + 1;+ return Ok(Some(start_char_offset));}Ok(Some(0)) // Return 0 if the subexpression was not found}diff --git a/datafusion/functions/src/regex/regexplike.rs b/datafusion/functions/src/regex/regexplike.rsindex 0791648277..f707c8e0d8 100644--- a/datafusion/functions/src/regex/regexplike.rs+++ b/datafusion/functions/src/regex/regexplike.rs@@ -23,11 +23,11 @@ use arrow::datatypes::DataType;use arrow::datatypes::DataType::{LargeUtf8, Utf8, Utf8View};use datafusion_common::types::logical_string;use datafusion_common::{- arrow_datafusion_err, exec_err, internal_err, plan_err, Result, ScalarValue,+ Result, ScalarValue, arrow_datafusion_err, exec_err, internal_err, plan_err,};use datafusion_expr::{- binary_expr, cast, Coercion, ColumnarValue, Documentation, Expr, ScalarUDFImpl,- Signature, TypeSignature, TypeSignatureClass, Volatility,+ Coercion, ColumnarValue, Documentation, Expr, ScalarUDFImpl, Signature,+ TypeSignature, TypeSignatureClass, Volatility, binary_expr, cast,};use datafusion_macros::user_doc;@@ -275,29 +275,31 @@ pub fn regexp_like(args: &[ArrayRef]) -> Result<ArrayRef> {Utf8 => args[2].as_string::<i32>(),LargeUtf8 => {let large_string_array = args[2].as_string::<i64>();- let string_vec: Vec<Option<&str>> = (0..large_string_array.len()).map(|i| {- if large_string_array.is_null(i) {- None- } else {- Some(large_string_array.value(i))- }- })- .collect();+ let string_vec: Vec<Option<&str>> = (0..large_string_array.len())+ .map(|i| {+ if large_string_array.is_null(i) {+ None+ } else {+ Some(large_string_array.value(i))+ }+ })+ .collect();&GenericStringArray::<i32>::from(string_vec)- },+ }_ => {let string_view_array = args[2].as_string_view();- let string_vec: Vec<Option<String>> = (0..string_view_array.len()).map(|i| {- if string_view_array.is_null(i) {- None- } else {- Some(string_view_array.value(i).to_string())- }- })- .collect();+ let string_vec: Vec<Option<String>> = (0..string_view_array.len())+ .map(|i| {+ if string_view_array.is_null(i) {+ None+ } else {+ Some(string_view_array.value(i).to_string())+ }+ })+ .collect();&GenericStringArray::<i32>::from(string_vec)- },+ }};if flags.iter().any(|s| s == Some("g")) {@@ -305,7 +307,7 @@ pub fn regexp_like(args: &[ArrayRef]) -> Result<ArrayRef> {}handle_regexp_like(&args[0], &args[1], Some(flags))- },+ }other => exec_err!("`regexp_like` was called with {other} arguments. It requires at least 2 and at most 3."),@@ -384,7 +386,7 @@ fn handle_regexp_like(other => {return internal_err!("Unsupported data type {other:?} for function `regexp_like`"- )+ );}};diff --git a/datafusion/functions/src/regex/regexpmatch.rs b/datafusion/functions/src/regex/regexpmatch.rsindex abbfc9be84..e026d16e1c 100644--- a/datafusion/functions/src/regex/regexpmatch.rs+++ b/datafusion/functions/src/regex/regexpmatch.rs@@ -20,9 +20,9 @@ use arrow::array::{Array, ArrayRef, AsArray};use arrow::compute::kernels::regexp;use arrow::datatypes::DataType;use arrow::datatypes::Field;-use datafusion_common::exec_err;use datafusion_common::Result;use datafusion_common::ScalarValue;+use datafusion_common::exec_err;use datafusion_common::{arrow_datafusion_err, plan_err};use datafusion_expr::{ColumnarValue, Documentation, TypeSignature};use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};@@ -155,29 +155,35 @@ impl ScalarUDFImpl for RegexpMatchFunc {pub fn regexp_match(args: &[ArrayRef]) -> Result<ArrayRef> {match args.len() {- 2 => {- regexp::regexp_match(&args[0], &args[1], None)- .map_err(|e| arrow_datafusion_err!(e))- }+ 2 => regexp::regexp_match(&args[0], &args[1], None)+ .map_err(|e| arrow_datafusion_err!(e)),3 => {match args[2].data_type() {DataType::Utf8View => {if args[2].as_string_view().iter().any(|s| s == Some("g")) {- return plan_err!("regexp_match() does not support the \"global\" option");+ return plan_err!(+ "regexp_match() does not support the \"global\" option"+ );}}DataType::Utf8 => {if args[2].as_string::<i32>().iter().any(|s| s == Some("g")) {- return plan_err!("regexp_match() does not support the \"global\" option");+ return plan_err!(+ "regexp_match() does not support the \"global\" option"+ );}}DataType::LargeUtf8 => {if args[2].as_string::<i64>().iter().any(|s| s == Some("g")) {- return plan_err!("regexp_match() does not support the \"global\" option");+ return plan_err!(+ "regexp_match() does not support the \"global\" option"+ );}}e => {- return plan_err!("regexp_match was called with unexpected data type {e:?}");+ return plan_err!(+ "regexp_match was called with unexpected data type {e:?}"+ );}}@@ -254,6 +260,9 @@ mod tests {regexp_match(&[Arc::new(values), Arc::new(patterns), Arc::new(flags)]).expect_err("unsupported flag should have failed");- assert_eq!(re_err.strip_backtrace(), "Error during planning: regexp_match() does not support the \"global\" option");+ assert_eq!(+ re_err.strip_backtrace(),+ "Error during planning: regexp_match() does not support the \"global\" option"+ );}}diff --git a/datafusion/functions/src/regex/regexpreplace.rs b/datafusion/functions/src/regex/regexpreplace.rsindex 81146eb54d..b5ab46f0ec 100644--- a/datafusion/functions/src/regex/regexpreplace.rs+++ b/datafusion/functions/src/regex/regexpreplace.rs@@ -20,22 +20,22 @@ use arrow::array::ArrayDataBuilder;use arrow::array::BufferBuilder;use arrow::array::GenericStringArray;use arrow::array::StringViewBuilder;-use arrow::array::{new_null_array, ArrayIter, AsArray};use arrow::array::{Array, ArrayRef, OffsetSizeTrait};use arrow::array::{ArrayAccessor, StringViewArray};+use arrow::array::{ArrayIter, AsArray, new_null_array};use arrow::datatypes::DataType;+use datafusion_common::ScalarValue;use datafusion_common::cast::{as_large_string_array, as_string_array, as_string_view_array,};use datafusion_common::exec_err;use datafusion_common::plan_err;-use datafusion_common::ScalarValue;use datafusion_common::{- cast::as_generic_string_array, internal_err, DataFusionError, Result,+ DataFusionError, Result, cast::as_generic_string_array, internal_err,};-use datafusion_expr::function::Hint;use datafusion_expr::ColumnarValue;use datafusion_expr::TypeSignature;+use datafusion_expr::function::Hint;use datafusion_expr::{Documentation, ScalarUDFImpl, Signature, Volatility};use datafusion_macros::user_doc;use regex::Regex;@@ -434,7 +434,7 @@ fn _regexp_replace_static_pattern_replace<T: OffsetSizeTrait>(other => {return exec_err!("regexp_replace was called with {other} arguments. It requires at least 3 and at most 4."- )+ );}};diff --git a/datafusion/functions/src/string/ascii.rs b/datafusion/functions/src/string/ascii.rsindex 8b55f8fb8f..fe3c508ede 100644--- a/datafusion/functions/src/string/ascii.rs+++ b/datafusion/functions/src/string/ascii.rs@@ -20,7 +20,7 @@ use arrow::array::{ArrayRef, AsArray, Int32Array, StringArrayType};use arrow::datatypes::DataType;use arrow::error::ArrowError;use datafusion_common::types::logical_string;-use datafusion_common::{internal_err, Result};+use datafusion_common::{Result, internal_err};use datafusion_expr::{ColumnarValue, Documentation, TypeSignatureClass};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};use datafusion_expr_common::signature::Coercion;diff --git a/datafusion/functions/src/string/btrim.rs b/datafusion/functions/src/string/btrim.rsindex a7fbdb3c69..2d0b064ffb 100644--- a/datafusion/functions/src/string/btrim.rs+++ b/datafusion/functions/src/string/btrim.rs@@ -20,7 +20,7 @@ use crate::utils::{make_scalar_function, utf8_to_str_type};use arrow::array::{ArrayRef, OffsetSizeTrait};use arrow::datatypes::DataType;use datafusion_common::types::logical_string;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::function::Hint;use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/string/chr.rs b/datafusion/functions/src/string/chr.rsindex 8706c43214..ba011b9436 100644--- a/datafusion/functions/src/string/chr.rs+++ b/datafusion/functions/src/string/chr.rs@@ -26,7 +26,7 @@ use arrow::datatypes::DataType::Utf8;use crate::utils::make_scalar_function;use datafusion_common::cast::as_int64_array;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, Documentation, Volatility};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};use datafusion_macros::user_doc;@@ -47,11 +47,11 @@ fn chr(args: &[ArrayRef]) -> Result<ArrayRef> {for integer in integer_array {match integer {Some(integer) => {- if let Ok(u) = u32::try_from(integer) {- if let Some(c) = core::char::from_u32(u) {- builder.append_value(c.encode_utf8(&mut buf));- continue;- }+ if let Ok(u) = u32::try_from(integer)+ && let Some(c) = core::char::from_u32(u)+ {+ builder.append_value(c.encode_utf8(&mut buf));+ continue;}return exec_err!("invalid Unicode scalar value: {integer}");diff --git a/datafusion/functions/src/string/common.rs b/datafusion/functions/src/string/common.rsindex 34f1b6232d..ebfada9536 100644--- a/datafusion/functions/src/string/common.rs+++ b/datafusion/functions/src/string/common.rs@@ -22,14 +22,14 @@ use std::sync::Arc;use crate::strings::make_and_append_view;use arrow::array::{- new_null_array, Array, ArrayRef, GenericStringArray, GenericStringBuilder,- NullBufferBuilder, OffsetSizeTrait, StringBuilder, StringViewArray,+ Array, ArrayRef, GenericStringArray, GenericStringBuilder, NullBufferBuilder,+ OffsetSizeTrait, StringBuilder, StringViewArray, new_null_array,};use arrow::buffer::{Buffer, ScalarBuffer};use arrow::datatypes::DataType;-use datafusion_common::cast::{as_generic_string_array, as_string_view_array};use datafusion_common::Result;-use datafusion_common::{exec_err, ScalarValue};+use datafusion_common::cast::{as_generic_string_array, as_string_view_array};+use datafusion_common::{ScalarValue, exec_err};use datafusion_expr::ColumnarValue;#[derive(Copy, Clone)]@@ -186,7 +186,7 @@ fn string_view_trim<'a>(}other => {return exec_err!(- "Function TRIM was called with {other} arguments. It requires at least 1 and at most 2."+ "Function TRIM was called with {other} arguments. It requires at least 1 and at most 2.");}}@@ -295,7 +295,7 @@ fn string_trim<'a, T: OffsetSizeTrait>(}other => {exec_err!(- "Function TRIM was called with {other} arguments. It requires at least 1 and at most 2."+ "Function TRIM was called with {other} arguments. It requires at least 1 and at most 2.")}}diff --git a/datafusion/functions/src/string/concat.rs b/datafusion/functions/src/string/concat.rsindex 3b53660463..42d455a057 100644--- a/datafusion/functions/src/string/concat.rs+++ b/datafusion/functions/src/string/concat.rs@@ -15,7 +15,7 @@// specific language governing permissions and limitations// under the License.-use arrow::array::{as_largestring_array, Array};+use arrow::array::{Array, as_largestring_array};use arrow::datatypes::DataType;use datafusion_expr::sort_properties::ExprProperties;use std::any::Any;@@ -26,10 +26,10 @@ use crate::strings::{ColumnarValueRef, LargeStringArrayBuilder, StringArrayBuilder, StringViewArrayBuilder,};use datafusion_common::cast::{as_string_array, as_string_view_array};-use datafusion_common::{internal_err, plan_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, internal_err, plan_err};use datafusion_expr::expr::ScalarFunction;use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};-use datafusion_expr::{lit, ColumnarValue, Documentation, Expr, Volatility};+use datafusion_expr::{ColumnarValue, Documentation, Expr, Volatility, lit};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};use datafusion_macros::user_doc;@@ -189,7 +189,7 @@ impl ScalarUDFImpl for ConcatFunc {ColumnarValueRef::NonNullableArray(string_array)};columns.push(column);- },+ }DataType::LargeUtf8 => {let string_array = as_largestring_array(array);@@ -197,10 +197,12 @@ impl ScalarUDFImpl for ConcatFunc {let column = if array.is_nullable() {ColumnarValueRef::NullableLargeStringArray(string_array)} else {- ColumnarValueRef::NonNullableLargeStringArray(string_array)+ ColumnarValueRef::NonNullableLargeStringArray(+ string_array,+ )};columns.push(column);- },+ }DataType::Utf8View => {let string_array = as_string_view_array(array)?;@@ -211,9 +213,11 @@ impl ScalarUDFImpl for ConcatFunc {ColumnarValueRef::NonNullableStringViewArray(string_array)};columns.push(column);- },+ }other => {- return plan_err!("Input was {other} which is not a supported datatype for concat function")+ return plan_err!(+ "Input was {other} which is not a supported datatype for concat function"+ );}};}@@ -305,9 +309,8 @@ pub(crate) fn simplify_concat(args: Vec<Expr>) -> Result<ExprSimplifyResult> {for arg in args.clone() {match arg {Expr::Literal(ScalarValue::Utf8(None), _) => {}- Expr::Literal(ScalarValue::LargeUtf8(None), _) => {- }- Expr::Literal(ScalarValue::Utf8View(None), _) => { }+ Expr::Literal(ScalarValue::LargeUtf8(None), _) => {}+ Expr::Literal(ScalarValue::Utf8View(None), _) => {}// filter out `null` args// All literals have been converted to Utf8 or LargeUtf8 in type_coercion.@@ -325,7 +328,7 @@ pub(crate) fn simplify_concat(args: Vec<Expr>) -> Result<ExprSimplifyResult> {Expr::Literal(x, _) => {return internal_err!("The scalar {x} should be casted to string type during the type coercion."- )+ );}// If the arg is not a literal, we should first push the current `contiguous_scalar`// to the `new_args` (if it is not empty) and reset it to empty string.@@ -334,8 +337,10 @@ pub(crate) fn simplify_concat(args: Vec<Expr>) -> Result<ExprSimplifyResult> {if !contiguous_scalar.is_empty() {match return_type {DataType::Utf8 => new_args.push(lit(contiguous_scalar)),- DataType::LargeUtf8 => new_args.push(lit(ScalarValue::LargeUtf8(Some(contiguous_scalar)))),- DataType::Utf8View => new_args.push(lit(ScalarValue::Utf8View(Some(contiguous_scalar)))),+ DataType::LargeUtf8 => new_args+ .push(lit(ScalarValue::LargeUtf8(Some(contiguous_scalar)))),+ DataType::Utf8View => new_args+ .push(lit(ScalarValue::Utf8View(Some(contiguous_scalar)))),_ => unreachable!(),}contiguous_scalar = "".to_string();@@ -374,11 +379,11 @@ pub(crate) fn simplify_concat(args: Vec<Expr>) -> Result<ExprSimplifyResult> {mod tests {use super::*;use crate::utils::test::test_function;+ use DataType::*;use arrow::array::{Array, LargeStringArray, StringViewArray};use arrow::array::{ArrayRef, StringArray};use arrow::datatypes::Field;use datafusion_common::config::ConfigOptions;- use DataType::*;#[test]fn test_functions() -> Result<()> {diff --git a/datafusion/functions/src/string/concat_ws.rs b/datafusion/functions/src/string/concat_ws.rsindex cdd30ac875..8fe095c5ce 100644--- a/datafusion/functions/src/string/concat_ws.rs+++ b/datafusion/functions/src/string/concat_ws.rs@@ -15,7 +15,7 @@// specific language governing permissions and limitations// under the License.-use arrow::array::{as_largestring_array, Array, StringArray};+use arrow::array::{Array, StringArray, as_largestring_array};use std::any::Any;use std::sync::Arc;@@ -26,10 +26,10 @@ use crate::string::concat::simplify_concat;use crate::string::concat_ws;use crate::strings::{ColumnarValueRef, StringArrayBuilder};use datafusion_common::cast::{as_string_array, as_string_view_array};-use datafusion_common::{exec_err, internal_err, plan_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_err, internal_err, plan_err};use datafusion_expr::expr::ScalarFunction;use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo};-use datafusion_expr::{lit, ColumnarValue, Documentation, Expr, Volatility};+use datafusion_expr::{ColumnarValue, Documentation, Expr, Volatility, lit};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};use datafusion_macros::user_doc;@@ -155,7 +155,7 @@ impl ScalarUDFImpl for ConcatWsFunc {}Some(None) => {} // null literal stringNone => {- return internal_err!("Expected string literal, got {scalar:?}")+ return internal_err!("Expected string literal, got {scalar:?}");}}}@@ -169,7 +169,7 @@ impl ScalarUDFImpl for ConcatWsFunc {}Some(None) => {} // null literal stringNone => {- return internal_err!("Expected string literal, got {scalar:?}")+ return internal_err!("Expected string literal, got {scalar:?}");}}}@@ -225,7 +225,7 @@ impl ScalarUDFImpl for ConcatWsFunc {ColumnarValueRef::NonNullableArray(string_array)};columns.push(column);- },+ }DataType::LargeUtf8 => {let string_array = as_largestring_array(array);@@ -233,23 +233,31 @@ impl ScalarUDFImpl for ConcatWsFunc {let column = if array.is_nullable() {ColumnarValueRef::NullableLargeStringArray(string_array)} else {- ColumnarValueRef::NonNullableLargeStringArray(string_array)+ ColumnarValueRef::NonNullableLargeStringArray(+ string_array,+ )};columns.push(column);- },+ }DataType::Utf8View => {let string_array = as_string_view_array(array)?;- data_size += string_array.data_buffers().iter().map(|buf| buf.len()).sum::<usize>();+ data_size += string_array+ .data_buffers()+ .iter()+ .map(|buf| buf.len())+ .sum::<usize>();let column = if array.is_nullable() {ColumnarValueRef::NullableStringViewArray(string_array)} else {ColumnarValueRef::NonNullableStringViewArray(string_array)};columns.push(column);- },+ }other => {- return plan_err!("Input was {other} which is not a supported datatype for concat_ws function.")+ return plan_err!(+ "Input was {other} which is not a supported datatype for concat_ws function."+ );}};}@@ -337,18 +345,30 @@ fn simplify_concat_ws(delimiter: &Expr, args: &[Expr]) -> Result<ExprSimplifyResfor arg in args {match arg {// filter out null args- Expr::Literal(ScalarValue::Utf8(None) | ScalarValue::LargeUtf8(None) | ScalarValue::Utf8View(None), _) => {}- Expr::Literal(ScalarValue::Utf8(Some(v)) | ScalarValue::LargeUtf8(Some(v)) | ScalarValue::Utf8View(Some(v)), _) => {- match contiguous_scalar {- None => contiguous_scalar = Some(v.to_string()),- Some(mut pre) => {- pre += delimiter;- pre += v;- contiguous_scalar = Some(pre)- }+ Expr::Literal(+ ScalarValue::Utf8(None)+ | ScalarValue::LargeUtf8(None)+ | ScalarValue::Utf8View(None),+ _,+ ) => {}+ Expr::Literal(+ ScalarValue::Utf8(Some(v))+ | ScalarValue::LargeUtf8(Some(v))+ | ScalarValue::Utf8View(Some(v)),+ _,+ ) => match contiguous_scalar {+ None => contiguous_scalar = Some(v.to_string()),+ Some(mut pre) => {+ pre += delimiter;+ pre += v;+ contiguous_scalar = Some(pre)}+ },+ Expr::Literal(s, _) => {+ return internal_err!(+ "The scalar {s} should be casted to string type during the type coercion."+ );}- Expr::Literal(s, _) => return internal_err!("The scalar {s} should be casted to string type during the type coercion."),// If the arg is not a literal, we should first push the current `contiguous_scalar`// to the `new_args` and reset it to None.// Then pushing this arg to the `new_args`.@@ -409,9 +429,9 @@ mod tests {use arrow::array::{Array, ArrayRef, StringArray};use arrow::datatypes::DataType::Utf8;use arrow::datatypes::Field;- use datafusion_common::config::ConfigOptions;use datafusion_common::Result;use datafusion_common::ScalarValue;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl};use crate::utils::test::test_function;diff --git a/datafusion/functions/src/string/contains.rs b/datafusion/functions/src/string/contains.rsindex 7e50676933..b85e0ed796 100644--- a/datafusion/functions/src/string/contains.rs+++ b/datafusion/functions/src/string/contains.rs@@ -21,7 +21,7 @@ use arrow::compute::contains as arrow_contains;use arrow::datatypes::DataType;use arrow::datatypes::DataType::{Boolean, LargeUtf8, Utf8, Utf8View};use datafusion_common::types::logical_string;-use datafusion_common::{exec_err, DataFusionError, Result};+use datafusion_common::{DataFusionError, Result, exec_err};use datafusion_expr::binary::{binary_to_string_coercion, string_coercion};use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,@@ -153,8 +153,8 @@ mod test {use crate::expr_fn::contains;use arrow::array::{BooleanArray, StringArray};use arrow::datatypes::{DataType, Field};- use datafusion_common::config::ConfigOptions;use datafusion_common::ScalarValue;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{ColumnarValue, Expr, ScalarFunctionArgs, ScalarUDFImpl};use std::sync::Arc;diff --git a/datafusion/functions/src/string/ends_with.rs b/datafusion/functions/src/string/ends_with.rsindex 6090d9c84d..e3fa7c92ca 100644--- a/datafusion/functions/src/string/ends_with.rs+++ b/datafusion/functions/src/string/ends_with.rs@@ -23,7 +23,7 @@ use arrow::datatypes::DataType;use crate::utils::make_scalar_function;use datafusion_common::types::logical_string;-use datafusion_common::{internal_err, Result};+use datafusion_common::{Result, internal_err};use datafusion_expr::binary::{binary_to_string_coercion, string_coercion};use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,@@ -99,9 +99,9 @@ impl ScalarUDFImpl for EndsWithFunc {DataType::Utf8View | DataType::Utf8 | DataType::LargeUtf8 => {make_scalar_function(ends_with, vec![])(&args.args)}- other => {- internal_err!("Unsupported data type {other:?} for function ends_with. Expected Utf8, LargeUtf8 or Utf8View")?- }+ other => internal_err!(+ "Unsupported data type {other:?} for function ends_with. Expected Utf8, LargeUtf8 or Utf8View"+ )?,}}diff --git a/datafusion/functions/src/string/levenshtein.rs b/datafusion/functions/src/string/levenshtein.rsindex 2f7894df90..f46c674cd7 100644--- a/datafusion/functions/src/string/levenshtein.rs+++ b/datafusion/functions/src/string/levenshtein.rs@@ -26,7 +26,7 @@ use datafusion_common::cast::{as_generic_string_array, as_string_view_array};use datafusion_common::types::logical_string;use datafusion_common::utils::datafusion_strsim;use datafusion_common::utils::take_function_args;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::type_coercion::binary::{binary_to_string_coercion, string_coercion,};@@ -101,7 +101,9 @@ impl ScalarUDFImpl for LevenshteinFunc {{utf8_to_int_type(&coercion_data_type, "levenshtein")} else {- exec_err!("Unsupported data types for levenshtein. Expected Utf8, LargeUtf8 or Utf8View")+ exec_err!(+ "Unsupported data types for levenshtein. Expected Utf8, LargeUtf8 or Utf8View"+ )}}@@ -198,7 +200,9 @@ fn levenshtein<T: OffsetSizeTrait>(args: &[ArrayRef]) -> Result<ArrayRef> {}}} else {- exec_err!("Unsupported data types for levenshtein. Expected Utf8, LargeUtf8 or Utf8View")+ exec_err!(+ "Unsupported data types for levenshtein. Expected Utf8, LargeUtf8 or Utf8View"+ )}}diff --git a/datafusion/functions/src/string/lower.rs b/datafusion/functions/src/string/lower.rsindex ee56a6a549..3750d3d290 100644--- a/datafusion/functions/src/string/lower.rs+++ b/datafusion/functions/src/string/lower.rs@@ -20,8 +20,8 @@ use std::any::Any;use crate::string::common::to_lower;use crate::utils::utf8_to_str_type;-use datafusion_common::types::logical_string;use datafusion_common::Result;+use datafusion_common::types::logical_string;use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,TypeSignatureClass, Volatility,diff --git a/datafusion/functions/src/string/ltrim.rs b/datafusion/functions/src/string/ltrim.rsindex dc6d30d381..18a61869a8 100644--- a/datafusion/functions/src/string/ltrim.rs+++ b/datafusion/functions/src/string/ltrim.rs@@ -23,7 +23,7 @@ use std::sync::Arc;use crate::string::common::*;use crate::utils::{make_scalar_function, utf8_to_str_type};use datafusion_common::types::logical_string;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::function::Hint;use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/string/octet_length.rs b/datafusion/functions/src/string/octet_length.rsindex aa8257ef8f..3732897f3d 100644--- a/datafusion/functions/src/string/octet_length.rs+++ b/datafusion/functions/src/string/octet_length.rs@@ -119,7 +119,7 @@ mod tests {use arrow::datatypes::DataType::Int32;use datafusion_common::ScalarValue;- use datafusion_common::{exec_err, Result};+ use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, ScalarUDFImpl};use crate::string::octet_length::OctetLengthFunc;diff --git a/datafusion/functions/src/string/repeat.rs b/datafusion/functions/src/string/repeat.rsindex 1fc62d747d..0656a32c24 100644--- a/datafusion/functions/src/string/repeat.rs+++ b/datafusion/functions/src/string/repeat.rs@@ -26,8 +26,8 @@ use arrow::array::{use arrow::datatypes::DataType;use arrow::datatypes::DataType::{LargeUtf8, Utf8, Utf8View};use datafusion_common::cast::as_int64_array;-use datafusion_common::types::{logical_int64, logical_string, NativeType};-use datafusion_common::{exec_err, DataFusionError, Result};+use datafusion_common::types::{NativeType, logical_int64, logical_string};+use datafusion_common::{DataFusionError, Result, exec_err};use datafusion_expr::{ColumnarValue, Documentation, Volatility};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};use datafusion_expr_common::signature::{Coercion, TypeSignatureClass};@@ -199,7 +199,7 @@ mod tests {use arrow::datatypes::DataType::Utf8;use datafusion_common::ScalarValue;- use datafusion_common::{exec_err, Result};+ use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, ScalarUDFImpl};use crate::string::repeat::RepeatFunc;diff --git a/datafusion/functions/src/string/replace.rs b/datafusion/functions/src/string/replace.rsindex f127b452b2..a976ca7b91 100644--- a/datafusion/functions/src/string/replace.rs+++ b/datafusion/functions/src/string/replace.rs@@ -24,7 +24,7 @@ use arrow::datatypes::DataType;use crate::utils::{make_scalar_function, utf8_to_str_type};use datafusion_common::cast::{as_generic_string_array, as_string_view_array};use datafusion_common::types::logical_string;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::type_coercion::binary::{binary_to_string_coercion, string_coercion,};@@ -101,7 +101,9 @@ impl ScalarUDFImpl for ReplaceFunc {{utf8_to_str_type(&coercion_data_type, "replace")} else {- exec_err!("Unsupported data types for replace. Expected Utf8, LargeUtf8 or Utf8View")+ exec_err!(+ "Unsupported data types for replace. Expected Utf8, LargeUtf8 or Utf8View"+ )}}diff --git a/datafusion/functions/src/string/rtrim.rs b/datafusion/functions/src/string/rtrim.rsindex be0595f655..f0bafc980e 100644--- a/datafusion/functions/src/string/rtrim.rs+++ b/datafusion/functions/src/string/rtrim.rs@@ -23,7 +23,7 @@ use std::sync::Arc;use crate::string::common::*;use crate::utils::{make_scalar_function, utf8_to_str_type};use datafusion_common::types::logical_string;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::function::Hint;use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,diff --git a/datafusion/functions/src/string/split_part.rs b/datafusion/functions/src/string/split_part.rsindex c8b293f298..8ac505bf36 100644--- a/datafusion/functions/src/string/split_part.rs+++ b/datafusion/functions/src/string/split_part.rs@@ -22,9 +22,9 @@ use arrow::array::{};use arrow::array::{AsArray, GenericStringBuilder};use arrow::datatypes::DataType;-use datafusion_common::cast::as_int64_array;use datafusion_common::ScalarValue;-use datafusion_common::{exec_err, DataFusionError, Result};+use datafusion_common::cast::as_int64_array;+use datafusion_common::{DataFusionError, Result, exec_err};use datafusion_expr::{ColumnarValue, Documentation, TypeSignature, Volatility};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};use datafusion_macros::user_doc;@@ -250,7 +250,7 @@ mod tests {use arrow::datatypes::DataType::Utf8;use datafusion_common::ScalarValue;- use datafusion_common::{exec_err, Result};+ use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, ScalarUDFImpl};use crate::string::split_part::SplitPartFunc;diff --git a/datafusion/functions/src/string/starts_with.rs b/datafusion/functions/src/string/starts_with.rsindex fd34e77b0f..1a60eb91aa 100644--- a/datafusion/functions/src/string/starts_with.rs+++ b/datafusion/functions/src/string/starts_with.rs@@ -27,10 +27,10 @@ use datafusion_expr::type_coercion::binary::{use crate::utils::make_scalar_function;use datafusion_common::types::logical_string;-use datafusion_common::{internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_expr::{- cast, Coercion, ColumnarValue, Documentation, Expr, Like, ScalarFunctionArgs,- ScalarUDFImpl, Signature, TypeSignatureClass, Volatility,+ Coercion, ColumnarValue, Documentation, Expr, Like, ScalarFunctionArgs,+ ScalarUDFImpl, Signature, TypeSignatureClass, Volatility, cast,};use datafusion_macros::user_doc;@@ -55,7 +55,9 @@ fn starts_with(args: &[ArrayRef]) -> Result<ArrayRef> {let result = arrow::compute::kernels::comparison::starts_with(&arg0, &arg1)?;Ok(Arc::new(result) as ArrayRef)} else {- internal_err!("Unsupported data types for starts_with. Expected Utf8, LargeUtf8 or Utf8View")+ internal_err!(+ "Unsupported data types for starts_with. Expected Utf8, LargeUtf8 or Utf8View"+ )}}@@ -121,7 +123,9 @@ impl ScalarUDFImpl for StartsWithFunc {DataType::Utf8View | DataType::Utf8 | DataType::LargeUtf8 => {make_scalar_function(starts_with, vec![])(&args.args)}- _ => internal_err!("Unsupported data types for starts_with. Expected Utf8, LargeUtf8 or Utf8View")?,+ _ => internal_err!(+ "Unsupported data types for starts_with. Expected Utf8, LargeUtf8 or Utf8View"+ )?,}}diff --git a/datafusion/functions/src/string/to_hex.rs b/datafusion/functions/src/string/to_hex.rsindex 4000f3bb3b..fb34c96ad8 100644--- a/datafusion/functions/src/string/to_hex.rs+++ b/datafusion/functions/src/string/to_hex.rs@@ -22,14 +22,14 @@ use std::sync::Arc;use crate::utils::make_scalar_function;use arrow::array::{ArrayRef, GenericStringBuilder};use arrow::datatypes::DataType::{- Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8, Utf8,+ Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Utf8,};use arrow::datatypes::{- ArrowNativeType, ArrowPrimitiveType, DataType, Int16Type, Int32Type, Int64Type,- Int8Type, UInt16Type, UInt32Type, UInt64Type, UInt8Type,+ ArrowNativeType, ArrowPrimitiveType, DataType, Int8Type, Int16Type, Int32Type,+ Int64Type, UInt8Type, UInt16Type, UInt32Type, UInt64Type,};-use datafusion_common::cast::as_primitive_array;use datafusion_common::Result;+use datafusion_common::cast::as_primitive_array;use datafusion_common::{exec_err, plan_err};use datafusion_expr::{ColumnarValue, Documentation};@@ -162,8 +162,8 @@ impl ScalarUDFImpl for ToHexFunc {#[cfg(test)]mod tests {use arrow::array::{- Int16Array, Int32Array, Int64Array, Int8Array, StringArray, UInt16Array,- UInt32Array, UInt64Array, UInt8Array,+ Int8Array, Int16Array, Int32Array, Int64Array, StringArray, UInt8Array,+ UInt16Array, UInt32Array, UInt64Array,};use datafusion_common::cast::as_string_array;diff --git a/datafusion/functions/src/string/upper.rs b/datafusion/functions/src/string/upper.rsindex 8bb2ec1d51..a2a7db1848 100644--- a/datafusion/functions/src/string/upper.rs+++ b/datafusion/functions/src/string/upper.rs@@ -18,8 +18,8 @@use crate::string::common::to_upper;use crate::utils::utf8_to_str_type;use arrow::datatypes::DataType;-use datafusion_common::types::logical_string;use datafusion_common::Result;+use datafusion_common::types::logical_string;use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarFunctionArgs, ScalarUDFImpl, Signature,TypeSignatureClass, Volatility,diff --git a/datafusion/functions/src/string/uuid.rs b/datafusion/functions/src/string/uuid.rsindex 61322f8ec9..3171eb98fa 100644--- a/datafusion/functions/src/string/uuid.rs+++ b/datafusion/functions/src/string/uuid.rs@@ -24,7 +24,7 @@ use arrow::datatypes::DataType::Utf8;use rand::Rng;use uuid::Uuid;-use datafusion_common::{assert_or_internal_err, Result};+use datafusion_common::{Result, assert_or_internal_err};use datafusion_expr::{ColumnarValue, Documentation, Volatility};use datafusion_expr::{ScalarFunctionArgs, ScalarUDFImpl, Signature};use datafusion_macros::user_doc;diff --git a/datafusion/functions/src/strings.rs b/datafusion/functions/src/strings.rsindex 108c20e136..a7be3ef792 100644--- a/datafusion/functions/src/strings.rs+++ b/datafusion/functions/src/strings.rs@@ -18,8 +18,8 @@use std::mem::size_of;use arrow::array::{- make_view, Array, ArrayAccessor, ArrayDataBuilder, ByteView, LargeStringArray,- NullBufferBuilder, StringArray, StringViewArray, StringViewBuilder,+ Array, ArrayAccessor, ArrayDataBuilder, ByteView, LargeStringArray,+ NullBufferBuilder, StringArray, StringViewArray, StringViewBuilder, make_view,};use arrow::buffer::{MutableBuffer, NullBuffer};use arrow::datatypes::DataType;diff --git a/datafusion/functions/src/unicode/character_length.rs b/datafusion/functions/src/unicode/character_length.rsindex a97bf9710e..1073fa060d 100644--- a/datafusion/functions/src/unicode/character_length.rs+++ b/datafusion/functions/src/unicode/character_length.rs@@ -227,7 +227,9 @@ mod tests {#[cfg(not(feature = "unicode_expressions"))]test_function!(CharacterLengthFunc::new(),- &[ColumnarValue::Scalar(ScalarValue::Utf8(Some(String::from("josé"))))],+ &[ColumnarValue::Scalar(ScalarValue::Utf8(Some(+ String::from("josé")+ )))],internal_err!("function character_length requires compilation with feature flag: unicode_expressions."),diff --git a/datafusion/functions/src/unicode/find_in_set.rs b/datafusion/functions/src/unicode/find_in_set.rsindex e83e3d99a3..a25c37266c 100644--- a/datafusion/functions/src/unicode/find_in_set.rs+++ b/datafusion/functions/src/unicode/find_in_set.rs@@ -19,14 +19,14 @@ use std::any::Any;use std::sync::Arc;use arrow::array::{- new_null_array, ArrayAccessor, ArrayIter, ArrayRef, ArrowPrimitiveType, AsArray,- OffsetSizeTrait, PrimitiveArray,+ ArrayAccessor, ArrayIter, ArrayRef, ArrowPrimitiveType, AsArray, OffsetSizeTrait,+ PrimitiveArray, new_null_array,};use arrow::datatypes::{ArrowNativeType, DataType, Int32Type, Int64Type};use crate::utils::utf8_to_int_type;use datafusion_common::{- exec_err, internal_err, utils::take_function_args, Result, ScalarValue,+ Result, ScalarValue, exec_err, internal_err, utils::take_function_args,};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{@@ -167,7 +167,9 @@ impl ScalarUDFImpl for FindInSetFunc {)}other => {- exec_err!("Unsupported data type {other:?} for function find_in_set")+ exec_err!(+ "Unsupported data type {other:?} for function find_in_set"+ )}};Arc::new(result?)@@ -211,7 +213,9 @@ impl ScalarUDFImpl for FindInSetFunc {)}other => {- exec_err!("Unsupported data type {other:?} for function find_in_set")+ exec_err!(+ "Unsupported data type {other:?} for function find_in_set"+ )}};Arc::new(result?)diff --git a/datafusion/functions/src/unicode/initcap.rs b/datafusion/functions/src/unicode/initcap.rsindex 62862fbe78..929b0c3169 100644--- a/datafusion/functions/src/unicode/initcap.rs+++ b/datafusion/functions/src/unicode/initcap.rs@@ -26,7 +26,7 @@ use arrow::datatypes::DataType;use crate::utils::{make_scalar_function, utf8_to_str_type};use datafusion_common::cast::{as_generic_string_array, as_string_view_array};use datafusion_common::types::logical_string;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarUDFImpl, Signature, TypeSignatureClass,Volatility,diff --git a/datafusion/functions/src/unicode/left.rs b/datafusion/functions/src/unicode/left.rsindex ec7ec456ab..ecff8f8699 100644--- a/datafusion/functions/src/unicode/left.rs+++ b/datafusion/functions/src/unicode/left.rs@@ -26,11 +26,11 @@ use arrow::array::{use arrow::datatypes::DataType;use crate::utils::{make_scalar_function, utf8_to_str_type};+use datafusion_common::Result;use datafusion_common::cast::{as_generic_string_array, as_int64_array, as_string_view_array,};use datafusion_common::exec_err;-use datafusion_common::Result;use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,diff --git a/datafusion/functions/src/unicode/lpad.rs b/datafusion/functions/src/unicode/lpad.rsindex 6940459b17..527aaf1389 100644--- a/datafusion/functions/src/unicode/lpad.rs+++ b/datafusion/functions/src/unicode/lpad.rs@@ -19,17 +19,17 @@ use std::any::Any;use std::fmt::Write;use std::sync::Arc;+use DataType::{LargeUtf8, Utf8, Utf8View};use arrow::array::{Array, ArrayRef, AsArray, GenericStringArray, GenericStringBuilder, Int64Array,OffsetSizeTrait, StringArrayType, StringViewArray,};use arrow::datatypes::DataType;use unicode_segmentation::UnicodeSegmentation;-use DataType::{LargeUtf8, Utf8, Utf8View};use crate::utils::{make_scalar_function, utf8_to_str_type};use datafusion_common::cast::as_int64_array;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,@@ -526,9 +526,13 @@ mod tests {);#[cfg(not(feature = "unicode_expressions"))]- test_lpad!(Some("josé".into()), ScalarValue::Int64(Some(5i64)), internal_err!(+ test_lpad!(+ Some("josé".into()),+ ScalarValue::Int64(Some(5i64)),+ internal_err!("function lpad requires compilation with feature flag: unicode_expressions."- ));+ )+ );Ok(())}diff --git a/datafusion/functions/src/unicode/planner.rs b/datafusion/functions/src/unicode/planner.rsindex e4f29be3d1..38c8248641 100644--- a/datafusion/functions/src/unicode/planner.rs+++ b/datafusion/functions/src/unicode/planner.rs@@ -17,9 +17,9 @@//! SQL planning extensions like [`UnicodeFunctionPlanner`]+use datafusion_expr::Expr;use datafusion_expr::expr::ScalarFunction;use datafusion_expr::planner::{ExprPlanner, PlannerResult};-use datafusion_expr::Expr;#[derive(Default, Debug)]pub struct UnicodeFunctionPlanner;diff --git a/datafusion/functions/src/unicode/reverse.rs b/datafusion/functions/src/unicode/reverse.rsindex 56f6048d6b..71a1e6842f 100644--- a/datafusion/functions/src/unicode/reverse.rs+++ b/datafusion/functions/src/unicode/reverse.rs@@ -19,16 +19,16 @@ use std::any::Any;use std::sync::Arc;use crate::utils::{make_scalar_function, utf8_to_str_type};+use DataType::{LargeUtf8, Utf8, Utf8View};use arrow::array::{Array, ArrayRef, AsArray, GenericStringBuilder, OffsetSizeTrait, StringArrayType,};use arrow::datatypes::DataType;-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,};use datafusion_macros::user_doc;-use DataType::{LargeUtf8, Utf8, Utf8View};#[user_doc(doc_section(label = "String Functions"),diff --git a/datafusion/functions/src/unicode/right.rs b/datafusion/functions/src/unicode/right.rsindex 670586e11b..ac98a3f202 100644--- a/datafusion/functions/src/unicode/right.rs+++ b/datafusion/functions/src/unicode/right.rs@@ -16,7 +16,7 @@// under the License.use std::any::Any;-use std::cmp::{max, Ordering};+use std::cmp::{Ordering, max};use std::sync::Arc;use arrow::array::{@@ -26,11 +26,11 @@ use arrow::array::{use arrow::datatypes::DataType;use crate::utils::{make_scalar_function, utf8_to_str_type};+use datafusion_common::Result;use datafusion_common::cast::{as_generic_string_array, as_int64_array, as_string_view_array,};use datafusion_common::exec_err;-use datafusion_common::Result;use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,diff --git a/datafusion/functions/src/unicode/rpad.rs b/datafusion/functions/src/unicode/rpad.rsindex a7e951051d..a3c2d501c9 100644--- a/datafusion/functions/src/unicode/rpad.rs+++ b/datafusion/functions/src/unicode/rpad.rs@@ -16,14 +16,15 @@// under the License.use crate::utils::{make_scalar_function, utf8_to_str_type};+use DataType::{LargeUtf8, Utf8, Utf8View};use arrow::array::{ArrayRef, AsArray, GenericStringArray, GenericStringBuilder, Int64Array,OffsetSizeTrait, StringArrayType, StringViewArray,};use arrow::datatypes::DataType;-use datafusion_common::cast::as_int64_array;use datafusion_common::DataFusionError;-use datafusion_common::{exec_err, Result};+use datafusion_common::cast::as_int64_array;+use datafusion_common::{Result, exec_err};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,@@ -33,7 +34,6 @@ use std::any::Any;use std::fmt::Write;use std::sync::Arc;use unicode_segmentation::UnicodeSegmentation;-use DataType::{LargeUtf8, Utf8, Utf8View};#[user_doc(doc_section(label = "String Functions"),diff --git a/datafusion/functions/src/unicode/strpos.rs b/datafusion/functions/src/unicode/strpos.rsindex 294f783ba6..1f980de9e8 100644--- a/datafusion/functions/src/unicode/strpos.rs+++ b/datafusion/functions/src/unicode/strpos.rs@@ -26,7 +26,7 @@ use arrow::datatypes::{ArrowNativeType, DataType, Field, FieldRef, Int32Type, Int64Type,};use datafusion_common::types::logical_string;-use datafusion_common::{exec_err, internal_err, Result};+use datafusion_common::{Result, exec_err, internal_err};use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarUDFImpl, Signature, TypeSignatureClass,Volatility,diff --git a/datafusion/functions/src/unicode/substr.rs b/datafusion/functions/src/unicode/substr.rsindex 27b194ca2b..cc1d53b3aa 100644--- a/datafusion/functions/src/unicode/substr.rs+++ b/datafusion/functions/src/unicode/substr.rs@@ -28,9 +28,9 @@ use arrow::buffer::ScalarBuffer;use arrow::datatypes::DataType;use datafusion_common::cast::as_int64_array;use datafusion_common::types::{- logical_int32, logical_int64, logical_string, NativeType,+ NativeType, logical_int32, logical_int64, logical_string,};-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::{Coercion, ColumnarValue, Documentation, ScalarUDFImpl, Signature, TypeSignature,TypeSignatureClass, Volatility,@@ -364,7 +364,7 @@ fn string_view_substr(other => {return exec_err!("substr was called with {other} arguments. It requires 2 or 3."- )+ );}}@@ -470,7 +470,7 @@ mod tests {use arrow::array::{Array, StringViewArray};use arrow::datatypes::DataType::Utf8View;- use datafusion_common::{exec_err, Result, ScalarValue};+ use datafusion_common::{Result, ScalarValue, exec_err};use datafusion_expr::{ColumnarValue, ScalarUDFImpl};use crate::unicode::substr::SubstrFunc;diff --git a/datafusion/functions/src/unicode/substrindex.rs b/datafusion/functions/src/unicode/substrindex.rsindex bf59787206..cd9d0702b4 100644--- a/datafusion/functions/src/unicode/substrindex.rs+++ b/datafusion/functions/src/unicode/substrindex.rs@@ -25,7 +25,7 @@ use arrow::array::{use arrow::datatypes::{DataType, Int32Type, Int64Type};use crate::utils::{make_scalar_function, utf8_to_str_type};-use datafusion_common::{exec_err, utils::take_function_args, Result};+use datafusion_common::{Result, exec_err, utils::take_function_args};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,diff --git a/datafusion/functions/src/unicode/translate.rs b/datafusion/functions/src/unicode/translate.rsindex 911b8d3119..db785f4f88 100644--- a/datafusion/functions/src/unicode/translate.rs+++ b/datafusion/functions/src/unicode/translate.rs@@ -26,7 +26,7 @@ use datafusion_common::HashMap;use unicode_segmentation::UnicodeSegmentation;use crate::utils::{make_scalar_function, utf8_to_str_type};-use datafusion_common::{exec_err, Result};+use datafusion_common::{Result, exec_err};use datafusion_expr::TypeSignature::Exact;use datafusion_expr::{ColumnarValue, Documentation, ScalarUDFImpl, Signature, Volatility,diff --git a/datafusion/functions/src/utils.rs b/datafusion/functions/src/utils.rsindex 74b7fa95cd..c4f15d0cca 100644--- a/datafusion/functions/src/utils.rs+++ b/datafusion/functions/src/utils.rs@@ -19,9 +19,9 @@ use arrow::array::{Array, ArrayRef, ArrowPrimitiveType, AsArray, PrimitiveArray}use arrow::compute::try_binary;use arrow::datatypes::{DataType, DecimalType};use arrow::error::ArrowError;-use datafusion_common::{not_impl_err, DataFusionError, Result, ScalarValue};-use datafusion_expr::function::Hint;+use datafusion_common::{DataFusionError, Result, ScalarValue, not_impl_err};use datafusion_expr::ColumnarValue;+use datafusion_expr::function::Hint;use std::sync::Arc;/// Creates a function to identify the optimal return type of a string function givendiff --git a/datafusion/physical-expr-adapter/Cargo.toml b/datafusion/physical-expr-adapter/Cargo.tomlindex 03e1b1f065..2436c2dbb3 100644--- a/datafusion/physical-expr-adapter/Cargo.toml+++ b/datafusion/physical-expr-adapter/Cargo.toml@@ -4,7 +4,7 @@ description = "Physical expression schema adaptation utilities for DataFusion"keywords = ["datafusion", "query", "sql"]readme = "README.md"version = { workspace = true }-edition = { workspace = true }+edition = "2024"homepage = { workspace = true }repository = { workspace = true }license = { workspace = true }diff --git a/datafusion/physical-expr-adapter/src/schema_rewriter.rs b/datafusion/physical-expr-adapter/src/schema_rewriter.rsindex daa4e6203c..cbb4687ab5 100644--- a/datafusion/physical-expr-adapter/src/schema_rewriter.rs+++ b/datafusion/physical-expr-adapter/src/schema_rewriter.rs@@ -22,16 +22,15 @@ use std::sync::Arc;use arrow::compute::can_cast_types;use arrow::datatypes::{DataType, FieldRef, Schema, SchemaRef};use datafusion_common::{- exec_err,+ Result, ScalarValue, exec_err,nested_struct::validate_struct_compatibility,tree_node::{Transformed, TransformedResult, TreeNode},- Result, ScalarValue,};use datafusion_functions::core::getfield::GetFieldFunc;use datafusion_physical_expr::expressions::CastColumnExpr;use datafusion_physical_expr::{- expressions::{self, Column},ScalarFunctionExpr,+ expressions::{self, Column},};use datafusion_physical_expr_common::physical_expr::PhysicalExpr;@@ -372,23 +371,24 @@ impl<'a> DefaultPhysicalExprAdapterRewriter<'a> {};// Check if the column exists in the physical schema- let physical_column_index =- match self.physical_file_schema.index_of(column.name()) {- Ok(index) => index,- Err(_) => {- if !logical_field.is_nullable() {- return exec_err!(+ let physical_column_index = match self+ .physical_file_schema+ .index_of(column.name())+ {+ Ok(index) => index,+ Err(_) => {+ if !logical_field.is_nullable() {+ return exec_err!("Non-nullable column '{}' is missing from the physical schema",column.name());- }- // If the column is missing from the physical schema fill it in with nulls as `SchemaAdapter` used to do.- // If users want a different behavior they need to provide a custom `PhysicalExprAdapter` implementation.- let null_value =- ScalarValue::Null.cast_to(logical_field.data_type())?;- return Ok(Transformed::yes(expressions::lit(null_value)));}- };+ // If the column is missing from the physical schema fill it in with nulls as `SchemaAdapter` used to do.+ // If users want a different behavior they need to provide a custom `PhysicalExprAdapter` implementation.+ let null_value = ScalarValue::Null.cast_to(logical_field.data_type())?;+ return Ok(Transformed::yes(expressions::lit(null_value)));+ }+ };let physical_field = self.physical_file_schema.field(physical_column_index);let column = match (@@ -463,9 +463,9 @@ mod tests {StringArray, StringViewArray, StructArray,};use arrow::datatypes::{DataType, Field, Fields, Schema, SchemaRef};- use datafusion_common::{assert_contains, record_batch, Result, ScalarValue};+ use datafusion_common::{Result, ScalarValue, assert_contains, record_batch};use datafusion_expr::Operator;- use datafusion_physical_expr::expressions::{col, lit, Column, Literal};+ use datafusion_physical_expr::expressions::{Column, Literal, col, lit};use datafusion_physical_expr_common::physical_expr::PhysicalExpr;use itertools::Itertools;use std::sync::Arc;diff --git a/datafusion/physical-expr/Cargo.toml b/datafusion/physical-expr/Cargo.tomlindex 11e0cc5c60..cc92ce5bac 100644--- a/datafusion/physical-expr/Cargo.toml+++ b/datafusion/physical-expr/Cargo.toml@@ -21,7 +21,7 @@ description = "Physical expression implementation for DataFusion query engine"keywords = ["arrow", "query", "sql"]readme = "README.md"version = { workspace = true }-edition = { workspace = true }+edition = "2024"homepage = { workspace = true }repository = { workspace = true }license = { workspace = true }diff --git a/datafusion/physical-expr/benches/binary_op.rs b/datafusion/physical-expr/benches/binary_op.rsindex 06a14e2fbc..99fc40fa1c 100644--- a/datafusion/physical-expr/benches/binary_op.rs+++ b/datafusion/physical-expr/benches/binary_op.rs@@ -20,12 +20,12 @@ use arrow::{datatypes::{DataType, Field, Schema},};use arrow::{array::StringArray, record_batch::RecordBatch};-use criterion::{criterion_group, criterion_main, Criterion};-use datafusion_expr::{and, binary_expr, col, lit, or, Operator};+use criterion::{Criterion, criterion_group, criterion_main};+use datafusion_expr::{Operator, and, binary_expr, col, lit, or};use datafusion_physical_expr::{+ PhysicalExpr,expressions::{BinaryExpr, Column},planner::logical2physical,- PhysicalExpr,};use std::hint::black_box;use std::sync::Arc;diff --git a/datafusion/physical-expr/benches/case_when.rs b/datafusion/physical-expr/benches/case_when.rsindex a05b4a9686..eb0886a31e 100644--- a/datafusion/physical-expr/benches/case_when.rs+++ b/datafusion/physical-expr/benches/case_when.rs@@ -19,13 +19,13 @@ use arrow::array::{Array, ArrayRef, Int32Array, Int32Builder, StringArray};use arrow::datatypes::{ArrowNativeTypeOp, Field, Schema};use arrow::record_batch::RecordBatch;use arrow::util::test_util::seedable_rng;-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};use datafusion_expr::Operator;-use datafusion_physical_expr::expressions::{case, col, lit, BinaryExpr};+use datafusion_physical_expr::expressions::{BinaryExpr, case, col, lit};use datafusion_physical_expr_common::physical_expr::PhysicalExpr;use itertools::Itertools;-use rand::distr::uniform::SampleUniform;use rand::distr::Alphanumeric;+use rand::distr::uniform::SampleUniform;use rand::rngs::StdRng;use rand::{Rng, RngCore};use std::fmt::{Display, Formatter};diff --git a/datafusion/physical-expr/benches/in_list.rs b/datafusion/physical-expr/benches/in_list.rsindex 778204055b..d3e4fc1684 100644--- a/datafusion/physical-expr/benches/in_list.rs+++ b/datafusion/physical-expr/benches/in_list.rs@@ -18,7 +18,7 @@use arrow::array::{Array, ArrayRef, Float32Array, Int32Array, StringArray};use arrow::datatypes::{Field, Schema};use arrow::record_batch::RecordBatch;-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_common::ScalarValue;use datafusion_physical_expr::expressions::{col, in_list, lit};use rand::distr::Alphanumeric;diff --git a/datafusion/physical-expr/benches/is_null.rs b/datafusion/physical-expr/benches/is_null.rsindex 80b2907a9e..0637ade1b3 100644--- a/datafusion/physical-expr/benches/is_null.rs+++ b/datafusion/physical-expr/benches/is_null.rs@@ -15,9 +15,9 @@// specific language governing permissions and limitations// under the License.-use arrow::array::{builder::Int32Builder, RecordBatch};+use arrow::array::{RecordBatch, builder::Int32Builder};use arrow::datatypes::{DataType, Field, Schema};-use criterion::{criterion_group, criterion_main, Criterion};+use criterion::{Criterion, criterion_group, criterion_main};use datafusion_physical_expr::expressions::{Column, IsNotNullExpr, IsNullExpr};use datafusion_physical_expr_common::physical_expr::PhysicalExpr;use std::hint::black_box;diff --git a/datafusion/physical-expr/src/aggregate.rs b/datafusion/physical-expr/src/aggregate.rsindex dfd2e93030..d031ad7d85 100644--- a/datafusion/physical-expr/src/aggregate.rs+++ b/datafusion/physical-expr/src/aggregate.rs@@ -21,7 +21,7 @@ pub(crate) mod groups_accumulator {pub use datafusion_functions_aggregate_common::aggregate::groups_accumulator::accumulate::NullState;}pub use datafusion_functions_aggregate_common::aggregate::groups_accumulator::{- accumulate::NullState, GroupsAccumulatorAdapter,+ GroupsAccumulatorAdapter, accumulate::NullState,};}pub(crate) mod stats {@@ -29,8 +29,8 @@ pub(crate) mod stats {}pub mod utils {pub use datafusion_functions_aggregate_common::utils::{- get_accum_scalar_values_as_arrays, get_sort_options, ordering_fields,- DecimalAverager, Hashable,+ DecimalAverager, Hashable, get_accum_scalar_values_as_arrays, get_sort_options,+ ordering_fields,};}@@ -42,7 +42,7 @@ use crate::expressions::Column;use arrow::compute::SortOptions;use arrow::datatypes::{DataType, FieldRef, Schema, SchemaRef};use datafusion_common::{- assert_or_internal_err, internal_err, not_impl_err, Result, ScalarValue,+ Result, ScalarValue, assert_or_internal_err, internal_err, not_impl_err,};use datafusion_expr::{AggregateUDF, ReversedUDAF, SetMonotonicity};use datafusion_expr_common::accumulator::Accumulator;@@ -226,7 +226,7 @@ impl AggregateExprBuilder {None => {return internal_err!("AggregateExprBuilder::alias must be provided prior to calling build"- )+ );}Some(alias) => alias,};@@ -739,18 +739,18 @@ fn replace_order_by_clause(order_by: &mut String) {(" ASC NULLS LAST]", " DESC NULLS FIRST]"),];- if let Some(start) = order_by.find("ORDER BY [") {- if let Some(end) = order_by[start..].find(']') {- let order_by_start = start + 9;- let order_by_end = start + end;-- let column_order = &order_by[order_by_start..=order_by_end];- for (suffix, replacement) in suffixes {- if column_order.ends_with(suffix) {- let new_order = column_order.replace(suffix, replacement);- order_by.replace_range(order_by_start..=order_by_end, &new_order);- break;- }+ if let Some(start) = order_by.find("ORDER BY [")+ && let Some(end) = order_by[start..].find(']')+ {+ let order_by_start = start + 9;+ let order_by_end = start + end;++ let column_order = &order_by[order_by_start..=order_by_end];+ for (suffix, replacement) in suffixes {+ if column_order.ends_with(suffix) {+ let new_order = column_order.replace(suffix, replacement);+ order_by.replace_range(order_by_start..=order_by_end, &new_order);+ break;}}}diff --git a/datafusion/physical-expr/src/analysis.rs b/datafusion/physical-expr/src/analysis.rsindex 166e639966..d734c86726 100644--- a/datafusion/physical-expr/src/analysis.rs+++ b/datafusion/physical-expr/src/analysis.rs@@ -20,18 +20,18 @@use std::fmt::Debug;use std::sync::Arc;+use crate::PhysicalExpr;use crate::expressions::Column;use crate::intervals::cp_solver::{ExprIntervalGraph, PropagationResult};use crate::utils::collect_columns;-use crate::PhysicalExpr;use arrow::datatypes::Schema;use datafusion_common::stats::Precision;use datafusion_common::{- assert_or_internal_err, internal_datafusion_err, internal_err, ColumnStatistics,- Result, ScalarValue,+ ColumnStatistics, Result, ScalarValue, assert_or_internal_err,+ internal_datafusion_err, internal_err,};-use datafusion_expr::interval_arithmetic::{cardinality_ratio, Interval};+use datafusion_expr::interval_arithmetic::{Interval, cardinality_ratio};/// The shared context used during the analysis of an expression. Includes/// the boundaries for all known columns.@@ -187,8 +187,8 @@ pub fn analyze(.any(|bound| bound.interval.is_none()){internal_err!(- "AnalysisContext is an inconsistent state. Some columns represent empty table while others don't"- )+ "AnalysisContext is an inconsistent state. Some columns represent empty table while others don't"+ )} else {let mut target_boundaries = context.boundaries;let mut graph = ExprIntervalGraph::try_new(Arc::clone(expr), schema)?;@@ -201,14 +201,13 @@ pub fn analyze(let target_expr_and_indices = graph.gather_node_indices(columns.as_slice());for (expr, index) in &target_expr_and_indices {- if let Some(column) = expr.as_any().downcast_ref::<Column>() {- if let Some(bound) =+ if let Some(column) = expr.as_any().downcast_ref::<Column>()+ && let Some(bound) =target_boundaries.iter().find(|b| b.column == *column)- {- // Now, it's safe to unwrap- target_indices_and_boundaries- .push((*index, bound.interval.as_ref().unwrap().clone()));- }+ {+ // Now, it's safe to unwrap+ target_indices_and_boundaries+ .push((*index, bound.interval.as_ref().unwrap().clone()));}}@@ -241,14 +240,13 @@ fn shrink_boundaries() -> Result<AnalysisContext> {let initial_boundaries = target_boundaries.clone();target_expr_and_indices.iter().for_each(|(expr, i)| {- if let Some(column) = expr.as_any().downcast_ref::<Column>() {- if let Some(bound) = target_boundaries+ if let Some(column) = expr.as_any().downcast_ref::<Column>()+ && let Some(bound) = target_boundaries.iter_mut().find(|bound| bound.column.eq(column))- {- bound.interval = Some(graph.get_interval(*i));- };- }+ {+ bound.interval = Some(graph.get_interval(*i));+ };});let selectivity = calculate_selectivity(&target_boundaries, &initial_boundaries)?;@@ -284,8 +282,8 @@ fn calculate_selectivity(}(None, Some(_)) => {return internal_err!(- "Initial boundary cannot be None while having a Some() target boundary"- );+ "Initial boundary cannot be None while having a Some() target boundary"+ );}_ => return Ok(0.0),}@@ -299,14 +297,14 @@ mod tests {use std::sync::Arc;use arrow::datatypes::{DataType, Field, Schema};- use datafusion_common::{assert_contains, DFSchema};+ use datafusion_common::{DFSchema, assert_contains};use datafusion_expr::{- col, execution_props::ExecutionProps, interval_arithmetic::Interval, lit, Expr,+ Expr, col, execution_props::ExecutionProps, interval_arithmetic::Interval, lit,};- use crate::{create_physical_expr, AnalysisContext};+ use crate::{AnalysisContext, create_physical_expr};- use super::{analyze, ExprBoundaries};+ use super::{ExprBoundaries, analyze};fn make_field(name: &str, data_type: DataType) -> Field {let nullable = false;@@ -373,7 +371,9 @@ mod tests {).unwrap();let Some(actual) = &analysis_result.boundaries[0].interval else {- panic!("The analysis result should contain non-empty intervals for all columns");+ panic!(+ "The analysis result should contain non-empty intervals for all columns"+ );};let expected = Interval::make(lower, upper).unwrap();assert_eq!(diff --git a/datafusion/physical-expr/src/async_scalar_function.rs b/datafusion/physical-expr/src/async_scalar_function.rsindex f1833666d6..2f50a17afc 100644--- a/datafusion/physical-expr/src/async_scalar_function.rs+++ b/datafusion/physical-expr/src/async_scalar_function.rs@@ -19,11 +19,11 @@ use crate::ScalarFunctionExpr;use arrow::array::RecordBatch;use arrow::compute::concat;use arrow::datatypes::{DataType, Field, FieldRef, Schema};-use datafusion_common::config::ConfigOptions;use datafusion_common::Result;+use datafusion_common::config::ConfigOptions;use datafusion_common::{internal_err, not_impl_err};-use datafusion_expr::async_udf::AsyncScalarUDF;use datafusion_expr::ScalarFunctionArgs;+use datafusion_expr::async_udf::AsyncScalarUDF;use datafusion_expr_common::columnar_value::ColumnarValue;use datafusion_physical_expr_common::physical_expr::PhysicalExpr;use std::any::Any;@@ -99,12 +99,11 @@ impl AsyncFuncExpr {/// Return the ideal batch size for this functionpub fn ideal_batch_size(&self) -> Result<Option<usize>> {- if let Some(expr) = self.func.as_any().downcast_ref::<ScalarFunctionExpr>() {- if let Some(udf) =+ if let Some(expr) = self.func.as_any().downcast_ref::<ScalarFunctionExpr>()+ && let Some(udf) =expr.fun().inner().as_any().downcast_ref::<AsyncScalarUDF>()- {- return Ok(udf.ideal_batch_size());- }+ {+ return Ok(udf.ideal_batch_size());}not_impl_err!("Can't get ideal_batch_size from {:?}", self.func)}diff --git a/datafusion/physical-expr/src/equivalence/class.rs b/datafusion/physical-expr/src/equivalence/class.rsindex 5b64884f65..91d339910b 100644--- a/datafusion/physical-expr/src/equivalence/class.rs+++ b/datafusion/physical-expr/src/equivalence/class.rs@@ -737,10 +737,10 @@ impl EquivalenceGroup {if let Some(lit) = expr.as_any().downcast_ref::<Literal>() {return Some(AcrossPartitions::Uniform(Some(lit.value().clone())));}- if let Some(cls) = self.get_equivalence_class(expr) {- if cls.constant.is_some() {- return cls.constant.clone();- }+ if let Some(cls) = self.get_equivalence_class(expr)+ && cls.constant.is_some()+ {+ return cls.constant.clone();}// TODO: This function should be able to return values of non-literal// complex constants as well; e.g. it should return `8` for the@@ -819,15 +819,15 @@ impl EquivalenceGroup {// Check if expressions are equivalent through equivalence classes// We need to check both directions since expressions might be in different classes- if let Some(left_class) = self.get_equivalence_class(left) {- if left_class.contains(right) {- return true;- }+ if let Some(left_class) = self.get_equivalence_class(left)+ && left_class.contains(right)+ {+ return true;}- if let Some(right_class) = self.get_equivalence_class(right) {- if right_class.contains(left) {- return true;- }+ if let Some(right_class) = self.get_equivalence_class(right)+ && right_class.contains(left)+ {+ return true;}// For non-leaf nodes, check structural equality@@ -910,7 +910,7 @@ impl From<Vec<EquivalenceClass>> for EquivalenceGroup {mod tests {use super::*;use crate::equivalence::tests::create_test_params;- use crate::expressions::{binary, col, lit, BinaryExpr, Column, Literal};+ use crate::expressions::{BinaryExpr, Column, Literal, binary, col, lit};use arrow::datatypes::{DataType, Field, Schema};use datafusion_common::{Result, ScalarValue};@@ -1082,8 +1082,7 @@ mod tests {left: Arc::clone(&col_a),right: Arc::clone(&col_b),expected: false,- description:- "Columns in different equivalence classes should not be equal",+ description: "Columns in different equivalence classes should not be equal",},// Literal testsTestCase {@@ -1111,8 +1110,7 @@ mod tests {Arc::clone(&col_y),)) as _,expected: true,- description:- "Binary expressions with equivalent operands should be equal",+ description: "Binary expressions with equivalent operands should be equal",},TestCase {left: Arc::new(BinaryExpr::new(@@ -1126,8 +1124,7 @@ mod tests {Arc::clone(&col_a),)) as _,expected: false,- description:- "Binary expressions with non-equivalent operands should not be equal",+ description: "Binary expressions with non-equivalent operands should not be equal",},TestCase {left: Arc::new(BinaryExpr::new(diff --git a/datafusion/physical-expr/src/equivalence/mod.rs b/datafusion/physical-expr/src/equivalence/mod.rsindex a728910380..0d6699c710 100644--- a/datafusion/physical-expr/src/equivalence/mod.rs+++ b/datafusion/physical-expr/src/equivalence/mod.rs@@ -31,9 +31,9 @@ pub use class::{AcrossPartitions, ConstExpr, EquivalenceClass, EquivalenceGroup}pub use ordering::OrderingEquivalenceClass;// Re-export for backwards compatibility, we recommend importing from// datafusion_physical_expr::projection instead-pub use crate::projection::{project_ordering, project_orderings, ProjectionMapping};+pub use crate::projection::{ProjectionMapping, project_ordering, project_orderings};pub use properties::{- calculate_union, join_equivalence_properties, EquivalenceProperties,+ EquivalenceProperties, calculate_union, join_equivalence_properties,};// Convert each tuple to a `PhysicalSortExpr` and construct a vector.@@ -57,7 +57,7 @@ pub fn convert_to_orderings<T: Borrow<Arc<dyn PhysicalExpr>>>(#[cfg(test)]mod tests {use super::*;- use crate::expressions::{col, Column};+ use crate::expressions::{Column, col};use crate::{LexRequirement, PhysicalSortExpr};use arrow::compute::SortOptions;diff --git a/datafusion/physical-expr/src/equivalence/ordering.rs b/datafusion/physical-expr/src/equivalence/ordering.rsindex aa65c4a80a..2ce8a8d246 100644--- a/datafusion/physical-expr/src/equivalence/ordering.rs+++ b/datafusion/physical-expr/src/equivalence/ordering.rs@@ -21,7 +21,7 @@ use std::sync::Arc;use std::vec::IntoIter;use crate::expressions::with_new_schema;-use crate::{add_offset_to_physical_sort_exprs, LexOrdering, PhysicalExpr};+use crate::{LexOrdering, PhysicalExpr, add_offset_to_physical_sort_exprs};use arrow::compute::SortOptions;use arrow::datatypes::SchemaRef;@@ -326,10 +326,10 @@ mod tests {use crate::equivalence::tests::create_test_schema;use crate::equivalence::{- convert_to_orderings, convert_to_sort_exprs, EquivalenceClass, EquivalenceGroup,- EquivalenceProperties, OrderingEquivalenceClass,+ EquivalenceClass, EquivalenceGroup, EquivalenceProperties,+ OrderingEquivalenceClass, convert_to_orderings, convert_to_sort_exprs,};- use crate::expressions::{col, BinaryExpr, Column};+ use crate::expressions::{BinaryExpr, Column, col};use crate::utils::tests::TestScalarUDF;use crate::{AcrossPartitions, ConstExpr, PhysicalExpr, PhysicalExprRef, PhysicalSortExpr,@@ -338,8 +338,8 @@ mod tests {use arrow::compute::SortOptions;use arrow::datatypes::{DataType, Field, Schema};- use datafusion_common::config::ConfigOptions;use datafusion_common::Result;+ use datafusion_common::config::ConfigOptions;use datafusion_expr::{Operator, ScalarUDF};#[test]@@ -639,8 +639,9 @@ mod tests {];for (orderings, eq_group, constants, reqs, expected) in test_cases {- let err_msg =- format!("error in test orderings: {orderings:?}, eq_group: {eq_group:?}, constants: {constants:?}, reqs: {reqs:?}, expected: {expected:?}");+ let err_msg = format!(+ "error in test orderings: {orderings:?}, eq_group: {eq_group:?}, constants: {constants:?}, reqs: {reqs:?}, expected: {expected:?}"+ );let mut eq_properties = EquivalenceProperties::new(Arc::clone(&test_schema));let orderings = convert_to_orderings(&orderings);eq_properties.add_orderings(orderings);diff --git a/datafusion/physical-expr/src/equivalence/properties/dependency.rs b/datafusion/physical-expr/src/equivalence/properties/dependency.rsindex 8945d18be4..edbf7033f4 100644--- a/datafusion/physical-expr/src/equivalence/properties/dependency.rs+++ b/datafusion/physical-expr/src/equivalence/properties/dependency.rs@@ -389,8 +389,8 @@ mod tests {use crate::equivalence::tests::{convert_to_sort_reqs, create_test_params, create_test_schema, parse_sort_expr,};- use crate::equivalence::{convert_to_sort_exprs, ProjectionMapping};- use crate::expressions::{col, BinaryExpr, CastExpr, Column};+ use crate::equivalence::{ProjectionMapping, convert_to_sort_exprs};+ use crate::expressions::{BinaryExpr, CastExpr, Column, col};use crate::projection::tests::output_schema;use crate::{ConstExpr, EquivalenceProperties, ScalarFunctionExpr};@@ -398,8 +398,8 @@ mod tests {use arrow::datatypes::{DataType, Field, Schema, TimeUnit};use datafusion_common::config::ConfigOptions;use datafusion_common::{Constraint, Constraints, Result};- use datafusion_expr::sort_properties::SortProperties;use datafusion_expr::Operator;+ use datafusion_expr::sort_properties::SortProperties;use datafusion_functions::string::concat;use datafusion_physical_expr_common::physical_expr::PhysicalExpr;use datafusion_physical_expr_common::sort_expr::{diff --git a/datafusion/physical-expr/src/equivalence/properties/joins.rs b/datafusion/physical-expr/src/equivalence/properties/joins.rsindex 485b11d586..aa3e1c5675 100644--- a/datafusion/physical-expr/src/equivalence/properties/joins.rs+++ b/datafusion/physical-expr/src/equivalence/properties/joins.rs@@ -16,7 +16,7 @@// under the License.use super::EquivalenceProperties;-use crate::{equivalence::OrderingEquivalenceClass, PhysicalExprRef};+use crate::{PhysicalExprRef, equivalence::OrderingEquivalenceClass};use arrow::datatypes::SchemaRef;use datafusion_common::{JoinSide, JoinType, Result};diff --git a/datafusion/physical-expr/src/equivalence/properties/mod.rs b/datafusion/physical-expr/src/equivalence/properties/mod.rsindex c13618feb8..70f97139f8 100644--- a/datafusion/physical-expr/src/equivalence/properties/mod.rs+++ b/datafusion/physical-expr/src/equivalence/properties/mod.rs@@ -27,13 +27,13 @@ use std::mem;use std::sync::Arc;use self::dependency::{- construct_prefix_orderings, generate_dependency_orderings, referred_dependencies,- Dependencies, DependencyMap,+ Dependencies, DependencyMap, construct_prefix_orderings,+ generate_dependency_orderings, referred_dependencies,};use crate::equivalence::{AcrossPartitions, EquivalenceGroup, OrderingEquivalenceClass, ProjectionMapping,};-use crate::expressions::{with_new_schema, CastExpr, Column, Literal};+use crate::expressions::{CastExpr, Column, Literal, with_new_schema};use crate::{ConstExpr, LexOrdering, LexRequirement, PhysicalExpr, PhysicalSortExpr,PhysicalSortRequirement,@@ -41,7 +41,7 @@ use crate::{use arrow::datatypes::SchemaRef;use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode};-use datafusion_common::{plan_err, Constraint, Constraints, HashMap, Result};+use datafusion_common::{Constraint, Constraints, HashMap, Result, plan_err};use datafusion_expr::interval_arithmetic::Interval;use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_physical_expr_common::sort_expr::options_compatible;diff --git a/datafusion/physical-expr/src/equivalence/properties/union.rs b/datafusion/physical-expr/src/equivalence/properties/union.rsindex efbefd0d39..d77129472a 100644--- a/datafusion/physical-expr/src/equivalence/properties/union.rs+++ b/datafusion/physical-expr/src/equivalence/properties/union.rs@@ -23,7 +23,7 @@ use crate::equivalence::class::AcrossPartitions;use crate::{ConstExpr, PhysicalSortExpr};use arrow::datatypes::SchemaRef;-use datafusion_common::{internal_err, Result};+use datafusion_common::{Result, internal_err};use datafusion_physical_expr_common::sort_expr::LexOrdering;/// Computes the union (in the sense of `UnionExec`) `EquivalenceProperties`@@ -307,9 +307,9 @@ fn advance_if_matches_constant<'a>(#[cfg(test)]mod tests {use super::*;+ use crate::PhysicalExpr;use crate::equivalence::tests::{create_test_schema, parse_sort_expr};use crate::expressions::col;- use crate::PhysicalExpr;use arrow::datatypes::{DataType, Field, Schema};use datafusion_common::ScalarValue;diff --git a/datafusion/physical-expr/src/expressions/binary.rs b/datafusion/physical-expr/src/expressions/binary.rsindex 1e5c7e7024..8df09c22bb 100644--- a/datafusion/physical-expr/src/expressions/binary.rs+++ b/datafusion/physical-expr/src/expressions/binary.rs@@ -17,26 +17,26 @@mod kernels;-use crate::intervals::cp_solver::{propagate_arithmetic, propagate_comparison};use crate::PhysicalExpr;+use crate::intervals::cp_solver::{propagate_arithmetic, propagate_comparison};use std::hash::Hash;use std::{any::Any, sync::Arc};use arrow::array::*;use arrow::compute::kernels::boolean::{and_kleene, or_kleene};use arrow::compute::kernels::concat_elements::concat_elements_utf8;-use arrow::compute::{cast, filter_record_batch, SlicesIterator};+use arrow::compute::{SlicesIterator, cast, filter_record_batch};use arrow::datatypes::*;use arrow::error::ArrowError;use datafusion_common::cast::as_boolean_array;-use datafusion_common::{internal_err, not_impl_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, internal_err, not_impl_err};use datafusion_expr::binary::BinaryTypeCoercer;-use datafusion_expr::interval_arithmetic::{apply_operator, Interval};+use datafusion_expr::interval_arithmetic::{Interval, apply_operator};use datafusion_expr::sort_properties::ExprProperties;use datafusion_expr::statistics::Distribution::{Bernoulli, Gaussian};use datafusion_expr::statistics::{- combine_bernoullis, combine_gaussians, create_bernoulli_from_comparison,- new_generic_from_binary_op, Distribution,+ Distribution, combine_bernoullis, combine_gaussians,+ create_bernoulli_from_comparison, new_generic_from_binary_op,};use datafusion_expr::{ColumnarValue, Operator};use datafusion_physical_expr_common::datum::{apply, apply_cmp};@@ -278,18 +278,14 @@ impl PhysicalExpr for BinaryExpr {let result_type = self.data_type(input_schema)?;// If the left-hand side is an array and the right-hand side is a non-null scalar, try the optimized kernel.- if let (ColumnarValue::Array(array), ColumnarValue::Scalar(ref scalar)) =- (&lhs, &rhs)+ if let (ColumnarValue::Array(array), ColumnarValue::Scalar(scalar)) = (&lhs, &rhs)+ && !scalar.is_null()+ && let Some(result_array) =+ self.evaluate_array_scalar(array, scalar.clone())?{- if !scalar.is_null() {- if let Some(result_array) =- self.evaluate_array_scalar(array, scalar.clone())?- {- let final_array = result_array- .and_then(|a| to_result_type_array(&self.op, a, &result_type));- return final_array.map(ColumnarValue::Array);- }- }+ let final_array = result_array+ .and_then(|a| to_result_type_array(&self.op, a, &result_type));+ return final_array.map(ColumnarValue::Array);}// if both arrays or both literals - extract arrays and continue execution@@ -420,10 +416,10 @@ impl PhysicalExpr for BinaryExpr {// We might be able to construct the output statistics more accurately,// without falling back to an unknown distribution, if we are dealing// with Gaussian distributions and numerical operations.- if let (Gaussian(left), Gaussian(right)) = (left, right) {- if let Some(result) = combine_gaussians(&self.op, left, right)? {- return Ok(Gaussian(result));- }+ if let (Gaussian(left), Gaussian(right)) = (left, right)+ && let Some(result) = combine_gaussians(&self.op, left, right)?+ {+ return Ok(Gaussian(result));}} else if self.op.is_logic_operator() {// If we are dealing with logical operators, we expect (and can only@@ -540,8 +536,8 @@ fn to_result_type_array(Ok(cast(&array, result_type)?)} else {internal_err!(- "Incompatible Dictionary value type {value_type} with result type {result_type} of Binary operator {op:?}"- )+ "Incompatible Dictionary value type {value_type} with result type {result_type} of Binary operator {op:?}"+ )}}_ => Ok(array),@@ -895,7 +891,7 @@ pub fn similar_to(#[cfg(test)]mod tests {use super::*;- use crate::expressions::{col, lit, try_cast, Column, Literal};+ use crate::expressions::{Column, Literal, col, lit, try_cast};use datafusion_expr::lit as expr_lit;use datafusion_common::plan_datafusion_err;@@ -1018,7 +1014,8 @@ mod tests {]);let a = $A_ARRAY::from($A_VEC);let b = $B_ARRAY::from($B_VEC);- let (lhs, rhs) = BinaryTypeCoercer::new(&$A_TYPE, &$OP, &$B_TYPE).get_input_types()?;+ let (lhs, rhs) =+ BinaryTypeCoercer::new(&$A_TYPE, &$OP, &$B_TYPE).get_input_types()?;let left = try_cast(col("a", &schema)?, &schema, lhs)?;let right = try_cast(col("b", &schema)?, &schema, rhs)?;@@ -1034,7 +1031,10 @@ mod tests {assert_eq!(expression.data_type(&schema)?, $C_TYPE);// compute- let result = expression.evaluate(&batch)?.into_array(batch.num_rows()).expect("Failed to convert to array");+ let result = expression+ .evaluate(&batch)?+ .into_array(batch.num_rows())+ .expect("Failed to convert to array");// verify that the array's data_type is correctassert_eq!(*result.data_type(), $C_TYPE);@@ -1048,8 +1048,7 @@ mod tests {for (i, x) in $VEC.iter().enumerate() {let v = result.value(i);assert_eq!(- v,- *x,+ v, *x,"Unexpected output at position {i}:\n\nActual:\n{v}\n\nExpected:\n{x}");}@@ -4426,11 +4425,13 @@ mod tests {// evaluate expressionlet result = expr.evaluate(&batch);- assert!(result- .err()- .unwrap()- .to_string()- .contains("Overflow happened on: 2147483647 + 1"));+ assert!(+ result+ .err()+ .unwrap()+ .to_string()+ .contains("Overflow happened on: 2147483647 + 1")+ );Ok(())}@@ -4455,11 +4456,13 @@ mod tests {// evaluate expressionlet result = expr.evaluate(&batch);- assert!(result- .err()- .unwrap()- .to_string()- .contains("Overflow happened on: -2147483648 - 1"));+ assert!(+ result+ .err()+ .unwrap()+ .to_string()+ .contains("Overflow happened on: -2147483648 - 1")+ );Ok(())}@@ -4484,11 +4487,13 @@ mod tests {// evaluate expressionlet result = expr.evaluate(&batch);- assert!(result- .err()- .unwrap()- .to_string()- .contains("Overflow happened on: 2147483647 * 2"));+ assert!(+ result+ .err()+ .unwrap()+ .to_string()+ .contains("Overflow happened on: 2147483647 * 2")+ );Ok(())}@@ -4797,9 +4802,10 @@ mod tests {let child_refs = child_view.iter().collect::<Vec<_>>();for op in &ops {let expr = binary_expr(Arc::clone(&a), *op, Arc::clone(&b), schema)?;- assert!(expr- .propagate_statistics(&parent, child_refs.as_slice())?- .is_some());+ assert!(+ expr.propagate_statistics(&parent, child_refs.as_slice())?+ .is_some()+ );}}diff --git a/datafusion/physical-expr/src/expressions/binary/kernels.rs b/datafusion/physical-expr/src/expressions/binary/kernels.rsindex ad44b00212..39e3a6f16b 100644--- a/datafusion/physical-expr/src/expressions/binary/kernels.rs+++ b/datafusion/physical-expr/src/expressions/binary/kernels.rs@@ -27,8 +27,8 @@ use arrow::compute::kernels::boolean::not;use arrow::compute::kernels::comparison::{regexp_is_match, regexp_is_match_scalar};use arrow::datatypes::DataType;use arrow::error::ArrowError;-use datafusion_common::{internal_err, plan_err};use datafusion_common::{Result, ScalarValue};+use datafusion_common::{internal_err, plan_err};use std::sync::Arc;@@ -108,16 +108,35 @@ macro_rules! call_scalar_kernel {/// downcasts left / right to the appropriate integral type and calls the kernelmacro_rules! create_left_integral_dyn_scalar_kernel {($FUNC:ident, $KERNEL:ident) => {- pub(crate) fn $FUNC(array: &dyn Array, scalar: ScalarValue) -> Option<Result<ArrayRef>> {+ pub(crate) fn $FUNC(+ array: &dyn Array,+ scalar: ScalarValue,+ ) -> Option<Result<ArrayRef>> {let result = match array.data_type() {- DataType::Int8 => call_scalar_kernel!(array, scalar, $KERNEL, Int8Array, i8),- DataType::Int16 => call_scalar_kernel!(array, scalar, $KERNEL, Int16Array, i16),- DataType::Int32 => call_scalar_kernel!(array, scalar, $KERNEL, Int32Array, i32),- DataType::Int64 => call_scalar_kernel!(array, scalar, $KERNEL, Int64Array, i64),- DataType::UInt8 => call_scalar_kernel!(array, scalar, $KERNEL, UInt8Array, u8),- DataType::UInt16 => call_scalar_kernel!(array, scalar, $KERNEL, UInt16Array, u16),- DataType::UInt32 => call_scalar_kernel!(array, scalar, $KERNEL, UInt32Array, u32),- DataType::UInt64 => call_scalar_kernel!(array, scalar, $KERNEL, UInt64Array, u64),+ DataType::Int8 => {+ call_scalar_kernel!(array, scalar, $KERNEL, Int8Array, i8)+ }+ DataType::Int16 => {+ call_scalar_kernel!(array, scalar, $KERNEL, Int16Array, i16)+ }+ DataType::Int32 => {+ call_scalar_kernel!(array, scalar, $KERNEL, Int32Array, i32)+ }+ DataType::Int64 => {+ call_scalar_kernel!(array, scalar, $KERNEL, Int64Array, i64)+ }+ DataType::UInt8 => {+ call_scalar_kernel!(array, scalar, $KERNEL, UInt8Array, u8)+ }+ DataType::UInt16 => {+ call_scalar_kernel!(array, scalar, $KERNEL, UInt16Array, u16)+ }+ DataType::UInt32 => {+ call_scalar_kernel!(array, scalar, $KERNEL, UInt32Array, u32)+ }+ DataType::UInt64 => {+ call_scalar_kernel!(array, scalar, $KERNEL, UInt64Array, u64)+ }other => plan_err!("Data type {} not supported for binary operation '{}' on dyn arrays",other,@@ -296,8 +315,8 @@ pub(crate) fn regex_match_dyn_scalar()}other => internal_err!(- "Data type {} not supported for operation 'regex_match_dyn_scalar' on string array",- other+ "Data type {} not supported for operation 'regex_match_dyn_scalar' on string array",+ other),};Some(result)diff --git a/datafusion/physical-expr/src/expressions/case.rs b/datafusion/physical-expr/src/expressions/case.rsindex a3c181368d..dbd138b761 100644--- a/datafusion/physical-expr/src/expressions/case.rs+++ b/datafusion/physical-expr/src/expressions/case.rs@@ -16,22 +16,22 @@// under the License.use super::{Column, Literal};+use crate::PhysicalExpr;use crate::expressions::case::ResultState::{Complete, Empty, Partial};use crate::expressions::{lit, try_cast};-use crate::PhysicalExpr;use arrow::array::*;use arrow::compute::kernels::zip::zip;use arrow::compute::{- is_not_null, not, nullif, prep_null_mask_filter, FilterBuilder, FilterPredicate,- SlicesIterator,+ FilterBuilder, FilterPredicate, SlicesIterator, is_not_null, not, nullif,+ prep_null_mask_filter,};use arrow::datatypes::{DataType, Schema, UInt32Type, UnionMode};use arrow::error::ArrowError;use datafusion_common::cast::as_boolean_array;use datafusion_common::tree_node::{Transformed, TreeNode, TreeNodeRecursion};use datafusion_common::{- assert_or_internal_err, exec_err, internal_datafusion_err, internal_err,- DataFusionError, HashMap, HashSet, Result, ScalarValue,+ DataFusionError, HashMap, HashSet, Result, ScalarValue, assert_or_internal_err,+ exec_err, internal_datafusion_err, internal_err,};use datafusion_expr::ColumnarValue;use std::borrow::Cow;@@ -831,10 +831,10 @@ impl CaseBody {}}// if all then results are null, we use data type of else expr instead if possible.- if data_type.equals_datatype(&DataType::Null) {- if let Some(e) = &self.else_expr {- data_type = e.data_type(input_schema)?;- }+ if data_type.equals_datatype(&DataType::Null)+ && let Some(e) = &self.else_expr+ {+ data_type = e.data_type(input_schema)?;}Ok(data_type)@@ -1505,7 +1505,7 @@ mod tests {use super::*;use crate::expressions;- use crate::expressions::{binary, cast, col, is_not_null, lit, BinaryExpr};+ use crate::expressions::{BinaryExpr, binary, cast, col, is_not_null, lit};use arrow::buffer::Buffer;use arrow::datatypes::DataType::Float64;use arrow::datatypes::Field;diff --git a/datafusion/physical-expr/src/expressions/cast.rs b/datafusion/physical-expr/src/expressions/cast.rsindex 263a628be8..bd5c63a699 100644--- a/datafusion/physical-expr/src/expressions/cast.rs+++ b/datafusion/physical-expr/src/expressions/cast.rs@@ -22,11 +22,11 @@ use std::sync::Arc;use crate::physical_expr::PhysicalExpr;-use arrow::compute::{can_cast_types, CastOptions};+use arrow::compute::{CastOptions, can_cast_types};use arrow::datatypes::{DataType, DataType::*, FieldRef, Schema};use arrow::record_batch::RecordBatch;use datafusion_common::format::DEFAULT_FORMAT_OPTIONS;-use datafusion_common::{not_impl_err, Result};+use datafusion_common::{Result, not_impl_err};use datafusion_expr_common::columnar_value::ColumnarValue;use datafusion_expr_common::interval_arithmetic::Interval;use datafusion_expr_common::sort_properties::ExprProperties;@@ -191,7 +191,7 @@ impl PhysicalExpr for CastExpr {// Get child's datatype:let cast_type = child_interval.data_type();Ok(Some(vec![- interval.cast_to(&cast_type, &DEFAULT_SAFE_CAST_OPTIONS)?+ interval.cast_to(&cast_type, &DEFAULT_SAFE_CAST_OPTIONS)?,]))}@@ -262,8 +262,8 @@ mod tests {use arrow::{array::{- Array, Decimal128Array, Float32Array, Float64Array, Int16Array, Int32Array,- Int64Array, Int8Array, StringArray, Time64NanosecondArray,+ Array, Decimal128Array, Float32Array, Float64Array, Int8Array, Int16Array,+ Int32Array, Int64Array, StringArray, Time64NanosecondArray,TimestampNanosecondArray, UInt32Array,},datatypes::*,@@ -774,9 +774,10 @@ mod tests {match result {Ok(_) => panic!("expected error"),Err(e) => {- assert!(e- .to_string()- .contains("Cannot cast string '9.1' to value of Int32 type"))+ assert!(+ e.to_string()+ .contains("Cannot cast string '9.1' to value of Int32 type")+ )}}Ok(())diff --git a/datafusion/physical-expr/src/expressions/cast_column.rs b/datafusion/physical-expr/src/expressions/cast_column.rsindex 80d71c3def..3dc0293da8 100644--- a/datafusion/physical-expr/src/expressions/cast_column.rs+++ b/datafusion/physical-expr/src/expressions/cast_column.rs@@ -24,7 +24,7 @@ use arrow::{record_batch::RecordBatch,};use datafusion_common::{- format::DEFAULT_CAST_OPTIONS, nested_struct::cast_column, Result, ScalarValue,+ Result, ScalarValue, format::DEFAULT_CAST_OPTIONS, nested_struct::cast_column,};use datafusion_expr_common::columnar_value::ColumnarValue;use std::{@@ -192,8 +192,8 @@ mod tests {datatypes::{DataType, Field, Fields, SchemaRef},};use datafusion_common::{- cast::{as_int64_array, as_string_array, as_struct_array, as_uint8_array},Result as DFResult, ScalarValue,+ cast::{as_int64_array, as_string_array, as_struct_array, as_uint8_array},};fn make_schema(field: &Field) -> SchemaRef {diff --git a/datafusion/physical-expr/src/expressions/column.rs b/datafusion/physical-expr/src/expressions/column.rsindex 9ca464b304..8c7e8c319f 100644--- a/datafusion/physical-expr/src/expressions/column.rs+++ b/datafusion/physical-expr/src/expressions/column.rs@@ -28,7 +28,7 @@ use arrow::{record_batch::RecordBatch,};use datafusion_common::tree_node::{Transformed, TreeNode};-use datafusion_common::{internal_err, plan_err, Result};+use datafusion_common::{Result, internal_err, plan_err};use datafusion_expr::ColumnarValue;/// Represents the column at a given index in a RecordBatch@@ -158,7 +158,11 @@ impl Column {self.name,self.index,input_schema.fields.len(),- input_schema.fields().iter().map(|f| f.name()).collect::<Vec<_>>()+ input_schema+ .fields()+ .iter()+ .map(|f| f.name())+ .collect::<Vec<_>>())}}diff --git a/datafusion/physical-expr/src/expressions/dynamic_filters.rs b/datafusion/physical-expr/src/expressions/dynamic_filters.rsindex 43a242472b..60b00117b7 100644--- a/datafusion/physical-expr/src/expressions/dynamic_filters.rs+++ b/datafusion/physical-expr/src/expressions/dynamic_filters.rs@@ -22,8 +22,8 @@ use tokio::sync::watch;use crate::PhysicalExpr;use arrow::datatypes::{DataType, Schema};use datafusion_common::{- tree_node::{Transformed, TransformedResult, TreeNode},Result,+ tree_node::{Transformed, TransformedResult, TreeNode},};use datafusion_expr::ColumnarValue;use datafusion_physical_expr_common::physical_expr::{DynEq, DynHash};@@ -420,7 +420,7 @@ impl PhysicalExpr for DynamicFilterPhysicalExpr {#[cfg(test)]mod test {use crate::{- expressions::{col, lit, BinaryExpr},+ expressions::{BinaryExpr, col, lit},utils::reassign_expr_columns,};use arrow::{diff --git a/datafusion/physical-expr/src/expressions/in_list.rs b/datafusion/physical-expr/src/expressions/in_list.rsindex bb033aac03..81c2bd17a8 100644--- a/datafusion/physical-expr/src/expressions/in_list.rs+++ b/datafusion/physical-expr/src/expressions/in_list.rs@@ -22,21 +22,21 @@ use std::fmt::Debug;use std::hash::{Hash, Hasher};use std::sync::Arc;-use crate::physical_expr::physical_exprs_bag_equal;use crate::PhysicalExpr;+use crate::physical_expr::physical_exprs_bag_equal;use arrow::array::*;use arrow::buffer::BooleanBuffer;use arrow::compute::kernels::boolean::{not, or_kleene};-use arrow::compute::{take, SortOptions};+use arrow::compute::{SortOptions, take};use arrow::datatypes::*;use arrow::util::bit_iterator::BitIndexIterator;use datafusion_common::hash_utils::with_hashes;use datafusion_common::{- assert_or_internal_err, exec_datafusion_err, exec_err, DFSchema, HashSet, Result,- ScalarValue,+ DFSchema, HashSet, Result, ScalarValue, assert_or_internal_err, exec_datafusion_err,+ exec_err,};-use datafusion_expr::{expr_vec_fmt, ColumnarValue};+use datafusion_expr::{ColumnarValue, expr_vec_fmt};use ahash::RandomState;use datafusion_common::HashMap;@@ -488,11 +488,7 @@ impl PhysicalExpr for InListExpr {},)?;- if self.negated {- not(&found)?- } else {- found- }+ if self.negated { not(&found)? } else { found }}};Ok(ColumnarValue::Array(Arc::new(r)))diff --git a/datafusion/physical-expr/src/expressions/like.rs b/datafusion/physical-expr/src/expressions/like.rsindex 5502def582..fc49ca35f0 100644--- a/datafusion/physical-expr/src/expressions/like.rs+++ b/datafusion/physical-expr/src/expressions/like.rs@@ -18,7 +18,7 @@use crate::PhysicalExpr;use arrow::datatypes::{DataType, Schema};use arrow::record_batch::RecordBatch;-use datafusion_common::{assert_or_internal_err, Result};+use datafusion_common::{Result, assert_or_internal_err};use datafusion_expr::{ColumnarValue, Operator};use datafusion_physical_expr_common::datum::apply_cmp;use std::hash::Hash;diff --git a/datafusion/physical-expr/src/expressions/mod.rs b/datafusion/physical-expr/src/expressions/mod.rsindex 59d675753d..c9e02708d6 100644--- a/datafusion/physical-expr/src/expressions/mod.rs+++ b/datafusion/physical-expr/src/expressions/mod.rs@@ -35,24 +35,24 @@ mod not;mod try_cast;mod unknown_column;+pub use crate::PhysicalSortExpr;/// Module with some convenient methods used in expression buildingpub use crate::aggregate::stats::StatsType;-pub use crate::PhysicalSortExpr;-pub use binary::{binary, similar_to, BinaryExpr};-pub use case::{case, CaseExpr};-pub use cast::{cast, CastExpr};+pub use binary::{BinaryExpr, binary, similar_to};+pub use case::{CaseExpr, case};+pub use cast::{CastExpr, cast};pub use cast_column::CastColumnExpr;-pub use column::{col, with_new_schema, Column};+pub use column::{Column, col, with_new_schema};pub use datafusion_expr::utils::format_state_name;pub use dynamic_filters::DynamicFilterPhysicalExpr;-pub use in_list::{in_list, InListExpr};-pub use is_not_null::{is_not_null, IsNotNullExpr};-pub use is_null::{is_null, IsNullExpr};-pub use like::{like, LikeExpr};-pub use literal::{lit, Literal};-pub use negative::{negative, NegativeExpr};+pub use in_list::{InListExpr, in_list};+pub use is_not_null::{IsNotNullExpr, is_not_null};+pub use is_null::{IsNullExpr, is_null};+pub use like::{LikeExpr, like};+pub use literal::{Literal, lit};+pub use negative::{NegativeExpr, negative};pub use no_op::NoOp;-pub use not::{not, NotExpr};-pub use try_cast::{try_cast, TryCastExpr};+pub use not::{NotExpr, not};+pub use try_cast::{TryCastExpr, try_cast};pub use unknown_column::UnKnownColumn;diff --git a/datafusion/physical-expr/src/expressions/negative.rs b/datafusion/physical-expr/src/expressions/negative.rsindex fa7224768a..0c9476beba 100644--- a/datafusion/physical-expr/src/expressions/negative.rs+++ b/datafusion/physical-expr/src/expressions/negative.rs@@ -29,15 +29,15 @@ use arrow::{datatypes::{DataType, Schema},record_batch::RecordBatch,};-use datafusion_common::{internal_err, plan_err, Result};+use datafusion_common::{Result, internal_err, plan_err};use datafusion_expr::interval_arithmetic::Interval;use datafusion_expr::sort_properties::ExprProperties;use datafusion_expr::statistics::Distribution::{self, Bernoulli, Exponential, Gaussian, Generic, Uniform,};use datafusion_expr::{- type_coercion::{is_interval, is_null, is_signed_numeric, is_timestamp},ColumnarValue,+ type_coercion::{is_interval, is_null, is_signed_numeric, is_timestamp},};/// Negative expression@@ -205,10 +205,10 @@ pub fn negative(#[cfg(test)]mod tests {use super::*;- use crate::expressions::{col, Column};+ use crate::expressions::{Column, col};use arrow::array::*;- use arrow::datatypes::DataType::{Float32, Float64, Int16, Int32, Int64, Int8};+ use arrow::datatypes::DataType::{Float32, Float64, Int8, Int16, Int32, Int64};use arrow::datatypes::*;use datafusion_common::cast::as_primitive_array;use datafusion_common::{DataFusionError, ScalarValue};@@ -277,11 +277,13 @@ mod tests {);// Bernoulli- assert!(negative_expr- .evaluate_statistics(&[&Distribution::new_bernoulli(ScalarValue::from(- 0.75- ))?])- .is_err());+ assert!(+ negative_expr+ .evaluate_statistics(&[&Distribution::new_bernoulli(ScalarValue::from(+ 0.75+ ))?])+ .is_err()+ );// Exponentialassert_eq!(diff --git a/datafusion/physical-expr/src/expressions/no_op.rs b/datafusion/physical-expr/src/expressions/no_op.rsindex 94610996c6..ff44a60a86 100644--- a/datafusion/physical-expr/src/expressions/no_op.rs+++ b/datafusion/physical-expr/src/expressions/no_op.rs@@ -26,7 +26,7 @@ use arrow::{datatypes::{DataType, Schema},record_batch::RecordBatch,};-use datafusion_common::{internal_err, Result};+use datafusion_common::{Result, internal_err};use datafusion_expr::ColumnarValue;/// A place holder expression, can not be evaluated.diff --git a/datafusion/physical-expr/src/expressions/not.rs b/datafusion/physical-expr/src/expressions/not.rsindex 655fc7f92e..a29ab2ff40 100644--- a/datafusion/physical-expr/src/expressions/not.rs+++ b/datafusion/physical-expr/src/expressions/not.rs@@ -26,10 +26,10 @@ use crate::PhysicalExpr;use arrow::datatypes::{DataType, FieldRef, Schema};use arrow::record_batch::RecordBatch;-use datafusion_common::{cast::as_boolean_array, internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, cast::as_boolean_array, internal_err};+use datafusion_expr::ColumnarValue;use datafusion_expr::interval_arithmetic::Interval;use datafusion_expr::statistics::Distribution::{self, Bernoulli};-use datafusion_expr::ColumnarValue;/// Not expression#[derive(Debug, Eq)]@@ -196,7 +196,7 @@ mod tests {use std::sync::LazyLock;use super::*;- use crate::expressions::{col, Column};+ use crate::expressions::{Column, col};use arrow::{array::BooleanArray, datatypes::*};use datafusion_physical_expr_common::physical_expr::fmt_sql;@@ -265,28 +265,31 @@ mod tests {let expr = not(a)?;// Uniform with non-boolean bounds- assert!(expr- .evaluate_statistics(&[&Distribution::new_uniform(+ assert!(+ expr.evaluate_statistics(&[&Distribution::new_uniform(Interval::make_unbounded(&DataType::Float64)?)?])- .is_err());+ .is_err()+ );// Exponential- assert!(expr- .evaluate_statistics(&[&Distribution::new_exponential(+ assert!(+ expr.evaluate_statistics(&[&Distribution::new_exponential(ScalarValue::from(1.0),ScalarValue::from(1.0),true)?])- .is_err());+ .is_err()+ );// Gaussian- assert!(expr- .evaluate_statistics(&[&Distribution::new_gaussian(+ assert!(+ expr.evaluate_statistics(&[&Distribution::new_gaussian(ScalarValue::from(1.0),ScalarValue::from(1.0),)?])- .is_err());+ .is_err()+ );// Bernoulliassert_eq!(@@ -310,24 +313,26 @@ mod tests {Distribution::new_bernoulli(ScalarValue::from(0.75))?);- assert!(expr- .evaluate_statistics(&[&Distribution::new_generic(+ assert!(+ expr.evaluate_statistics(&[&Distribution::new_generic(ScalarValue::Null,ScalarValue::Null,ScalarValue::Null,Interval::make_unbounded(&DataType::UInt8)?)?])- .is_err());+ .is_err()+ );// Unknown with non-boolean interval as range- assert!(expr- .evaluate_statistics(&[&Distribution::new_generic(+ assert!(+ expr.evaluate_statistics(&[&Distribution::new_generic(ScalarValue::Null,ScalarValue::Null,ScalarValue::Null,Interval::make_unbounded(&DataType::Float64)?)?])- .is_err());+ .is_err()+ );Ok(())}diff --git a/datafusion/physical-expr/src/expressions/try_cast.rs b/datafusion/physical-expr/src/expressions/try_cast.rsindex b32aabbe5b..c9ace3239c 100644--- a/datafusion/physical-expr/src/expressions/try_cast.rs+++ b/datafusion/physical-expr/src/expressions/try_cast.rs@@ -27,7 +27,7 @@ use arrow::datatypes::{DataType, FieldRef, Schema};use arrow::record_batch::RecordBatch;use compute::can_cast_types;use datafusion_common::format::DEFAULT_FORMAT_OPTIONS;-use datafusion_common::{not_impl_err, Result};+use datafusion_common::{Result, not_impl_err};use datafusion_expr::ColumnarValue;/// TRY_CAST expression casts an expression to a specific data type and returns NULL on invalid cast@@ -155,8 +155,8 @@ mod tests {};use arrow::{array::{- Array, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array,- Int8Array, TimestampNanosecondArray, UInt32Array,+ Array, Float32Array, Float64Array, Int8Array, Int16Array, Int32Array,+ Int64Array, TimestampNanosecondArray, UInt32Array,},datatypes::*,};diff --git a/datafusion/physical-expr/src/expressions/unknown_column.rs b/datafusion/physical-expr/src/expressions/unknown_column.rsindex 2face4eb6b..f06d880985 100644--- a/datafusion/physical-expr/src/expressions/unknown_column.rs+++ b/datafusion/physical-expr/src/expressions/unknown_column.rs@@ -27,7 +27,7 @@ use arrow::{datatypes::{DataType, Schema},record_batch::RecordBatch,};-use datafusion_common::{internal_err, Result};+use datafusion_common::{Result, internal_err};use datafusion_expr::ColumnarValue;#[derive(Debug, Clone, Eq)]diff --git a/datafusion/physical-expr/src/intervals/cp_solver.rs b/datafusion/physical-expr/src/intervals/cp_solver.rsindex cb2391fd1d..e5e9304ab1 100644--- a/datafusion/physical-expr/src/intervals/cp_solver.rs+++ b/datafusion/physical-expr/src/intervals/cp_solver.rs@@ -148,19 +148,19 @@ use std::sync::Arc;use super::utils::{convert_duration_type_to_interval, convert_interval_type_to_duration, get_inverse_op,};-use crate::expressions::{BinaryExpr, Literal};-use crate::utils::{build_dag, ExprTreeNode};use crate::PhysicalExpr;+use crate::expressions::{BinaryExpr, Literal};+use crate::utils::{ExprTreeNode, build_dag};use arrow::datatypes::{DataType, Schema};-use datafusion_common::{internal_err, not_impl_err, Result};-use datafusion_expr::interval_arithmetic::{apply_operator, satisfy_greater, Interval};+use datafusion_common::{Result, internal_err, not_impl_err};use datafusion_expr::Operator;+use datafusion_expr::interval_arithmetic::{Interval, apply_operator, satisfy_greater};+use petgraph::Outgoing;use petgraph::graph::NodeIndex;use petgraph::stable_graph::{DefaultIx, StableGraph};use petgraph::visit::{Bfs, Dfs, DfsPostOrder, EdgeRef};-use petgraph::Outgoing;/// This object implements a directed acyclic expression graph (DAEG) that/// is used to compute ranges for expressions through interval arithmetic.diff --git a/datafusion/physical-expr/src/intervals/test_utils.rs b/datafusion/physical-expr/src/intervals/test_utils.rsindex 9a59227970..805ffd2761 100644--- a/datafusion/physical-expr/src/intervals/test_utils.rs+++ b/datafusion/physical-expr/src/intervals/test_utils.rs@@ -19,8 +19,8 @@use std::sync::Arc;-use crate::expressions::{binary, BinaryExpr, Literal};use crate::PhysicalExpr;+use crate::expressions::{BinaryExpr, Literal, binary};use arrow::datatypes::Schema;use datafusion_common::{DataFusionError, ScalarValue};use datafusion_expr::Operator;diff --git a/datafusion/physical-expr/src/intervals/utils.rs b/datafusion/physical-expr/src/intervals/utils.rsindex 22752a00e9..3cada63a34 100644--- a/datafusion/physical-expr/src/intervals/utils.rs+++ b/datafusion/physical-expr/src/intervals/utils.rs@@ -20,15 +20,15 @@use std::sync::Arc;use crate::{- expressions::{BinaryExpr, CastExpr, Column, Literal, NegativeExpr},PhysicalExpr,+ expressions::{BinaryExpr, CastExpr, Column, Literal, NegativeExpr},};use arrow::array::types::{IntervalDayTime, IntervalMonthDayNano};use arrow::datatypes::{DataType, SchemaRef};-use datafusion_common::{internal_err, Result, ScalarValue};-use datafusion_expr::interval_arithmetic::Interval;+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_expr::Operator;+use datafusion_expr::interval_arithmetic::Interval;/// Indicates whether interval arithmetic is supported for the given expression./// Currently, we do not support all [`PhysicalExpr`]s for interval calculations.diff --git a/datafusion/physical-expr/src/lib.rs b/datafusion/physical-expr/src/lib.rsindex 871cebe602..988e14c28e 100644--- a/datafusion/physical-expr/src/lib.rs+++ b/datafusion/physical-expr/src/lib.rs@@ -54,9 +54,9 @@ pub mod execution_props {}pub use aggregate::groups_accumulator::{GroupsAccumulatorAdapter, NullState};-pub use analysis::{analyze, AnalysisContext, ExprBoundaries};+pub use analysis::{AnalysisContext, ExprBoundaries, analyze};pub use equivalence::{- calculate_union, AcrossPartitions, ConstExpr, EquivalenceProperties,+ AcrossPartitions, ConstExpr, EquivalenceProperties, calculate_union,};pub use partitioning::{Distribution, Partitioning};pub use physical_expr::{diff --git a/datafusion/physical-expr/src/partitioning.rs b/datafusion/physical-expr/src/partitioning.rsindex d6b2b1b046..839df7bb88 100644--- a/datafusion/physical-expr/src/partitioning.rs+++ b/datafusion/physical-expr/src/partitioning.rs@@ -18,8 +18,8 @@//! [`Partitioning`] and [`Distribution`] for `ExecutionPlans`use crate::{- equivalence::ProjectionMapping, expressions::UnKnownColumn, physical_exprs_equal,- EquivalenceProperties, PhysicalExpr,+ EquivalenceProperties, PhysicalExpr, equivalence::ProjectionMapping,+ expressions::UnKnownColumn, physical_exprs_equal,};use datafusion_physical_expr_common::physical_expr::format_physical_expr_list;use std::fmt;diff --git a/datafusion/physical-expr/src/physical_expr.rs b/datafusion/physical-expr/src/physical_expr.rsindex c658a8eddc..e750bfd79d 100644--- a/datafusion/physical-expr/src/physical_expr.rs+++ b/datafusion/physical-expr/src/physical_expr.rs@@ -18,13 +18,13 @@use std::sync::Arc;use crate::expressions::{self, Column};-use crate::{create_physical_expr, LexOrdering, PhysicalSortExpr};+use crate::{LexOrdering, PhysicalSortExpr, create_physical_expr};use arrow::compute::SortOptions;use arrow::datatypes::{Schema, SchemaRef};use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode};-use datafusion_common::{plan_err, Result};use datafusion_common::{DFSchema, HashMap};+use datafusion_common::{Result, plan_err};use datafusion_expr::execution_props::ExecutionProps;use datafusion_expr::{Expr, SortExpr};diff --git a/datafusion/physical-expr/src/planner.rs b/datafusion/physical-expr/src/planner.rsindex 7790380dff..3323ea029c 100644--- a/datafusion/physical-expr/src/planner.rs+++ b/datafusion/physical-expr/src/planner.rs@@ -19,22 +19,22 @@ use std::sync::Arc;use crate::ScalarFunctionExpr;use crate::{- expressions::{self, binary, like, similar_to, Column, Literal},PhysicalExpr,+ expressions::{self, Column, Literal, binary, like, similar_to},};use arrow::datatypes::Schema;use datafusion_common::config::ConfigOptions;use datafusion_common::metadata::FieldMetadata;use datafusion_common::{- exec_err, not_impl_err, plan_err, DFSchema, Result, ScalarValue, ToDFSchema,+ DFSchema, Result, ScalarValue, ToDFSchema, exec_err, not_impl_err, plan_err,};use datafusion_expr::execution_props::ExecutionProps;use datafusion_expr::expr::{Alias, Cast, InList, Placeholder, ScalarFunction};-use datafusion_expr::var_provider::is_system_variables;use datafusion_expr::var_provider::VarType;+use datafusion_expr::var_provider::is_system_variables;use datafusion_expr::{- binary_expr, lit, Between, BinaryExpr, Expr, Like, Operator, TryCast,+ Between, BinaryExpr, Expr, Like, Operator, TryCast, binary_expr, lit,};/// [PhysicalExpr] evaluate DataFusion expressions such as `A + 1`, or `CAST(c1diff --git a/datafusion/physical-expr/src/projection.rs b/datafusion/physical-expr/src/projection.rsindex 485109001e..6f12fbdfe7 100644--- a/datafusion/physical-expr/src/projection.rs+++ b/datafusion/physical-expr/src/projection.rs@@ -18,16 +18,16 @@use std::ops::Deref;use std::sync::Arc;+use crate::PhysicalExpr;use crate::expressions::Column;use crate::utils::collect_columns;-use crate::PhysicalExpr;use arrow::array::{RecordBatch, RecordBatchOptions};use arrow::datatypes::{Field, Schema, SchemaRef};use datafusion_common::stats::ColumnStatistics;use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode};use datafusion_common::{- assert_or_internal_err, internal_datafusion_err, plan_err, Result,+ Result, assert_or_internal_err, internal_datafusion_err, plan_err,};use datafusion_physical_expr_common::sort_expr::{LexOrdering, PhysicalSortExpr};@@ -991,8 +991,8 @@ pub(crate) mod tests {use std::collections::HashMap;use super::*;- use crate::equivalence::{convert_to_orderings, EquivalenceProperties};- use crate::expressions::{col, BinaryExpr, Literal};+ use crate::equivalence::{EquivalenceProperties, convert_to_orderings};+ use crate::expressions::{BinaryExpr, Literal, col};use crate::utils::tests::TestScalarUDF;use crate::{PhysicalExprRef, ScalarFunctionExpr};diff --git a/datafusion/physical-expr/src/scalar_function.rs b/datafusion/physical-expr/src/scalar_function.rsindex 743d5b99cd..e6a6db75be 100644--- a/datafusion/physical-expr/src/scalar_function.rs+++ b/datafusion/physical-expr/src/scalar_function.rs@@ -34,19 +34,19 @@ use std::fmt::{self, Debug, Formatter};use std::hash::{Hash, Hasher};use std::sync::Arc;-use crate::expressions::Literal;use crate::PhysicalExpr;+use crate::expressions::Literal;use arrow::array::{Array, RecordBatch};use arrow::datatypes::{DataType, FieldRef, Schema};use datafusion_common::config::{ConfigEntry, ConfigOptions};-use datafusion_common::{internal_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, internal_err};use datafusion_expr::interval_arithmetic::Interval;use datafusion_expr::sort_properties::ExprProperties;use datafusion_expr::type_coercion::functions::data_types_with_scalar_udf;use datafusion_expr::{- expr_vec_fmt, ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDF,- Volatility,+ ColumnarValue, ReturnFieldArgs, ScalarFunctionArgs, ScalarUDF, Volatility,+ expr_vec_fmt,};/// Physical expression of a scalar function@@ -283,19 +283,22 @@ impl PhysicalExpr for ScalarFunctionExpr {config_options: Arc::clone(&self.config_options),})?;- if let ColumnarValue::Array(array) = &output {- if array.len() != batch.num_rows() {- // If the arguments are a non-empty slice of scalar values, we can assume that- // returning a one-element array is equivalent to returning a scalar.- let preserve_scalar =- array.len() == 1 && !input_empty && input_all_scalar;- return if preserve_scalar {- ScalarValue::try_from_array(array, 0).map(ColumnarValue::Scalar)- } else {- internal_err!("UDF {} returned a different number of rows than expected. Expected: {}, Got: {}",- self.name, batch.num_rows(), array.len())- };- }+ if let ColumnarValue::Array(array) = &output+ && array.len() != batch.num_rows()+ {+ // If the arguments are a non-empty slice of scalar values, we can assume that+ // returning a one-element array is equivalent to returning a scalar.+ let preserve_scalar = array.len() == 1 && !input_empty && input_all_scalar;+ return if preserve_scalar {+ ScalarValue::try_from_array(array, 0).map(ColumnarValue::Scalar)+ } else {+ internal_err!(+ "UDF {} returned a different number of rows than expected. Expected: {}, Got: {}",+ self.name,+ batch.num_rows(),+ array.len()+ )+ };}Ok(output)}diff --git a/datafusion/physical-expr/src/simplifier/mod.rs b/datafusion/physical-expr/src/simplifier/mod.rsindex 437632656c..bb7ec4d1e0 100644--- a/datafusion/physical-expr/src/simplifier/mod.rs+++ b/datafusion/physical-expr/src/simplifier/mod.rs@@ -19,12 +19,12 @@use arrow::datatypes::Schema;use datafusion_common::{- tree_node::{Transformed, TreeNode, TreeNodeRewriter},Result,+ tree_node::{Transformed, TreeNode, TreeNodeRewriter},};use std::sync::Arc;-use crate::{simplifier::not::simplify_not_expr, PhysicalExpr};+use crate::{PhysicalExpr, simplifier::not::simplify_not_expr};pub mod const_evaluator;pub mod not;@@ -96,7 +96,7 @@ impl<'a> TreeNodeRewriter for PhysicalExprSimplifier<'a> {mod tests {use super::*;use crate::expressions::{- col, in_list, lit, BinaryExpr, CastExpr, Literal, NotExpr, TryCastExpr,+ BinaryExpr, CastExpr, Literal, NotExpr, TryCastExpr, col, in_list, lit,};use arrow::datatypes::{DataType, Field, Schema};use datafusion_common::ScalarValue;@@ -140,8 +140,7 @@ mod tests {) {let result = simplifier.simplify(Arc::clone(&input)).unwrap();assert_eq!(- &result,- &expected,+ &result, &expected,"Simplification should transform:\n input: {input}\n to: {expected}\n got: {result}");}diff --git a/datafusion/physical-expr/src/simplifier/not.rs b/datafusion/physical-expr/src/simplifier/not.rsindex 1ea969f58f..9b65d5cba9 100644--- a/datafusion/physical-expr/src/simplifier/not.rs+++ b/datafusion/physical-expr/src/simplifier/not.rs@@ -32,11 +32,11 @@use std::sync::Arc;use arrow::datatypes::Schema;-use datafusion_common::{tree_node::Transformed, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, tree_node::Transformed};use datafusion_expr::Operator;-use crate::expressions::{in_list, lit, BinaryExpr, InListExpr, Literal, NotExpr};use crate::PhysicalExpr;+use crate::expressions::{BinaryExpr, InListExpr, Literal, NotExpr, in_list, lit};/// Attempts to simplify NOT expressions by applying one level of transformation///diff --git a/datafusion/physical-expr/src/simplifier/unwrap_cast.rs b/datafusion/physical-expr/src/simplifier/unwrap_cast.rsindex d409ce9cb5..ae6da9c5e0 100644--- a/datafusion/physical-expr/src/simplifier/unwrap_cast.rs+++ b/datafusion/physical-expr/src/simplifier/unwrap_cast.rs@@ -35,14 +35,14 @@ use std::sync::Arc;use arrow::datatypes::{DataType, Schema};use datafusion_common::{- tree_node::{Transformed, TreeNode},Result, ScalarValue,+ tree_node::{Transformed, TreeNode},};use datafusion_expr::Operator;use datafusion_expr_common::casts::try_cast_literal_to_type;-use crate::expressions::{lit, BinaryExpr, CastExpr, Literal, TryCastExpr};use crate::PhysicalExpr;+use crate::expressions::{BinaryExpr, CastExpr, Literal, TryCastExpr, lit};/// Attempts to unwrap casts in comparison expressions.pub(crate) fn unwrap_cast_in_comparison(@@ -50,10 +50,10 @@ pub(crate) fn unwrap_cast_in_comparison(schema: &Schema,) -> Result<Transformed<Arc<dyn PhysicalExpr>>> {expr.transform_down(|e| {- if let Some(binary) = e.as_any().downcast_ref::<BinaryExpr>() {- if let Some(unwrapped) = try_unwrap_cast_binary(binary, schema)? {- return Ok(Transformed::yes(unwrapped));- }+ if let Some(binary) = e.as_any().downcast_ref::<BinaryExpr>()+ && let Some(unwrapped) = try_unwrap_cast_binary(binary, schema)?+ {+ return Ok(Transformed::yes(unwrapped));}Ok(Transformed::no(e))})@@ -68,17 +68,15 @@ fn try_unwrap_cast_binary(if let (Some((inner_expr, _cast_type)), Some(literal)) = (extract_cast_info(binary.left()),binary.right().as_any().downcast_ref::<Literal>(),- ) {- if binary.op().supports_propagation() {- if let Some(unwrapped) = try_unwrap_cast_comparison(- Arc::clone(inner_expr),- literal.value(),- *binary.op(),- schema,- )? {- return Ok(Some(unwrapped));- }- }+ ) && binary.op().supports_propagation()+ && let Some(unwrapped) = try_unwrap_cast_comparison(+ Arc::clone(inner_expr),+ literal.value(),+ *binary.op(),+ schema,+ )?+ {+ return Ok(Some(unwrapped));}// Case 2: literal op cast(right_expr)@@ -87,17 +85,16 @@ fn try_unwrap_cast_binary(extract_cast_info(binary.right()),) {// For literal op cast(expr), we need to swap the operator- if let Some(swapped_op) = binary.op().swap() {- if binary.op().supports_propagation() {- if let Some(unwrapped) = try_unwrap_cast_comparison(- Arc::clone(inner_expr),- literal.value(),- swapped_op,- schema,- )? {- return Ok(Some(unwrapped));- }- }+ if let Some(swapped_op) = binary.op().swap()+ && binary.op().supports_propagation()+ && let Some(unwrapped) = try_unwrap_cast_comparison(+ Arc::clone(inner_expr),+ literal.value(),+ swapped_op,+ schema,+ )?+ {+ return Ok(Some(unwrapped));}// If the operator cannot be swapped, we skip this optimization case// but don't prevent other optimizationsdiff --git a/datafusion/physical-expr/src/statistics/stats_solver.rs b/datafusion/physical-expr/src/statistics/stats_solver.rsindex fae6996646..5665f7d1be 100644--- a/datafusion/physical-expr/src/statistics/stats_solver.rs+++ b/datafusion/physical-expr/src/statistics/stats_solver.rs@@ -20,18 +20,18 @@ use std::sync::Arc;use crate::expressions::Literal;use crate::intervals::cp_solver::PropagationResult;use crate::physical_expr::PhysicalExpr;-use crate::utils::{build_dag, ExprTreeNode};+use crate::utils::{ExprTreeNode, build_dag};use arrow::datatypes::{DataType, Schema};use datafusion_common::{Result, ScalarValue};use datafusion_expr::statistics::Distribution;use datafusion_expr_common::interval_arithmetic::Interval;+use petgraph::Outgoing;use petgraph::adj::DefaultIx;use petgraph::prelude::Bfs;use petgraph::stable_graph::{NodeIndex, StableGraph};use petgraph::visit::DfsPostOrder;-use petgraph::Outgoing;/// This object implements a directed acyclic expression graph (DAEG) that/// is used to compute statistics/distributions for expressions hierarchically.@@ -205,7 +205,7 @@ impl ExprStatisticsGraph {mod tests {use std::sync::Arc;- use crate::expressions::{binary, try_cast, Column};+ use crate::expressions::{Column, binary, try_cast};use crate::intervals::cp_solver::PropagationResult;use crate::statistics::stats_solver::ExprStatisticsGraph;diff --git a/datafusion/physical-expr/src/utils/guarantee.rs b/datafusion/physical-expr/src/utils/guarantee.rsindex d63a9590c3..c4ce74fd3a 100644--- a/datafusion/physical-expr/src/utils/guarantee.rs+++ b/datafusion/physical-expr/src/utils/guarantee.rs@@ -19,7 +19,7 @@//! constant.use crate::utils::split_disjunction;-use crate::{split_conjunction, PhysicalExpr};+use crate::{PhysicalExpr, split_conjunction};use datafusion_common::{Column, HashMap, ScalarValue};use datafusion_expr::Operator;use std::collections::HashSet;@@ -550,7 +550,7 @@ mod test {use arrow::datatypes::{DataType, Field, Schema, SchemaRef};use datafusion_expr::expr_fn::*;- use datafusion_expr::{lit, Expr};+ use datafusion_expr::{Expr, lit};use itertools::Itertools;diff --git a/datafusion/physical-expr/src/utils/mod.rs b/datafusion/physical-expr/src/utils/mod.rsindex 745ae855ef..cd476ee3b3 100644--- a/datafusion/physical-expr/src/utils/mod.rs+++ b/datafusion/physical-expr/src/utils/mod.rs@@ -21,10 +21,10 @@ pub use guarantee::{Guarantee, LiteralGuarantee};use std::borrow::Borrow;use std::sync::Arc;-use crate::expressions::{BinaryExpr, Column};-use crate::tree_node::ExprContext;use crate::PhysicalExpr;use crate::PhysicalSortExpr;+use crate::expressions::{BinaryExpr, Column};+use crate::tree_node::ExprContext;use arrow::datatypes::Schema;use datafusion_common::tree_node::{@@ -271,11 +271,11 @@ pub(crate) mod tests {use std::fmt::{Display, Formatter};use super::*;- use crate::expressions::{binary, cast, col, in_list, lit, Literal};+ use crate::expressions::{Literal, binary, cast, col, in_list, lit};use arrow::array::{ArrayRef, Float32Array, Float64Array};use arrow::datatypes::{DataType, Field, Schema};- use datafusion_common::{exec_err, internal_datafusion_err, ScalarValue};+ use datafusion_common::{ScalarValue, exec_err, internal_datafusion_err};use datafusion_expr::sort_properties::{ExprProperties, SortProperties};use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,diff --git a/datafusion/physical-expr/src/window/aggregate.rs b/datafusion/physical-expr/src/window/aggregate.rsindex 2ed9770902..1ff13d107c 100644--- a/datafusion/physical-expr/src/window/aggregate.rs+++ b/datafusion/physical-expr/src/window/aggregate.rs@@ -23,7 +23,7 @@ use std::sync::Arc;use crate::aggregate::AggregateFunctionExpr;use crate::window::standard::add_new_ordering_expr_with_partition_by;-use crate::window::window_expr::{filter_array, AggregateWindowExpr, WindowFn};+use crate::window::window_expr::{AggregateWindowExpr, WindowFn, filter_array};use crate::window::{PartitionBatches, PartitionWindowAggStates, SlidingAggregateWindowExpr, WindowExpr,};@@ -33,7 +33,7 @@ use arrow::array::ArrayRef;use arrow::array::BooleanArray;use arrow::datatypes::FieldRef;use arrow::record_batch::RecordBatch;-use datafusion_common::{exec_datafusion_err, Result, ScalarValue};+use datafusion_common::{Result, ScalarValue, exec_datafusion_err};use datafusion_expr::{Accumulator, WindowFrame, WindowFrameBound, WindowFrameUnits};use datafusion_physical_expr_common::sort_expr::PhysicalSortExpr;diff --git a/datafusion/physical-expr/src/window/sliding_aggregate.rs b/datafusion/physical-expr/src/window/sliding_aggregate.rsindex f93b13fef4..a71df3ec88 100644--- a/datafusion/physical-expr/src/window/sliding_aggregate.rs+++ b/datafusion/physical-expr/src/window/sliding_aggregate.rs@@ -22,11 +22,11 @@ use std::ops::Range;use std::sync::Arc;use crate::aggregate::AggregateFunctionExpr;-use crate::window::window_expr::{filter_array, AggregateWindowExpr, WindowFn};+use crate::window::window_expr::{AggregateWindowExpr, WindowFn, filter_array};use crate::window::{PartitionBatches, PartitionWindowAggStates, PlainAggregateWindowExpr, WindowExpr,};-use crate::{expressions::PhysicalSortExpr, PhysicalExpr};+use crate::{PhysicalExpr, expressions::PhysicalSortExpr};use arrow::array::{ArrayRef, BooleanArray};use arrow::datatypes::FieldRef;diff --git a/datafusion/physical-expr/src/window/standard.rs b/datafusion/physical-expr/src/window/standard.rsindex e9e7f6abf6..f8d92d5de4 100644--- a/datafusion/physical-expr/src/window/standard.rs+++ b/datafusion/physical-expr/src/window/standard.rs@@ -22,17 +22,17 @@ use std::ops::Range;use std::sync::Arc;use super::{StandardWindowFunctionExpr, WindowExpr};-use crate::window::window_expr::{get_orderby_values, WindowFn};+use crate::window::window_expr::{WindowFn, get_orderby_values};use crate::window::{PartitionBatches, PartitionWindowAggStates, WindowState};use crate::{EquivalenceProperties, PhysicalExpr};-use arrow::array::{new_empty_array, ArrayRef};+use arrow::array::{ArrayRef, new_empty_array};use arrow::datatypes::FieldRef;use arrow::record_batch::RecordBatch;use datafusion_common::utils::evaluate_partition_ranges;use datafusion_common::{Result, ScalarValue};-use datafusion_expr::window_state::{WindowAggState, WindowFrameContext};use datafusion_expr::WindowFrame;+use datafusion_expr::window_state::{WindowAggState, WindowFrameContext};use datafusion_physical_expr_common::sort_expr::PhysicalSortExpr;/// A window expr that takes the form of a [`StandardWindowFunctionExpr`].diff --git a/datafusion/physical-expr/src/window/window_expr.rs b/datafusion/physical-expr/src/window/window_expr.rsindex 8f6f61a2da..0f0ec647a5 100644--- a/datafusion/physical-expr/src/window/window_expr.rs+++ b/datafusion/physical-expr/src/window/window_expr.rs@@ -23,16 +23,16 @@ use std::sync::Arc;use crate::PhysicalExpr;use arrow::array::BooleanArray;-use arrow::array::{new_empty_array, Array, ArrayRef};+use arrow::array::{Array, ArrayRef, new_empty_array};+use arrow::compute::SortOptions;use arrow::compute::filter as arrow_filter;use arrow::compute::kernels::sort::SortColumn;-use arrow::compute::SortOptions;use arrow::datatypes::FieldRef;use arrow::record_batch::RecordBatch;use datafusion_common::cast::as_boolean_array;use datafusion_common::utils::compare_rows;use datafusion_common::{- arrow_datafusion_err, exec_datafusion_err, internal_err, Result, ScalarValue,+ Result, ScalarValue, arrow_datafusion_err, exec_datafusion_err, internal_err,};use datafusion_expr::window_state::{PartitionBatchState, WindowAggState, WindowFrameContext, WindowFrameStateGroups,