Improve visitor performance by reducing Vec and String allocations

encodings/alp/src/alp/array.rs

@@ -444,12 +444,23 @@ impl BaseArrayVTable<ALPVTable> for ALPVTable {
 impl VisitorVTable<ALPVTable> for ALPVTable {
     fn visit_buffers(_array: &ALPArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &ALPArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &ALPArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("encoded", array.encoded());
         if let Some(patches) = array.patches() {
             visitor.visit_patches(patches);
         }
     }
+
+    fn nchildren(array: &ALPArray) -> usize {
+        // encoded + optional patches (indices + values + optional chunk_offsets)
+        1 + array
+            .patches()
+            .map_or(0, |p| 2 + p.chunk_offsets().is_some() as usize)
+    }
 }
 
 #[cfg(test)]

encodings/alp/src/alp_rd/array.rs

@@ -461,13 +461,24 @@ impl BaseArrayVTable<ALPRDVTable> for ALPRDVTable {
 impl VisitorVTable<ALPRDVTable> for ALPRDVTable {
     fn visit_buffers(_array: &ALPRDArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &ALPRDArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &ALPRDArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("left_parts", array.left_parts());
         visitor.visit_child("right_parts", array.right_parts());
         if let Some(patches) = array.left_parts_patches() {
             visitor.visit_patches(patches);
         }
     }
+
+    fn nchildren(array: &ALPRDArray) -> usize {
+        // left_parts + right_parts + optional patches (indices + values)
+        2 + array
+            .left_parts_patches()
+            .map_or(0, |p| 2 + p.chunk_offsets().is_some() as usize)
+    }
 }
 
 #[cfg(test)]

encodings/bytebool/src/array.rs

@@ -27,6 +27,7 @@ use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityHelper;
 use vortex_array::vtable::ValidityVTableFromValidityHelper;
 use vortex_array::vtable::VisitorVTable;
+use vortex_array::vtable::validity_nchildren;
 use vortex_buffer::BitBuffer;
 use vortex_buffer::ByteBuffer;
 use vortex_dtype::DType;
@@ -229,9 +230,17 @@ impl VisitorVTable<ByteBoolVTable> for ByteBoolVTable {
         visitor.visit_buffer_handle("values", array.buffer());
     }
 
+    fn nbuffers(_array: &ByteBoolArray) -> usize {
+        1
+    }
+
     fn visit_children(array: &ByteBoolArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_validity(array.validity(), array.len());
     }
+
+    fn nchildren(array: &ByteBoolArray) -> usize {
+        validity_nchildren(array.validity())
+    }
 }
 
 impl From<Vec<bool>> for ByteBoolArray {

encodings/datetime-parts/src/array.rs

@@ -299,9 +299,17 @@ impl ValidityChild<DateTimePartsVTable> for DateTimePartsVTable {
 impl VisitorVTable<DateTimePartsVTable> for DateTimePartsVTable {
     fn visit_buffers(_array: &DateTimePartsArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &DateTimePartsArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &DateTimePartsArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("days", array.days());
         visitor.visit_child("seconds", array.seconds());
         visitor.visit_child("subseconds", array.subseconds());
     }
+
+    fn nchildren(_array: &DateTimePartsArray) -> usize {
+        3
+    }
 }

encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs

@@ -292,9 +292,17 @@ impl ValidityChild<DecimalBytePartsVTable> for DecimalBytePartsVTable {
 impl VisitorVTable<DecimalBytePartsVTable> for DecimalBytePartsVTable {
     fn visit_buffers(_array: &DecimalBytePartsArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &DecimalBytePartsArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &DecimalBytePartsArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("msp", &array.msp);
     }
+
+    fn nchildren(_array: &DecimalBytePartsArray) -> usize {
+        1
+    }
 }
 
 #[cfg(test)]

encodings/fastlanes/src/bitpacking/vtable/visitor.rs

@@ -5,6 +5,7 @@ use vortex_array::ArrayBufferVisitor;
 use vortex_array::ArrayChildVisitor;
 use vortex_array::vtable::ValidityHelper;
 use vortex_array::vtable::VisitorVTable;
+use vortex_array::vtable::validity_nchildren;
 
 use crate::BitPackedArray;
 use crate::BitPackedVTable;
@@ -14,10 +15,22 @@ impl VisitorVTable<BitPackedVTable> for BitPackedVTable {
         visitor.visit_buffer_handle("packed", array.packed());
     }
 
+    fn nbuffers(_array: &BitPackedArray) -> usize {
+        1
+    }
+
     fn visit_children(array: &BitPackedArray, visitor: &mut dyn ArrayChildVisitor) {
         if let Some(patches) = array.patches() {
             visitor.visit_patches(patches);
         }
         visitor.visit_validity(array.validity(), array.len());
     }
+
+    fn nchildren(array: &BitPackedArray) -> usize {
+        // optional patches (indices + values + optional chunk_offsets) + optional validity
+        array
+            .patches()
+            .map_or(0, |p| 2 + p.chunk_offsets().is_some() as usize)
+            + validity_nchildren(array.validity())
+    }
 }

encodings/fastlanes/src/delta/vtable/visitor.rs

@@ -11,8 +11,16 @@ use crate::DeltaArray;
 impl VisitorVTable<DeltaVTable> for DeltaVTable {
     fn visit_buffers(_array: &DeltaArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &DeltaArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &DeltaArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("bases", array.bases());
         visitor.visit_child("deltas", array.deltas());
     }
+
+    fn nchildren(_array: &DeltaArray) -> usize {
+        2
+    }
 }

encodings/fastlanes/src/for/vtable/visitor.rs

@@ -11,7 +11,15 @@ use crate::FoRArray;
 impl VisitorVTable<FoRVTable> for FoRVTable {
     fn visit_buffers(_array: &FoRArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &FoRArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &FoRArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("encoded", array.encoded())
     }
+
+    fn nchildren(_array: &FoRArray) -> usize {
+        1
+    }
 }

encodings/fastlanes/src/rle/vtable/visitor.rs

@@ -13,10 +13,18 @@ impl VisitorVTable<RLEVTable> for RLEVTable {
         // RLE stores all data in child arrays, no direct buffers
     }
 
+    fn nbuffers(_array: &RLEArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &RLEArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("values", array.values());
         visitor.visit_child("indices", array.indices());
         visitor.visit_child("values_idx_offsets", array.values_idx_offsets());
         // Don't call visit_validity since the nullability is stored in the indices array.
     }
+
+    fn nchildren(_array: &RLEArray) -> usize {
+        3
+    }
 }

encodings/fsst/src/array.rs

@@ -40,6 +40,7 @@ use vortex_array::vtable::ValidityChild;
 use vortex_array::vtable::ValidityHelper;
 use vortex_array::vtable::ValidityVTableFromChild;
 use vortex_array::vtable::VisitorVTable;
+use vortex_array::vtable::validity_nchildren;
 use vortex_buffer::Buffer;
 use vortex_buffer::ByteBuffer;
 use vortex_dtype::DType;
@@ -488,11 +489,20 @@ impl VisitorVTable<FSSTVTable> for FSSTVTable {
         visitor.visit_buffer_handle("compressed_codes", array.codes.bytes_handle())
     }
 
+    fn nbuffers(_array: &FSSTArray) -> usize {
+        3
+    }
+
     fn visit_children(array: &FSSTArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("uncompressed_lengths", array.uncompressed_lengths());
         visitor.visit_child("codes_offsets", array.codes.offsets());
         visitor.visit_validity(array.codes.validity(), array.codes.len());
     }
+
+    fn nchildren(array: &FSSTArray) -> usize {
+        // uncompressed_lengths + codes_offsets + optional validity
+        2 + validity_nchildren(array.codes.validity())
+    }
 }
 
 #[cfg(test)]

encodings/pco/src/array.rs

@@ -42,6 +42,7 @@ use vortex_array::vtable::ValidityHelper;
 use vortex_array::vtable::ValiditySliceHelper;
 use vortex_array::vtable::ValidityVTableFromValiditySliceHelper;
 use vortex_array::vtable::VisitorVTable;
+use vortex_array::vtable::validity_nchildren;
 use vortex_buffer::BufferMut;
 use vortex_buffer::ByteBuffer;
 use vortex_buffer::ByteBufferMut;
@@ -553,9 +554,17 @@ impl VisitorVTable<PcoVTable> for PcoVTable {
         }
     }
 
