implement append_to_builder for Patched

We call append_to_builder on the inner first, then just do a single pass
and overwrite what it just wrote.

Signed-off-by: Andrew Duffy <andrew@a10y.dev>

Author: a10y

vortex-array/src/arrays/patched/vtable/mod.rs

@@ -10,6 +10,7 @@ use std::hash::Hasher;
 use std::sync::Arc;
 
 use vortex_buffer::Buffer;
+use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
@@ -34,6 +35,8 @@ use crate::arrays::patched::patch_lanes;
 use crate::arrays::patched::vtable::kernels::PARENT_KERNELS;
 use crate::arrays::primitive::PrimitiveArrayParts;
 use crate::buffer::BufferHandle;
+use crate::builders::ArrayBuilder;
+use crate::builders::PrimitiveBuilder;
 use crate::dtype::DType;
 use crate::dtype::NativePType;
 use crate::match_each_native_ptype;
@@ -169,6 +172,56 @@ impl VTable for Patched {
         Ok(ProstMetadata(inner))
     }
 
+    fn append_to_builder(
+        array: &Self::Array,
+        builder: &mut dyn ArrayBuilder,
+        ctx: &mut ExecutionCtx,
+    ) -> VortexResult<()> {
+        let dtype = array.dtype();
+
+        if !dtype.is_primitive() {
+            // Default pathway: canonicalize and propagate.
+            let canonical = array.to_array().execute::<Canonical>(ctx)?.into_array();
+            builder.extend_from_array(&canonical);
+            return Ok(());
+        }
+
+        let ptype = dtype.as_ptype();
+
+        let len = array.len();
+        array.inner.append_to_builder(builder, ctx)?;
+
+        let offset = array.offset;
+        let lane_offsets: Buffer<u32> =
+            Buffer::from_byte_buffer(array.lane_offsets.clone().unwrap_host());
+        let indices: Buffer<u16> = Buffer::from_byte_buffer(array.indices.clone().unwrap_host());
+        let values = array.values.clone().execute::<PrimitiveArray>(ctx)?;
+
+        match_each_native_ptype!(ptype, |V| {
+            let typed_builder = builder
+                .as_any_mut()
+                .downcast_mut::<PrimitiveBuilder<V>>()
+                .vortex_expect("correctly typed builder");
+
+            // Overwrite the last `len` elements of the builder. These would have been
+            // populated by the inner.append_to_builder() call above.
+            let mut output = typed_builder.values_mut();
+
+            apply_patches_primitive::<V>(
+                &mut output[(values.len() - len)..],
+                offset,
+                len,
+                array.n_chunks,
+                array.n_lanes,
+                &lane_offsets,
+                &indices,
+                values.as_slice::<V>(),
+            );
+        });
+
+        Ok(())
+    }
+
     fn build(
         dtype: &DType,
         len: usize,

vortex-array/src/builders/primitive.rs

@@ -62,6 +62,11 @@ impl<T: NativePType> PrimitiveBuilder<T> {
         self.values.as_ref()
     }
 
+    /// Returns the raw primitive values in this builder as a mutable slice.
+    pub fn values_mut(&mut self) -> &[T] {
+        self.values.as_mut()
+    }
+
     /// Create a new handle to the next `len` uninitialized values in the builder.
     ///
     /// All reads/writes through the handle to the values buffer or the validity buffer will operate