cargo clippy fix

Author: kosiew

datafusion/physical-expr-adapter/src/schema_rewriter.rs

@@ -439,7 +439,7 @@ impl DefaultPhysicalExprAdapterRewriter {
         // TODO: add optimization to move the cast from the column to literal expressions in the case of `col = 123`
         // since that's much cheaper to evalaute.
         // See https://github.com/apache/datafusion/issues/15780#issuecomment-2824716928
-        self.create_cast_expr(resolved_column, physical_field, logical_field)
+        self.create_cast_expr(resolved_column, &physical_field, logical_field)
     }
 
     /// Resolves a logical column to the corresponding physical column and field.
@@ -483,7 +483,7 @@ impl DefaultPhysicalExprAdapterRewriter {
     fn create_cast_expr(
         &self,
         column: Column,
-        physical_field: FieldRef,
+        physical_field: &FieldRef,
         logical_field: &Field,
     ) -> Result<Transformed<Arc<dyn PhysicalExpr>>> {
         // For struct types, use validate_struct_compatibility which handles:
@@ -1597,7 +1597,7 @@ mod tests {
         let transformed = rewriter
             .create_cast_expr(
                 Column::new("a", 0),
-                Arc::new(physical_schema.field_with_name("a").unwrap().clone()),
+                &Arc::new(physical_schema.field_with_name("a").unwrap().clone()),
                 logical_schema.field_with_name("a").unwrap(),
             )
             .unwrap();

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

@@ -341,26 +341,23 @@ pub(crate) fn cast_with_target_field_and_options(
     cast_options: Option<CastOptions<'static>>,
 ) -> Result<Arc<dyn PhysicalExpr>> {
     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 {
@@ -933,15 +930,12 @@ 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 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(
-                col("a", &schema)?,
-                &schema,
-                Arc::new(Field::new("logical_a", Int32, true).with_metadata(
-                    HashMap::from([("target_meta".to_string(), "1".to_string())]),
-                )),
-                None,
-            )?;
+            cast_with_target_field_and_options(a_col, &schema, logical_field, None)?;
 
         let cast_expr = expr
             .as_any()
@@ -962,12 +956,10 @@ mod tests {
     #[test]
     fn default_same_type_cast_is_elided() -> Result<()> {
         let schema = Schema::new(vec![Field::new("a", Int32, false)]);
-        let expr = cast_with_target_field_and_options(
-            col("a", &schema)?,
-            &schema,
-            Int32.into_nullable_field_ref(),
-            None,
-        )?;
+        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)?;
 
         assert!(expr.as_any().downcast_ref::<Column>().is_some());
         assert!(expr.as_any().downcast_ref::<CastExpr>().is_none());

datafusion/physical-expr/src/planner.rs

@@ -289,8 +289,9 @@ 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),
                 None,