CI: add clippy::needless_pass_by_value rule

ci/scripts/rust_clippy.sh

@@ -18,4 +18,4 @@
 # under the License.
 
 set -ex
-cargo clippy --all-targets --workspace --features avro,pyarrow,integration-tests,extended_tests -- -D warnings
+cargo clippy --all-targets --workspace --features avro,pyarrow,integration-tests,extended_tests -- -D warnings

datafusion/common/Cargo.toml

@@ -31,8 +31,12 @@ rust-version = { workspace = true }
 [package.metadata.docs.rs]
 all-features = true
 
-[lints]
-workspace = true
+[lints] # Overrides / extends workspace.lints
+[lints.clippy]
+# Avoid unnecessary clones for performance, okay to ignore for tests or intentional
+# moves.
+# Reference: <https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value>
+needless_pass_by_value = "deny"
 
 [lib]
 name = "datafusion_common"

datafusion/common/src/column.rs

@@ -382,6 +382,7 @@ mod tests {
     use arrow::datatypes::{DataType, SchemaBuilder};
     use std::sync::Arc;
 
+    #[allow(clippy::needless_pass_by_value)]
     fn create_qualified_schema(qualifier: &str, names: Vec<&str>) -> Result<DFSchema> {
         let mut schema_builder = SchemaBuilder::new();
         schema_builder.extend(

datafusion/common/src/error.rs

@@ -1185,6 +1185,7 @@ mod test {
         Err(ArrowError::SchemaError("bar".to_string()).into())
     }
 
+    #[allow(clippy::needless_pass_by_value)]
     fn do_root_test(e: DataFusionError, exp: DataFusionError) {
         let e = e.find_root();
 

datafusion/common/src/file_options/parquet_writer.rs

@@ -478,6 +478,7 @@ mod tests {
         }
     }
 
+    #[allow(clippy::needless_pass_by_value)]
     fn extract_column_options(
         props: &WriterProperties,
         col: ColumnPath,

datafusion/common/src/hash_utils.rs

@@ -141,7 +141,7 @@ fn hash_array_primitive<T>(
 /// with the new hash using `combine_hashes`
 #[cfg(not(feature = "force_hash_collisions"))]
 fn hash_array<T>(
-    array: T,
+    array: &T,
     random_state: &RandomState,
     hashes_buffer: &mut [u64],
     rehash: bool,
@@ -400,16 +400,16 @@ pub fn create_hashes<'a>(
         downcast_primitive_array! {
             array => hash_array_primitive(array, random_state, hashes_buffer, rehash),
             DataType::Null => hash_null(random_state, hashes_buffer, rehash),
-            DataType::Boolean => hash_array(as_boolean_array(array)?, random_state, hashes_buffer, rehash),
-            DataType::Utf8 => hash_array(as_string_array(array)?, random_state, hashes_buffer, rehash),
-            DataType::Utf8View => hash_array(as_string_view_array(array)?, random_state, hashes_buffer, rehash),
-            DataType::LargeUtf8 => hash_array(as_largestring_array(array), random_state, hashes_buffer, rehash),
-            DataType::Binary => hash_array(as_generic_binary_array::<i32>(array)?, random_state, hashes_buffer, rehash),
-            DataType::BinaryView => hash_array(as_binary_view_array(array)?, random_state, hashes_buffer, rehash),
-            DataType::LargeBinary => hash_array(as_generic_binary_array::<i64>(array)?, random_state, hashes_buffer, rehash),
+            DataType::Boolean => hash_array(&as_boolean_array(array)?, random_state, hashes_buffer, rehash),
+            DataType::Utf8 => hash_array(&as_string_array(array)?, random_state, hashes_buffer, rehash),
+            DataType::Utf8View => hash_array(&as_string_view_array(array)?, random_state, hashes_buffer, rehash),
+            DataType::LargeUtf8 => hash_array(&as_largestring_array(array), random_state, hashes_buffer, rehash),
+            DataType::Binary => hash_array(&as_generic_binary_array::<i32>(array)?, random_state, hashes_buffer, rehash),
+            DataType::BinaryView => hash_array(&as_binary_view_array(array)?, random_state, hashes_buffer, rehash),
+            DataType::LargeBinary => hash_array(&as_generic_binary_array::<i64>(array)?, random_state, hashes_buffer, rehash),
             DataType::FixedSizeBinary(_) => {
                 let array: &FixedSizeBinaryArray = array.as_any().downcast_ref().unwrap();
-                hash_array(array, random_state, hashes_buffer, rehash)
+                hash_array(&array, random_state, hashes_buffer, rehash)
             }
             DataType::Dictionary(_, _) => downcast_dictionary_array! {
                 array => hash_dictionary(array, random_state, hashes_buffer, rehash)?,

datafusion/common/src/scalar/mod.rs

@@ -4648,9 +4648,9 @@ impl fmt::Display for ScalarValue {
                 }
                 None => write!(f, "NULL")?,
             },
-            ScalarValue::List(arr) => fmt_list(arr.to_owned() as ArrayRef, f)?,
-            ScalarValue::LargeList(arr) => fmt_list(arr.to_owned() as ArrayRef, f)?,
-            ScalarValue::FixedSizeList(arr) => fmt_list(arr.to_owned() as ArrayRef, f)?,
+            ScalarValue::List(arr) => fmt_list(arr.as_ref(), f)?,
+            ScalarValue::LargeList(arr) => fmt_list(arr.as_ref(), f)?,
+            ScalarValue::FixedSizeList(arr) => fmt_list(arr.as_ref(), f)?,
             ScalarValue::Date32(e) => format_option!(
                 f,
                 e.map(|v| {
@@ -4772,12 +4772,11 @@ impl fmt::Display for ScalarValue {
     }
 }
 
-fn fmt_list(arr: ArrayRef, f: &mut fmt::Formatter) -> fmt::Result {
+fn fmt_list(arr: &dyn Array, f: &mut fmt::Formatter) -> fmt::Result {
     // ScalarValue List, LargeList, FixedSizeList should always have a single element
     assert_eq!(arr.len(), 1);
     let options = FormatOptions::default().with_display_error(true);
-    let formatter =
-        ArrayFormatter::try_new(arr.as_ref() as &dyn Array, &options).unwrap();
+    let formatter = ArrayFormatter::try_new(arr, &options).unwrap();
     let value_formatter = formatter.value(0);
     write!(f, "{value_formatter}")
 }
@@ -5568,6 +5567,7 @@ mod tests {
     }
 
     // Verifies that ScalarValue has the same behavior with compute kernel when it overflows.
+    #[allow(clippy::needless_pass_by_value)]
     fn check_scalar_add_overflow<T>(left: ScalarValue, right: ScalarValue)
     where
         T: ArrowNumericType,
@@ -7097,6 +7097,7 @@ mod tests {
     /// 1. convert to a `ScalarValue`
     /// 2. Convert `ScalarValue` back to an `ArrayRef`
     /// 3. Compare the original array (sliced) and new array for equality
+    #[allow(clippy::needless_pass_by_value)]
     fn round_trip_through_scalar(arr: ArrayRef) {
         for i in 0..arr.len() {
             // convert Scalar --> Array
@@ -7569,6 +7570,7 @@ mod tests {
     }
 
     // mimics how casting work on scalar values by `casting` `scalar` to `desired_type`
+    #[allow(clippy::needless_pass_by_value)]
     fn check_scalar_cast(scalar: ScalarValue, desired_type: DataType) {
         // convert from scalar --> Array to call cast
         let scalar_array = scalar.to_array().expect("Failed to convert to array");

datafusion/common/src/scalar/struct_builder.rs

@@ -83,6 +83,7 @@ impl ScalarStructBuilder {
     }
 
     /// Add the specified field and `ScalarValue` to the struct.
+    #[allow(clippy::needless_pass_by_value)]
     pub fn with_scalar(self, field: impl IntoFieldRef, value: ScalarValue) -> Self {
         // valid scalar value should not fail
         let array = value.to_array().unwrap();