Skip to content

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.toml
index 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 DataFusion
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-aggregate/benches/array_agg.rs b/datafusion/functions-aggregate/benches/array_agg.rs
index 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 RNG
pub fn seedable_rng() -> StdRng {
diff --git a/datafusion/functions-aggregate/benches/count.rs b/datafusion/functions-aggregate/benches/count.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 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 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.toml
index 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.rs
index 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 implementation
use 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 with
diff --git a/datafusion/functions/benches/initcap.rs b/datafusion/functions/benches/initcap.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 signature
debug_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.rs
index 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 array
diff --git a/datafusion/functions/src/core/greatest_least_utils.rs b/datafusion/functions/src/core/greatest_least_utils.rs
index 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.rs
index 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 array
diff --git a/datafusion/functions/src/core/named_struct.rs b/datafusion/functions/src/core/named_struct.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 @@ where
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}"
+ );
+ }
},
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),
) = v
else {
- 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.rs
index 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.rs
index 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 nanoseconds
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 string
None => {
- 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 string
None => {
- 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<ExprSimplifyRes
for 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 given
diff --git a/datafusion/physical-expr-adapter/Cargo.toml b/datafusion/physical-expr-adapter/Cargo.toml
index 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.rs
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 function
pub 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.rs
index 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 tests
TestCase {
@@ -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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 correct
assert_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 expression
let 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 expression
let 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 expression
let 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.rs
index 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 kernel
macro_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 building
pub 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.rs
index 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()
+ );
// Exponential
assert_eq!(
diff --git a/datafusion/physical-expr/src/expressions/no_op.rs b/datafusion/physical-expr/src/expressions/no_op.rs
index 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.rs
index 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()
+ );
// Bernoulli
assert_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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(c1
diff --git a/datafusion/physical-expr/src/projection.rs b/datafusion/physical-expr/src/projection.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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 optimizations
diff --git a/datafusion/physical-expr/src/statistics/stats_solver.rs b/datafusion/physical-expr/src/statistics/stats_solver.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,