clippy

Author: comphead

native/core/src/execution/planner.rs

@@ -69,11 +69,11 @@ use datafusion_comet_spark_expr::{create_comet_physical_fun, create_negate_expr}
 use crate::execution::operators::ExecutionError::GeneralError;
 use crate::execution::shuffle::CompressionCodec;
 use crate::execution::spark_plan::SparkPlan;
-use crate::parquet::parquet_support::{prepare_object_store, SparkParquetOptions};
+use crate::parquet::parquet_support::prepare_object_store;
 use datafusion::common::scalar::ScalarStructBuilder;
 use datafusion::common::{
     tree_node::{Transformed, TransformedResult, TreeNode, TreeNodeRecursion, TreeNodeRewriter},
-    ExprSchema, JoinType as DFJoinType, ScalarValue,
+    JoinType as DFJoinType, ScalarValue,
 };
 use datafusion::datasource::listing::PartitionedFile;
 use datafusion::logical_expr::type_coercion::other::get_coerce_type_for_case_expression;
@@ -86,10 +86,6 @@ use datafusion::physical_expr::window::WindowExpr;
 use datafusion::physical_expr::LexOrdering;
 
 use crate::parquet::parquet_exec::init_datasource_exec;
-use crate::parquet::schema_adapter::SparkSchemaAdapterFactory;
-use datafusion::datasource::object_store::ObjectStoreUrl;
-use datafusion::datasource::physical_plan::{FileGroup, FileScanConfigBuilder, ParquetSource};
-use datafusion::datasource::source::DataSourceExec;
 use datafusion::physical_plan::coalesce_batches::CoalesceBatchesExec;
 use datafusion::physical_plan::filter::FilterExec as DataFusionFilterExec;
 use datafusion_comet_proto::spark_operator::SparkFilePartition;
@@ -112,14 +108,12 @@ use datafusion_comet_spark_expr::{
     SparkCastOptions, StartsWith, Stddev, StringSpaceExpr, SubstringExpr, SumDecimal,
     TimestampTruncExpr, ToJson, UnboundColumn, Variance,
 };
-use futures::StreamExt;
 use itertools::Itertools;
 use jni::objects::GlobalRef;
 use num::{BigInt, ToPrimitive};
 use object_store::path::Path;
 use std::cmp::max;
 use std::{collections::HashMap, sync::Arc};
-use tokio::runtime::Runtime;
 use url::Url;
 
 // For clippy error on type_complexity.
@@ -3512,22 +3506,20 @@ mod tests {
     #[test]
     fn test_struct_field_2() {
         let session_ctx = SessionContext::new();
-        let task_ctx = session_ctx.task_ctx();
 
         let required_schema = Schema::new(Fields::from(vec![Field::new(
             "c0",
             DataType::List(
                 Field::new(
                     "element",
                     DataType::Struct(Fields::from(vec![
-                        Field::new("a", DataType::Int32, false).into(),
-                        Field::new("c", DataType::Utf8, false).into(),
+                        Field::new("a", DataType::Int32, false),
+                        Field::new("c", DataType::Utf8, false),
                     ] as Vec<Field>)),
                     false,
                 )
                 .into(),
-            )
-            .into(),
+            ),
             false,
         )]));
 
@@ -3553,7 +3545,7 @@ mod tests {
         let rt = Runtime::new().unwrap();
         let result: Vec<_> = rt.block_on(stream.collect());
 
-        let actual = result.get(0).unwrap().as_ref().unwrap();
+        let actual = result.first().unwrap().as_ref().unwrap();
 
         let expected = [
             "+----------------+",

native/core/src/parquet/parquet_support.rs

@@ -18,7 +18,6 @@
 use crate::execution::operators::ExecutionError;
 use arrow::array::ListArray;
 use arrow::compute::can_cast_types;
-use arrow::datatypes::Field;
 use arrow::{
     array::{
         cast::AsArray, new_null_array, types::Int32Type, types::TimestampMicrosecondType, Array,
@@ -192,21 +191,20 @@ fn cast_list_to_list(
     parquet_options: &SparkParquetOptions,
 ) -> DataFusionResult<ArrayRef> {
     match (from_type, to_type) {
-        (DataType::List(from_inner_type), DataType::List(to_inner_type)) => {
+        (DataType::List(_), DataType::List(to_inner_type)) => {
             //dbg!(from_type);
             //dbg!(to_type);
             //dbg!(from_inner_type);
             //dbg!(to_inner_type);
 
             let cast_field = cast_array(
-                array.values().clone(),
+                Arc::clone(array.values()),
                 to_inner_type.data_type(),
                 parquet_options,
-            )
-            .unwrap();
+            )?;
 
             Ok(Arc::new(ListArray::new(
-                to_inner_type.clone(),
+                Arc::clone(to_inner_type),
                 array.offsets().clone(),
                 cast_field,
                 array.nulls().cloned(),
@@ -318,9 +316,7 @@ pub(crate) fn prepare_object_store(
 #[cfg(test)]
 mod tests {
     use crate::parquet::parquet_support::prepare_object_store;
-    use arrow::array::{
-        Array, ArrayBuilder, Int32Builder, ListBuilder, StringBuilder, StructBuilder,
-    };
+    use arrow::array::{Array, Int32Builder, ListBuilder, StringBuilder, StructBuilder};
     use arrow::compute::{can_cast_types, cast_with_options, CastOptions};
     use arrow::datatypes::{DataType, Field, Fields};
     use datafusion::execution::object_store::ObjectStoreUrl;
@@ -404,8 +400,6 @@ mod tests {
             Arc::new(Field::new("c", DataType::Utf8, true)),
         ]);
 
-        let struct_field = Field::new_list_field(DataType::Struct(fields.clone()), true);
-        let list_field = Field::new("list", DataType::List(Arc::new(struct_field)), true);
         let a_col_builder = Int32Builder::with_capacity(1);
         let b_col_builder = StringBuilder::new();
         let c_col_builder = StringBuilder::new();
@@ -447,8 +441,8 @@ mod tests {
             Field::new(
                 "element",
                 DataType::Struct(Fields::from(vec![
-                    Field::new("a", DataType::Int32, false).into(),
-                    Field::new("c", DataType::Utf8, false).into(),
+                    Field::new("a", DataType::Int32, false),
+                    Field::new("c", DataType::Utf8, false),
                 ] as Vec<Field>)),
                 false,
             )