Add more arrow execution

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

vortex-array/src/array/mod.rs

@@ -4,7 +4,6 @@
 mod visitor;
 
 use std::any::Any;
-use std::any::type_name;
 use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::hash::Hash;

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

@@ -344,6 +344,10 @@ impl StructArray {
         Ok(unsafe { Self::new_unchecked(fields, dtype, length, validity) })
     }
 
+    pub fn into_fields(self) -> Vec<ArrayRef> {
+        self.fields.to_vec()
+    }
+
     pub fn from_fields<N: AsRef<str>>(items: &[(N, ArrayRef)]) -> VortexResult<Self> {
         Self::try_from_iter(items.iter().map(|(a, b)| (a, b.to_array())))
     }

vortex-array/src/arrow/executor/list.rs

@@ -84,6 +84,7 @@ fn list_to_list<O: OffsetSizeTrait + NativePType>(
 
     let elements = array
         .elements()
+        .clone()
         .execute_arrow(elements_field.data_type(), session)?;
     vortex_ensure!(
         elements_field.is_nullable() || elements.null_count() == 0,

vortex-array/src/arrow/executor/struct_.rs

@@ -11,6 +11,7 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_ensure;
 use vortex_session::VortexSession;
 
+use crate::Array;
 use crate::ArrayRef;
 use crate::arrays::StructVTable;
 use crate::arrow::ArrowArrayExecutor;
@@ -25,36 +26,40 @@ pub(super) fn to_arrow_struct(
     let validity = array.validity_mask();
 
     let mut field_arrays = Vec::with_capacity(fields.len());
-    if let Some(array) = array.as_opt::<StructVTable>() {
-        // If the array is already a struct type, then we can convert each field.
-        for (field, child) in fields.iter().zip_eq(array.fields().iter()) {
-            let field_array = child.execute_arrow(field.data_type(), session)?;
-            vortex_ensure!(
-                field.is_nullable() || field_array.null_count() == 0,
-                "Cannot convert field '{}' to non-nullable Arrow field because it contains nulls",
-                field.name()
-            );
-            field_arrays.push(field_array);
+
+    match array.try_into::<StructVTable>() {
+        Ok(array) => {
+            // If the array is already a struct type, then we can convert each field.
+            for (field, child) in fields.iter().zip_eq(array.into_fields().into_iter()) {
+                let field_array = child.execute_arrow(field.data_type(), session)?;
+                vortex_ensure!(
+                    field.is_nullable() || field_array.null_count() == 0,
+                    "Cannot convert field '{}' to non-nullable Arrow field because it contains nulls",
+                    field.name()
+                );
+                field_arrays.push(field_array);
+            }
         }
-    } else {
-        // Otherwise, we have some options:
-        //  1. Use get_item expression to extract each field? This is a bit sad because get_item
-        //     will perform the validity masking again.
-        //  2. Execute a full struct vector. But this may do unnecessary work on fields that may
-        //    have a more direct conversion to the desired Arrow field type.
-        //  3. Something else?
-        //
-        // For now, we go with option 1. Although we really ought to figure out CSE for this.
-        for field in fields.iter() {
-            let field_array = array
-                .get_item(field.name().as_str())?
-                .execute_arrow(field.data_type(), session)?;
-            vortex_ensure!(
-                field.is_nullable() || field_array.null_count() == 0,
-                "Cannot convert field '{}' to non-nullable Arrow field because it contains nulls",
-                field.name()
-            );
-            field_arrays.push(field_array);
+        Err(array) => {
+            // Otherwise, we have some options:
+            //  1. Use get_item expression to extract each field? This is a bit sad because get_item
+            //     will perform the validity masking again.
+            //  2. Execute a full struct vector. But this may do unnecessary work on fields that may
+            //    have a more direct conversion to the desired Arrow field type.
+            //  3. Something else?
+            //
+            // For now, we go with option 1. Although we really ought to figure out CSE for this.
+            for field in fields.iter() {
+                let field_array = array
+                    .get_item(field.name().as_str())?
+                    .execute_arrow(field.data_type(), session)?;
+                vortex_ensure!(
+                    field.is_nullable() || field_array.null_count() == 0,
+                    "Cannot convert field '{}' to non-nullable Arrow field because it contains nulls",
+                    field.name()
+                );
+                field_arrays.push(field_array);
+            }
         }
     }
 

vortex-array/src/arrow/executor/temporal.rs

@@ -97,7 +97,7 @@ pub(super) fn to_arrow_temporal(
 }
 
 fn to_temporal<T: ArrowTemporalType>(
-    array: &ArrayRef,
+    array: ArrayRef,
     session: &VortexSession,
 ) -> VortexResult<ArrowArrayRef>
 where
@@ -108,7 +108,7 @@ where
 }
 
 fn to_arrow_timestamp<T: ArrowTimestampType>(
-    array: &ArrayRef,
+    array: ArrayRef,
     arrow_tz: &Option<Arc<str>>,
     session: &VortexSession,
 ) -> VortexResult<ArrowArrayRef>
@@ -121,7 +121,7 @@ where
 }
 
 fn to_arrow_temporal_primitive<T: ArrowTemporalType>(
-    array: &ArrayRef,
+    array: ArrayRef,
     session: &VortexSession,
 ) -> VortexResult<ArrowPrimitiveArray<T>>
 where