refactor: improve readability

Author: dariocurr

benches/mode.rs

@@ -19,7 +19,7 @@ use arrow::util::bench_util::{create_primitive_array, create_string_array};
 use criterion::{Criterion, criterion_group, criterion_main};
 use datafusion::{arrow, logical_expr::Accumulator};
 use datafusion_functions_extra::common::mode::{BytesModeAccumulator, PrimitiveModeAccumulator};
-use std::{hint, sync};
+use std::{hint, slice, sync};
 
 fn prepare_primitive_mode_accumulator() -> Box<dyn Accumulator> {
     Box::new(PrimitiveModeAccumulator::<arrow::datatypes::Int32Type>::new(
@@ -35,7 +35,7 @@ fn mode_bench_primitive(c: &mut Criterion, name: &str, values: arrow::array::Arr
     let mut accumulator = prepare_primitive_mode_accumulator();
     c.bench_function(name, |b| {
         b.iter(|| {
-            accumulator.update_batch(&[values.clone()]).unwrap();
+            accumulator.update_batch(slice::from_ref(&values)).unwrap();
             hint::black_box(accumulator.evaluate().unwrap());
         });
     });
@@ -45,7 +45,7 @@ fn mode_bench_bytes(c: &mut Criterion, name: &str, values: arrow::array::ArrayRe
     let mut accumulator = prepare_bytes_mode_accumulator();
     c.bench_function(name, |b| {
         b.iter(|| {
-            accumulator.update_batch(&[values.clone()]).unwrap();
+            accumulator.update_batch(slice::from_ref(&values)).unwrap();
             hint::black_box(accumulator.evaluate().unwrap());
         });
     });

src/common/mode/bytes.rs

@@ -17,7 +17,7 @@
 
 use datafusion::arrow::array::AsArray;
 use datafusion::{arrow, common, error, logical_expr, scalar};
-use std::collections;
+use std::{collections, mem};
 
 #[derive(Debug)]
 pub struct BytesModeAccumulator {
@@ -142,7 +142,7 @@ impl logical_expr::Accumulator for BytesModeAccumulator {
     }
 
     fn size(&self) -> usize {
-        self.value_counts.capacity() * std::mem::size_of::<(String, i64)>() + std::mem::size_of_val(&self.data_type)
+        self.value_counts.capacity() * mem::size_of::<(String, i64)>() + mem::size_of_val(&self.data_type)
     }
 }
 

src/common/mode/native.rs

@@ -17,7 +17,7 @@
 
 use datafusion::physical_expr::aggregate::utils::Hashable;
 use datafusion::{arrow, common, error, logical_expr, scalar};
-use std::{collections, fmt, hash};
+use std::{cmp, collections, fmt, hash, mem};
 
 #[derive(fmt::Debug)]
 pub struct PrimitiveModeAccumulator<T>
@@ -108,11 +108,11 @@ where
 
         self.value_counts.iter().for_each(|(value, &count)| {
             match count.cmp(&max_count) {
-                std::cmp::Ordering::Greater => {
+                cmp::Ordering::Greater => {
                     max_value = Some(*value);
                     max_count = count;
                 }
-                std::cmp::Ordering::Equal => {
+                cmp::Ordering::Equal => {
                     max_value = match max_value {
                         Some(ref current_max_value) if value > current_max_value => Some(*value),
                         Some(ref current_max_value) => Some(*current_max_value),
@@ -130,7 +130,7 @@ where
     }
 
     fn size(&self) -> usize {
-        std::mem::size_of_val(&self.value_counts) + self.value_counts.len() * std::mem::size_of::<(T::Native, i64)>()
+        mem::size_of_val(&self.value_counts) + self.value_counts.len() * mem::size_of::<(T::Native, i64)>()
     }
 }
 
@@ -221,11 +221,11 @@ where
 
         self.value_counts.iter().for_each(|(value, &count)| {
             match count.cmp(&max_count) {
-                std::cmp::Ordering::Greater => {
+                cmp::Ordering::Greater => {
                     max_value = Some(value.0);
                     max_count = count;
                 }
-                std::cmp::Ordering::Equal => {
+                cmp::Ordering::Equal => {
                     max_value = match max_value {
                         Some(current_max_value) if value.0 > current_max_value => Some(value.0),
                         Some(current_max_value) => Some(current_max_value),
@@ -243,8 +243,7 @@ where
     }
 
     fn size(&self) -> usize {
-        std::mem::size_of_val(&self.value_counts)
-            + self.value_counts.len() * std::mem::size_of::<(Hashable<T::Native>, i64)>()
+        mem::size_of_val(&self.value_counts) + self.value_counts.len() * mem::size_of::<(Hashable<T::Native>, i64)>()
     }
 }
 

src/kurtosis.rs

@@ -17,7 +17,7 @@
 
 use datafusion::arrow::array::{Float64Array, UInt64Array};
 use datafusion::{arrow, common, error, logical_expr, scalar};
-use std::{any, fmt};
+use std::{any, fmt, mem};
 
 make_udaf_expr_and_func!(
     KurtosisFunction,
@@ -179,7 +179,7 @@ impl logical_expr::Accumulator for KurtosisAccumulator {
     }
 
     fn size(&self) -> usize {
-        std::mem::size_of_val(self)
+        mem::size_of_val(self)
     }
 
     fn state(&mut self) -> error::Result<Vec<scalar::ScalarValue>> {

src/kurtosis_pop.rs

@@ -20,7 +20,7 @@
 
 use datafusion::arrow::array::{Float64Array, UInt64Array};
 use datafusion::{arrow, common, error, logical_expr, scalar};
-use std::{any, fmt};
+use std::{any, fmt, mem};
 
 make_udaf_expr_and_func!(
     KurtosisPopFunction,
@@ -177,7 +177,7 @@ impl logical_expr::Accumulator for KurtosisPopAccumulator {
     }
 
     fn size(&self) -> usize {
-        std::mem::size_of_val(self)
+        mem::size_of_val(self)
     }
 
     fn state(&mut self) -> error::Result<Vec<scalar::ScalarValue>> {

src/skewness.rs

@@ -18,7 +18,7 @@
 use datafusion::arrow::array::AsArray;
 use datafusion::{arrow, logical_expr, scalar};
 use std::ops::{Div, Mul, Sub};
-use std::{any, fmt};
+use std::{any, fmt, mem};
 
 make_udaf_expr_and_func!(SkewnessFunc, skewness, x, "Computes the skewness value.", skewness_udaf);
 
@@ -28,7 +28,7 @@ pub struct SkewnessFunc {
 }
 
 impl fmt::Debug for SkewnessFunc {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SkewnessFunc")
             .field("signature", &self.signature)
             .finish()
@@ -143,7 +143,7 @@ impl logical_expr::Accumulator for SkewnessAccumulator {
     }
 
     fn size(&self) -> usize {
-        std::mem::size_of_val(self)
+        mem::size_of_val(self)
     }
 
     fn state(&mut self) -> datafusion::common::Result<Vec<scalar::ScalarValue>> {