clippy fix

Author: kosiew

datafusion/physical-expr/src/expressions/cast.rs

@@ -324,45 +324,40 @@ pub fn cast_with_options(
     cast_type: DataType,
     cast_options: Option<CastOptions<'static>>,
 ) -> Result<Arc<dyn PhysicalExpr>> {
-    // borrow expr and temporary field reference; the helper clones as needed
     cast_with_target_field_and_options(
-        &expr,
+        expr,
         input_schema,
-        &cast_type.into_nullable_field_ref(),
+        cast_type.into_nullable_field_ref(),
         cast_options,
     )
 }
 
 /// Return a [`PhysicalExpr`] representing `expr` casted to `target_field`,
 /// preserving the field metadata in the resulting expression.
 pub(crate) fn cast_with_target_field_and_options(
-    expr: &Arc<dyn PhysicalExpr>,
+    expr: Arc<dyn PhysicalExpr>,
     input_schema: &Schema,
-    target_field: &FieldRef,
+    target_field: FieldRef,
     cast_options: Option<CastOptions<'static>>,
 ) -> Result<Arc<dyn PhysicalExpr>> {
-    // borrow inputs to satisfy clippy
     let expr_type = expr.data_type(input_schema)?;
-    let cast_type = target_field.data_type();
-    let candidate = CastExpr::new_with_target_field(
-        Arc::clone(expr),
-        Arc::clone(target_field),
-        cast_options.clone(),
-    );
-
-    if expr_type == *cast_type
+    let cast_type = target_field.data_type().clone();
+    let candidate =
+        CastExpr::new_with_target_field(Arc::clone(&expr), target_field, cast_options);
+
+    if expr_type == cast_type
         && candidate.preserves_child_field_semantics(input_schema)?
     {
-        return Ok(Arc::clone(expr));
+        return Ok(expr);
     }
 
-    let is_valid_cast = match (&expr_type, cast_type) {
+    let is_valid_cast = match (&expr_type, &cast_type) {
         // Allow struct-to-struct casts that pass name-based compatibility validation.
         // This validation is applied at planning time (now) to fail fast, rather than
         // deferring errors to execution time. The name-based casting logic will be
         // executed at runtime via ColumnarValue::cast_to.
-        (Struct(_), Struct(_)) => can_cast_struct_types(&expr_type, cast_type),
-        _ => can_cast_types(&expr_type, cast_type),
+        (Struct(_), Struct(_)) => can_cast_struct_types(&expr_type, &cast_type),
+        _ => can_cast_types(&expr_type, &cast_type),
     };
 
     if !is_valid_cast {
@@ -940,7 +935,7 @@ mod tests {
             HashMap::from([("target_meta".to_string(), "1".to_string())]),
         ));
         let expr =
-            cast_with_target_field_and_options(&a_col, &schema, &logical_field, None)?;
+            cast_with_target_field_and_options(a_col, &schema, logical_field, None)?;
 
         let cast_expr = expr
             .as_any()
@@ -964,7 +959,7 @@ mod tests {
         let a_col = col("a", &schema)?;
         let target_field = Int32.into_nullable_field_ref();
         let expr =
-            cast_with_target_field_and_options(&a_col, &schema, &target_field, None)?;
+            cast_with_target_field_and_options(a_col, &schema, target_field, None)?;
 
         assert!(expr.as_any().downcast_ref::<Column>().is_some());
         assert!(expr.as_any().downcast_ref::<CastExpr>().is_none());

datafusion/physical-expr/src/planner.rs

@@ -291,9 +291,9 @@ pub fn create_physical_expr(
         Expr::Cast(Cast { expr, field }) => {
             let child = create_physical_expr(expr, input_dfschema, execution_props)?;
             expressions::cast_with_target_field_and_options(
-                &child,
+                child,
                 input_schema,
-                &field,
+                Arc::clone(field),
                 None,
             )
         }