refactor(array): canonicalize chunked structs and FSLs through the builder

`pack_struct_chunks` and `swizzle_fixed_size_list_chunks` existed because
`append_to_builder` used to decode a builder's children: without them,
canonicalizing a `ChunkedArray` would concatenate every chunk's children
instead of reusing them. Their doc comments describe what the builders now
do on their own, so both are dead weight.

Route both dtypes through the generic builder path. `ListArray` keeps its
swizzle for now — that one also allocates its offsets and sizes through the
session allocator, which the builders cannot yet do.

Signed-off-by: Claude <noreply@anthropic.com>
Signed-off-by: Robert Kruszewski <robert@spiraldb.com>

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: claude

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

@@ -15,13 +15,10 @@ use crate::IntoArray;
 use crate::array::ArrayView;
 use crate::arrays::Chunked;
 use crate::arrays::ChunkedArray;
-use crate::arrays::FixedSizeListArray;
 use crate::arrays::ListViewArray;
 use crate::arrays::PrimitiveArray;
-use crate::arrays::StructArray;
 use crate::arrays::VariantArray;
 use crate::arrays::chunked::ChunkedArrayExt;
-use crate::arrays::fixed_size_list::FixedSizeListArraySlotsExt;
 use crate::arrays::listview::ListViewArraySlotsExt;
 use crate::arrays::listview::ListViewRebuildMode;
 use crate::arrays::variant::VariantArraySlotsExt;
@@ -48,28 +45,20 @@ pub(super) fn _canonicalize(
         return array.chunk(0).clone().execute::<Canonical>(ctx);
     }
 