+    fn nbuffers(array: &PcoArray) -> usize {
+        array.chunk_metas.len() + array.pages.len()
+    }
+
     fn visit_children(array: &PcoArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_validity(&array.unsliced_validity, array.unsliced_n_rows());
     }
+
+    fn nchildren(array: &PcoArray) -> usize {
+        validity_nchildren(&array.unsliced_validity)
+    }
 }
 
 #[cfg(test)]

encodings/runend/src/lib.rs

@@ -34,10 +34,18 @@ use vortex_session::VortexSession;
 impl VisitorVTable<RunEndVTable> for RunEndVTable {
     fn visit_buffers(_array: &RunEndArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &RunEndArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &RunEndArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("ends", array.ends());
         visitor.visit_child("values", array.values());
     }
+
+    fn nchildren(_array: &RunEndArray) -> usize {
+        2
+    }
 }
 
 /// Initialize run-end encoding in the given session.

encodings/sequence/src/array.rs

@@ -373,7 +373,15 @@ impl VisitorVTable<SequenceVTable> for SequenceVTable {
         // TODO(joe): expose scalar values
     }
 
+    fn nbuffers(_array: &SequenceArray) -> usize {
+        0
+    }
+
     fn visit_children(_array: &SequenceArray, _visitor: &mut dyn ArrayChildVisitor) {}
