fix tests

Author: alamb

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

@@ -44,6 +44,18 @@ const DEFAULT_SAFE_CAST_OPTIONS: CastOptions<'static> = CastOptions {
     format_options: DEFAULT_FORMAT_OPTIONS,
 };
 
+fn has_positional_fields(fields: &[FieldRef]) -> bool {
+    fields.iter().enumerate().any(|(idx, f)| {
+        f.name().is_empty()
+            || f.name()
+                .as_str()
+                .strip_prefix('c')
+                .and_then(|suffix| suffix.parse::<usize>().ok())
+                .map(|n| n == idx)
+                .unwrap_or(false)
+    })
+}
+
 /// CAST expression casts an expression to a specific data type and returns a runtime error on invalid cast
 #[derive(Debug, Clone, Eq)]
 pub struct CastExpr {
@@ -150,34 +162,35 @@ impl PhysicalExpr for CastExpr {
 
     fn evaluate(&self, batch: &RecordBatch) -> Result<ColumnarValue> {
         let value = self.expr.evaluate(batch)?;
-        // delegate to cast_to, except for struct-to-struct casts   
         let Struct(target_fields) = &self.cast_type else {
             return value.cast_to(&self.cast_type, Some(&self.cast_options));
         };
         let Struct(source_fields) = self.expr.data_type(batch.schema().as_ref())? else {
             return value.cast_to(&self.cast_type, Some(&self.cast_options));
         };
-        if &source_fields == target_fields {
+
+        let use_struct_cast = target_fields.len() > source_fields.len()
+            || has_positional_fields(&source_fields)
+            || has_positional_fields(target_fields)
+            || target_fields
+                .iter()
+                .any(|t| source_fields.iter().all(|s| s.name() != t.name()));
+
+        if !use_struct_cast || source_fields == *target_fields {
             return value.cast_to(&self.cast_type, Some(&self.cast_options));
-        };
+        }
 
         let target_field = self.return_field(batch.schema().as_ref())?;
         match value {
             ColumnarValue::Array(array) => {
-                let casted = cast_column(
-                    &array,
-                    target_field.as_ref(),
-                    &self.cast_options,
-                )?;
+                let casted =
+                    cast_column(&array, target_field.as_ref(), &self.cast_options)?;
                 Ok(ColumnarValue::Array(casted))
             }
             ColumnarValue::Scalar(scalar) => {
                 let as_array = scalar.to_array_of_size(1)?;
-                let casted = cast_column(
-                    &as_array,
-                    target_field.as_ref(),
-                    &self.cast_options,
-                )?;
+                let casted =
+                    cast_column(&as_array, target_field.as_ref(), &self.cast_options)?;
                 let result = ScalarValue::try_from_array(casted.as_ref(), 0)?;
                 Ok(ColumnarValue::Scalar(result))
             }