-    let owned_chunks: Vec<ArrayRef> = array.iter_chunks().cloned().collect();
     Ok(match array.dtype() {
-        DType::Struct(..) => {
-            let struct_array = pack_struct_chunks(owned_chunks, ctx)?;
-            Canonical::Struct(struct_array)
-        }
-        DType::List(elem_dtype, _) => Canonical::List(swizzle_list_chunks(
-            &owned_chunks,
-            array.array().validity()?,
-            elem_dtype,
-            ctx,
-        )?),
-        DType::FixedSizeList(elem_dtype, list_size, _) => {
-            Canonical::FixedSizeList(swizzle_fixed_size_list_chunks(
+        DType::List(elem_dtype, _) => {
+            let owned_chunks: Vec<ArrayRef> = array.iter_chunks().cloned().collect();
+            Canonical::List(swizzle_list_chunks(
                 &owned_chunks,
                 array.array().validity()?,
                 elem_dtype,
-                *list_size,
                 ctx,
             )?)
         }
-        DType::Variant(_) => Canonical::Variant(pack_variant_chunks(owned_chunks, ctx)?),
+        DType::Variant(_) => {
+            let owned_chunks: Vec<ArrayRef> = array.iter_chunks().cloned().collect();
+            Canonical::Variant(pack_variant_chunks(owned_chunks, ctx)?)
+        }
         _ => {
             let mut builder = builder_with_capacity_in(ctx.allocator(), array.dtype(), array.len());
             array.array().append_to_builder(builder.as_mut(), ctx)?;
@@ -78,17 +67,6 @@ pub(super) fn _canonicalize(
     })
 }
 
-/// Packs many [`StructArray`]s to instead be a single [`StructArray`], where the [`DynArrayData`](crate::array::DynArrayData) for each
-/// field is a [`ChunkedArray`].
-///
-/// The caller guarantees there are at least 2 chunks.
-fn pack_struct_chunks(chunks: Vec<ArrayRef>, ctx: &mut ExecutionCtx) -> VortexResult<StructArray> {
-    chunks
-        .into_iter()
-        .map(|c| c.execute::<StructArray>(ctx))
-        .process_results(|iter| StructArray::try_concat(iter))?
-}
-
 /// Packs many [`VariantArray`]s into one [`VariantArray`] with chunked children.
 ///
 /// The caller guarantees there are at least 2 chunks.
@@ -253,45 +231,16 @@ fn swizzle_list_chunks(
     })
 }
 
-/// Packs [`FixedSizeListArray`]s together into a single [`FixedSizeListArray`] whose `elements`
-/// child is a [`ChunkedArray`].
-///
-/// Every chunk shares the same `list_size`, and each chunk's `elements` child is exactly
-/// `list_size * chunk.len()` long and starts at the first list, so we can reuse the chunks'
-/// `elements` children directly as the chunks of a combined `elements` array without copying.
-///
-/// The caller guarantees there are at least 2 chunks.
-fn swizzle_fixed_size_list_chunks(
-    chunks: &[ArrayRef],
-    validity: Validity,
-    elem_dtype: &DType,
-    list_size: u32,
-    ctx: &mut ExecutionCtx,
-) -> VortexResult<FixedSizeListArray> {
-    let len: usize = chunks.iter().map(|c| c.len()).sum();
-
-    let mut element_chunks = Vec::with_capacity(chunks.len());
-    for chunk in chunks {
-        let chunk_array = chunk.clone().execute::<FixedSizeListArray>(ctx)?;
-        // A canonical `FixedSizeListArray` keeps its `elements` child trimmed to exactly
-        // `list_size * chunk.len()` starting at the first list, so the children concatenate
-        // cleanly into the combined `elements` array.
-        element_chunks.push(chunk_array.elements().clone());
-    }
-
-    let chunked_elements = ChunkedArray::try_new(element_chunks, elem_dtype.clone())?.into_array();
-
-    FixedSizeListArray::try_new(chunked_elements, list_size, validity, len)
-}
-
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
     use std::sync::LazyLock;
     use std::sync::atomic::AtomicUsize;
     use std::sync::atomic::Ordering;
 
+    use rstest::rstest;
     use vortex_buffer::buffer;
+    use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
     use vortex_error::vortex_bail;
     use vortex_error::vortex_err;
@@ -301,15 +250,20 @@ mod tests {
     use crate::Canonical;
     use crate::IntoArray;
     use crate::VortexSessionExecute;
+    use crate::arrays::Chunked;
     use crate::arrays::ChunkedArray;
     use crate::arrays::ConstantArray;
+    use crate::arrays::FixedSizeList;
     use crate::arrays::FixedSizeListArray;
     use crate::arrays::ListArray;
     use crate::arrays::ListViewArray;
     use crate::arrays::PrimitiveArray;
+    use crate::arrays::Struct;
     use crate::arrays::StructArray;
     use crate::arrays::VarBinViewArray;
     use crate::arrays::VariantArray;
+    use crate::arrays::chunked::ChunkedArrayExt;
+    use crate::arrays::fixed_size_list::FixedSizeListArraySlotsExt;
     use crate::arrays::struct_::StructArrayExt;
     use crate::arrays::variant::VariantArraySlotsExt;
     use crate::assert_arrays_eq;
@@ -660,6 +614,46 @@ mod tests {
         Ok(())
     }
 
+    /// Canonicalizing a `ChunkedArray` reuses each chunk's children instead of concatenating
+    /// them, which is why the builder is told to keep every chunk boundary. The chunks here are
+    /// far shorter than the threshold a nested builder would apply on its own.
+    #[rstest]
+    #[case::struct_(
+        StructArray::try_from_iter([("a", buffer![1i32, 2])])
+            .vortex_expect("struct array")
+            .into_array(),
+        |array: &ArrayRef| array.as_::<Struct>().unmasked_field(0).clone()
+    )]
+    #[case::fixed_size_list(
+        FixedSizeListArray::new(buffer![1i32, 2].into_array(), 2, Validity::NonNullable, 1)
+            .into_array(),
+        |array: &ArrayRef| array.as_::<FixedSizeList>().elements().clone()
+    )]
+    fn canonicalize_reuses_chunk_children(
+        #[case] chunk: ArrayRef,
+        #[case] child_of: fn(&ArrayRef) -> ArrayRef,
+    ) -> VortexResult<()> {
+        let mut ctx = SESSION.create_execution_ctx();
+
+        let chunked =
+            ChunkedArray::try_new(vec![chunk.clone(), chunk.clone()], chunk.dtype().clone())?
+                .into_array();
+        let canonical = chunked.execute::<Canonical>(&mut ctx)?.into_array();
+
+        let child = child_of(&canonical);
+        assert_eq!(
+            child.as_::<Chunked>().nchunks(),
+            2,
+            "each chunk's child should have become a chunk of the combined child",
+        );
+
+        let expected =
+            ChunkedArray::try_new(vec![chunk.clone(), chunk], canonical.dtype().clone())?;
+        assert_arrays_eq!(&canonical, &expected, &mut ctx);
+
+        Ok(())
+    }
+
     #[test]
     fn list_canonicalize_uses_memory_session_allocator() {
         let allocations = Arc::new(AtomicUsize::new(0));