resolve unnecessary borrow clippy lints (#613)

arrow-flight/src/utils.rs

@@ -36,7 +36,7 @@ pub fn flight_data_from_arrow_batch(
     let mut dictionary_tracker = writer::DictionaryTracker::new(false);
 
     let (encoded_dictionaries, encoded_batch) = data_gen
-        .encoded_batch(batch, &mut dictionary_tracker, &options)
+        .encoded_batch(batch, &mut dictionary_tracker, options)
         .expect("DictionaryTracker configured above to not error on replacement");
 
     let flight_dictionaries = encoded_dictionaries.into_iter().map(Into::into).collect();
@@ -68,7 +68,7 @@ pub fn flight_data_to_arrow_batch(
                 &data.data_body,
                 batch,
                 schema,
-                &dictionaries_by_field,
+                dictionaries_by_field,
             )
         })?
 }

arrow/benches/aggregate_kernels.rs

@@ -26,19 +26,19 @@ use arrow::util::bench_util::*;
 use arrow::{array::*, datatypes::Float32Type};
 
 fn bench_sum(arr_a: &Float32Array) {
-    criterion::black_box(sum(&arr_a).unwrap());
+    criterion::black_box(sum(arr_a).unwrap());
 }
 
 fn bench_min(arr_a: &Float32Array) {
-    criterion::black_box(min(&arr_a).unwrap());
+    criterion::black_box(min(arr_a).unwrap());
 }
 
 fn bench_max(arr_a: &Float32Array) {
-    criterion::black_box(max(&arr_a).unwrap());
+    criterion::black_box(max(arr_a).unwrap());
 }
 
 fn bench_min_string(arr_a: &StringArray) {
-    criterion::black_box(min_string(&arr_a).unwrap());
+    criterion::black_box(min_string(arr_a).unwrap());
 }
 
 fn add_benchmark(c: &mut Criterion) {

arrow/benches/arithmetic_kernels.rs

@@ -44,24 +44,24 @@ fn bench_add(arr_a: &ArrayRef, arr_b: &ArrayRef) {
 fn bench_subtract(arr_a: &ArrayRef, arr_b: &ArrayRef) {
     let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
     let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(subtract(&arr_a, &arr_b).unwrap());
+    criterion::black_box(subtract(arr_a, arr_b).unwrap());
 }
 
 fn bench_multiply(arr_a: &ArrayRef, arr_b: &ArrayRef) {
     let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
     let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(multiply(&arr_a, &arr_b).unwrap());
+    criterion::black_box(multiply(arr_a, arr_b).unwrap());
 }
 
 fn bench_divide(arr_a: &ArrayRef, arr_b: &ArrayRef) {
     let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
     let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(divide(&arr_a, &arr_b).unwrap());
+    criterion::black_box(divide(arr_a, arr_b).unwrap());
 }
 
 fn bench_divide_scalar(array: &ArrayRef, divisor: f32) {
     let array = array.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(divide_scalar(&array, divisor).unwrap());
+    criterion::black_box(divide_scalar(array, divisor).unwrap());
 }
 
 fn bench_limit(arr_a: &ArrayRef, max: usize) {

arrow/benches/array_from_vec.rs

@@ -97,22 +97,22 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     let (field1, strings, field2, ints) = struct_array_values(128);
     c.bench_function("struct_array_from_vec 128", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 
     let (field1, strings, field2, ints) = struct_array_values(256);
     c.bench_function("struct_array_from_vec 256", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 
     let (field1, strings, field2, ints) = struct_array_values(512);
     c.bench_function("struct_array_from_vec 512", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 
     let (field1, strings, field2, ints) = struct_array_values(1024);
     c.bench_function("struct_array_from_vec 1024", |b| {
-        b.iter(|| struct_array_from_vec(&field1, &strings, &field2, &ints))
+        b.iter(|| struct_array_from_vec(field1, &strings, field2, &ints))
     });
 }
 

arrow/benches/boolean_kernels.rs

@@ -35,7 +35,7 @@ fn bench_or(lhs: &BooleanArray, rhs: &BooleanArray) {
 }
 
 fn bench_not(array: &BooleanArray) {
-    criterion::black_box(boolean_kernels::not(&array).unwrap());
+    criterion::black_box(boolean_kernels::not(array).unwrap());
 }
 
 fn add_benchmark(c: &mut Criterion) {
@@ -58,12 +58,12 @@ fn add_benchmark(c: &mut Criterion) {
         .unwrap();
 
     c.bench_function("and_sliced", |b| {
-        b.iter(|| bench_and(&array1_slice, &array2_slice))
+        b.iter(|| bench_and(array1_slice, array2_slice))
     });
     c.bench_function("or_sliced", |b| {
-        b.iter(|| bench_or(&array1_slice, &array2_slice))
+        b.iter(|| bench_or(array1_slice, array2_slice))
     });
-    c.bench_function("not_sliced", |b| b.iter(|| bench_not(&array1_slice)));
+    c.bench_function("not_sliced", |b| b.iter(|| bench_not(array1_slice)));
 }
 
 criterion_group!(benches, add_benchmark);

arrow/benches/filter_kernels.rs

@@ -30,7 +30,7 @@ fn bench_filter(data_array: &dyn Array, filter_array: &BooleanArray) {
 }
 
 fn bench_built_filter<'a>(filter: &Filter<'a>, data: &impl Array) {
-    criterion::black_box(filter(&data.data()));
+    criterion::black_box(filter(data.data()));
 }
 
 fn add_benchmark(c: &mut Criterion) {

arrow/benches/take_kernels.rs

@@ -43,12 +43,12 @@ fn create_random_index(size: usize, null_density: f32) -> UInt32Array {
 }
 
 fn bench_take(values: &dyn Array, indices: &UInt32Array) {
-    criterion::black_box(take(values, &indices, None).unwrap());
+    criterion::black_box(take(values, indices, None).unwrap());
 }
 
 fn bench_take_bounds_check(values: &dyn Array, indices: &UInt32Array) {
     criterion::black_box(
-        take(values, &indices, Some(TakeOptions { check_bounds: true })).unwrap(),
+        take(values, indices, Some(TakeOptions { check_bounds: true })).unwrap(),
     );
 }
 

arrow/src/array/array.rs

@@ -558,7 +558,7 @@ where
             writeln!(f, "  null,")?;
         } else {
             write!(f, "  ")?;
-            print_item(&array, i, f)?;
+            print_item(array, i, f)?;
             writeln!(f, ",")?;
         }
     }
@@ -574,7 +574,7 @@ where
                 writeln!(f, "  null,")?;
             } else {
                 write!(f, "  ")?;
-                print_item(&array, i, f)?;
+                print_item(array, i, f)?;
                 writeln!(f, ",")?;
             }
         }

arrow/src/array/array_binary.rs

@@ -174,7 +174,7 @@ impl<OffsetSize: BinaryOffsetSizeTrait> GenericBinaryArray<OffsetSize> {
 impl<'a, T: BinaryOffsetSizeTrait> GenericBinaryArray<T> {
     /// constructs a new iterator
     pub fn iter(&'a self) -> GenericBinaryIter<'a, T> {
-        GenericBinaryIter::<'a, T>::new(&self)
+        GenericBinaryIter::<'a, T>::new(self)
     }
 }
 

arrow/src/array/array_boolean.rs

@@ -167,7 +167,7 @@ impl<'a> IntoIterator for &'a BooleanArray {
 impl<'a> BooleanArray {
     /// constructs a new iterator
     pub fn iter(&'a self) -> BooleanIter<'a> {
-        BooleanIter::<'a>::new(&self)
+        BooleanIter::<'a>::new(self)
     }
 }
 

arrow/src/array/array_list.rs

@@ -110,7 +110,7 @@ impl<OffsetSize: OffsetSizeTrait> GenericListArray<OffsetSize> {
 
     /// constructs a new iterator
     pub fn iter<'a>(&'a self) -> GenericListArrayIter<'a, OffsetSize> {
-        GenericListArrayIter::<'a, OffsetSize>::new(&self)
+        GenericListArrayIter::<'a, OffsetSize>::new(self)
     }
 
     #[inline]

arrow/src/array/array_primitive.rs

@@ -299,7 +299,7 @@ impl<'a, T: ArrowPrimitiveType> IntoIterator for &'a PrimitiveArray<T> {
 impl<'a, T: ArrowPrimitiveType> PrimitiveArray<T> {
     /// constructs a new iterator
     pub fn iter(&'a self) -> PrimitiveIter<'a, T> {
-        PrimitiveIter::<'a, T>::new(&self)
+        PrimitiveIter::<'a, T>::new(self)
     }
 }
 

arrow/src/array/array_string.rs

@@ -264,7 +264,7 @@ impl<'a, T: StringOffsetSizeTrait> IntoIterator for &'a GenericStringArray<T> {
 impl<'a, T: StringOffsetSizeTrait> GenericStringArray<T> {
     /// constructs a new iterator
     pub fn iter(&'a self) -> GenericStringIter<'a, T> {
-        GenericStringIter::<'a, T>::new(&self)
+        GenericStringIter::<'a, T>::new(self)
     }
 }
 

arrow/src/array/equal_json.rs

@@ -66,7 +66,7 @@ impl JsonEqual for BooleanArray {
 impl<T: ArrowPrimitiveType> PartialEq<Value> for PrimitiveArray<T> {
     fn eq(&self, json: &Value) -> bool {
         match json {
-            Value::Array(array) => self.equals_json_values(&array),
+            Value::Array(array) => self.equals_json_values(array),
             _ => false,
         }
     }
@@ -75,7 +75,7 @@ impl<T: ArrowPrimitiveType> PartialEq<Value> for PrimitiveArray<T> {
 impl<T: ArrowPrimitiveType> PartialEq<PrimitiveArray<T>> for Value {
     fn eq(&self, arrow: &PrimitiveArray<T>) -> bool {
         match self {
-            Value::Array(array) => arrow.equals_json_values(&array),
+            Value::Array(array) => arrow.equals_json_values(array),
             _ => false,
         }
     }
@@ -204,7 +204,7 @@ impl JsonEqual for StructArray {
 impl PartialEq<Value> for StructArray {
     fn eq(&self, json: &Value) -> bool {
         match json {
-            Value::Array(json_array) => self.equals_json_values(&json_array),
+            Value::Array(json_array) => self.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -213,7 +213,7 @@ impl PartialEq<Value> for StructArray {
 impl PartialEq<StructArray> for Value {
     fn eq(&self, arrow: &StructArray) -> bool {
         match self {
-            Value::Array(json_array) => arrow.equals_json_values(&json_array),
+            Value::Array(json_array) => arrow.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -244,7 +244,7 @@ impl<OffsetSize: BinaryOffsetSizeTrait> PartialEq<Value>
 {
     fn eq(&self, json: &Value) -> bool {
         match json {
-            Value::Array(json_array) => self.equals_json_values(&json_array),
+            Value::Array(json_array) => self.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -255,7 +255,7 @@ impl<OffsetSize: BinaryOffsetSizeTrait> PartialEq<GenericBinaryArray<OffsetSize>
 {
     fn eq(&self, arrow: &GenericBinaryArray<OffsetSize>) -> bool {
         match self {
-            Value::Array(json_array) => arrow.equals_json_values(&json_array),
+            Value::Array(json_array) => arrow.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -280,7 +280,7 @@ impl<OffsetSize: StringOffsetSizeTrait> PartialEq<Value>
 {
     fn eq(&self, json: &Value) -> bool {
         match json {
-            Value::Array(json_array) => self.equals_json_values(&json_array),
+            Value::Array(json_array) => self.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -291,7 +291,7 @@ impl<OffsetSize: StringOffsetSizeTrait> PartialEq<GenericStringArray<OffsetSize>
 {
     fn eq(&self, arrow: &GenericStringArray<OffsetSize>) -> bool {
         match self {
-            Value::Array(json_array) => arrow.equals_json_values(&json_array),
+            Value::Array(json_array) => arrow.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -320,7 +320,7 @@ impl JsonEqual for FixedSizeBinaryArray {
 impl PartialEq<Value> for FixedSizeBinaryArray {
     fn eq(&self, json: &Value) -> bool {
         match json {
-            Value::Array(json_array) => self.equals_json_values(&json_array),
+            Value::Array(json_array) => self.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -329,7 +329,7 @@ impl PartialEq<Value> for FixedSizeBinaryArray {
 impl PartialEq<FixedSizeBinaryArray> for Value {
     fn eq(&self, arrow: &FixedSizeBinaryArray) -> bool {
         match self {
-            Value::Array(json_array) => arrow.equals_json_values(&json_array),
+            Value::Array(json_array) => arrow.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -357,7 +357,7 @@ impl JsonEqual for DecimalArray {
 impl PartialEq<Value> for DecimalArray {
     fn eq(&self, json: &Value) -> bool {
         match json {
-            Value::Array(json_array) => self.equals_json_values(&json_array),
+            Value::Array(json_array) => self.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -366,7 +366,7 @@ impl PartialEq<Value> for DecimalArray {
 impl PartialEq<DecimalArray> for Value {
     fn eq(&self, arrow: &DecimalArray) -> bool {
         match self {
-            Value::Array(json_array) => arrow.equals_json_values(&json_array),
+            Value::Array(json_array) => arrow.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -394,7 +394,7 @@ impl JsonEqual for NullArray {
 impl PartialEq<NullArray> for Value {
     fn eq(&self, arrow: &NullArray) -> bool {
         match self {
-            Value::Array(json_array) => arrow.equals_json_values(&json_array),
+            Value::Array(json_array) => arrow.equals_json_values(json_array),
             _ => false,
         }
     }
@@ -403,7 +403,7 @@ impl PartialEq<NullArray> for Value {
 impl PartialEq<Value> for NullArray {
     fn eq(&self, json: &Value) -> bool {
         match json {
-            Value::Array(json_array) => self.equals_json_values(&json_array),
+            Value::Array(json_array) => self.equals_json_values(json_array),
             _ => false,
         }
     }

arrow/src/array/ord.rs

@@ -77,7 +77,7 @@ where
     let left: StringArray = StringArray::from(left.data().clone());
     let right: StringArray = StringArray::from(right.data().clone());
 
-    Box::new(move |i, j| left.value(i).cmp(&right.value(j)))
+    Box::new(move |i, j| left.value(i).cmp(right.value(j)))
 }
 
 fn compare_dict_string<T>(left: &dyn Array, right: &dyn Array) -> DynComparator
@@ -97,7 +97,7 @@ where
         let key_right = right_keys.value(j).to_usize().unwrap();
         let left = left_values.value(key_left);
         let right = right_values.value(key_right);
-        left.cmp(&right)
+        left.cmp(right)
     })
 }
 

arrow/src/buffer/immutable.rs

@@ -188,14 +188,14 @@ impl Buffer {
             return self.slice(offset / 8);
         }
 
-        bitwise_unary_op_helper(&self, offset, len, |a| a)
+        bitwise_unary_op_helper(self, offset, len, |a| a)
     }
 
     /// Returns a `BitChunks` instance which can be used to iterate over this buffers bits
     /// in larger chunks and starting at arbitrary bit offsets.
     /// Note that both `offset` and `length` are measured in bits.
     pub fn bit_chunks(&self, offset: usize, len: usize) -> BitChunks {
-        BitChunks::new(&self.as_slice(), offset, len)
+        BitChunks::new(self.as_slice(), offset, len)
     }
 
     /// Returns the number of 1-bits in this buffer.

arrow/src/buffer/mod.rs

@@ -39,7 +39,7 @@ impl<'a, 'b> BitAnd<&'b Buffer> for &'a Buffer {
         }
 
         let len_in_bits = self.len() * 8;
-        Ok(buffer_bin_and(&self, 0, &rhs, 0, len_in_bits))
+        Ok(buffer_bin_and(self, 0, rhs, 0, len_in_bits))
     }
 }
 
@@ -55,7 +55,7 @@ impl<'a, 'b> BitOr<&'b Buffer> for &'a Buffer {
 
         let len_in_bits = self.len() * 8;
 
-        Ok(buffer_bin_or(&self, 0, &rhs, 0, len_in_bits))
+        Ok(buffer_bin_or(self, 0, rhs, 0, len_in_bits))
     }
 }
 
@@ -64,6 +64,6 @@ impl Not for &Buffer {
 
     fn not(self) -> Buffer {
         let len_in_bits = self.len() * 8;
-        buffer_unary_not(&self, 0, len_in_bits)
+        buffer_unary_not(self, 0, len_in_bits)
     }
 }