cargo clippy fix

Author: kosiew

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

@@ -324,34 +324,35 @@ 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>> {
+) -> 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),
+        Arc::clone(expr),
+        Arc::clone(target_field),
         cast_options.clone(),
     );
 
     if expr_type == *cast_type
         && candidate.preserves_child_field_semantics(input_schema)?
     {
-        return Ok(Arc::clone(&expr));
+        return Ok(Arc::clone(expr));
     }
 
     let is_valid_cast = match (&expr_type, cast_type) {
@@ -933,15 +934,16 @@ mod tests {
     #[test]
     fn field_aware_same_type_cast_preserves_explicit_target_field() -> Result<()> {
         let schema = Schema::new(vec![Field::new("a", Int32, false)]);
-        let expr =
-            cast_with_target_field_and_options(
-                col("a", &schema)?,
-                &schema,
-                Arc::new(Field::new("logical_a", Int32, true).with_metadata(
-                    HashMap::from([("target_meta".to_string(), "1".to_string())]),
-                )),
-                None,
-            )?;
+        let a_col = col("a", &schema)?;
+        let logical_field = Arc::new(Field::new("logical_a", Int32, true).with_metadata(
+            HashMap::from([("target_meta".to_string(), "1".to_string())]),
+        ));
+        let expr = cast_with_target_field_and_options(
+            &a_col,
+            &schema,
+            &logical_field,
+            None,
+        )?;
 
         let cast_expr = expr
             .as_any()
@@ -962,10 +964,12 @@ mod tests {
     #[test]
     fn default_same_type_cast_is_elided() -> Result<()> {
         let schema = Schema::new(vec![Field::new("a", Int32, false)]);
+        let a_col = col("a", &schema)?;
+        let target_field = Int32.into_nullable_field_ref();
         let expr = cast_with_target_field_and_options(
-            col("a", &schema)?,
+            &a_col,
             &schema,
-            Int32.into_nullable_field_ref(),
+            &target_field,
             None,
         )?;
 

datafusion/physical-expr/src/planner.rs

@@ -289,10 +289,11 @@ pub fn create_physical_expr(
             Ok(expressions::case(expr, when_then_expr, else_expr)?)
         }
         Expr::Cast(Cast { expr, field }) => {
+            let child = create_physical_expr(expr, input_dfschema, execution_props)?;
             expressions::cast_with_target_field_and_options(
-                create_physical_expr(expr, input_dfschema, execution_props)?,
+                &child,
                 input_schema,
-                Arc::clone(field),
+                &field,
                 None,
             )
         }