+
+    fn nchildren(_array: &SequenceArray) -> usize {
+        0
+    }
 }
 
 #[derive(Debug)]

encodings/sparse/src/lib.rs

@@ -425,9 +425,18 @@ impl VisitorVTable<SparseVTable> for SparseVTable {
         visitor.visit_buffer_handle("fill_value", &BufferHandle::new_host(fill_value_buffer));
     }
 
+    fn nbuffers(_array: &SparseArray) -> usize {
+        1
+    }
+
     fn visit_children(array: &SparseArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_patches(array.patches())
     }
+
+    fn nchildren(array: &SparseArray) -> usize {
+        // patches have indices + values + optional chunk_offsets
+        2 + array.patches().chunk_offsets().is_some() as usize
+    }
 }
 
 #[cfg(test)]

encodings/zigzag/src/array.rs

@@ -211,9 +211,17 @@ impl ValidityChild<ZigZagVTable> for ZigZagVTable {
 impl VisitorVTable<ZigZagVTable> for ZigZagVTable {
     fn visit_buffers(_array: &ZigZagArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
+    fn nbuffers(_array: &ZigZagArray) -> usize {
+        0
+    }
+
     fn visit_children(array: &ZigZagArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_child("encoded", array.encoded())
     }
+
+    fn nchildren(_array: &ZigZagArray) -> usize {
+        1
+    }
 }
 
 #[cfg(test)]

encodings/zstd/src/array.rs

@@ -38,6 +38,7 @@ use vortex_array::vtable::ValidityHelper;
 use vortex_array::vtable::ValiditySliceHelper;
 use vortex_array::vtable::ValidityVTableFromValiditySliceHelper;
 use vortex_array::vtable::VisitorVTable;
+use vortex_array::vtable::validity_nchildren;
 use vortex_buffer::Alignment;
 use vortex_buffer::Buffer;
 use vortex_buffer::BufferMut;
@@ -914,7 +915,15 @@ impl VisitorVTable<ZstdVTable> for ZstdVTable {
         }
     }
 
+    fn nbuffers(array: &ZstdArray) -> usize {
+        array.dictionary.is_some() as usize + array.frames.len()
+    }
+
     fn visit_children(array: &ZstdArray, visitor: &mut dyn ArrayChildVisitor) {
         visitor.visit_validity(&array.unsliced_validity, array.unsliced_n_rows());
     }
+
+    fn nchildren(array: &ZstdArray) -> usize {
+        validity_nchildren(&array.unsliced_validity)
+    }
 }

vortex-array/src/array/mod.rs

@@ -633,23 +633,27 @@ 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
     }
 
     fn nchildren(&self) -> usize {
         <V::VisitorVTable as VisitorVTable<V>>::nchildren(&self.0)
     }
 
+    fn nth_child(&self, idx: usize) -> Option<ArrayRef> {
+        <V::VisitorVTable as VisitorVTable<V>>::nth_child(&self.0, idx)
+    }
+
     fn children_names(&self) -> Vec<String> {
         struct ChildNameCollector {
             names: Vec<String>,