Day 1

datafusion/src/execution/dataframe_impl.rs

@@ -19,7 +19,7 @@
 
 use std::sync::{Arc, Mutex};
 
-use arrow::io::print
+use arrow::io::print;
 use arrow::record_batch::RecordBatch;
 use crate::error::Result;
 use crate::execution::context::{ExecutionContext, ExecutionContextState};

datafusion/src/logical_plan/plan.rs

@@ -31,18 +31,6 @@ use std::{
     sync::Arc,
 };
 
-use arrow::datatypes::{DataType, Field, Schema, SchemaRef};
-
-use crate::datasource::TableProvider;
-use crate::sql::parser::FileType;
-
-use super::extension::UserDefinedLogicalNode;
-use super::{
-    display::{GraphvizVisitor, IndentVisitor},
-    Column,
-};
-use crate::logical_plan::dfschema::DFSchemaRef;
-
 /// Join type
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum JoinType {

datafusion/src/optimizer/constant_folding.rs

@@ -21,7 +21,6 @@
 use std::sync::Arc;
 
 use arrow::compute::cast;
-use arrow::compute::kernels::cast_utils::string_to_timestamp_nanos;
 use arrow::datatypes::DataType;
 use arrow::temporal_conversions::utf8_to_timestamp_ns_scalar;
 
@@ -32,7 +31,6 @@ use crate::optimizer::optimizer::OptimizerRule;
 use crate::optimizer::utils;
 use crate::physical_plan::functions::BuiltinScalarFunction;
 use crate::scalar::ScalarValue;
-use arrow::compute::{kernels, DEFAULT_CAST_OPTIONS};
 
 /// Optimizer that simplifies comparison expressions involving boolean literals.
 ///

datafusion/src/physical_plan/analyze.rs

@@ -25,7 +25,7 @@ use crate::{
     physical_plan::{display::DisplayableExecutionPlan, Partitioning},
     physical_plan::{DisplayFormatType, ExecutionPlan},
 };
-use arrow::{array::StringBuilder, datatypes::SchemaRef, record_batch::RecordBatch};
+use arrow::{datatypes::SchemaRef, record_batch::RecordBatch};
 use futures::StreamExt;
 
 use super::{stream::RecordBatchReceiverStream, Distribution, SendableRecordBatchStream};

datafusion/src/physical_plan/datetime_expressions.rs

@@ -27,8 +27,7 @@ use arrow::{
     array::*,
     compute::cast,
     datatypes::{
-        ArrowPrimitiveType, DataType, TimeUnit, TimestampMicrosecondType,
-        TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType,
+        DataType, TimeUnit,
     },
     temporal_conversions::utf8_to_timestamp_ns_scalar,
     types::NativeType,

datafusion/src/physical_plan/expressions/binary.rs

@@ -776,25 +776,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn modulus_op() -> Result<()> {
-        let schema = Arc::new(Schema::new(vec![
-            Field::new("a", DataType::Int32, false),
-            Field::new("b", DataType::Int32, false),
-        ]));
-        let a = Arc::new(Int32Array::from(vec![8, 32, 128, 512, 2048]));
-        let b = Arc::new(Int32Array::from(vec![2, 4, 7, 14, 32]));
-
-        apply_arithmetic::<i32>(
-            schema,
-            vec![a, b],
-            Operator::Modulo,
-            Int32Array::from(vec![0, 0, 2, 8, 0]),
-        )?;
-
-        Ok(())
-    }
-
     fn apply_arithmetic<T: NativeType>(
         schema: Arc<Schema>,
         data: Vec<Arc<dyn Array>>,

datafusion/src/physical_plan/expressions/in_list.rs

@@ -41,6 +41,17 @@ macro_rules! compare_op_scalar {
     }};
 }
 
+// TODO: primitive array currently doesn't have `values_iter()`, it may
+// worth adding one there, and this specialized case could be removed.
+macro_rules! compare_primitive_op_scalar {
+    ($left: expr, $right:expr, $op:expr) => {{
+        let validity = $left.validity();
+        let values =
+            Bitmap::from_trusted_len_iter($left.values().iter().map(|x| $op(x, $right)));
+        Ok(BooleanArray::from_data(DataType::Boolean, values, validity))
+    }};
+}
+
 /// InList
 #[derive(Debug)]
 pub struct InListExpr {
@@ -162,18 +173,18 @@ macro_rules! make_contains_primitive {
 // whether each value on the left (can be null) is contained in the non-null list
 fn in_list_primitive<T: NativeType>(
     array: &PrimitiveArray<T>,
-    values: &[<T as NativeType>],
+    values: &[T],
 ) -> Result<BooleanArray> {
-    compare_op_scalar!(array, values, |x, v: &[<T as NativeType>]| v
+    compare_primitive_op_scalar!(array, values, |x, v| v
         .contains(&x))
 }
 
 // whether each value on the left (can be null) is contained in the non-null list
 fn not_in_list_primitive<T: NativeType>(
     array: &PrimitiveArray<T>,
-    values: &[<T as NativeType>],
+    values: &[T],
 ) -> Result<BooleanArray> {
-    compare_op_scalar!(array, values, |x, v: &[<T as NativeType>]| !v
+    compare_primitive_op_scalar!(array, values, |x, v| !v
         .contains(&x))
 }
 

datafusion/src/physical_plan/hash_utils.rs

@@ -116,7 +116,7 @@ fn combine_hashes(l: u64, r: u64) -> u64 {
 }
 
 macro_rules! hash_array {
-    ($array_type:ident, $column: ident, $ty: ident, $hashes: ident, $random_state: ident, $multi_col: ident) => {
+    ($array_type:ty, $column: ident, $ty: ident, $hashes: ident, $random_state: ident, $multi_col: ident) => {
         let array = $column.as_any().downcast_ref::<$array_type>().unwrap();
         if array.null_count() == 0 {
             if $multi_col {

datafusion/src/physical_plan/mod.rs

@@ -22,7 +22,7 @@ use self::metrics::MetricsSet;
 use self::{
     coalesce_partitions::CoalescePartitionsExec, display::DisplayableExecutionPlan,
 };
-use crate::expressions::{PhysicalSortExpr, SortColumn};
+use crate::physical_plan::expressions::{PhysicalSortExpr, SortColumn};
 use crate::{
     error::{DataFusionError, Result},
     scalar::ScalarValue,

datafusion/src/physical_plan/parquet.rs

@@ -41,7 +41,7 @@ use arrow::{
     record_batch::RecordBatch,
 };
 use log::debug;
-use parquet::file::reader::{FileReader, SerializedFileReader};
+
 use parquet::statistics::{
     BinaryStatistics as ParquetBinaryStatistics,
     BooleanStatistics as ParquetBooleanStatistics,
@@ -579,7 +579,7 @@ fn read_partition(
             ParquetFileMetrics::new(partition_index, &*partitioned_file.path, &metrics);
         let mut file = File::open(partitioned_file.path.as_str())?;
         let reader = read::RecordReader::try_new(
-            std::io::BufReader::new(file)
+            std::io::BufReader::new(file),
             Some(projection.to_vec()),
             limit,
             None,

datafusion/src/physical_plan/repartition.rs

@@ -28,7 +28,7 @@ use crate::physical_plan::hash_utils::create_hashes;
 use crate::physical_plan::{DisplayFormatType, ExecutionPlan, Partitioning};
 use arrow::record_batch::RecordBatch;
 use arrow::{
-    array::{Array, ArrayRef, UInt32Array, UInt64Array, Utf8Array},
+    array::{Array, UInt64Array},
     error::Result as ArrowResult,
 };
 use arrow::{compute::take, datatypes::SchemaRef};