Visit children in an unnamed way

Signed-off-by: Adam Gutglick <adam@spiraldb.com>

Author: AdamGS

vortex-array/src/array/mod.rs

@@ -633,16 +633,16 @@ impl<V: VTable> ArrayVisitor for ArrayAdapter<V> {
             children: Vec<ArrayRef>,
         }
 
-        impl ArrayChildVisitor for ChildrenCollector {
-            fn visit_child(&mut self, _name: &str, array: &ArrayRef) {
+        impl ArrayChildVisitorUnnamed for ChildrenCollector {
+            fn visit_child(&mut self, array: &ArrayRef) {
                 self.children.push(array.clone());
             }
         }
 
         let mut collector = ChildrenCollector {
             children: Vec::new(),
         };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children(&self.0, &mut collector);
+        <V::VisitorVTable as VisitorVTable<V>>::visit_children_unnamed(&self.0, &mut collector);
         collector.children
     }
 

vortex-array/src/array/visitor.rs

@@ -156,6 +156,40 @@ pub trait ArrayBufferVisitor {
     fn visit_buffer_handle(&mut self, _name: &str, handle: &BufferHandle);
 }
 
+/// A visitor for array children that does not require names.
+///
+/// This is more efficient than [`ArrayChildVisitor`] when you only need to
+/// iterate over children without accessing their names (e.g., for counting
+/// or accessing by index).
+pub trait ArrayChildVisitorUnnamed {
+    /// Visit a child of this array.
+    fn visit_child(&mut self, array: &ArrayRef);
+
+    /// Utility for visiting Array validity.
+    fn visit_validity(&mut self, validity: &Validity, len: usize) {
+        if let Some(vlen) = validity.maybe_len() {
+            assert_eq!(vlen, len, "Validity length mismatch");
+        }
+
+        match validity {
+            Validity::NonNullable | Validity::AllValid => {}
+            Validity::AllInvalid => self.visit_child(&ConstantArray::new(false, len).into_array()),
+            Validity::Array(array) => {
+                self.visit_child(array);
+            }
+        }
+    }
+
+    /// Utility for visiting Array patches.
+    fn visit_patches(&mut self, patches: &Patches) {
+        self.visit_child(patches.indices());
+        self.visit_child(patches.values());
+        if let Some(chunk_offsets) = patches.chunk_offsets() {
+            self.visit_child(chunk_offsets);
+        }
+    }
+}
+
 pub trait ArrayChildVisitor {
     /// Visit a child of this array.
     fn visit_child(&mut self, _name: &str, _array: &ArrayRef);

vortex-array/src/arrays/chunked/vtable/visitor.rs

@@ -3,6 +3,7 @@
 
 use crate::ArrayBufferVisitor;
 use crate::ArrayChildVisitor;
+use crate::ArrayChildVisitorUnnamed;
 use crate::arrays::ChunkedArray;
 use crate::arrays::ChunkedVTable;
 use crate::vtable::VisitorVTable;
@@ -17,4 +18,12 @@ impl VisitorVTable<ChunkedVTable> for ChunkedVTable {
             visitor.visit_child(format!("chunks[{idx}]").as_str(), chunk);
         }
     }
+
+    fn visit_children_unnamed(array: &ChunkedArray, visitor: &mut dyn ArrayChildVisitorUnnamed) {
+        visitor.visit_child(&array.chunk_offsets.to_array());
+
+        for chunk in array.chunks().iter() {
+            visitor.visit_child(chunk);
+        }
+    }
 }

vortex-array/src/arrays/scalar_fn/vtable/visitor.rs

@@ -3,6 +3,7 @@
 
 use crate::ArrayBufferVisitor;
 use crate::ArrayChildVisitor;
+use crate::ArrayChildVisitorUnnamed;
 use crate::ArrayRef;
 use crate::arrays::scalar_fn::array::ScalarFnArray;
 use crate::arrays::scalar_fn::vtable::ScalarFnVTable;
@@ -18,6 +19,16 @@ impl VisitorVTable<ScalarFnVTable> for ScalarFnVTable {
         }
     }
 
