refactor

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

vortex-array/src/arrays/struct_/compute/cast.rs

@@ -6,9 +6,9 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 
 use crate::ArrayRef;
+use crate::ArrayView;
 use crate::ExecutionCtx;
 use crate::IntoArray;
-use crate::array::ArrayView;
 use crate::arrays::ConstantArray;
 use crate::arrays::Struct;
 use crate::arrays::StructArray;
@@ -19,23 +19,12 @@ use crate::dtype::DType;
 use crate::matcher::Matcher;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::cast::Cast;
-use crate::scalar_fn::fns::cast::CastKernel;
-
-impl CastKernel for Struct {
-    fn cast(
-        array: ArrayView<'_, Struct>,
-        dtype: &DType,
-        ctx: &mut ExecutionCtx,
-    ) -> VortexResult<Option<ArrayRef>> {
-        cast_struct(array, dtype)
-    }
-}
 
 pub(crate) fn struct_cast_execute_parent(
     child: &ArrayRef,
     parent: &ArrayRef,
     _child_idx: usize,
-    _ctx: &mut ExecutionCtx,
+    ctx: &mut ExecutionCtx,
 ) -> VortexResult<Option<ArrayRef>> {
     let Some(array) = child.as_opt::<Struct>() else {
         return Ok(None);
@@ -45,14 +34,18 @@ pub(crate) fn struct_cast_execute_parent(
     };
 
     let dtype = parent.options;
-    if array.dtype() == dtype {
+    if array.dtype() == parent.options {
         return Ok(Some(array.array().clone()));
     }
 
-    cast_struct(array, dtype)
+    struct_cast(array, dtype, ctx)
 }
 
-fn cast_struct(array: ArrayView<'_, Struct>, dtype: &DType) -> VortexResult<Option<ArrayRef>> {
+pub(crate) fn struct_cast(
+    array: ArrayView<Struct>,
+    dtype: &DType,
+    ctx: &mut ExecutionCtx,
+) -> VortexResult<Option<ArrayRef>> {
     let Some(target_sdtype) = dtype.as_struct_fields_opt() else {
         return Ok(None);
     };
@@ -84,19 +77,20 @@ fn cast_struct(array: ArrayView<'_, Struct>, dtype: &DType) -> VortexResult<Opti
 
     let validity = array
         .validity()?
-        .cast_nullability(dtype.nullability(), array.len())?;
-
-    StructArray::try_new(
-        target_sdtype.names().clone(),
-        cast_fields,
-        array.len(),
-        validity,
-    )
-    .map(|a| Some(a.into_array()))
+        .cast_nullability(dtype.nullability(), array.len(), ctx)?;
+
+    Ok(Some(
+        unsafe {
+            StructArray::new_unchecked(cast_fields, target_sdtype.clone(), array.len(), validity)
+        }
+        .into_array(),
+    ))
 }
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use rstest::rstest;
     use vortex_buffer::buffer;
     use vortex_error::VortexResult;
@@ -105,8 +99,7 @@ mod tests {
     use crate::ArrayRef;
     use crate::ExecutionCtx;
     use crate::IntoArray;
-    #[expect(deprecated)]
-    use crate::ToCanonical as _;
+    use crate::VortexSessionExecute;
     use crate::arrays::ConstantArray;
     use crate::arrays::PrimitiveArray;
     use crate::arrays::StructArray;
@@ -127,8 +120,12 @@ mod tests {
     use crate::optimizer::kernels::ExecuteParentFn;
     use crate::scalar::Scalar;
     use crate::scalar_fn::fns::cast::Cast;
+    use crate::session::ArraySession;
     use crate::validity::Validity;
 
+    static SESSION: LazyLock<VortexSession> =
+        LazyLock::new(|| VortexSession::empty().with::<ArraySession>());
+
     fn null_struct_cast_execute_parent(
         child: &ArrayRef,
         parent: &ArrayRef,
@@ -206,12 +203,11 @@ mod tests {
         session.kernels().register_execute_parent(
             parent_id,
             child_id,
-            [null_struct_cast_execute_parent as ExecuteParentFn],
+            &[null_struct_cast_execute_parent as ExecuteParentFn],
         );
-        let mut ctx = ExecutionCtx::new(session);
+        let mut ctx = session.create_execution_ctx();
 
-        #[expect(deprecated)]
-        let result = cast.execute::<ArrayRef>(&mut ctx).unwrap().to_struct();
+        let result = cast.execute::<StructArray>(&mut ctx).unwrap();
 
         assert_eq!(result.dtype(), &target);
         assert_arrays_eq!(
@@ -309,14 +305,17 @@ mod tests {
 
         let target_dtype = struct_array.dtype().as_nullable();
 
-        let result = struct_array
+        let cast = struct_array
             .into_array()
             .cast(target_dtype.clone())
             .unwrap();
-        assert_eq!(result.dtype(), &target_dtype);
-        assert_eq!(result.len(), 3);
-        #[expect(deprecated)]
-        let nfields = result.to_struct().struct_fields().nfields();
+        assert_eq!(cast.dtype(), &target_dtype);
+        assert_eq!(cast.len(), 3);
+        let nfields = cast
+            .execute::<StructArray>(&mut SESSION.create_execution_ctx())
+            .unwrap()
+            .struct_fields()
+            .nfields();
         assert_eq!(nfields, 2);
     }
 
@@ -346,8 +345,11 @@ mod tests {
             .unwrap();
         assert_eq!(result.dtype(), &target_dtype);
         assert_eq!(result.len(), 3);
-        #[expect(deprecated)]
-        let nfields = result.to_struct().struct_fields().nfields();
+        let nfields = result
+            .execute::<StructArray>(&mut SESSION.create_execution_ctx())
+            .unwrap()
+            .struct_fields()
+            .nfields();
         assert_eq!(nfields, 3);
     }
 }