arrow-cast: Bring back in-order casting

Author: brancz

arrow-cast/src/cast/mod.rs

@@ -254,7 +254,7 @@ pub fn can_cast_types(from_type: &DataType, to_type: &DataType) -> bool {
             }
 
             // slow path, we match the fields by name
-            to_fields.iter().all(|to_field| {
+            if to_fields.iter().all(|to_field| {
                 from_fields
                     .iter()
                     .find(|from_field| from_field.name() == to_field.name())
@@ -263,7 +263,15 @@ pub fn can_cast_types(from_type: &DataType, to_type: &DataType) -> bool {
                         // cast kernel will return error.
                         can_cast_types(from_field.data_type(), to_field.data_type())
                     })
-            })
+            }) {
+                return true;
+            }
+
+            // if we couldn't match by name, we try to see if they can be matched by position
+            from_fields
+                .iter()
+                .zip(to_fields.iter())
+                .all(|(f1, f2)| can_cast_types(f1.data_type(), f2.data_type()))
         }
         (Struct(_), _) => false,
         (_, Struct(_)) => false,
@@ -1240,7 +1248,7 @@ pub fn cast_with_options(
                     .collect::<Result<Vec<ArrayRef>, ArrowError>>()?
             } else {
                 // Slow path: match fields by name and reorder
-                to_fields
+                match to_fields
                     .iter()
                     .map(|to_field| {
                         let from_field_idx = from_fields
@@ -1255,7 +1263,25 @@ pub fn cast_with_options(
                         let column = array.column(from_field_idx);
                         cast_with_options(column, to_field.data_type(), cast_options)
                     })
-                    .collect::<Result<Vec<ArrayRef>, ArrowError>>()?
+                    .collect::<Result<Vec<ArrayRef>, ArrowError>>()
+                {
+                    Ok(casted_fields) => casted_fields,
+                    Err(e) => {
+                        // If it's Field not found, we cast field by field
+                        if !e.to_string().starts_with("Field '")
+                            && !e.to_string().ends_with("' not found in source struct")
+                        {
+                            return Err(e);
+                        }
+
+                        array
+                            .columns()
+                            .iter()
+                            .zip(to_fields.iter())
+                            .map(|(l, field)| cast_with_options(l, field.data_type(), cast_options))
+                            .collect::<Result<Vec<ArrayRef>, ArrowError>>()?
+                    }
+                }
             };
 
             let array = StructArray::try_new(to_fields.clone(), fields, array.nulls().cloned())?;
@@ -10917,11 +10943,11 @@ mod tests {
         let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
         let struct_array = StructArray::from(vec![
             (
-                Arc::new(Field::new("a", DataType::Boolean, false)),
+                Arc::new(Field::new("b", DataType::Boolean, false)),
                 boolean.clone() as ArrayRef,
             ),
             (
-                Arc::new(Field::new("b", DataType::Int32, false)),
+                Arc::new(Field::new("c", DataType::Int32, false)),
                 int.clone() as ArrayRef,
             ),
         ]);
@@ -10965,11 +10991,11 @@ mod tests {
         let int = Arc::new(Int32Array::from(vec![Some(42), None, Some(19), None]));
         let struct_array = StructArray::from(vec![
             (
-                Arc::new(Field::new("a", DataType::Boolean, false)),
+                Arc::new(Field::new("b", DataType::Boolean, false)),
                 boolean.clone() as ArrayRef,
             ),
             (
-                Arc::new(Field::new("b", DataType::Int32, true)),
+                Arc::new(Field::new("c", DataType::Int32, true)),
                 int.clone() as ArrayRef,
             ),
         ]);
@@ -10999,11 +11025,11 @@ mod tests {
         let int = Arc::new(Int32Array::from(vec![i32::MAX, 25, 1, 100]));
         let struct_array = StructArray::from(vec![
             (
-                Arc::new(Field::new("a", DataType::Boolean, false)),
+                Arc::new(Field::new("b", DataType::Boolean, false)),
                 boolean.clone() as ArrayRef,
             ),
             (
-                Arc::new(Field::new("b", DataType::Int32, false)),
+                Arc::new(Field::new("c", DataType::Int32, false)),
                 int.clone() as ArrayRef,
             ),
         ]);
@@ -11139,7 +11165,7 @@ mod tests {
         assert!(result.is_err());
         assert_eq!(
             result.unwrap_err().to_string(),
-            "Cast error: Field 'b' not found in source struct"
+            "Invalid argument error: Incorrect number of arrays for StructArray fields, expected 2 got 1"
         );
     }
 
@@ -11196,7 +11222,7 @@ mod tests {
     }
 
     #[test]
-    fn test_can_cast_struct_with_missing_field() {
+    fn test_can_cast_struct_rename_field() {
         // Test that can_cast_types returns false when target has a field not in source
         let from_type = DataType::Struct(
             vec![
@@ -11214,7 +11240,7 @@ mod tests {
             .into(),
         );
 
-        assert!(!can_cast_types(&from_type, &to_type));
+        assert!(can_cast_types(&from_type, &to_type));
     }
 
     fn run_decimal_cast_test_case_between_multiple_types(t: DecimalCastTestConfig) {