From 4edbdd7d09d97f361748c086afbd7b3dda972f76 Mon Sep 17 00:00:00 2001 From: Ruihang Xia Date: Wed, 24 Apr 2024 14:32:36 +0800 Subject: [PATCH] fix: cargo warnings of import item (#10196) * fix: cargo warnings of import item Signed-off-by: Ruihang Xia * deny unused imports Signed-off-by: Ruihang Xia * allow util macro re-export Signed-off-by: Ruihang Xia * lift windows target feature gate to mod level Signed-off-by: Ruihang Xia --------- Signed-off-by: Ruihang Xia --- .github/workflows/rust.yml | 2 +- Cargo.toml | 3 ++ .../examples/custom_datasource.rs | 3 +- .../examples/flight/flight_client.rs | 1 - datafusion-examples/examples/simple_udaf.rs | 1 - datafusion-examples/examples/simple_udwf.rs | 1 - datafusion/common/src/column.rs | 2 +- datafusion/common/src/dfschema.rs | 4 +- datafusion/common/src/hash_utils.rs | 2 - datafusion/common/src/scalar/mod.rs | 7 +--- datafusion/common/src/utils.rs | 4 -- datafusion/core/benches/physical_plan.rs | 2 +- datafusion/core/src/dataframe/mod.rs | 8 ++-- .../core/src/datasource/file_format/avro.rs | 2 +- .../core/src/datasource/file_format/csv.rs | 6 +-- .../src/datasource/file_format/parquet.rs | 8 ---- .../core/src/datasource/listing/helpers.rs | 2 - .../core/src/datasource/listing/table.rs | 5 --- datafusion/core/src/datasource/memory.rs | 3 -- .../core/src/datasource/physical_plan/csv.rs | 1 - .../datasource/physical_plan/file_stream.rs | 8 +--- .../core/src/datasource/physical_plan/json.rs | 4 +- .../datasource/physical_plan/parquet/mod.rs | 6 +-- .../physical_plan/parquet/row_groups.rs | 4 +- datafusion/core/src/execution/context/mod.rs | 5 --- .../aggregate_statistics.rs | 4 +- .../combine_partial_final_agg.rs | 4 -- .../enforce_distribution.rs | 16 ++------ .../src/physical_optimizer/enforce_sorting.rs | 2 - .../src/physical_optimizer/join_selection.rs | 20 +++------ .../limited_distinct_aggregation.rs | 4 +- .../physical_optimizer/projection_pushdown.rs | 41 ++++--------------- .../core/src/physical_optimizer/pruning.rs | 7 ++-- .../replace_with_order_preserving_variants.rs | 3 -- datafusion/core/src/physical_planner.rs | 15 +++---- .../provider_filter_pushdown.rs | 4 +- .../tests/dataframe/dataframe_functions.rs | 7 +--- .../core/tests/parquet/filter_pushdown.rs | 2 - datafusion/core/tests/parquet/mod.rs | 1 + datafusion/core/tests/parquet/schema.rs | 1 - datafusion/core/tests/simplification.rs | 2 +- datafusion/core/tests/sql/select.rs | 1 - .../user_defined_scalar_functions.rs | 4 +- datafusion/execution/src/disk_manager.rs | 3 -- datafusion/expr/src/expr.rs | 10 +---- datafusion/expr/src/expr_rewriter/mod.rs | 3 +- datafusion/expr/src/expr_schema.rs | 4 +- datafusion/expr/src/literal.rs | 1 - datafusion/expr/src/logical_plan/builder.rs | 4 +- datafusion/expr/src/logical_plan/extension.rs | 2 +- datafusion/expr/src/logical_plan/plan.rs | 6 +-- .../expr/src/type_coercion/aggregates.rs | 2 - datafusion/expr/src/type_coercion/binary.rs | 4 +- .../expr/src/type_coercion/functions.rs | 3 +- datafusion/expr/src/window_frame.rs | 1 - datafusion/expr/src/window_state.rs | 7 +--- datafusion/functions-array/src/utils.rs | 3 +- datafusion/functions/src/core/nullif.rs | 1 - datafusion/functions/src/core/nvl.rs | 2 +- .../functions/src/string/levenshtein.rs | 2 +- datafusion/functions/src/string/to_hex.rs | 5 +-- datafusion/functions/src/utils.rs | 1 + .../src/analyzer/count_wildcard_rule.rs | 8 ++-- .../optimizer/src/common_subexpr_eliminate.rs | 7 +--- .../src/decorrelate_predicate_subquery.rs | 7 +--- .../optimizer/src/eliminate_one_union.rs | 3 +- .../optimizer/src/filter_null_join_keys.rs | 4 +- datafusion/optimizer/src/plan_signature.rs | 2 +- .../optimizer/src/propagate_empty_relation.rs | 3 +- datafusion/optimizer/src/push_down_filter.rs | 6 +-- datafusion/optimizer/src/push_down_limit.rs | 6 +-- .../optimizer/src/scalar_subquery_to_join.rs | 2 - .../simplify_expressions/expr_simplifier.rs | 3 -- .../src/simplify_expressions/guarantees.rs | 2 +- .../src/single_distinct_to_groupby.rs | 4 +- .../src/unwrap_cast_in_comparison.rs | 9 ++-- .../src/aggregate/approx_distinct.rs | 2 - .../physical-expr/src/aggregate/array_agg.rs | 3 -- .../src/aggregate/array_agg_distinct.rs | 4 +- .../src/aggregate/bit_and_or_xor.rs | 2 - .../src/aggregate/bool_and_or.rs | 2 - .../src/aggregate/correlation.rs | 2 - .../physical-expr/src/aggregate/count.rs | 2 - .../src/aggregate/count_distinct/mod.rs | 9 +--- .../src/aggregate/count_distinct/native.rs | 1 - .../physical-expr/src/aggregate/covariance.rs | 2 - .../groups_accumulator/accumulate.rs | 1 - .../physical-expr/src/aggregate/median.rs | 1 - .../physical-expr/src/aggregate/min_max.rs | 3 -- .../physical-expr/src/aggregate/stddev.rs | 2 - .../physical-expr/src/aggregate/string_agg.rs | 1 - .../src/aggregate/sum_distinct.rs | 3 +- .../physical-expr/src/aggregate/variance.rs | 2 - datafusion/physical-expr/src/binary_map.rs | 1 - .../physical-expr/src/equivalence/class.rs | 4 +- .../physical-expr/src/equivalence/mod.rs | 3 +- .../src/equivalence/projection.rs | 3 +- .../src/equivalence/properties.rs | 7 +--- .../physical-expr/src/expressions/binary.rs | 6 +-- .../physical-expr/src/expressions/case.rs | 4 +- .../physical-expr/src/expressions/cast.rs | 2 - .../physical-expr/src/expressions/in_list.rs | 3 -- .../src/expressions/is_not_null.rs | 2 - .../physical-expr/src/expressions/is_null.rs | 2 - .../physical-expr/src/expressions/literal.rs | 1 - .../physical-expr/src/expressions/negative.rs | 1 - .../physical-expr/src/expressions/not.rs | 1 - .../physical-expr/src/expressions/try_cast.rs | 1 - datafusion/physical-expr/src/functions.rs | 5 +-- .../physical-expr/src/intervals/cp_solver.rs | 2 +- .../physical-expr/src/math_expressions.rs | 1 - datafusion/physical-expr/src/partitioning.rs | 1 - datafusion/physical-expr/src/planner.rs | 3 +- datafusion/physical-expr/src/utils/mod.rs | 6 +-- .../physical-expr/src/window/lead_lag.rs | 2 - .../physical-expr/src/window/nth_value.rs | 2 - .../physical-expr/src/window/row_number.rs | 3 +- .../physical-plan/src/aggregates/mod.rs | 18 ++------ .../physical-plan/src/aggregates/row_hash.rs | 2 +- .../src/aggregates/topk/hash_table.rs | 1 - .../physical-plan/src/aggregates/topk/heap.rs | 1 - .../src/aggregates/topk/priority_map.rs | 3 +- datafusion/physical-plan/src/common.rs | 5 +-- datafusion/physical-plan/src/empty.rs | 2 +- datafusion/physical-plan/src/filter.rs | 8 +--- .../physical-plan/src/joins/hash_join.rs | 12 +++--- .../src/joins/nested_loop_join.rs | 3 +- .../src/joins/sort_merge_join.rs | 1 - .../src/joins/stream_join_utils.rs | 14 +------ .../src/joins/symmetric_hash_join.rs | 2 +- .../physical-plan/src/placeholder_row.rs | 2 +- .../physical-plan/src/repartition/mod.rs | 4 +- .../src/sorts/sort_preserving_merge.rs | 1 - datafusion/physical-plan/src/union.rs | 1 - datafusion/physical-plan/src/unnest.rs | 2 +- datafusion/physical-plan/src/values.rs | 2 +- datafusion/physical-plan/src/windows/mod.rs | 2 - datafusion/physical-plan/src/work_table.rs | 3 +- .../proto/src/physical_plan/from_proto.rs | 1 - datafusion/proto/src/physical_plan/mod.rs | 1 - .../proto/src/physical_plan/to_proto.rs | 5 +-- .../tests/cases/roundtrip_logical_plan.rs | 8 ++-- datafusion/sql/src/expr/mod.rs | 2 +- 143 files changed, 140 insertions(+), 436 deletions(-) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index f27b5d12f47f..ce4b4b06cf44 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -77,7 +77,7 @@ jobs: run: cargo check --all-targets --no-default-features -p datafusion-functions - name: Check workspace in debug mode - run: cargo check + run: cargo check --all-targets --workspace - name: Check workspace with avro,json features run: cargo check --workspace --benches --features avro,json diff --git a/Cargo.toml b/Cargo.toml index 2941be20e85d..3ca3af284675 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -130,3 +130,6 @@ rpath = false [workspace.lints.clippy] # Detects large stack-allocated futures that may cause stack overflow crashes (see threshold in clippy.toml) large_futures = "warn" + +[workspace.lints.rust] +unused_imports = "deny" diff --git a/datafusion-examples/examples/custom_datasource.rs b/datafusion-examples/examples/custom_datasource.rs index ba0d2f3b30f8..c2ea6f2b52a1 100644 --- a/datafusion-examples/examples/custom_datasource.rs +++ b/datafusion-examples/examples/custom_datasource.rs @@ -24,7 +24,6 @@ use std::time::Duration; use datafusion::arrow::array::{UInt64Builder, UInt8Builder}; use datafusion::arrow::datatypes::{DataType, Field, Schema, SchemaRef}; use datafusion::arrow::record_batch::RecordBatch; -use datafusion::dataframe::DataFrame; use datafusion::datasource::{provider_as_source, TableProvider, TableType}; use datafusion::error::Result; use datafusion::execution::context::{SessionState, TaskContext}; @@ -34,7 +33,7 @@ use datafusion::physical_plan::{ Partitioning, PlanProperties, SendableRecordBatchStream, }; use datafusion::prelude::*; -use datafusion_expr::{Expr, LogicalPlanBuilder}; +use datafusion_expr::LogicalPlanBuilder; use datafusion_physical_expr::EquivalenceProperties; use async_trait::async_trait; diff --git a/datafusion-examples/examples/flight/flight_client.rs b/datafusion-examples/examples/flight/flight_client.rs index fe87740d9b8f..e3237284b430 100644 --- a/datafusion-examples/examples/flight/flight_client.rs +++ b/datafusion-examples/examples/flight/flight_client.rs @@ -16,7 +16,6 @@ // under the License. use std::collections::HashMap; -use std::convert::TryFrom; use std::sync::Arc; use datafusion::arrow::datatypes::Schema; diff --git a/datafusion-examples/examples/simple_udaf.rs b/datafusion-examples/examples/simple_udaf.rs index 0996a67245a8..140fc0d3572d 100644 --- a/datafusion-examples/examples/simple_udaf.rs +++ b/datafusion-examples/examples/simple_udaf.rs @@ -23,7 +23,6 @@ use datafusion::arrow::{ use datafusion::{error::Result, physical_plan::Accumulator}; use datafusion::{logical_expr::Volatility, prelude::*, scalar::ScalarValue}; use datafusion_common::cast::as_float64_array; -use datafusion_expr::create_udaf; use std::sync::Arc; // create local session context with an in-memory table diff --git a/datafusion-examples/examples/simple_udwf.rs b/datafusion-examples/examples/simple_udwf.rs index 5555e873aeb7..95339eff1cae 100644 --- a/datafusion-examples/examples/simple_udwf.rs +++ b/datafusion-examples/examples/simple_udwf.rs @@ -22,7 +22,6 @@ use arrow::{ datatypes::Float64Type, }; use arrow_schema::DataType; -use datafusion::datasource::file_format::options::CsvReadOptions; use datafusion::error::Result; use datafusion::prelude::*; diff --git a/datafusion/common/src/column.rs b/datafusion/common/src/column.rs index ae3146516349..911ff079def1 100644 --- a/datafusion/common/src/column.rs +++ b/datafusion/common/src/column.rs @@ -373,7 +373,7 @@ impl fmt::Display for Column { mod tests { use super::*; use arrow::datatypes::DataType; - use arrow_schema::{Field, SchemaBuilder}; + use arrow_schema::SchemaBuilder; fn create_qualified_schema(qualifier: &str, names: Vec<&str>) -> Result { let mut schema_builder = SchemaBuilder::new(); diff --git a/datafusion/common/src/dfschema.rs b/datafusion/common/src/dfschema.rs index 83e53b3cc6ff..f1909f0dc8e1 100644 --- a/datafusion/common/src/dfschema.rs +++ b/datafusion/common/src/dfschema.rs @@ -19,7 +19,6 @@ //! fields with optional relation names. use std::collections::{BTreeSet, HashMap, HashSet}; -use std::convert::TryFrom; use std::fmt::{Display, Formatter}; use std::hash::Hash; use std::sync::Arc; @@ -453,7 +452,7 @@ impl DFSchema { let matches = self.qualified_fields_with_unqualified_name(name); match matches.len() { 0 => Err(unqualified_field_not_found(name, self)), - 1 => Ok((matches[0].0, &matches[0].1)), + 1 => Ok((matches[0].0, (matches[0].1))), _ => { // When `matches` size > 1, it doesn't necessarily mean an `ambiguous name` problem. // Because name may generate from Alias/... . It means that it don't own qualifier. @@ -1004,7 +1003,6 @@ mod tests { use crate::assert_contains; use super::*; - use arrow::datatypes::DataType; #[test] fn qualifier_in_name() -> Result<()> { diff --git a/datafusion/common/src/hash_utils.rs b/datafusion/common/src/hash_utils.rs index d1a7a675cb45..9819fc7b344d 100644 --- a/datafusion/common/src/hash_utils.rs +++ b/datafusion/common/src/hash_utils.rs @@ -24,7 +24,6 @@ use arrow::array::*; use arrow::datatypes::*; use arrow::row::Rows; use arrow::{downcast_dictionary_array, downcast_primitive_array}; -use arrow_buffer::i256; use crate::cast::{ as_boolean_array, as_fixed_size_list_array, as_generic_binary_array, @@ -450,7 +449,6 @@ pub fn create_row_hashes_v2<'a>( #[cfg(test)] mod tests { use arrow::{array::*, datatypes::*}; - use std::sync::Arc; use super::*; diff --git a/datafusion/common/src/scalar/mod.rs b/datafusion/common/src/scalar/mod.rs index 365898abc3d7..e71d82fb3beb 100644 --- a/datafusion/common/src/scalar/mod.rs +++ b/datafusion/common/src/scalar/mod.rs @@ -22,7 +22,7 @@ mod struct_builder; use std::borrow::Borrow; use std::cmp::Ordering; use std::collections::{HashSet, VecDeque}; -use std::convert::{Infallible, TryFrom, TryInto}; +use std::convert::Infallible; use std::fmt; use std::hash::Hash; use std::iter::repeat; @@ -52,7 +52,6 @@ use arrow::{ UInt16Type, UInt32Type, UInt64Type, UInt8Type, DECIMAL128_MAX_PRECISION, }, }; -use arrow_array::{ArrowNativeTypeOp, Scalar}; use arrow_buffer::Buffer; use arrow_schema::{UnionFields, UnionMode}; @@ -3424,8 +3423,6 @@ impl ScalarType for Date32Type { #[cfg(test)] mod tests { - use std::cmp::Ordering; - use std::sync::Arc; use super::*; use crate::cast::{ @@ -3435,9 +3432,7 @@ mod tests { use crate::assert_batches_eq; use arrow::buffer::OffsetBuffer; use arrow::compute::{is_null, kernels}; - use arrow::datatypes::{ArrowNumericType, ArrowPrimitiveType}; use arrow::util::pretty::pretty_format_columns; - use arrow_buffer::Buffer; use arrow_schema::Fields; use chrono::NaiveDate; use rand::Rng; diff --git a/datafusion/common/src/utils.rs b/datafusion/common/src/utils.rs index 3296e68d17da..102e4d73083e 100644 --- a/datafusion/common/src/utils.rs +++ b/datafusion/common/src/utils.rs @@ -681,12 +681,8 @@ pub fn find_indices>( #[cfg(test)] mod tests { - use crate::ScalarValue; use crate::ScalarValue::Null; use arrow::array::Float64Array; - use arrow_array::Array; - use std::ops::Range; - use std::sync::Arc; use super::*; diff --git a/datafusion/core/benches/physical_plan.rs b/datafusion/core/benches/physical_plan.rs index 59fb726a3c13..3ad71be1f447 100644 --- a/datafusion/core/benches/physical_plan.rs +++ b/datafusion/core/benches/physical_plan.rs @@ -21,7 +21,7 @@ use criterion::{BatchSize, Criterion}; extern crate arrow; extern crate datafusion; -use std::{iter::FromIterator, sync::Arc}; +use std::sync::Arc; use arrow::{ array::{ArrayRef, Int64Array, StringArray}, diff --git a/datafusion/core/src/dataframe/mod.rs b/datafusion/core/src/dataframe/mod.rs index bd561e89832e..f877b7d698b4 100644 --- a/datafusion/core/src/dataframe/mod.rs +++ b/datafusion/core/src/dataframe/mod.rs @@ -1570,19 +1570,17 @@ mod tests { use std::vec; use super::*; + use crate::assert_batches_sorted_eq; use crate::execution::context::SessionConfig; use crate::physical_plan::{ColumnarValue, Partitioning, PhysicalExpr}; use crate::test_util::{register_aggregate_csv, test_table, test_table_with_name}; - use crate::{assert_batches_sorted_eq, execution::context::SessionContext}; use arrow::array::{self, Int32Array}; - use arrow::datatypes::DataType; use datafusion_common::{Constraint, Constraints}; use datafusion_common_runtime::SpawnedTask; use datafusion_expr::{ - avg, cast, count, count_distinct, create_udf, expr, lit, max, min, sum, - BuiltInWindowFunction, ScalarFunctionImplementation, Volatility, WindowFrame, - WindowFunctionDefinition, + cast, count_distinct, create_udf, expr, lit, sum, BuiltInWindowFunction, + ScalarFunctionImplementation, Volatility, WindowFrame, WindowFunctionDefinition, }; use datafusion_physical_expr::expressions::Column; use datafusion_physical_plan::{get_plan_string, ExecutionPlanProperties}; diff --git a/datafusion/core/src/datasource/file_format/avro.rs b/datafusion/core/src/datasource/file_format/avro.rs index 6d424bf0b28f..132dae14c684 100644 --- a/datafusion/core/src/datasource/file_format/avro.rs +++ b/datafusion/core/src/datasource/file_format/avro.rs @@ -21,7 +21,7 @@ use std::any::Any; use std::sync::Arc; use arrow::datatypes::Schema; -use arrow::{self, datatypes::SchemaRef}; +use arrow::datatypes::SchemaRef; use async_trait::async_trait; use datafusion_common::FileType; use datafusion_physical_expr::PhysicalExpr; diff --git a/datafusion/core/src/datasource/file_format/csv.rs b/datafusion/core/src/datasource/file_format/csv.rs index 84235cde0f5d..645f98cd3fb0 100644 --- a/datafusion/core/src/datasource/file_format/csv.rs +++ b/datafusion/core/src/datasource/file_format/csv.rs @@ -37,8 +37,8 @@ use crate::physical_plan::{ExecutionPlan, SendableRecordBatchStream}; use arrow::array::RecordBatch; use arrow::csv::WriterBuilder; +use arrow::datatypes::SchemaRef; use arrow::datatypes::{DataType, Field, Fields, Schema}; -use arrow::{self, datatypes::SchemaRef}; use datafusion_common::config::CsvOptions; use datafusion_common::file_options::csv_writer::CsvWriterOptions; use datafusion_common::{exec_err, not_impl_err, DataFusionError, FileType}; @@ -537,12 +537,10 @@ mod tests { use arrow::compute::concat_batches; use datafusion_common::cast::as_string_array; use datafusion_common::stats::Precision; - use datafusion_common::{internal_err, FileType, GetExt}; + use datafusion_common::{internal_err, GetExt}; use datafusion_expr::{col, lit}; - use bytes::Bytes; use chrono::DateTime; - use futures::StreamExt; use object_store::local::LocalFileSystem; use object_store::path::Path; use regex::Regex; diff --git a/datafusion/core/src/datasource/file_format/parquet.rs b/datafusion/core/src/datasource/file_format/parquet.rs index 731f25b5dbb1..66f506f9aa2e 100644 --- a/datafusion/core/src/datasource/file_format/parquet.rs +++ b/datafusion/core/src/datasource/file_format/parquet.rs @@ -1021,10 +1021,7 @@ pub(crate) mod test_util { use super::*; use crate::test::object_store::local_unpartitioned_file; - use arrow::record_batch::RecordBatch; - use parquet::arrow::ArrowWriter; - use parquet::file::properties::WriterProperties; use tempfile::NamedTempFile; /// How many rows per page should be written @@ -1112,7 +1109,6 @@ mod tests { use crate::physical_plan::metrics::MetricValue; use crate::prelude::{SessionConfig, SessionContext}; use arrow::array::{Array, ArrayRef, StringArray}; - use arrow::record_batch::RecordBatch; use arrow_schema::Field; use async_trait::async_trait; use bytes::Bytes; @@ -1121,16 +1117,13 @@ mod tests { as_int32_array, as_timestamp_nanosecond_array, }; use datafusion_common::config::ParquetOptions; - use datafusion_common::config::TableParquetOptions; use datafusion_common::ScalarValue; use datafusion_execution::object_store::ObjectStoreUrl; use datafusion_execution::runtime_env::RuntimeEnv; use datafusion_physical_plan::stream::RecordBatchStreamAdapter; use futures::stream::BoxStream; - use futures::StreamExt; use log::error; use object_store::local::LocalFileSystem; - use object_store::path::Path; use object_store::{ GetOptions, GetResult, ListResult, MultipartId, PutOptions, PutResult, }; @@ -1139,7 +1132,6 @@ mod tests { use parquet::file::metadata::{ParquetColumnIndex, ParquetOffsetIndex}; use parquet::file::page_index::index::Index; use tokio::fs::File; - use tokio::io::AsyncWrite; #[tokio::test] async fn read_merged_batches() -> Result<()> { diff --git a/datafusion/core/src/datasource/listing/helpers.rs b/datafusion/core/src/datasource/listing/helpers.rs index 637a0daf13d1..9dfd18f1881e 100644 --- a/datafusion/core/src/datasource/listing/helpers.rs +++ b/datafusion/core/src/datasource/listing/helpers.rs @@ -423,8 +423,6 @@ where mod tests { use std::ops::Not; - use futures::StreamExt; - use crate::logical_expr::{case, col, lit}; use crate::test::object_store::make_test_store_and_state; diff --git a/datafusion/core/src/datasource/listing/table.rs b/datafusion/core/src/datasource/listing/table.rs index ab40160c7b54..6ee19828f1d4 100644 --- a/datafusion/core/src/datasource/listing/table.rs +++ b/datafusion/core/src/datasource/listing/table.rs @@ -1004,23 +1004,18 @@ impl ListingTable { #[cfg(test)] mod tests { - use std::collections::HashMap; use super::*; #[cfg(feature = "parquet")] - use crate::datasource::file_format::parquet::ParquetFormat; use crate::datasource::{provider_as_source, MemTable}; use crate::execution::options::ArrowReadOptions; use crate::physical_plan::collect; use crate::prelude::*; use crate::{ assert_batches_eq, - datasource::file_format::avro::AvroFormat, - logical_expr::{col, lit}, test::{columns, object_store::register_test_store}, }; - use arrow::datatypes::{DataType, Schema}; use arrow::record_batch::RecordBatch; use arrow_schema::SortOptions; use datafusion_common::stats::Precision; diff --git a/datafusion/core/src/datasource/memory.rs b/datafusion/core/src/datasource/memory.rs index 42e05ebeb33f..aab42285a0b2 100644 --- a/datafusion/core/src/datasource/memory.rs +++ b/datafusion/core/src/datasource/memory.rs @@ -363,7 +363,6 @@ impl DataSink for MemSink { #[cfg(test)] mod tests { - use std::collections::HashMap; use super::*; use crate::datasource::provider_as_source; @@ -376,8 +375,6 @@ mod tests { use datafusion_common::DataFusionError; use datafusion_expr::LogicalPlanBuilder; - use futures::StreamExt; - #[tokio::test] async fn test_with_projection() -> Result<()> { let session_ctx = SessionContext::new(); diff --git a/datafusion/core/src/datasource/physical_plan/csv.rs b/datafusion/core/src/datasource/physical_plan/csv.rs index 0526df8e21f6..879461c2eb1e 100644 --- a/datafusion/core/src/datasource/physical_plan/csv.rs +++ b/datafusion/core/src/datasource/physical_plan/csv.rs @@ -526,7 +526,6 @@ mod tests { use datafusion_common::test_util::arrow_test_data; use datafusion_common::FileType; - use futures::StreamExt; use object_store::chunked::ChunkedStore; use object_store::local::LocalFileSystem; use rstest::*; diff --git a/datafusion/core/src/datasource/physical_plan/file_stream.rs b/datafusion/core/src/datasource/physical_plan/file_stream.rs index 67a57ed73fbd..619bcb29e2cc 100644 --- a/datafusion/core/src/datasource/physical_plan/file_stream.rs +++ b/datafusion/core/src/datasource/physical_plan/file_stream.rs @@ -521,19 +521,13 @@ mod tests { use super::*; use crate::datasource::file_format::write::BatchSerializer; use crate::datasource::object_store::ObjectStoreUrl; - use crate::datasource::physical_plan::FileMeta; - use crate::physical_plan::metrics::ExecutionPlanMetricsSet; use crate::prelude::SessionContext; - use crate::{ - error::Result, - test::{make_partition, object_store::register_test_store}, - }; + use crate::test::{make_partition, object_store::register_test_store}; use arrow_schema::Schema; use datafusion_common::{internal_err, Statistics}; use bytes::Bytes; - use futures::StreamExt; /// Test `FileOpener` which will simulate errors during file opening or scanning #[derive(Default)] diff --git a/datafusion/core/src/datasource/physical_plan/json.rs b/datafusion/core/src/datasource/physical_plan/json.rs index a5afda47527f..2ec1b91d08ea 100644 --- a/datafusion/core/src/datasource/physical_plan/json.rs +++ b/datafusion/core/src/datasource/physical_plan/json.rs @@ -44,7 +44,7 @@ use datafusion_physical_expr::{EquivalenceProperties, LexOrdering}; use bytes::{Buf, Bytes}; use futures::{ready, StreamExt, TryStreamExt}; use object_store::buffered::BufWriter; -use object_store::{self, GetOptions, GetResultPayload, ObjectStore}; +use object_store::{GetOptions, GetResultPayload, ObjectStore}; use tokio::io::AsyncWriteExt; use tokio::task::JoinSet; @@ -387,7 +387,6 @@ mod tests { use crate::dataframe::DataFrameWriteOptions; use crate::datasource::file_format::file_compression_type::FileTypeExt; use crate::datasource::file_format::{json::JsonFormat, FileFormat}; - use crate::datasource::listing::PartitionedFile; use crate::datasource::object_store::ObjectStoreUrl; use crate::execution::context::SessionState; use crate::prelude::{ @@ -401,7 +400,6 @@ mod tests { use datafusion_common::FileType; use flate2::write::GzEncoder; use flate2::Compression; - use futures::StreamExt; use object_store::chunked::ChunkedStore; use object_store::local::LocalFileSystem; use rstest::*; diff --git a/datafusion/core/src/datasource/physical_plan/parquet/mod.rs b/datafusion/core/src/datasource/physical_plan/parquet/mod.rs index c4a888f5462d..73fb82980fc4 100644 --- a/datafusion/core/src/datasource/physical_plan/parquet/mod.rs +++ b/datafusion/core/src/datasource/physical_plan/parquet/mod.rs @@ -773,7 +773,7 @@ mod tests { use crate::datasource::file_format::options::CsvReadOptions; use crate::datasource::file_format::parquet::test_util::store_parquet; use crate::datasource::file_format::test_util::scan_format; - use crate::datasource::listing::{FileRange, ListingOptions, PartitionedFile}; + use crate::datasource::listing::{FileRange, ListingOptions}; use crate::datasource::object_store::ObjectStoreUrl; use crate::execution::context::SessionState; use crate::physical_plan::displayable; @@ -790,7 +790,7 @@ mod tests { StructArray, }; - use arrow::datatypes::{DataType, Field, Schema, SchemaBuilder}; + use arrow::datatypes::{Field, Schema, SchemaBuilder}; use arrow::record_batch::RecordBatch; use arrow_schema::Fields; use datafusion_common::{assert_contains, FileType, GetExt, ScalarValue, ToDFSchema}; @@ -799,9 +799,7 @@ mod tests { use datafusion_physical_expr::create_physical_expr; use chrono::{TimeZone, Utc}; - use futures::StreamExt; use object_store::local::LocalFileSystem; - use object_store::path::Path; use object_store::ObjectMeta; use parquet::arrow::ArrowWriter; use tempfile::TempDir; diff --git a/datafusion/core/src/datasource/physical_plan/parquet/row_groups.rs b/datafusion/core/src/datasource/physical_plan/parquet/row_groups.rs index 4305066ceffe..bcd9e1fa4479 100644 --- a/datafusion/core/src/datasource/physical_plan/parquet/row_groups.rs +++ b/datafusion/core/src/datasource/physical_plan/parquet/row_groups.rs @@ -359,7 +359,6 @@ mod tests { use crate::datasource::physical_plan::parquet::ParquetFileReader; use crate::physical_plan::metrics::ExecutionPlanMetricsSet; use arrow::datatypes::DataType::Decimal128; - use arrow::datatypes::Schema; use arrow::datatypes::{DataType, Field}; use datafusion_common::{Result, ToDFSchema}; use datafusion_expr::execution_props::ExecutionProps; @@ -370,8 +369,7 @@ mod tests { use parquet::basic::LogicalType; use parquet::data_type::{ByteArray, FixedLenByteArray}; use parquet::{ - basic::Type as PhysicalType, - file::{metadata::RowGroupMetaData, statistics::Statistics as ParquetStatistics}, + basic::Type as PhysicalType, file::statistics::Statistics as ParquetStatistics, schema::types::SchemaDescPtr, }; use std::ops::Rem; diff --git a/datafusion/core/src/execution/context/mod.rs b/datafusion/core/src/execution/context/mod.rs index 215bdbc3d579..d83644597e78 100644 --- a/datafusion/core/src/execution/context/mod.rs +++ b/datafusion/core/src/execution/context/mod.rs @@ -20,7 +20,6 @@ use std::collections::{hash_map::Entry, HashMap, HashSet}; use std::fmt::Debug; use std::ops::ControlFlow; -use std::string::String; use std::sync::{Arc, Weak}; use super::options::ReadOptions; @@ -2359,19 +2358,15 @@ impl<'a> TreeNodeVisitor for BadPlanVisitor<'a> { mod tests { use std::env; use std::path::PathBuf; - use std::sync::Weak; use super::{super::options::CsvReadOptions, *}; use crate::assert_batches_eq; - use crate::execution::context::QueryPlanner; use crate::execution::memory_pool::MemoryConsumer; use crate::execution::runtime_env::RuntimeConfig; use crate::test; use crate::test_util::{plan_and_collect, populate_csv_partitions}; - use crate::variable::VarType; use datafusion_common_runtime::SpawnedTask; - use datafusion_expr::Expr; use async_trait::async_trait; use tempfile::TempDir; diff --git a/datafusion/core/src/physical_optimizer/aggregate_statistics.rs b/datafusion/core/src/physical_optimizer/aggregate_statistics.rs index 98f8884e4985..505748860388 100644 --- a/datafusion/core/src/physical_optimizer/aggregate_statistics.rs +++ b/datafusion/core/src/physical_optimizer/aggregate_statistics.rs @@ -295,12 +295,10 @@ fn take_optimizable_max( #[cfg(test)] pub(crate) mod tests { - use std::sync::Arc; use super::*; - use crate::error::Result; use crate::logical_expr::Operator; - use crate::physical_plan::aggregates::{AggregateExec, PhysicalGroupBy}; + use crate::physical_plan::aggregates::PhysicalGroupBy; use crate::physical_plan::coalesce_partitions::CoalescePartitionsExec; use crate::physical_plan::common; use crate::physical_plan::expressions::Count; diff --git a/datafusion/core/src/physical_optimizer/combine_partial_final_agg.rs b/datafusion/core/src/physical_optimizer/combine_partial_final_agg.rs index 3d8f89d56919..92787df461d3 100644 --- a/datafusion/core/src/physical_optimizer/combine_partial_final_agg.rs +++ b/datafusion/core/src/physical_optimizer/combine_partial_final_agg.rs @@ -201,16 +201,12 @@ mod tests { use crate::datasource::listing::PartitionedFile; use crate::datasource::object_store::ObjectStoreUrl; use crate::datasource::physical_plan::{FileScanConfig, ParquetExec}; - use crate::physical_plan::aggregates::{ - AggregateExec, AggregateMode, PhysicalGroupBy, - }; use crate::physical_plan::expressions::lit; use crate::physical_plan::repartition::RepartitionExec; use crate::physical_plan::{displayable, Partitioning, Statistics}; use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; use datafusion_physical_expr::expressions::{col, Count, Sum}; - use datafusion_physical_expr::AggregateExpr; /// Runs the CombinePartialFinalAggregate optimizer and asserts the plan against the expected macro_rules! assert_optimized { diff --git a/datafusion/core/src/physical_optimizer/enforce_distribution.rs b/datafusion/core/src/physical_optimizer/enforce_distribution.rs index eacc842c342d..14232f4933f8 100644 --- a/datafusion/core/src/physical_optimizer/enforce_distribution.rs +++ b/datafusion/core/src/physical_optimizer/enforce_distribution.rs @@ -1290,31 +1290,21 @@ pub(crate) mod tests { use crate::physical_optimizer::test_utils::{ check_integrity, coalesce_partitions_exec, repartition_exec, }; - use crate::physical_plan::aggregates::{ - AggregateExec, AggregateMode, PhysicalGroupBy, - }; use crate::physical_plan::coalesce_batches::CoalesceBatchesExec; use crate::physical_plan::expressions::col; use crate::physical_plan::filter::FilterExec; - use crate::physical_plan::joins::{ - utils::JoinOn, HashJoinExec, PartitionMode, SortMergeJoinExec, - }; + use crate::physical_plan::joins::utils::JoinOn; use crate::physical_plan::limit::{GlobalLimitExec, LocalLimitExec}; - use crate::physical_plan::projection::ProjectionExec; use crate::physical_plan::sorts::sort::SortExec; - use crate::physical_plan::sorts::sort_preserving_merge::SortPreservingMergeExec; use crate::physical_plan::{displayable, DisplayAs, DisplayFormatType, Statistics}; - use arrow::compute::SortOptions; use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; - use datafusion_common::tree_node::TransformedResult; use datafusion_common::ScalarValue; - use datafusion_expr::logical_plan::JoinType; use datafusion_expr::Operator; use datafusion_physical_expr::expressions::{BinaryExpr, Literal}; use datafusion_physical_expr::{ - expressions, expressions::binary, expressions::lit, expressions::Column, - LexOrdering, PhysicalExpr, PhysicalSortExpr, PhysicalSortRequirement, + expressions, expressions::binary, expressions::lit, LexOrdering, + PhysicalSortExpr, PhysicalSortRequirement, }; use datafusion_physical_plan::PlanProperties; diff --git a/datafusion/core/src/physical_optimizer/enforce_sorting.rs b/datafusion/core/src/physical_optimizer/enforce_sorting.rs index 2dced0de6adb..a1e2f6c666dc 100644 --- a/datafusion/core/src/physical_optimizer/enforce_sorting.rs +++ b/datafusion/core/src/physical_optimizer/enforce_sorting.rs @@ -611,7 +611,6 @@ fn get_sort_exprs( #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; use crate::physical_optimizer::enforce_distribution::EnforceDistribution; @@ -622,7 +621,6 @@ mod tests { repartition_exec, sort_exec, sort_expr, sort_expr_options, sort_merge_join_exec, sort_preserving_merge_exec, spr_repartition_exec, union_exec, }; - use crate::physical_plan::repartition::RepartitionExec; use crate::physical_plan::{displayable, get_plan_string, Partitioning}; use crate::prelude::{SessionConfig, SessionContext}; use crate::test::{csv_exec_ordered, csv_exec_sorted, stream_exec_ordered}; diff --git a/datafusion/core/src/physical_optimizer/join_selection.rs b/datafusion/core/src/physical_optimizer/join_selection.rs index b20f041366aa..4fefcdf7aad6 100644 --- a/datafusion/core/src/physical_optimizer/join_selection.rs +++ b/datafusion/core/src/physical_optimizer/join_selection.rs @@ -702,21 +702,18 @@ fn apply_subrules( #[cfg(test)] mod tests_statistical { - use std::sync::Arc; use super::*; use crate::{ - physical_plan::{ - displayable, joins::PartitionMode, ColumnStatistics, Statistics, - }, + physical_plan::{displayable, ColumnStatistics, Statistics}, test::StatisticsExec, }; - use arrow::datatypes::{DataType, Field, Schema}; + use arrow::datatypes::{DataType, Field}; use datafusion_common::{stats::Precision, JoinType, ScalarValue}; use datafusion_expr::Operator; - use datafusion_physical_expr::expressions::{BinaryExpr, Column}; - use datafusion_physical_expr::{PhysicalExpr, PhysicalExprRef}; + use datafusion_physical_expr::expressions::BinaryExpr; + use datafusion_physical_expr::PhysicalExprRef; use rstest::rstest; @@ -1571,22 +1568,15 @@ mod util_tests { #[cfg(test)] mod hash_join_tests { - use std::sync::Arc; use self::tests_statistical::crosscheck_plans; use super::*; - use crate::physical_optimizer::join_selection::swap_join_type; use crate::physical_optimizer::test_utils::SourceType; - use crate::physical_plan::expressions::Column; - use crate::physical_plan::joins::PartitionMode; - use crate::physical_plan::projection::ProjectionExec; use crate::test_util::UnboundedExec; - use arrow::datatypes::{DataType, Field, Schema}; + use arrow::datatypes::{DataType, Field}; use arrow::record_batch::RecordBatch; use datafusion_common::utils::DataPtr; - use datafusion_common::JoinType; - use datafusion_physical_plan::ExecutionPlanProperties; struct TestCase { case: String, diff --git a/datafusion/core/src/physical_optimizer/limited_distinct_aggregation.rs b/datafusion/core/src/physical_optimizer/limited_distinct_aggregation.rs index dbdcfed2ae2f..d211d2c8b2d7 100644 --- a/datafusion/core/src/physical_optimizer/limited_distinct_aggregation.rs +++ b/datafusion/core/src/physical_optimizer/limited_distinct_aggregation.rs @@ -191,15 +191,13 @@ impl PhysicalOptimizerRule for LimitedDistinctAggregation { #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; - use crate::error::Result; use crate::physical_optimizer::aggregate_statistics::tests::TestAggregate; use crate::physical_optimizer::enforce_distribution::tests::{ parquet_exec_with_sort, schema, trim_plan_display, }; - use crate::physical_plan::aggregates::{AggregateExec, PhysicalGroupBy}; + use crate::physical_plan::aggregates::PhysicalGroupBy; use crate::physical_plan::collect; use crate::physical_plan::memory::MemoryExec; use crate::prelude::SessionContext; diff --git a/datafusion/core/src/physical_optimizer/projection_pushdown.rs b/datafusion/core/src/physical_optimizer/projection_pushdown.rs index 337c566e8f33..359916de0f1e 100644 --- a/datafusion/core/src/physical_optimizer/projection_pushdown.rs +++ b/datafusion/core/src/physical_optimizer/projection_pushdown.rs @@ -1288,30 +1288,15 @@ fn new_join_children( mod tests { use super::*; use std::any::Any; - use std::sync::Arc; use crate::datasource::file_format::file_compression_type::FileCompressionType; use crate::datasource::listing::PartitionedFile; - use crate::datasource::physical_plan::{CsvExec, FileScanConfig}; - use crate::physical_optimizer::output_requirements::OutputRequirementExec; - use crate::physical_optimizer::projection_pushdown::{ - join_table_borders, update_expr, ProjectionPushdown, - }; - use crate::physical_optimizer::PhysicalOptimizerRule; - use crate::physical_plan::coalesce_partitions::CoalescePartitionsExec; - use crate::physical_plan::filter::FilterExec; - use crate::physical_plan::joins::utils::{ColumnIndex, JoinFilter}; + use crate::datasource::physical_plan::FileScanConfig; + use crate::physical_plan::get_plan_string; use crate::physical_plan::joins::StreamJoinPartitionMode; - use crate::physical_plan::memory::MemoryExec; - use crate::physical_plan::projection::ProjectionExec; - use crate::physical_plan::repartition::RepartitionExec; - use crate::physical_plan::sorts::sort::SortExec; - use crate::physical_plan::sorts::sort_preserving_merge::SortPreservingMergeExec; - use crate::physical_plan::{get_plan_string, ExecutionPlan}; - - use arrow_schema::{DataType, Field, Schema, SchemaRef, SortOptions}; - use datafusion_common::config::ConfigOptions; - use datafusion_common::{JoinSide, JoinType, Result, ScalarValue, Statistics}; + + use arrow_schema::{DataType, Field, Schema, SortOptions}; + use datafusion_common::{JoinType, ScalarValue, Statistics}; use datafusion_execution::object_store::ObjectStoreUrl; use datafusion_execution::{SendableRecordBatchStream, TaskContext}; use datafusion_expr::{ @@ -1319,19 +1304,11 @@ mod tests { Signature, Volatility, }; use datafusion_physical_expr::expressions::{ - BinaryExpr, CaseExpr, CastExpr, Column, Literal, NegativeExpr, - }; - use datafusion_physical_expr::{ - Distribution, Partitioning, PhysicalExpr, PhysicalSortExpr, - PhysicalSortRequirement, ScalarFunctionExpr, + BinaryExpr, CaseExpr, CastExpr, NegativeExpr, }; - use datafusion_physical_plan::joins::{ - HashJoinExec, PartitionMode, SymmetricHashJoinExec, - }; - use datafusion_physical_plan::streaming::{PartitionStream, StreamingTableExec}; - use datafusion_physical_plan::union::UnionExec; - - use itertools::Itertools; + use datafusion_physical_expr::ScalarFunctionExpr; + use datafusion_physical_plan::joins::PartitionMode; + use datafusion_physical_plan::streaming::PartitionStream; /// Mocked UDF #[derive(Debug)] diff --git a/datafusion/core/src/physical_optimizer/pruning.rs b/datafusion/core/src/physical_optimizer/pruning.rs index c65235f5fda2..605ef9f9023f 100644 --- a/datafusion/core/src/physical_optimizer/pruning.rs +++ b/datafusion/core/src/physical_optimizer/pruning.rs @@ -20,7 +20,6 @@ //! //! [`Expr`]: crate::prelude::Expr use std::collections::HashSet; -use std::convert::TryFrom; use std::sync::Arc; use crate::{ @@ -1551,15 +1550,15 @@ pub(crate) enum StatisticsType { #[cfg(test)] mod tests { use super::*; + use crate::assert_batches_eq; use crate::logical_expr::{col, lit}; - use crate::{assert_batches_eq, physical_optimizer::pruning::StatisticsType}; use arrow::array::Decimal128Array; use arrow::{ array::{BinaryArray, Int32Array, Int64Array, StringArray}, - datatypes::{DataType, TimeUnit}, + datatypes::TimeUnit, }; use arrow_array::UInt64Array; - use datafusion_common::{ScalarValue, ToDFSchema}; + use datafusion_common::ToDFSchema; use datafusion_expr::execution_props::ExecutionProps; use datafusion_expr::expr::InList; use datafusion_expr::{cast, is_null, try_cast, Expr}; diff --git a/datafusion/core/src/physical_optimizer/replace_with_order_preserving_variants.rs b/datafusion/core/src/physical_optimizer/replace_with_order_preserving_variants.rs index b438e40ece02..9b6e2076912c 100644 --- a/datafusion/core/src/physical_optimizer/replace_with_order_preserving_variants.rs +++ b/datafusion/core/src/physical_optimizer/replace_with_order_preserving_variants.rs @@ -279,12 +279,9 @@ mod tests { use crate::datasource::physical_plan::{CsvExec, FileScanConfig}; use crate::physical_optimizer::test_utils::check_integrity; use crate::physical_plan::coalesce_batches::CoalesceBatchesExec; - use crate::physical_plan::coalesce_partitions::CoalescePartitionsExec; use crate::physical_plan::filter::FilterExec; use crate::physical_plan::joins::{HashJoinExec, PartitionMode}; - use crate::physical_plan::repartition::RepartitionExec; use crate::physical_plan::sorts::sort::SortExec; - use crate::physical_plan::sorts::sort_preserving_merge::SortPreservingMergeExec; use crate::physical_plan::{ displayable, get_plan_string, ExecutionPlan, Partitioning, }; diff --git a/datafusion/core/src/physical_planner.rs b/datafusion/core/src/physical_planner.rs index 848f561ffb85..b7b6c20b19bb 100644 --- a/datafusion/core/src/physical_planner.rs +++ b/datafusion/core/src/physical_planner.rs @@ -2297,8 +2297,6 @@ fn tuple_err(value: (Result, Result)) -> Result<(T, R)> { #[cfg(test)] mod tests { use std::any::Any; - use std::collections::HashMap; - use std::convert::TryFrom; use std::fmt::{self, Debug}; use std::ops::{BitAnd, Not}; @@ -2306,22 +2304,19 @@ mod tests { use crate::datasource::file_format::options::CsvReadOptions; use crate::datasource::MemTable; use crate::physical_plan::{ - expressions, DisplayAs, DisplayFormatType, ExecutionMode, Partitioning, - PlanProperties, SendableRecordBatchStream, + expressions, DisplayAs, DisplayFormatType, ExecutionMode, PlanProperties, + SendableRecordBatchStream, }; - use crate::physical_planner::PhysicalPlanner; use crate::prelude::{SessionConfig, SessionContext}; use crate::test_util::{scan_empty, scan_empty_with_partitions}; use arrow::array::{ArrayRef, DictionaryArray, Int32Array}; - use arrow::datatypes::{DataType, Field, Int32Type, SchemaRef}; - use arrow::record_batch::RecordBatch; - use datafusion_common::{assert_contains, DFSchema, DFSchemaRef, TableReference}; + use arrow::datatypes::{DataType, Field, Int32Type}; + use datafusion_common::{assert_contains, DFSchemaRef, TableReference}; use datafusion_execution::runtime_env::RuntimeEnv; use datafusion_execution::TaskContext; use datafusion_expr::{ - col, lit, sum, Extension, GroupingSet, LogicalPlanBuilder, - UserDefinedLogicalNodeCore, + col, lit, sum, LogicalPlanBuilder, UserDefinedLogicalNodeCore, }; use datafusion_physical_expr::EquivalenceProperties; diff --git a/datafusion/core/tests/custom_sources_cases/provider_filter_pushdown.rs b/datafusion/core/tests/custom_sources_cases/provider_filter_pushdown.rs index 2ae41391f42d..4579fe806d6f 100644 --- a/datafusion/core/tests/custom_sources_cases/provider_filter_pushdown.rs +++ b/datafusion/core/tests/custom_sources_cases/provider_filter_pushdown.rs @@ -23,8 +23,8 @@ use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; use arrow::record_batch::RecordBatch; use datafusion::datasource::provider::{TableProvider, TableType}; use datafusion::error::Result; -use datafusion::execution::context::{SessionContext, SessionState, TaskContext}; -use datafusion::logical_expr::{Expr, TableProviderFilterPushDown}; +use datafusion::execution::context::{SessionState, TaskContext}; +use datafusion::logical_expr::TableProviderFilterPushDown; use datafusion::physical_plan::stream::RecordBatchStreamAdapter; use datafusion::physical_plan::{ DisplayAs, DisplayFormatType, ExecutionMode, ExecutionPlan, Partitioning, diff --git a/datafusion/core/tests/dataframe/dataframe_functions.rs b/datafusion/core/tests/dataframe/dataframe_functions.rs index c97735ce9cf1..7806461bb1ac 100644 --- a/datafusion/core/tests/dataframe/dataframe_functions.rs +++ b/datafusion/core/tests/dataframe/dataframe_functions.rs @@ -25,19 +25,14 @@ use arrow_array::ListArray; use arrow_schema::SchemaRef; use std::sync::Arc; -use datafusion::dataframe::DataFrame; - use datafusion::error::Result; use datafusion::prelude::*; -use datafusion::execution::context::SessionContext; - use datafusion::assert_batches_eq; use datafusion_common::DFSchema; use datafusion_expr::expr::Alias; -use datafusion_expr::{approx_median, cast, ExprSchemable}; -use datafusion_functions_array::expr_fn::array_to_string; +use datafusion_expr::ExprSchemable; fn test_schema() -> SchemaRef { Arc::new(Schema::new(vec![ diff --git a/datafusion/core/tests/parquet/filter_pushdown.rs b/datafusion/core/tests/parquet/filter_pushdown.rs index c0193fe04f04..feb928a3a474 100644 --- a/datafusion/core/tests/parquet/filter_pushdown.rs +++ b/datafusion/core/tests/parquet/filter_pushdown.rs @@ -63,7 +63,6 @@ fn generate_file(tempdir: &TempDir, props: WriterProperties) -> TestParquetFile test_parquet_file } -#[cfg(not(target_family = "windows"))] #[tokio::test] async fn single_file() { // Only create the parquet file once as it is fairly large @@ -222,7 +221,6 @@ async fn single_file() { case.run().await; } -#[cfg(not(target_family = "windows"))] #[tokio::test] async fn single_file_small_data_pages() { let tempdir = TempDir::new().unwrap(); diff --git a/datafusion/core/tests/parquet/mod.rs b/datafusion/core/tests/parquet/mod.rs index d92a56d7fa04..bb938e3af493 100644 --- a/datafusion/core/tests/parquet/mod.rs +++ b/datafusion/core/tests/parquet/mod.rs @@ -43,6 +43,7 @@ use tempfile::NamedTempFile; mod custom_reader; mod file_statistics; +#[cfg(not(target_family = "windows"))] mod filter_pushdown; mod page_pruning; mod row_group_pruning; diff --git a/datafusion/core/tests/parquet/schema.rs b/datafusion/core/tests/parquet/schema.rs index 0dd15cb00e57..1b572914d7bd 100644 --- a/datafusion/core/tests/parquet/schema.rs +++ b/datafusion/core/tests/parquet/schema.rs @@ -18,7 +18,6 @@ //! Tests for parquet schema handling use std::{collections::HashMap, fs, path::Path}; -use ::parquet::arrow::ArrowWriter; use tempfile::TempDir; use super::*; diff --git a/datafusion/core/tests/simplification.rs b/datafusion/core/tests/simplification.rs index 46923ee9074f..880c294bb7aa 100644 --- a/datafusion/core/tests/simplification.rs +++ b/datafusion/core/tests/simplification.rs @@ -28,7 +28,7 @@ use datafusion_expr::expr::ScalarFunction; use datafusion_expr::logical_plan::builder::table_scan_with_filters; use datafusion_expr::simplify::SimplifyInfo; use datafusion_expr::{ - expr, table_scan, Cast, ColumnarValue, Expr, ExprSchemable, LogicalPlan, + expr, table_scan, Cast, ColumnarValue, ExprSchemable, LogicalPlan, LogicalPlanBuilder, ScalarUDF, Volatility, }; use datafusion_functions::{math, string}; diff --git a/datafusion/core/tests/sql/select.rs b/datafusion/core/tests/sql/select.rs index 667d3eeab31e..f2710e659240 100644 --- a/datafusion/core/tests/sql/select.rs +++ b/datafusion/core/tests/sql/select.rs @@ -17,7 +17,6 @@ use super::*; use datafusion_common::ScalarValue; -use tempfile::TempDir; #[tokio::test] async fn test_list_query_parameters() -> Result<()> { diff --git a/datafusion/core/tests/user_defined/user_defined_scalar_functions.rs b/datafusion/core/tests/user_defined/user_defined_scalar_functions.rs index e31a1081621a..c40573a8df80 100644 --- a/datafusion/core/tests/user_defined/user_defined_scalar_functions.rs +++ b/datafusion/core/tests/user_defined/user_defined_scalar_functions.rs @@ -33,8 +33,8 @@ use datafusion_common::{exec_err, internal_err, DataFusionError}; use datafusion_execution::runtime_env::{RuntimeConfig, RuntimeEnv}; use datafusion_expr::simplify::{ExprSimplifyResult, SimplifyInfo}; use datafusion_expr::{ - create_udaf, create_udf, Accumulator, ColumnarValue, CreateFunction, ExprSchemable, - LogicalPlanBuilder, ScalarUDF, ScalarUDFImpl, Signature, Volatility, + Accumulator, ColumnarValue, CreateFunction, ExprSchemable, LogicalPlanBuilder, + ScalarUDF, ScalarUDFImpl, Signature, Volatility, }; use rand::{thread_rng, Rng}; use std::any::Any; diff --git a/datafusion/execution/src/disk_manager.rs b/datafusion/execution/src/disk_manager.rs index fa9a75b2f496..85cc6f8499f0 100644 --- a/datafusion/execution/src/disk_manager.rs +++ b/datafusion/execution/src/disk_manager.rs @@ -187,10 +187,7 @@ fn create_local_dirs(local_dirs: Vec) -> Result>> { #[cfg(test)] mod tests { - use std::path::Path; - use super::*; - use tempfile::TempDir; #[test] fn lazy_temp_dir_creation() -> Result<()> { diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rs index ea2cfeafe6e5..0d8e8d816b33 100644 --- a/datafusion/expr/src/expr.rs +++ b/datafusion/expr/src/expr.rs @@ -1942,17 +1942,9 @@ fn create_names(exprs: &[Expr]) -> Result { #[cfg(test)] mod test { - use crate::expr::Cast; use crate::expr_fn::col; - use crate::{ - case, lit, ColumnarValue, Expr, ScalarFunctionDefinition, ScalarUDF, - ScalarUDFImpl, Signature, Volatility, - }; - use arrow::datatypes::DataType; - use datafusion_common::Column; - use datafusion_common::{Result, ScalarValue}; + use crate::{case, lit, ColumnarValue, ScalarUDF, ScalarUDFImpl, Volatility}; use std::any::Any; - use std::sync::Arc; #[test] fn format_case_when() -> Result<()> { diff --git a/datafusion/expr/src/expr_rewriter/mod.rs b/datafusion/expr/src/expr_rewriter/mod.rs index fd6446eba971..14154189a126 100644 --- a/datafusion/expr/src/expr_rewriter/mod.rs +++ b/datafusion/expr/src/expr_rewriter/mod.rs @@ -287,8 +287,7 @@ mod test { use crate::expr::Sort; use crate::{col, lit, Cast}; use arrow::datatypes::{DataType, Field, Schema}; - use datafusion_common::tree_node::{TreeNode, TreeNodeRewriter}; - use datafusion_common::{DFSchema, ScalarValue, TableReference}; + use datafusion_common::ScalarValue; #[derive(Default)] struct RecordingRewriter { diff --git a/datafusion/expr/src/expr_schema.rs b/datafusion/expr/src/expr_schema.rs index e01ec2296a32..c5ae0f1b831a 100644 --- a/datafusion/expr/src/expr_schema.rs +++ b/datafusion/expr/src/expr_schema.rs @@ -545,8 +545,8 @@ pub fn cast_subquery(subquery: Subquery, cast_to_type: &DataType) -> Result {{ diff --git a/datafusion/expr/src/literal.rs b/datafusion/expr/src/literal.rs index 2f04729af2ed..90ba5a9a693c 100644 --- a/datafusion/expr/src/literal.rs +++ b/datafusion/expr/src/literal.rs @@ -180,7 +180,6 @@ mod test { use super::*; use crate::expr_fn::col; - use datafusion_common::ScalarValue; #[test] fn test_lit_nonzero() { diff --git a/datafusion/expr/src/logical_plan/builder.rs b/datafusion/expr/src/logical_plan/builder.rs index fa4b0b964295..43873cb90cda 100644 --- a/datafusion/expr/src/logical_plan/builder.rs +++ b/datafusion/expr/src/logical_plan/builder.rs @@ -20,7 +20,6 @@ use std::any::Any; use std::cmp::Ordering; use std::collections::{HashMap, HashSet}; -use std::convert::TryFrom; use std::iter::zip; use std::sync::Arc; @@ -1611,8 +1610,7 @@ mod tests { use crate::logical_plan::StringifiedPlan; use crate::{col, expr, expr_fn::exists, in_subquery, lit, scalar_subquery, sum}; - use arrow::datatypes::{DataType, Field}; - use datafusion_common::{SchemaError, TableReference}; + use datafusion_common::SchemaError; #[test] fn plan_builder_simple() -> Result<()> { diff --git a/datafusion/expr/src/logical_plan/extension.rs b/datafusion/expr/src/logical_plan/extension.rs index b55256ca17de..7e6f07e0c509 100644 --- a/datafusion/expr/src/logical_plan/extension.rs +++ b/datafusion/expr/src/logical_plan/extension.rs @@ -19,7 +19,7 @@ use crate::{Expr, LogicalPlan}; use datafusion_common::{DFSchema, DFSchemaRef}; use std::hash::{Hash, Hasher}; -use std::{any::Any, cmp::Eq, collections::HashSet, fmt, sync::Arc}; +use std::{any::Any, collections::HashSet, fmt, sync::Arc}; /// This defines the interface for [`LogicalPlan`] nodes that can be /// used to extend DataFusion with custom relational operators. diff --git a/datafusion/expr/src/logical_plan/plan.rs b/datafusion/expr/src/logical_plan/plan.rs index 6df5516b1bba..64c5b56a4080 100644 --- a/datafusion/expr/src/logical_plan/plan.rs +++ b/datafusion/expr/src/logical_plan/plan.rs @@ -2526,18 +2526,14 @@ pub struct Unnest { #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; use crate::builder::LogicalTableSource; use crate::logical_plan::table_scan; use crate::{col, count, exists, in_subquery, lit, placeholder, GroupingSet}; - use arrow::datatypes::{DataType, Field, Schema}; use datafusion_common::tree_node::TreeNodeVisitor; - use datafusion_common::{ - not_impl_err, Constraint, DFSchema, ScalarValue, TableReference, - }; + use datafusion_common::{not_impl_err, Constraint, ScalarValue}; fn employee_schema() -> Schema { Schema::new(vec![ diff --git a/datafusion/expr/src/type_coercion/aggregates.rs b/datafusion/expr/src/type_coercion/aggregates.rs index 44f2671f4f99..5ffdc8f94753 100644 --- a/datafusion/expr/src/type_coercion/aggregates.rs +++ b/datafusion/expr/src/type_coercion/aggregates.rs @@ -582,8 +582,6 @@ pub fn is_string_agg_supported_arg_type(arg_type: &DataType) -> bool { mod tests { use super::*; - use arrow::datatypes::DataType; - #[test] fn test_aggregate_coerce_types() { // test input args with error number input types diff --git a/datafusion/expr/src/type_coercion/binary.rs b/datafusion/expr/src/type_coercion/binary.rs index e41934354806..7eec606658f4 100644 --- a/datafusion/expr/src/type_coercion/binary.rs +++ b/datafusion/expr/src/type_coercion/binary.rs @@ -858,10 +858,8 @@ fn null_coercion(lhs_type: &DataType, rhs_type: &DataType) -> Option { #[cfg(test)] mod tests { use super::*; - use crate::Operator; - use arrow::datatypes::DataType; - use datafusion_common::{assert_contains, Result}; + use datafusion_common::assert_contains; #[test] fn test_coercion_error() -> Result<()> { diff --git a/datafusion/expr/src/type_coercion/functions.rs b/datafusion/expr/src/type_coercion/functions.rs index 37eeb7d464b8..07516c1f6f53 100644 --- a/datafusion/expr/src/type_coercion/functions.rs +++ b/datafusion/expr/src/type_coercion/functions.rs @@ -467,12 +467,11 @@ fn coerced_from<'a>( #[cfg(test)] mod tests { - use std::sync::Arc; use crate::Volatility; use super::*; - use arrow::datatypes::{DataType, Field, TimeUnit}; + use arrow::datatypes::Field; #[test] fn test_maybe_data_types() { diff --git a/datafusion/expr/src/window_frame.rs b/datafusion/expr/src/window_frame.rs index acada3582f53..c0617eaf4ed4 100644 --- a/datafusion/expr/src/window_frame.rs +++ b/datafusion/expr/src/window_frame.rs @@ -23,7 +23,6 @@ //! - An ending frame boundary, //! - An EXCLUDE clause. -use std::convert::{From, TryFrom}; use std::fmt::{self, Formatter}; use std::hash::Hash; diff --git a/datafusion/expr/src/window_state.rs b/datafusion/expr/src/window_state.rs index 5104d899c449..e7f31bbfbf2b 100644 --- a/datafusion/expr/src/window_state.rs +++ b/datafusion/expr/src/window_state.rs @@ -667,14 +667,9 @@ fn check_equality(current: &[ScalarValue], target: &[ScalarValue]) -> Result (Vec, Vec) { let range_columns: Vec = vec![Arc::new(Float64Array::from(vec![ diff --git a/datafusion/functions-array/src/utils.rs b/datafusion/functions-array/src/utils.rs index d86e4fe2ab7b..86fd281b5845 100644 --- a/datafusion/functions-array/src/utils.rs +++ b/datafusion/functions-array/src/utils.rs @@ -257,8 +257,7 @@ pub(crate) fn compute_array_dims( mod tests { use super::*; use arrow::datatypes::Int64Type; - use arrow_array::ListArray; - use datafusion_common::{cast::as_list_array, utils::array_into_list_array}; + use datafusion_common::utils::array_into_list_array; /// Only test internal functions, array-related sql functions will be tested in sqllogictest `array.slt` #[test] diff --git a/datafusion/functions/src/core/nullif.rs b/datafusion/functions/src/core/nullif.rs index dc9696bd8d72..e8bf2db514c3 100644 --- a/datafusion/functions/src/core/nullif.rs +++ b/datafusion/functions/src/core/nullif.rs @@ -144,7 +144,6 @@ mod tests { use arrow::array::*; use super::*; - use datafusion_common::{Result, ScalarValue}; #[test] fn nullif_int32() -> Result<()> { diff --git a/datafusion/functions/src/core/nvl.rs b/datafusion/functions/src/core/nvl.rs index 274e36fbdecc..05515c6e925c 100644 --- a/datafusion/functions/src/core/nvl.rs +++ b/datafusion/functions/src/core/nvl.rs @@ -129,7 +129,7 @@ mod tests { use arrow::array::*; use super::*; - use datafusion_common::{Result, ScalarValue}; + use datafusion_common::ScalarValue; #[test] fn nvl_int32() -> Result<()> { diff --git a/datafusion/functions/src/string/levenshtein.rs b/datafusion/functions/src/string/levenshtein.rs index 390b0d72bee2..ec22b0a4a480 100644 --- a/datafusion/functions/src/string/levenshtein.rs +++ b/datafusion/functions/src/string/levenshtein.rs @@ -122,7 +122,7 @@ pub fn levenshtein(args: &[ArrayRef]) -> Result { #[cfg(test)] mod tests { - use arrow::array::{Int32Array, StringArray}; + use arrow::array::StringArray; use datafusion_common::cast::as_int32_array; diff --git a/datafusion/functions/src/string/to_hex.rs b/datafusion/functions/src/string/to_hex.rs index feedeb47f564..5050d8bab3e9 100644 --- a/datafusion/functions/src/string/to_hex.rs +++ b/datafusion/functions/src/string/to_hex.rs @@ -107,10 +107,7 @@ impl ScalarUDFImpl for ToHexFunc { #[cfg(test)] mod tests { - use arrow::{ - array::{Int32Array, StringArray}, - datatypes::Int32Type, - }; + use arrow::array::{Int32Array, StringArray}; use datafusion_common::cast::as_string_array; diff --git a/datafusion/functions/src/utils.rs b/datafusion/functions/src/utils.rs index 9b7144b483bd..d14844c4a445 100644 --- a/datafusion/functions/src/utils.rs +++ b/datafusion/functions/src/utils.rs @@ -177,5 +177,6 @@ pub mod test { }; } + #[allow(unused_imports)] pub(crate) use test_function; } diff --git a/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs b/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs index 835c041fc376..1ab3d1a81038 100644 --- a/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs +++ b/datafusion/optimizer/src/analyzer/count_wildcard_rule.rs @@ -103,12 +103,12 @@ mod tests { use super::*; use crate::test::*; use arrow::datatypes::DataType; - use datafusion_common::{Result, ScalarValue}; + use datafusion_common::ScalarValue; use datafusion_expr::expr::Sort; use datafusion_expr::{ - col, count, exists, expr, in_subquery, lit, logical_plan::LogicalPlanBuilder, - max, out_ref_col, scalar_subquery, sum, wildcard, AggregateFunction, Expr, - WindowFrame, WindowFrameBound, WindowFrameUnits, WindowFunctionDefinition, + col, count, exists, expr, in_subquery, logical_plan::LogicalPlanBuilder, max, + out_ref_col, scalar_subquery, sum, wildcard, AggregateFunction, WindowFrame, + WindowFrameBound, WindowFrameUnits, }; use std::sync::Arc; diff --git a/datafusion/optimizer/src/common_subexpr_eliminate.rs b/datafusion/optimizer/src/common_subexpr_eliminate.rs index 081d9c250573..cb3b4accf35d 100644 --- a/datafusion/optimizer/src/common_subexpr_eliminate.rs +++ b/datafusion/optimizer/src/common_subexpr_eliminate.rs @@ -765,13 +765,10 @@ fn replace_common_expr( mod test { use std::iter; - use arrow::datatypes::{Field, Schema}; + use arrow::datatypes::Schema; - use datafusion_common::DFSchema; use datafusion_expr::logical_plan::{table_scan, JoinType}; - use datafusion_expr::{ - avg, col, lit, logical_plan::builder::LogicalPlanBuilder, sum, - }; + use datafusion_expr::{avg, lit, logical_plan::builder::LogicalPlanBuilder, sum}; use datafusion_expr::{ grouping_set, AccumulatorFactoryFunction, AggregateUDF, Signature, SimpleAggregateUDF, Volatility, diff --git a/datafusion/optimizer/src/decorrelate_predicate_subquery.rs b/datafusion/optimizer/src/decorrelate_predicate_subquery.rs index d9fc5a6ce261..2e726321704f 100644 --- a/datafusion/optimizer/src/decorrelate_predicate_subquery.rs +++ b/datafusion/optimizer/src/decorrelate_predicate_subquery.rs @@ -331,12 +331,7 @@ mod tests { use crate::test::*; use arrow::datatypes::DataType; - use datafusion_common::Result; - use datafusion_expr::{ - and, binary_expr, col, exists, in_subquery, lit, - logical_plan::LogicalPlanBuilder, not_exists, not_in_subquery, or, out_ref_col, - Operator, - }; + use datafusion_expr::{and, binary_expr, col, lit, or, out_ref_col}; fn assert_optimized_plan_equal(plan: LogicalPlan, expected: &str) -> Result<()> { assert_optimized_plan_eq_display_indent( diff --git a/datafusion/optimizer/src/eliminate_one_union.rs b/datafusion/optimizer/src/eliminate_one_union.rs index 11a9009cd96c..68d0ddba8b20 100644 --- a/datafusion/optimizer/src/eliminate_one_union.rs +++ b/datafusion/optimizer/src/eliminate_one_union.rs @@ -75,8 +75,7 @@ mod tests { use arrow::datatypes::{DataType, Field, Schema}; use datafusion_common::ToDFSchema; use datafusion_expr::{ - expr_rewriter::coerce_plan_expr_for_schema, - logical_plan::{table_scan, Union}, + expr_rewriter::coerce_plan_expr_for_schema, logical_plan::table_scan, }; use std::sync::Arc; diff --git a/datafusion/optimizer/src/filter_null_join_keys.rs b/datafusion/optimizer/src/filter_null_join_keys.rs index a4e345ceb3c1..ecd1901abe58 100644 --- a/datafusion/optimizer/src/filter_null_join_keys.rs +++ b/datafusion/optimizer/src/filter_null_join_keys.rs @@ -115,9 +115,9 @@ mod tests { use super::*; use crate::test::assert_optimized_plan_eq; use arrow::datatypes::{DataType, Field, Schema}; - use datafusion_common::{Column, Result}; + use datafusion_common::Column; use datafusion_expr::logical_plan::table_scan; - use datafusion_expr::{col, lit, logical_plan::JoinType, LogicalPlanBuilder}; + use datafusion_expr::{col, lit, LogicalPlanBuilder}; fn assert_optimized_plan_equal(plan: LogicalPlan, expected: &str) -> Result<()> { assert_optimized_plan_eq(Arc::new(FilterNullJoinKeys {}), plan, expected) diff --git a/datafusion/optimizer/src/plan_signature.rs b/datafusion/optimizer/src/plan_signature.rs index d642e2c26e47..d22795797478 100644 --- a/datafusion/optimizer/src/plan_signature.rs +++ b/datafusion/optimizer/src/plan_signature.rs @@ -89,7 +89,7 @@ mod tests { use std::sync::Arc; use datafusion_common::{DFSchema, Result}; - use datafusion_expr::{self, lit, LogicalPlan}; + use datafusion_expr::{lit, LogicalPlan}; use crate::plan_signature::get_node_number; diff --git a/datafusion/optimizer/src/propagate_empty_relation.rs b/datafusion/optimizer/src/propagate_empty_relation.rs index 445109bbdf77..4003acaa7d65 100644 --- a/datafusion/optimizer/src/propagate_empty_relation.rs +++ b/datafusion/optimizer/src/propagate_empty_relation.rs @@ -192,8 +192,7 @@ mod tests { use datafusion_common::{Column, DFSchema, ScalarValue}; use datafusion_expr::logical_plan::table_scan; use datafusion_expr::{ - binary_expr, col, lit, logical_plan::builder::LogicalPlanBuilder, Expr, JoinType, - Operator, + binary_expr, col, lit, logical_plan::builder::LogicalPlanBuilder, Expr, Operator, }; use super::*; diff --git a/datafusion/optimizer/src/push_down_filter.rs b/datafusion/optimizer/src/push_down_filter.rs index e1561ad9d6fe..0572dc5ea4f1 100644 --- a/datafusion/optimizer/src/push_down_filter.rs +++ b/datafusion/optimizer/src/push_down_filter.rs @@ -1028,7 +1028,6 @@ mod tests { use super::*; use std::any::Any; use std::fmt::{Debug, Formatter}; - use std::sync::Arc; use crate::optimizer::Optimizer; use crate::rewrite_disjunctive_predicate::RewriteDisjunctivePredicate; @@ -1036,12 +1035,11 @@ mod tests { use crate::OptimizerContext; use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; - use datafusion_common::{DFSchema, DFSchemaRef, ScalarValue}; + use datafusion_common::ScalarValue; use datafusion_expr::expr::ScalarFunction; use datafusion_expr::logical_plan::table_scan; use datafusion_expr::{ - and, col, in_list, in_subquery, lit, logical_plan::JoinType, or, sum, BinaryExpr, - ColumnarValue, Expr, Extension, LogicalPlanBuilder, Operator, ScalarUDF, + col, in_list, in_subquery, lit, sum, ColumnarValue, Extension, ScalarUDF, ScalarUDFImpl, Signature, TableSource, TableType, UserDefinedLogicalNodeCore, Volatility, }; diff --git a/datafusion/optimizer/src/push_down_limit.rs b/datafusion/optimizer/src/push_down_limit.rs index 6f1d7bf97cfe..1af246fc556d 100644 --- a/datafusion/optimizer/src/push_down_limit.rs +++ b/datafusion/optimizer/src/push_down_limit.rs @@ -279,11 +279,7 @@ mod test { use super::*; use crate::test::*; - use datafusion_expr::{ - col, exists, - logical_plan::{builder::LogicalPlanBuilder, JoinType, LogicalPlan}, - max, - }; + use datafusion_expr::{col, exists, logical_plan::builder::LogicalPlanBuilder, max}; fn assert_optimized_plan_equal(plan: LogicalPlan, expected: &str) -> Result<()> { assert_optimized_plan_eq(Arc::new(PushDownLimit::new()), plan, expected) diff --git a/datafusion/optimizer/src/scalar_subquery_to_join.rs b/datafusion/optimizer/src/scalar_subquery_to_join.rs index f9f602297f90..3ee6af415e08 100644 --- a/datafusion/optimizer/src/scalar_subquery_to_join.rs +++ b/datafusion/optimizer/src/scalar_subquery_to_join.rs @@ -385,8 +385,6 @@ mod tests { use crate::test::*; use arrow::datatypes::DataType; - use datafusion_common::Result; - use datafusion_expr::logical_plan::LogicalPlanBuilder; use datafusion_expr::{ col, lit, max, min, out_ref_col, scalar_subquery, sum, Between, }; diff --git a/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs b/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs index a7df2b8ca147..2fb06e659d70 100644 --- a/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs +++ b/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs @@ -1687,11 +1687,8 @@ mod tests { sync::Arc, }; - use arrow::datatypes::{DataType, Field, Schema}; - use datafusion_common::{assert_contains, ToDFSchema}; use datafusion_expr::{interval_arithmetic::Interval, *}; - use datafusion_physical_expr::execution_props::ExecutionProps; use crate::simplify_expressions::SimplifyContext; use crate::test::test_table_scan_with_name; diff --git a/datafusion/optimizer/src/simplify_expressions/guarantees.rs b/datafusion/optimizer/src/simplify_expressions/guarantees.rs index 6eb583257dcb..9d8e3fecebc1 100644 --- a/datafusion/optimizer/src/simplify_expressions/guarantees.rs +++ b/datafusion/optimizer/src/simplify_expressions/guarantees.rs @@ -206,7 +206,7 @@ mod tests { use arrow::datatypes::DataType; use datafusion_common::tree_node::{TransformedResult, TreeNode}; use datafusion_common::ScalarValue; - use datafusion_expr::{col, lit, Operator}; + use datafusion_expr::{col, Operator}; #[test] fn test_null_handling() { diff --git a/datafusion/optimizer/src/single_distinct_to_groupby.rs b/datafusion/optimizer/src/single_distinct_to_groupby.rs index 602994a9e3e2..aaf4667fb000 100644 --- a/datafusion/optimizer/src/single_distinct_to_groupby.rs +++ b/datafusion/optimizer/src/single_distinct_to_groupby.rs @@ -309,8 +309,8 @@ mod tests { use datafusion_expr::expr; use datafusion_expr::expr::GroupingSet; use datafusion_expr::{ - col, count, count_distinct, lit, logical_plan::builder::LogicalPlanBuilder, max, - min, sum, AggregateFunction, + count, count_distinct, lit, logical_plan::builder::LogicalPlanBuilder, max, min, + sum, AggregateFunction, }; fn assert_optimized_plan_equal(plan: LogicalPlan, expected: &str) -> Result<()> { diff --git a/datafusion/optimizer/src/unwrap_cast_in_comparison.rs b/datafusion/optimizer/src/unwrap_cast_in_comparison.rs index 1d80e235e7e9..138769674dd1 100644 --- a/datafusion/optimizer/src/unwrap_cast_in_comparison.rs +++ b/datafusion/optimizer/src/unwrap_cast_in_comparison.rs @@ -475,16 +475,13 @@ fn cast_between_timestamp(from: DataType, to: DataType, value: i128) -> Option { diff --git a/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs b/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs index 8e7b9d91ee49..b8671c39a943 100644 --- a/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs +++ b/datafusion/physical-expr/src/aggregate/array_agg_distinct.rs @@ -181,8 +181,8 @@ mod tests { use super::*; use crate::expressions::col; use crate::expressions::tests::aggregate; - use arrow::array::{ArrayRef, Int32Array}; - use arrow::datatypes::{DataType, Schema}; + use arrow::array::Int32Array; + use arrow::datatypes::Schema; use arrow::record_batch::RecordBatch; use arrow_array::types::Int32Type; use arrow_array::Array; diff --git a/datafusion/physical-expr/src/aggregate/bit_and_or_xor.rs b/datafusion/physical-expr/src/aggregate/bit_and_or_xor.rs index ad5e8a5ac78f..7244686a5195 100644 --- a/datafusion/physical-expr/src/aggregate/bit_and_or_xor.rs +++ b/datafusion/physical-expr/src/aggregate/bit_and_or_xor.rs @@ -702,8 +702,6 @@ mod tests { use crate::generic_test_op; use arrow::array::*; use arrow::datatypes::*; - use arrow::record_batch::RecordBatch; - use datafusion_common::Result; #[test] fn bit_and_i32() -> Result<()> { diff --git a/datafusion/physical-expr/src/aggregate/bool_and_or.rs b/datafusion/physical-expr/src/aggregate/bool_and_or.rs index 0a018fe086d2..341932bd77a4 100644 --- a/datafusion/physical-expr/src/aggregate/bool_and_or.rs +++ b/datafusion/physical-expr/src/aggregate/bool_and_or.rs @@ -345,8 +345,6 @@ mod tests { use crate::generic_test_op; use arrow::datatypes::*; use arrow::record_batch::RecordBatch; - use arrow_array::BooleanArray; - use datafusion_common::Result; #[test] fn test_bool_and() -> Result<()> { diff --git a/datafusion/physical-expr/src/aggregate/correlation.rs b/datafusion/physical-expr/src/aggregate/correlation.rs index 4dca1e4a881e..a47d35053208 100644 --- a/datafusion/physical-expr/src/aggregate/correlation.rs +++ b/datafusion/physical-expr/src/aggregate/correlation.rs @@ -252,9 +252,7 @@ mod tests { use crate::expressions::col; use crate::expressions::tests::aggregate; use crate::generic_test_op2; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; - use datafusion_common::Result; #[test] fn correlation_f64_1() -> Result<()> { diff --git a/datafusion/physical-expr/src/aggregate/count.rs b/datafusion/physical-expr/src/aggregate/count.rs index 3b0fe0efd3ca..567a5589cb8b 100644 --- a/datafusion/physical-expr/src/aggregate/count.rs +++ b/datafusion/physical-expr/src/aggregate/count.rs @@ -338,9 +338,7 @@ mod tests { use crate::expressions::tests::aggregate; use crate::expressions::{col, lit}; use crate::generic_test_op; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; - use datafusion_common::Result; #[test] fn count_elements() -> Result<()> { diff --git a/datafusion/physical-expr/src/aggregate/count_distinct/mod.rs b/datafusion/physical-expr/src/aggregate/count_distinct/mod.rs index ae3370df723a..52f1c5c0f9a0 100644 --- a/datafusion/physical-expr/src/aggregate/count_distinct/mod.rs +++ b/datafusion/physical-expr/src/aggregate/count_distinct/mod.rs @@ -315,13 +315,8 @@ impl Accumulator for DistinctCountAccumulator { #[cfg(test)] mod tests { use arrow::array::{ - ArrayRef, BooleanArray, Float32Array, Float64Array, Int16Array, Int32Array, - Int64Array, Int8Array, UInt16Array, UInt32Array, UInt64Array, UInt8Array, - }; - use arrow::datatypes::DataType; - use arrow::datatypes::{ - Float32Type, Float64Type, Int16Type, Int32Type, Int64Type, Int8Type, UInt16Type, - UInt32Type, UInt64Type, UInt8Type, + BooleanArray, Float32Array, Float64Array, Int16Array, Int32Array, Int64Array, + Int8Array, UInt16Array, UInt32Array, UInt64Array, UInt8Array, }; use arrow_array::Decimal256Array; use arrow_buffer::i256; diff --git a/datafusion/physical-expr/src/aggregate/count_distinct/native.rs b/datafusion/physical-expr/src/aggregate/count_distinct/native.rs index 97ff1ef257b4..95d8662e0f6e 100644 --- a/datafusion/physical-expr/src/aggregate/count_distinct/native.rs +++ b/datafusion/physical-expr/src/aggregate/count_distinct/native.rs @@ -20,7 +20,6 @@ //! //! [`Int64Array`]: arrow::array::Int64Array //! [`Float64Array`]: arrow::array::Float64Array -use std::cmp::Eq; use std::collections::HashSet; use std::fmt::Debug; use std::hash::Hash; diff --git a/datafusion/physical-expr/src/aggregate/covariance.rs b/datafusion/physical-expr/src/aggregate/covariance.rs index 45f9926975d3..ba9bdbc8aee3 100644 --- a/datafusion/physical-expr/src/aggregate/covariance.rs +++ b/datafusion/physical-expr/src/aggregate/covariance.rs @@ -412,9 +412,7 @@ mod tests { use crate::expressions::col; use crate::expressions::tests::aggregate; use crate::generic_test_op2; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; - use datafusion_common::Result; #[test] fn covariance_f64_1() -> Result<()> { diff --git a/datafusion/physical-expr/src/aggregate/groups_accumulator/accumulate.rs b/datafusion/physical-expr/src/aggregate/groups_accumulator/accumulate.rs index 7080ea40039d..9850b002e40e 100644 --- a/datafusion/physical-expr/src/aggregate/groups_accumulator/accumulate.rs +++ b/datafusion/physical-expr/src/aggregate/groups_accumulator/accumulate.rs @@ -463,7 +463,6 @@ mod test { use super::*; use arrow_array::UInt32Array; - use arrow_buffer::BooleanBuffer; use hashbrown::HashSet; use rand::{rngs::ThreadRng, Rng}; diff --git a/datafusion/physical-expr/src/aggregate/median.rs b/datafusion/physical-expr/src/aggregate/median.rs index 94cc5c7fb76a..ed373ba13d5e 100644 --- a/datafusion/physical-expr/src/aggregate/median.rs +++ b/datafusion/physical-expr/src/aggregate/median.rs @@ -202,7 +202,6 @@ mod tests { use crate::expressions::col; use crate::expressions::tests::aggregate; use crate::generic_test_op; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; #[test] diff --git a/datafusion/physical-expr/src/aggregate/min_max.rs b/datafusion/physical-expr/src/aggregate/min_max.rs index c7ba9a38c9a8..95ae3207462e 100644 --- a/datafusion/physical-expr/src/aggregate/min_max.rs +++ b/datafusion/physical-expr/src/aggregate/min_max.rs @@ -18,7 +18,6 @@ //! Defines physical expressions that can evaluated at runtime during query execution use std::any::Any; -use std::convert::TryFrom; use std::sync::Arc; use crate::aggregate::groups_accumulator::prim_op::PrimitiveGroupsAccumulator; @@ -1113,8 +1112,6 @@ mod tests { use crate::{generic_test_op, generic_test_op_new}; use arrow::datatypes::*; use arrow::record_batch::RecordBatch; - use datafusion_common::Result; - use datafusion_common::ScalarValue; use datafusion_common::ScalarValue::Decimal128; #[test] diff --git a/datafusion/physical-expr/src/aggregate/stddev.rs b/datafusion/physical-expr/src/aggregate/stddev.rs index 6033d63cbe21..e5ce1b9230db 100644 --- a/datafusion/physical-expr/src/aggregate/stddev.rs +++ b/datafusion/physical-expr/src/aggregate/stddev.rs @@ -247,9 +247,7 @@ mod tests { use crate::expressions::col; use crate::expressions::tests::aggregate; use crate::generic_test_op; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; - use datafusion_common::Result; #[test] fn stddev_f64_1() -> Result<()> { diff --git a/datafusion/physical-expr/src/aggregate/string_agg.rs b/datafusion/physical-expr/src/aggregate/string_agg.rs index 1c620c22a164..dc0ffc557968 100644 --- a/datafusion/physical-expr/src/aggregate/string_agg.rs +++ b/datafusion/physical-expr/src/aggregate/string_agg.rs @@ -173,7 +173,6 @@ mod tests { use super::*; use crate::expressions::tests::aggregate; use crate::expressions::{col, create_aggregate_expr, try_cast}; - use arrow::array::ArrayRef; use arrow::datatypes::*; use arrow::record_batch::RecordBatch; use arrow_array::LargeStringArray; diff --git a/datafusion/physical-expr/src/aggregate/sum_distinct.rs b/datafusion/physical-expr/src/aggregate/sum_distinct.rs index a62a7b08da35..09f3f9b498c1 100644 --- a/datafusion/physical-expr/src/aggregate/sum_distinct.rs +++ b/datafusion/physical-expr/src/aggregate/sum_distinct.rs @@ -24,7 +24,7 @@ use ahash::RandomState; use arrow::array::{Array, ArrayRef}; use arrow_array::cast::AsArray; use arrow_array::types::*; -use arrow_array::{ArrowNativeTypeOp, ArrowPrimitiveType}; +use arrow_array::ArrowNativeTypeOp; use arrow_buffer::ArrowNativeType; use std::collections::HashSet; @@ -206,7 +206,6 @@ mod tests { use super::*; use crate::expressions::tests::assert_aggregate; use arrow::array::*; - use datafusion_common::Result; use datafusion_expr::AggregateFunction; fn run_update_batch( diff --git a/datafusion/physical-expr/src/aggregate/variance.rs b/datafusion/physical-expr/src/aggregate/variance.rs index 94d7be4265d7..989041097730 100644 --- a/datafusion/physical-expr/src/aggregate/variance.rs +++ b/datafusion/physical-expr/src/aggregate/variance.rs @@ -339,9 +339,7 @@ mod tests { use crate::expressions::col; use crate::expressions::tests::aggregate; use crate::generic_test_op; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; - use datafusion_common::Result; #[test] fn variance_f64_1() -> Result<()> { diff --git a/datafusion/physical-expr/src/binary_map.rs b/datafusion/physical-expr/src/binary_map.rs index 6c3a452a8611..0923fcdaeb91 100644 --- a/datafusion/physical-expr/src/binary_map.rs +++ b/datafusion/physical-expr/src/binary_map.rs @@ -605,7 +605,6 @@ where #[cfg(test)] mod tests { use super::*; - use arrow::array::ArrayRef; use arrow_array::{BinaryArray, LargeBinaryArray, StringArray}; use hashbrown::HashMap; diff --git a/datafusion/physical-expr/src/equivalence/class.rs b/datafusion/physical-expr/src/equivalence/class.rs index 8a3f8b8280f6..9ea456b0f879 100644 --- a/datafusion/physical-expr/src/equivalence/class.rs +++ b/datafusion/physical-expr/src/equivalence/class.rs @@ -481,12 +481,10 @@ impl EquivalenceGroup { #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; use crate::equivalence::tests::create_test_params; - use crate::equivalence::{EquivalenceClass, EquivalenceGroup}; - use crate::expressions::{lit, Column, Literal}; + use crate::expressions::{lit, Literal}; use datafusion_common::{Result, ScalarValue}; diff --git a/datafusion/physical-expr/src/equivalence/mod.rs b/datafusion/physical-expr/src/equivalence/mod.rs index f78d69d672a6..7fc27172e431 100644 --- a/datafusion/physical-expr/src/equivalence/mod.rs +++ b/datafusion/physical-expr/src/equivalence/mod.rs @@ -112,10 +112,9 @@ pub fn add_offset_to_expr( #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; - use crate::expressions::{col, Column}; + use crate::expressions::col; use crate::PhysicalSortExpr; use arrow::compute::{lexsort_to_indices, SortColumn}; diff --git a/datafusion/physical-expr/src/equivalence/projection.rs b/datafusion/physical-expr/src/equivalence/projection.rs index 18e350b0977e..260610f23dc6 100644 --- a/datafusion/physical-expr/src/equivalence/projection.rs +++ b/datafusion/physical-expr/src/equivalence/projection.rs @@ -114,13 +114,12 @@ impl ProjectionMapping { #[cfg(test)] mod tests { - use std::sync::Arc; use arrow::datatypes::{DataType, Field, Schema}; use arrow_schema::{SortOptions, TimeUnit}; use itertools::Itertools; - use datafusion_common::{DFSchema, Result}; + use datafusion_common::DFSchema; use datafusion_expr::{Operator, ScalarUDF}; use crate::equivalence::tests::{ diff --git a/datafusion/physical-expr/src/equivalence/properties.rs b/datafusion/physical-expr/src/equivalence/properties.rs index 1036779c1412..555f0ad31786 100644 --- a/datafusion/physical-expr/src/equivalence/properties.rs +++ b/datafusion/physical-expr/src/equivalence/properties.rs @@ -1295,13 +1295,11 @@ impl Hash for ExprWrapper { #[cfg(test)] mod tests { use std::ops::Not; - use std::sync::Arc; use arrow::datatypes::{DataType, Field, Schema}; - use arrow_schema::{Fields, SortOptions, TimeUnit}; - use itertools::Itertools; + use arrow_schema::{Fields, TimeUnit}; - use datafusion_common::{DFSchema, Result}; + use datafusion_common::DFSchema; use datafusion_expr::{Operator, ScalarUDF}; use crate::equivalence::add_offset_to_expr; @@ -1312,7 +1310,6 @@ mod tests { }; use crate::expressions::{col, BinaryExpr, Column}; use crate::utils::tests::TestScalarUDF; - use crate::PhysicalSortExpr; use super::*; diff --git a/datafusion/physical-expr/src/expressions/binary.rs b/datafusion/physical-expr/src/expressions/binary.rs index 7c57dc050db5..76154dca0338 100644 --- a/datafusion/physical-expr/src/expressions/binary.rs +++ b/datafusion/physical-expr/src/expressions/binary.rs @@ -34,7 +34,6 @@ use arrow::compute::kernels::comparison::regexp_is_match_utf8_scalar; use arrow::compute::kernels::concat_elements::concat_elements_utf8; use arrow::compute::{cast, ilike, like, nilike, nlike}; use arrow::datatypes::*; -use arrow::record_batch::RecordBatch; use datafusion_common::cast::as_boolean_array; use datafusion_common::{internal_err, Result, ScalarValue}; @@ -624,10 +623,7 @@ pub fn binary( mod tests { use super::*; use crate::expressions::{col, lit, try_cast, Literal}; - use arrow::datatypes::{ - ArrowNumericType, Decimal128Type, Field, Int32Type, SchemaRef, - }; - use datafusion_common::{plan_datafusion_err, Result}; + use datafusion_common::plan_datafusion_err; use datafusion_expr::type_coercion::binary::get_input_types; /// Performs a binary operation, applying any type coercion necessary diff --git a/datafusion/physical-expr/src/expressions/case.rs b/datafusion/physical-expr/src/expressions/case.rs index e376d3e7bbac..7b10df9ac146 100644 --- a/datafusion/physical-expr/src/expressions/case.rs +++ b/datafusion/physical-expr/src/expressions/case.rs @@ -28,7 +28,6 @@ use arrow::compute::kernels::cmp::eq; use arrow::compute::kernels::zip::zip; use arrow::compute::{and, is_null, not, nullif, or, prep_null_mask_filter}; use arrow::datatypes::{DataType, Schema}; -use arrow::record_batch::RecordBatch; use datafusion_common::cast::as_boolean_array; use datafusion_common::{exec_err, internal_err, DataFusionError, Result, ScalarValue}; use datafusion_expr::ColumnarValue; @@ -416,13 +415,12 @@ mod tests { use super::*; use crate::expressions::{binary, cast, col, lit}; - use arrow::array::StringArray; use arrow::buffer::Buffer; use arrow::datatypes::DataType::Float64; use arrow::datatypes::*; use datafusion_common::cast::{as_float64_array, as_int32_array}; + use datafusion_common::plan_err; use datafusion_common::tree_node::{Transformed, TransformedResult, TreeNode}; - use datafusion_common::{plan_err, ScalarValue}; use datafusion_expr::type_coercion::binary::comparison_coercion; use datafusion_expr::Operator; diff --git a/datafusion/physical-expr/src/expressions/cast.rs b/datafusion/physical-expr/src/expressions/cast.rs index e87c643cdeb5..a3b32461e581 100644 --- a/datafusion/physical-expr/src/expressions/cast.rs +++ b/datafusion/physical-expr/src/expressions/cast.rs @@ -228,8 +228,6 @@ mod tests { datatypes::*, }; - use datafusion_common::Result; - // runs an end-to-end test of physical type cast // 1. construct a record batch with a column "a" of type A // 2. construct a physical expression of CAST(a AS B) diff --git a/datafusion/physical-expr/src/expressions/in_list.rs b/datafusion/physical-expr/src/expressions/in_list.rs index 07185b4d6527..9ae4c2784ccf 100644 --- a/datafusion/physical-expr/src/expressions/in_list.rs +++ b/datafusion/physical-expr/src/expressions/in_list.rs @@ -31,7 +31,6 @@ use arrow::compute::kernels::boolean::{not, or_kleene}; use arrow::compute::kernels::cmp::eq; use arrow::compute::take; use arrow::datatypes::*; -use arrow::record_batch::RecordBatch; use arrow::util::bit_iterator::BitIndexIterator; use arrow::{downcast_dictionary_array, downcast_primitive_array}; use datafusion_common::cast::{ @@ -455,13 +454,11 @@ pub fn in_list( #[cfg(test)] mod tests { - use arrow::{array::StringArray, datatypes::Field}; use super::*; use crate::expressions; use crate::expressions::{col, lit, try_cast}; use datafusion_common::plan_err; - use datafusion_common::Result; use datafusion_expr::type_coercion::binary::comparison_coercion; type InListCastResult = (Arc, Vec>); diff --git a/datafusion/physical-expr/src/expressions/is_not_null.rs b/datafusion/physical-expr/src/expressions/is_not_null.rs index 2e6a2bec9cab..c5c673ec28ea 100644 --- a/datafusion/physical-expr/src/expressions/is_not_null.rs +++ b/datafusion/physical-expr/src/expressions/is_not_null.rs @@ -119,10 +119,8 @@ mod tests { use arrow::{ array::{BooleanArray, StringArray}, datatypes::*, - record_batch::RecordBatch, }; use datafusion_common::cast::as_boolean_array; - use std::sync::Arc; #[test] fn is_not_null_op() -> Result<()> { diff --git a/datafusion/physical-expr/src/expressions/is_null.rs b/datafusion/physical-expr/src/expressions/is_null.rs index 3ad4058dd649..b0f70b6f0d7a 100644 --- a/datafusion/physical-expr/src/expressions/is_null.rs +++ b/datafusion/physical-expr/src/expressions/is_null.rs @@ -120,10 +120,8 @@ mod tests { use arrow::{ array::{BooleanArray, StringArray}, datatypes::*, - record_batch::RecordBatch, }; use datafusion_common::cast::as_boolean_array; - use std::sync::Arc; #[test] fn is_null_op() -> Result<()> { diff --git a/datafusion/physical-expr/src/expressions/literal.rs b/datafusion/physical-expr/src/expressions/literal.rs index cd3b51f09105..35ea80ea574d 100644 --- a/datafusion/physical-expr/src/expressions/literal.rs +++ b/datafusion/physical-expr/src/expressions/literal.rs @@ -118,7 +118,6 @@ mod tests { use arrow::array::Int32Array; use arrow::datatypes::*; use datafusion_common::cast::as_int32_array; - use datafusion_common::Result; #[test] fn literal_i32() -> Result<()> { diff --git a/datafusion/physical-expr/src/expressions/negative.rs b/datafusion/physical-expr/src/expressions/negative.rs index d6dd3ddbea5e..f6d4620c427f 100644 --- a/datafusion/physical-expr/src/expressions/negative.rs +++ b/datafusion/physical-expr/src/expressions/negative.rs @@ -180,7 +180,6 @@ mod tests { use arrow_schema::DataType::{Float32, Float64, Int16, Int32, Int64, Int8}; use datafusion_common::cast::as_primitive_array; use datafusion_common::DataFusionError; - use datafusion_common::Result; use paste::paste; diff --git a/datafusion/physical-expr/src/expressions/not.rs b/datafusion/physical-expr/src/expressions/not.rs index f17df73e3070..1428be71cc21 100644 --- a/datafusion/physical-expr/src/expressions/not.rs +++ b/datafusion/physical-expr/src/expressions/not.rs @@ -125,7 +125,6 @@ mod tests { use super::*; use crate::expressions::col; use arrow::{array::BooleanArray, datatypes::*}; - use datafusion_common::Result; #[test] fn neg_op() -> Result<()> { diff --git a/datafusion/physical-expr/src/expressions/try_cast.rs b/datafusion/physical-expr/src/expressions/try_cast.rs index ddfe49dda7a3..d25a904f7d6a 100644 --- a/datafusion/physical-expr/src/expressions/try_cast.rs +++ b/datafusion/physical-expr/src/expressions/try_cast.rs @@ -159,7 +159,6 @@ mod tests { }, datatypes::*, }; - use datafusion_common::Result; // runs an end-to-end test of physical type cast // 1. construct a record batch with a column "a" of type A diff --git a/datafusion/physical-expr/src/functions.rs b/datafusion/physical-expr/src/functions.rs index 875fe7ac3be1..ac5b87e701af 100644 --- a/datafusion/physical-expr/src/functions.rs +++ b/datafusion/physical-expr/src/functions.rs @@ -222,15 +222,14 @@ fn func_order_in_one_dimension( #[cfg(test)] mod tests { use arrow::{ - array::{Array, ArrayRef, UInt64Array}, + array::UInt64Array, datatypes::{DataType, Field}, }; use arrow_schema::DataType::Utf8; use datafusion_common::cast::as_uint64_array; + use datafusion_common::DataFusionError; use datafusion_common::{internal_err, plan_err}; - use datafusion_common::{DataFusionError, Result, ScalarValue}; - use datafusion_expr::type_coercion::functions::data_types; use datafusion_expr::{Signature, Volatility}; use crate::expressions::try_cast; diff --git a/datafusion/physical-expr/src/intervals/cp_solver.rs b/datafusion/physical-expr/src/intervals/cp_solver.rs index 3bd059afa6be..0c25e26d17aa 100644 --- a/datafusion/physical-expr/src/intervals/cp_solver.rs +++ b/datafusion/physical-expr/src/intervals/cp_solver.rs @@ -723,7 +723,7 @@ mod tests { use crate::intervals::test_utils::gen_conjunctive_numerical_expr; use arrow::datatypes::TimeUnit; - use arrow_schema::{DataType, Field}; + use arrow_schema::Field; use datafusion_common::ScalarValue; use itertools::Itertools; diff --git a/datafusion/physical-expr/src/math_expressions.rs b/datafusion/physical-expr/src/math_expressions.rs index cee1b8c787e2..503565b1e261 100644 --- a/datafusion/physical-expr/src/math_expressions.rs +++ b/datafusion/physical-expr/src/math_expressions.rs @@ -79,7 +79,6 @@ pub fn isnan(args: &[ArrayRef]) -> Result { #[cfg(test)] mod tests { - use arrow::array::Float64Array; use datafusion_common::cast::as_boolean_array; diff --git a/datafusion/physical-expr/src/partitioning.rs b/datafusion/physical-expr/src/partitioning.rs index a4a246daf676..fcb3278b6022 100644 --- a/datafusion/physical-expr/src/partitioning.rs +++ b/datafusion/physical-expr/src/partitioning.rs @@ -236,7 +236,6 @@ impl Distribution { #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; use crate::expressions::Column; diff --git a/datafusion/physical-expr/src/planner.rs b/datafusion/physical-expr/src/planner.rs index bf7b52f1c147..f46e5f6ec68f 100644 --- a/datafusion/physical-expr/src/planner.rs +++ b/datafusion/physical-expr/src/planner.rs @@ -386,9 +386,8 @@ where #[cfg(test)] mod tests { use arrow_array::{ArrayRef, BooleanArray, RecordBatch, StringArray}; - use arrow_schema::{DataType, Field, Schema}; + use arrow_schema::{DataType, Field}; - use datafusion_common::{DFSchema, Result}; use datafusion_expr::{col, lit}; use super::*; diff --git a/datafusion/physical-expr/src/utils/mod.rs b/datafusion/physical-expr/src/utils/mod.rs index 2232f6de4452..76cee3a1a786 100644 --- a/datafusion/physical-expr/src/utils/mod.rs +++ b/datafusion/physical-expr/src/utils/mod.rs @@ -258,14 +258,12 @@ pub(crate) mod tests { use arrow_array::{ArrayRef, Float32Array, Float64Array}; use std::any::Any; use std::fmt::{Display, Formatter}; - use std::sync::Arc; use super::*; - use crate::expressions::{binary, cast, col, in_list, lit, Column, Literal}; - use crate::PhysicalSortExpr; + use crate::expressions::{binary, cast, col, in_list, lit, Literal}; use arrow_schema::{DataType, Field, Schema}; - use datafusion_common::{exec_err, DataFusionError, Result, ScalarValue}; + use datafusion_common::{exec_err, DataFusionError, ScalarValue}; use datafusion_expr::{ ColumnarValue, FuncMonotonicity, ScalarUDFImpl, Signature, Volatility, diff --git a/datafusion/physical-expr/src/window/lead_lag.rs b/datafusion/physical-expr/src/window/lead_lag.rs index 2b77e57161a8..7e35bddef568 100644 --- a/datafusion/physical-expr/src/window/lead_lag.rs +++ b/datafusion/physical-expr/src/window/lead_lag.rs @@ -397,10 +397,8 @@ impl PartitionEvaluator for WindowShiftEvaluator { mod tests { use super::*; use crate::expressions::Column; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; use datafusion_common::cast::as_int32_array; - use datafusion_common::Result; fn test_i32_result(expr: WindowShift, expected: Int32Array) -> Result<()> { let arr: ArrayRef = Arc::new(Int32Array::from(vec![1, -2, 3, -4, 5, -6, 7, 8])); diff --git a/datafusion/physical-expr/src/window/nth_value.rs b/datafusion/physical-expr/src/window/nth_value.rs index 9de71c2d604c..55d112e1f6e0 100644 --- a/datafusion/physical-expr/src/window/nth_value.rs +++ b/datafusion/physical-expr/src/window/nth_value.rs @@ -322,10 +322,8 @@ impl PartitionEvaluator for NthValueEvaluator { mod tests { use super::*; use crate::expressions::Column; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; use datafusion_common::cast::as_int32_array; - use datafusion_common::Result; fn test_i32_result(expr: NthValue, expected: Int32Array) -> Result<()> { let arr: ArrayRef = Arc::new(Int32Array::from(vec![1, -2, 3, -4, 5, -6, 7, 8])); diff --git a/datafusion/physical-expr/src/window/row_number.rs b/datafusion/physical-expr/src/window/row_number.rs index 01403424057c..0a1255018d30 100644 --- a/datafusion/physical-expr/src/window/row_number.rs +++ b/datafusion/physical-expr/src/window/row_number.rs @@ -125,9 +125,8 @@ impl PartitionEvaluator for NumRowsEvaluator { #[cfg(test)] mod tests { use super::*; - use arrow::record_batch::RecordBatch; use arrow::{array::*, datatypes::*}; - use datafusion_common::{cast::as_uint64_array, Result}; + use datafusion_common::cast::as_uint64_array; #[test] fn row_number_all_null() -> Result<()> { diff --git a/datafusion/physical-plan/src/aggregates/mod.rs b/datafusion/physical-plan/src/aggregates/mod.rs index ba9a6b1be0ef..14485c833794 100644 --- a/datafusion/physical-plan/src/aggregates/mod.rs +++ b/datafusion/physical-plan/src/aggregates/mod.rs @@ -1185,12 +1185,9 @@ pub(crate) fn evaluate_group_by( #[cfg(test)] mod tests { - use std::any::Any; - use std::sync::Arc; use std::task::{Context, Poll}; use super::*; - use crate::aggregates::{AggregateExec, AggregateMode, PhysicalGroupBy}; use crate::coalesce_batches::CoalesceBatchesExec; use crate::coalesce_partitions::CoalescePartitionsExec; use crate::common; @@ -1198,18 +1195,14 @@ mod tests { use crate::memory::MemoryExec; use crate::test::assert_is_pending; use crate::test::exec::{assert_strong_count_converges_to_zero, BlockingExec}; - use crate::{ - DisplayAs, ExecutionPlan, Partitioning, RecordBatchStream, - SendableRecordBatchStream, Statistics, - }; + use crate::RecordBatchStream; use arrow::array::{Float64Array, UInt32Array}; use arrow::compute::{concat_batches, SortOptions}; - use arrow::datatypes::{DataType, Field, Schema, SchemaRef}; - use arrow::record_batch::RecordBatch; + use arrow::datatypes::DataType; use datafusion_common::{ assert_batches_eq, assert_batches_sorted_eq, internal_err, DataFusionError, - Result, ScalarValue, + ScalarValue, }; use datafusion_execution::config::SessionConfig; use datafusion_execution::memory_pool::FairSpillPool; @@ -1217,10 +1210,7 @@ mod tests { use datafusion_physical_expr::expressions::{ lit, ApproxDistinct, Count, FirstValue, LastValue, Median, OrderSensitiveArrayAgg, }; - use datafusion_physical_expr::{ - reverse_order_bys, AggregateExpr, EquivalenceProperties, PhysicalExpr, - PhysicalSortExpr, - }; + use datafusion_physical_expr::{reverse_order_bys, PhysicalSortExpr}; use futures::{FutureExt, Stream}; diff --git a/datafusion/physical-plan/src/aggregates/row_hash.rs b/datafusion/physical-plan/src/aggregates/row_hash.rs index 45d408bb4de7..ad0860b93a3a 100644 --- a/datafusion/physical-plan/src/aggregates/row_hash.rs +++ b/datafusion/physical-plan/src/aggregates/row_hash.rs @@ -36,7 +36,7 @@ use crate::{aggregates, ExecutionPlan, PhysicalExpr}; use crate::{RecordBatchStream, SendableRecordBatchStream}; use arrow::array::*; -use arrow::{datatypes::SchemaRef, record_batch::RecordBatch}; +use arrow::datatypes::SchemaRef; use arrow_schema::SortOptions; use datafusion_common::{DataFusionError, Result}; use datafusion_execution::disk_manager::RefCountedTempFile; diff --git a/datafusion/physical-plan/src/aggregates/topk/hash_table.rs b/datafusion/physical-plan/src/aggregates/topk/hash_table.rs index 808a068b2850..bae4c6133b9f 100644 --- a/datafusion/physical-plan/src/aggregates/topk/hash_table.rs +++ b/datafusion/physical-plan/src/aggregates/topk/hash_table.rs @@ -386,7 +386,6 @@ pub fn new_hash_table(limit: usize, kt: DataType) -> Result Result Result<()> { diff --git a/datafusion/physical-plan/src/aggregates/topk/priority_map.rs b/datafusion/physical-plan/src/aggregates/topk/priority_map.rs index ee72e4083bf4..668018b9c24c 100644 --- a/datafusion/physical-plan/src/aggregates/topk/priority_map.rs +++ b/datafusion/physical-plan/src/aggregates/topk/priority_map.rs @@ -117,8 +117,7 @@ mod tests { use arrow_array::{Int64Array, RecordBatch, StringArray}; use arrow_schema::Field; use arrow_schema::Schema; - use arrow_schema::{DataType, SchemaRef}; - use datafusion_common::Result; + use arrow_schema::SchemaRef; use std::sync::Arc; #[test] diff --git a/datafusion/physical-plan/src/common.rs b/datafusion/physical-plan/src/common.rs index 59c54199333e..f7cad9df4ba1 100644 --- a/datafusion/physical-plan/src/common.rs +++ b/datafusion/physical-plan/src/common.rs @@ -361,11 +361,10 @@ mod tests { use arrow::compute::SortOptions; use arrow::{ array::{Float32Array, Float64Array, UInt64Array}, - datatypes::{DataType, Field, Schema}, - record_batch::RecordBatch, + datatypes::{DataType, Field}, }; use datafusion_expr::Operator; - use datafusion_physical_expr::expressions::{col, Column}; + use datafusion_physical_expr::expressions::col; #[test] fn get_meet_of_orderings_helper_common_prefix_test() -> Result<()> { diff --git a/datafusion/physical-plan/src/empty.rs b/datafusion/physical-plan/src/empty.rs index 6178f7c88c07..33bf1668b3c9 100644 --- a/datafusion/physical-plan/src/empty.rs +++ b/datafusion/physical-plan/src/empty.rs @@ -162,8 +162,8 @@ impl ExecutionPlan for EmptyExec { #[cfg(test)] mod tests { use super::*; + use crate::test; use crate::with_new_children_if_necessary; - use crate::{common, test}; #[tokio::test] async fn empty() -> Result<()> { diff --git a/datafusion/physical-plan/src/filter.rs b/datafusion/physical-plan/src/filter.rs index a9201f435ad8..bf1ab8b73126 100644 --- a/datafusion/physical-plan/src/filter.rs +++ b/datafusion/physical-plan/src/filter.rs @@ -433,20 +433,16 @@ pub type EqualAndNonEqual<'a> = #[cfg(test)] mod tests { - use std::iter::Iterator; - use std::sync::Arc; use super::*; use crate::expressions::*; use crate::test; use crate::test::exec::StatisticsExec; - use crate::ExecutionPlan; use crate::empty::EmptyExec; - use arrow::datatypes::{DataType, Field, Schema}; + use arrow::datatypes::{Field, Schema}; use arrow_schema::{UnionFields, UnionMode}; - use datafusion_common::{ColumnStatistics, ScalarValue}; - use datafusion_expr::Operator; + use datafusion_common::ScalarValue; #[tokio::test] async fn collect_columns_predicates() -> Result<()> { diff --git a/datafusion/physical-plan/src/joins/hash_join.rs b/datafusion/physical-plan/src/joins/hash_join.rs index 2b553135ada1..d3abedbe3806 100644 --- a/datafusion/physical-plan/src/joins/hash_join.rs +++ b/datafusion/physical-plan/src/joins/hash_join.rs @@ -1556,16 +1556,15 @@ impl Stream for HashJoinStream { #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; use crate::{ - common, expressions::Column, hash_utils::create_hashes, memory::MemoryExec, - repartition::RepartitionExec, test::build_table_i32, test::exec::MockExec, + common, expressions::Column, memory::MemoryExec, repartition::RepartitionExec, + test::build_table_i32, test::exec::MockExec, }; - use arrow::array::{ArrayRef, Date32Array, Int32Array, UInt32Builder, UInt64Builder}; - use arrow::datatypes::{DataType, Field, Schema}; + use arrow::array::{Date32Array, Int32Array, UInt32Builder, UInt64Builder}; + use arrow::datatypes::{DataType, Field}; use datafusion_common::{ assert_batches_eq, assert_batches_sorted_eq, assert_contains, exec_err, ScalarValue, @@ -1574,11 +1573,10 @@ mod tests { use datafusion_execution::runtime_env::{RuntimeConfig, RuntimeEnv}; use datafusion_expr::Operator; use datafusion_physical_expr::expressions::{BinaryExpr, Literal}; - use datafusion_physical_expr::PhysicalExpr; use hashbrown::raw::RawTable; use rstest::*; - use rstest_reuse::{self, *}; + use rstest_reuse::*; fn div_ceil(a: usize, b: usize) -> usize { (a + b - 1) / b diff --git a/datafusion/physical-plan/src/joins/nested_loop_join.rs b/datafusion/physical-plan/src/joins/nested_loop_join.rs index 5fccd63029a1..47e262c3c8f6 100644 --- a/datafusion/physical-plan/src/joins/nested_loop_join.rs +++ b/datafusion/physical-plan/src/joins/nested_loop_join.rs @@ -661,7 +661,6 @@ impl RecordBatchStream for NestedLoopJoinStream { #[cfg(test)] mod tests { - use std::sync::Arc; use super::*; use crate::{ @@ -674,7 +673,7 @@ mod tests { use datafusion_execution::runtime_env::{RuntimeConfig, RuntimeEnv}; use datafusion_expr::Operator; use datafusion_physical_expr::expressions::{BinaryExpr, Literal}; - use datafusion_physical_expr::{Partitioning, PhysicalExpr}; + use datafusion_physical_expr::PhysicalExpr; fn build_table( a: (&str, &Vec), diff --git a/datafusion/physical-plan/src/joins/sort_merge_join.rs b/datafusion/physical-plan/src/joins/sort_merge_join.rs index 21630087f2ca..2da88173a410 100644 --- a/datafusion/physical-plan/src/joins/sort_merge_join.rs +++ b/datafusion/physical-plan/src/joins/sort_merge_join.rs @@ -46,7 +46,6 @@ use arrow::array::*; use arrow::compute::{self, concat_batches, take, SortOptions}; use arrow::datatypes::{DataType, SchemaRef, TimeUnit}; use arrow::error::ArrowError; -use arrow::record_batch::RecordBatch; use datafusion_common::{ internal_err, not_impl_err, plan_err, DataFusionError, JoinSide, JoinType, Result, }; diff --git a/datafusion/physical-plan/src/joins/stream_join_utils.rs b/datafusion/physical-plan/src/joins/stream_join_utils.rs index ef3fda37377d..f19eb30313e6 100644 --- a/datafusion/physical-plan/src/joins/stream_join_utils.rs +++ b/datafusion/physical-plan/src/joins/stream_join_utils.rs @@ -1121,22 +1121,12 @@ pub fn prepare_sorted_exprs( #[cfg(test)] pub mod tests { - use std::sync::Arc; use super::*; - use crate::joins::stream_join_utils::{ - build_filter_input_order, check_filter_expr_contains_sort_information, - convert_sort_expr_with_filter_schema, PruningJoinHashMap, - }; - use crate::{ - expressions::{Column, PhysicalSortExpr}, - joins::test_utils::complicated_filter, - joins::utils::{ColumnIndex, JoinFilter}, - }; + use crate::{joins::test_utils::complicated_filter, joins::utils::ColumnIndex}; use arrow::compute::SortOptions; - use arrow::datatypes::{DataType, Field, Schema}; - use datafusion_common::JoinSide; + use arrow::datatypes::{DataType, Field}; use datafusion_expr::Operator; use datafusion_physical_expr::expressions::{binary, cast, col}; diff --git a/datafusion/physical-plan/src/joins/symmetric_hash_join.rs b/datafusion/physical-plan/src/joins/symmetric_hash_join.rs index 453b217f7fc7..9d48c2a7d408 100644 --- a/datafusion/physical-plan/src/joins/symmetric_hash_join.rs +++ b/datafusion/physical-plan/src/joins/symmetric_hash_join.rs @@ -1335,7 +1335,7 @@ mod tests { }; use arrow::compute::SortOptions; - use arrow::datatypes::{DataType, Field, IntervalUnit, Schema, TimeUnit}; + use arrow::datatypes::{DataType, Field, IntervalUnit, TimeUnit}; use datafusion_common::ScalarValue; use datafusion_execution::config::SessionConfig; use datafusion_expr::Operator; diff --git a/datafusion/physical-plan/src/placeholder_row.rs b/datafusion/physical-plan/src/placeholder_row.rs index d781c41d0447..c94c2b0607d7 100644 --- a/datafusion/physical-plan/src/placeholder_row.rs +++ b/datafusion/physical-plan/src/placeholder_row.rs @@ -180,7 +180,7 @@ impl ExecutionPlan for PlaceholderRowExec { #[cfg(test)] mod tests { use super::*; - use crate::{common, test, with_new_children_if_necessary}; + use crate::{test, with_new_children_if_necessary}; #[test] fn with_new_children() -> Result<()> { diff --git a/datafusion/physical-plan/src/repartition/mod.rs b/datafusion/physical-plan/src/repartition/mod.rs index faf55aaf01ef..b6554f46cf78 100644 --- a/datafusion/physical-plan/src/repartition/mod.rs +++ b/datafusion/physical-plan/src/repartition/mod.rs @@ -1010,14 +1010,12 @@ mod tests { {collect, expressions::col, memory::MemoryExec}, }; - use arrow::array::{ArrayRef, StringArray, UInt32Array}; + use arrow::array::{StringArray, UInt32Array}; use arrow::datatypes::{DataType, Field, Schema}; - use arrow::record_batch::RecordBatch; use datafusion_common::cast::as_string_array; use datafusion_common::{assert_batches_sorted_eq, exec_err}; use datafusion_execution::runtime_env::{RuntimeConfig, RuntimeEnv}; - use futures::FutureExt; use tokio::task::JoinSet; #[tokio::test] diff --git a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs index edef022b0c00..88c6c312b94b 100644 --- a/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs +++ b/datafusion/physical-plan/src/sorts/sort_preserving_merge.rs @@ -261,7 +261,6 @@ impl ExecutionPlan for SortPreservingMergeExec { #[cfg(test)] mod tests { - use std::iter::FromIterator; use super::*; use crate::coalesce_partitions::CoalescePartitionsExec; diff --git a/datafusion/physical-plan/src/union.rs b/datafusion/physical-plan/src/union.rs index 69901aa2fa37..1354644788ea 100644 --- a/datafusion/physical-plan/src/union.rs +++ b/datafusion/physical-plan/src/union.rs @@ -599,7 +599,6 @@ mod tests { use crate::memory::MemoryExec; use crate::test; - use arrow::record_batch::RecordBatch; use arrow_schema::{DataType, SortOptions}; use datafusion_common::ScalarValue; use datafusion_physical_expr::expressions::col; diff --git a/datafusion/physical-plan/src/unnest.rs b/datafusion/physical-plan/src/unnest.rs index d2b5e1975d56..06dd8230d39e 100644 --- a/datafusion/physical-plan/src/unnest.rs +++ b/datafusion/physical-plan/src/unnest.rs @@ -590,7 +590,7 @@ fn batch_from_indices( #[cfg(test)] mod tests { use super::*; - use arrow::datatypes::{DataType, Field}; + use arrow::datatypes::Field; use arrow_array::{GenericListArray, OffsetSizeTrait, StringArray}; use arrow_buffer::{BooleanBufferBuilder, NullBuffer, OffsetBuffer}; diff --git a/datafusion/physical-plan/src/values.rs b/datafusion/physical-plan/src/values.rs index 3d38081fcd8c..2aa893fd2916 100644 --- a/datafusion/physical-plan/src/values.rs +++ b/datafusion/physical-plan/src/values.rs @@ -214,7 +214,7 @@ mod tests { use crate::expressions::lit; use crate::test::{self, make_partition}; - use arrow_schema::{DataType, Field, Schema}; + use arrow_schema::{DataType, Field}; #[tokio::test] async fn values_empty_case() -> Result<()> { diff --git a/datafusion/physical-plan/src/windows/mod.rs b/datafusion/physical-plan/src/windows/mod.rs index e01ee06a12b8..6de94b0e4103 100644 --- a/datafusion/physical-plan/src/windows/mod.rs +++ b/datafusion/physical-plan/src/windows/mod.rs @@ -18,7 +18,6 @@ //! Physical expressions for window functions use std::borrow::Borrow; -use std::convert::TryInto; use std::sync::Arc; use crate::{ @@ -559,7 +558,6 @@ mod tests { use crate::test::exec::{assert_strong_count_converges_to_zero, BlockingExec}; use arrow::compute::SortOptions; - use arrow::datatypes::{DataType, Field, SchemaRef}; use datafusion_execution::TaskContext; use futures::FutureExt; diff --git a/datafusion/physical-plan/src/work_table.rs b/datafusion/physical-plan/src/work_table.rs index dfdb624a5625..b3c9043d4fdc 100644 --- a/datafusion/physical-plan/src/work_table.rs +++ b/datafusion/physical-plan/src/work_table.rs @@ -219,9 +219,8 @@ impl ExecutionPlan for WorkTableExec { #[cfg(test)] mod tests { use super::*; - use arrow_array::{ArrayRef, Int32Array, RecordBatch}; + use arrow_array::{ArrayRef, Int32Array}; use datafusion_execution::memory_pool::{MemoryConsumer, UnboundedMemoryPool}; - use std::sync::Arc; #[test] fn test_work_table() { diff --git a/datafusion/proto/src/physical_plan/from_proto.rs b/datafusion/proto/src/physical_plan/from_proto.rs index 4b8a48062381..6184332ea581 100644 --- a/datafusion/proto/src/physical_plan/from_proto.rs +++ b/datafusion/proto/src/physical_plan/from_proto.rs @@ -18,7 +18,6 @@ //! Serde code to convert from protocol buffers to Rust data structures. use std::collections::HashMap; -use std::convert::{TryFrom, TryInto}; use std::sync::Arc; use arrow::compute::SortOptions; diff --git a/datafusion/proto/src/physical_plan/mod.rs b/datafusion/proto/src/physical_plan/mod.rs index a481e7090fb3..1c5ba861d297 100644 --- a/datafusion/proto/src/physical_plan/mod.rs +++ b/datafusion/proto/src/physical_plan/mod.rs @@ -15,7 +15,6 @@ // specific language governing permissions and limitations // under the License. -use std::convert::TryInto; use std::fmt::Debug; use std::sync::Arc; diff --git a/datafusion/proto/src/physical_plan/to_proto.rs b/datafusion/proto/src/physical_plan/to_proto.rs index 7b6f745fed6a..aa6121bebc34 100644 --- a/datafusion/proto/src/physical_plan/to_proto.rs +++ b/datafusion/proto/src/physical_plan/to_proto.rs @@ -16,10 +16,7 @@ // under the License.language governing permissions and // limitations under the License. -use std::{ - convert::{TryFrom, TryInto}, - sync::Arc, -}; +use std::sync::Arc; #[cfg(feature = "parquet")] use datafusion::datasource::file_format::parquet::ParquetSink; diff --git a/datafusion/proto/tests/cases/roundtrip_logical_plan.rs b/datafusion/proto/tests/cases/roundtrip_logical_plan.rs index f97559e03af2..1fd6160c2c6c 100644 --- a/datafusion/proto/tests/cases/roundtrip_logical_plan.rs +++ b/datafusion/proto/tests/cases/roundtrip_logical_plan.rs @@ -46,10 +46,10 @@ use datafusion_expr::expr::{ }; use datafusion_expr::logical_plan::{Extension, UserDefinedLogicalNodeCore}; use datafusion_expr::{ - col, create_udaf, lit, Accumulator, AggregateFunction, ColumnarValue, Expr, - ExprSchemable, LogicalPlan, Operator, PartitionEvaluator, ScalarUDF, ScalarUDFImpl, - Signature, TryCast, Volatility, WindowFrame, WindowFrameBound, WindowFrameUnits, - WindowFunctionDefinition, WindowUDF, WindowUDFImpl, + Accumulator, AggregateFunction, ColumnarValue, ExprSchemable, LogicalPlan, Operator, + PartitionEvaluator, ScalarUDF, ScalarUDFImpl, Signature, TryCast, Volatility, + WindowFrame, WindowFrameBound, WindowFrameUnits, WindowFunctionDefinition, WindowUDF, + WindowUDFImpl, }; use datafusion_proto::bytes::{ logical_plan_from_bytes, logical_plan_from_bytes_with_extension_codec, diff --git a/datafusion/sql/src/expr/mod.rs b/datafusion/sql/src/expr/mod.rs index 3f2134bf7e9b..0d1db8a29cce 100644 --- a/datafusion/sql/src/expr/mod.rs +++ b/datafusion/sql/src/expr/mod.rs @@ -1030,7 +1030,7 @@ mod tests { use std::collections::HashMap; use std::sync::Arc; - use arrow::datatypes::{DataType, Field, Schema}; + use arrow::datatypes::{Field, Schema}; use sqlparser::dialect::GenericDialect; use sqlparser::parser::Parser;