+    fn visit_children_unnamed(array: &ScalarFnArray, visitor: &mut dyn ArrayChildVisitorUnnamed) {
+        for child in array.children.iter() {
+            visitor.visit_child(child);
+        }
+    }
+
+    fn nchildren(array: &ScalarFnArray) -> usize {
+        array.children.len()
+    }
+
     fn nth_child(array: &ScalarFnArray, idx: usize) -> Option<ArrayRef> {
         array.children.get(idx).cloned()
     }

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

@@ -5,6 +5,7 @@ use itertools::Itertools;
 
 use crate::ArrayBufferVisitor;
 use crate::ArrayChildVisitor;
+use crate::ArrayChildVisitorUnnamed;
 use crate::arrays::struct_::StructArray;
 use crate::arrays::struct_::StructVTable;
 use crate::vtable::ValidityHelper;
@@ -19,4 +20,11 @@ impl VisitorVTable<StructVTable> for StructVTable {
             visitor.visit_child(name.as_ref(), field);
         }
     }
+
+    fn visit_children_unnamed(array: &StructArray, visitor: &mut dyn ArrayChildVisitorUnnamed) {
+        visitor.visit_validity(array.validity(), array.len());
+        for field in array.unmasked_fields().iter() {
+            visitor.visit_child(field);
+        }
+    }
 }

vortex-array/src/vtable/visitor.rs

@@ -3,6 +3,7 @@
 
 use crate::ArrayBufferVisitor;
 use crate::ArrayChildVisitor;
+use crate::ArrayChildVisitorUnnamed;
 use crate::ArrayRef;
 use crate::buffer::BufferHandle;
 use crate::vtable::VTable;
@@ -44,18 +45,36 @@ pub trait VisitorVTable<V: VTable> {
     /// Visit the children of the array.
     fn visit_children(array: &V::Array, visitor: &mut dyn ArrayChildVisitor);
 
+    /// Visit the children of the array without names.
+    ///
+    /// This is more efficient than [`visit_children`] when you don't need the
+    /// child names (e.g., for counting or accessing by index). The default
+    /// implementation wraps the named visitor, but array types can override
+    /// this to avoid allocating names.
+    fn visit_children_unnamed(array: &V::Array, visitor: &mut dyn ArrayChildVisitorUnnamed) {
+        struct UnnamedWrapper<'a>(&'a mut dyn ArrayChildVisitorUnnamed);
+
+        impl ArrayChildVisitor for UnnamedWrapper<'_> {
+            fn visit_child(&mut self, _name: &str, array: &ArrayRef) {
+                self.0.visit_child(array);
+            }
+        }
+
+        <V::VisitorVTable as VisitorVTable<V>>::visit_children(array, &mut UnnamedWrapper(visitor));
+    }
+
     /// Count the number of children in the array.
     fn nchildren(array: &V::Array) -> usize {
         struct NChildren(usize);
 
-        impl ArrayChildVisitor for NChildren {
-            fn visit_child(&mut self, _name: &str, _array: &ArrayRef) {
+        impl ArrayChildVisitorUnnamed for NChildren {
+            fn visit_child(&mut self, _array: &ArrayRef) {
                 self.0 += 1;
             }
         }
 
         let mut visitor = NChildren(0);
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children(array, &mut visitor);
+        <V::VisitorVTable as VisitorVTable<V>>::visit_children_unnamed(array, &mut visitor);
         visitor.0
     }
 
@@ -69,8 +88,8 @@ pub trait VisitorVTable<V: VTable> {
             result: Option<ArrayRef>,
         }
 
-        impl ArrayChildVisitor for NthChildVisitor {
-            fn visit_child(&mut self, _name: &str, array: &ArrayRef) {
+        impl ArrayChildVisitorUnnamed for NthChildVisitor {
+            fn visit_child(&mut self, array: &ArrayRef) {
                 if self.current_idx == self.target_idx && self.result.is_none() {
                     self.result = Some(array.clone());
                 }
@@ -83,7 +102,7 @@ pub trait VisitorVTable<V: VTable> {
             current_idx: 0,
             result: None,
         };
-        <V::VisitorVTable as VisitorVTable<V>>::visit_children(array, &mut visitor);
+        <V::VisitorVTable as VisitorVTable<V>>::visit_children_unnamed(array, &mut visitor);
         visitor.result
     }
 }