fix

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

encodings/alp/public-api.lock

@@ -118,7 +118,7 @@ pub fn vortex_alp::ALPArray::into_parts(self) -> (vortex_array::array::ArrayRef,
 
 pub fn vortex_alp::ALPArray::new(encoded: vortex_array::array::ArrayRef, exponents: vortex_alp::Exponents, patches: core::option::Option<vortex_array::patches::Patches>) -> Self
 
-pub fn vortex_alp::ALPArray::patches(&self) -> core::option::Option<&vortex_array::patches::Patches>
+pub fn vortex_alp::ALPArray::patches(&self) -> core::option::Option<vortex_array::patches::Patches>
 
 pub fn vortex_alp::ALPArray::ptype(&self) -> vortex_array::dtype::ptype::PType
 

encodings/alp/src/alp/array.rs

@@ -34,6 +34,7 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
+use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 use vortex_session::VortexSession;
 
@@ -76,14 +77,14 @@ impl VTable for ALP {
         array.dtype.hash(state);
         array.encoded().array_hash(state, precision);
         array.exponents.hash(state);
-        array.patches.array_hash(state, precision);
+        array.patches().array_hash(state, precision);
     }
 
     fn array_eq(array: &ALPArray, other: &ALPArray, precision: Precision) -> bool {
         array.dtype == other.dtype
             && array.encoded().array_eq(other.encoded(), precision)
             && array.exponents == other.exponents
-            && array.patches.array_eq(&other.patches, precision)
+            && array.patches().array_eq(&other.patches(), precision)
     }
 
     fn nbuffers(_array: &ALPArray) -> usize {
@@ -107,30 +108,9 @@ impl VTable for ALP {
     }
 
     fn with_slots(array: &mut ALPArray, slots: Vec<Option<ArrayRef>>) -> VortexResult<()> {
-        vortex_ensure!(
-            slots.len() == NUM_SLOTS,
-            "ALPArray expects {} slots, got {}",
-            NUM_SLOTS,
-            slots.len()
-        );
-
-        // Reconstruct patches from slots + existing metadata
-        array.patches = match (&slots[PATCH_INDICES_SLOT], &slots[PATCH_VALUES_SLOT]) {
-            (Some(indices), Some(values)) => {
-                let old = array
-                    .patches
-                    .as_ref()
-                    .vortex_expect("ALPArray had patch slots but no patches metadata");
-                Some(Patches::new(
-                    old.array_len(),
-                    old.offset(),
-                    indices.clone(),
-                    values.clone(),
-                    slots[PATCH_CHUNK_OFFSETS_SLOT].clone(),
-                )?)
-            }
-            _ => None,
-        };
+        let slots: [Option<ArrayRef>; NUM_SLOTS] = slots.try_into().map_err(|v: Vec<_>| {
+            vortex_err!("ALPArray expects {} slots, got {}", NUM_SLOTS, v.len())
+        })?;
         array.slots = slots;
         Ok(())
     }
@@ -142,6 +122,7 @@ impl VTable for ALP {
             exp_f: exponents.f as u32,
             patches: array
                 .patches()
+                .as_ref()
                 .map(|p| p.to_metadata(array.len(), array.dtype()))
                 .transpose()?,
         }))
@@ -239,8 +220,9 @@ pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = [
 
 #[derive(Clone, Debug)]
 pub struct ALPArray {
-    slots: Vec<Option<ArrayRef>>,
-    patches: Option<Patches>,
+    slots: [Option<ArrayRef>; NUM_SLOTS],
+    patches_offset: usize,
+    patches_offset_within_chunk: Option<usize>,
     dtype: DType,
     exponents: Exponents,
     stats_set: ArrayStats,
@@ -408,13 +390,15 @@ impl ALPArray {
             _ => unreachable!(),
         };
 
-        let slots = Self::make_slots(&encoded, &patches);
+        let (slots, patches_offset, patches_offset_within_chunk) =
+            Self::decompose(encoded, patches);
 
         Ok(Self {
             dtype,
             slots,
+            patches_offset,
+            patches_offset_within_chunk,
             exponents,
-            patches,
             stats_set: Default::default(),
         })
     }
@@ -429,32 +413,37 @@ impl ALPArray {
         patches: Option<Patches>,
         dtype: DType,
     ) -> Self {
-        let slots = Self::make_slots(&encoded, &patches);
+        let (slots, patches_offset, patches_offset_within_chunk) =
+            Self::decompose(encoded, patches);
 
         Self {
             dtype,
             slots,
+            patches_offset,
+            patches_offset_within_chunk,
             exponents,
-            patches,
             stats_set: Default::default(),
         }
     }
 
-    fn make_slots(encoded: &ArrayRef, patches: &Option<Patches>) -> Vec<Option<ArrayRef>> {
-        let (patch_indices, patch_values, patch_chunk_offsets) = match patches {
-            Some(p) => (
-                Some(p.indices().clone()),
-                Some(p.values().clone()),
-                p.chunk_offsets().clone(),
-            ),
-            None => (None, None, None),
-        };
-        vec![
-            Some(encoded.clone()),
-            patch_indices,
-            patch_values,
-            patch_chunk_offsets,
-        ]
+    /// Decompose encoded + patches into slots and patch metadata, moving ArrayRefs
+    /// without cloning.
+    fn decompose(
+        encoded: ArrayRef,
+        patches: Option<Patches>,
+    ) -> ([Option<ArrayRef>; NUM_SLOTS], usize, Option<usize>) {
+        match patches {
+            Some(p) => {
+                let (_array_len, offset, indices, values, chunk_offsets, offset_within_chunk) =
+                    p.into_parts();
+                let slots = [Some(encoded), Some(indices), Some(values), chunk_offsets];
+                (slots, offset, offset_within_chunk)
+            }
+            None => {
+                let slots = [Some(encoded), None, None, None];
+                (slots, 0, None)
+            }
+        }
     }
 
     pub fn ptype(&self) -> PType {
@@ -472,17 +461,69 @@ impl ALPArray {
         self.exponents
     }
 
-    pub fn patches(&self) -> Option<&Patches> {
-        self.patches.as_ref()
+    /// Reconstruct patches from slots on demand.
+    pub fn patches(&self) -> Option<Patches> {
+        let indices = self.slots[PATCH_INDICES_SLOT].as_ref()?;
+        let values = self.slots[PATCH_VALUES_SLOT]
+            .as_ref()
+            .vortex_expect("ALPArray has patch indices but no values");
+        // SAFETY: the patches were validated at construction time.
+        Some(unsafe {
+            Patches::new_unchecked(
+                self.encoded().len(),
+                self.patches_offset,
+                indices.clone(),
+                values.clone(),
+                self.slots[PATCH_CHUNK_OFFSETS_SLOT].clone(),
+                self.patches_offset_within_chunk,
+            )
+        })
     }
 
     /// Consumes the array and returns its parts.
     #[inline]
-    pub fn into_parts(mut self) -> (ArrayRef, Exponents, Option<Patches>, DType) {
-        let encoded = self.slots[ENCODED_SLOT]
-            .take()
-            .vortex_expect("ALPArray encoded slot");
-        (encoded, self.exponents, self.patches, self.dtype)
+    pub fn into_parts(self) -> (ArrayRef, Exponents, Option<Patches>, DType) {
+        let (encoded, exponents, patches_offset, patches_offset_within_chunk, slots, dtype) =
+            self.into_raw_parts();
+        let patches = slots[PATCH_INDICES_SLOT].as_ref().map(|_| {
+            let [_, indices, values, chunk_offsets] = slots;
+            // SAFETY: validated at construction time.
+            unsafe {
+                Patches::new_unchecked(
+                    encoded.len(),
+                    patches_offset,
+                    indices.vortex_expect("ALPArray has patch indices"),
+                    values.vortex_expect("ALPArray has patch values"),
+                    chunk_offsets,
+                    patches_offset_within_chunk,
+                )
+            }
+        });
+        (encoded, exponents, patches, dtype)
+    }
+
+    /// Consumes the array and returns raw slot components without reconstructing Patches.
+    #[inline]
+    pub(crate) fn into_raw_parts(
+        self,
+    ) -> (
+        ArrayRef,
+        Exponents,
+        usize,
+        Option<usize>,
+        [Option<ArrayRef>; NUM_SLOTS],
+        DType,
+    ) {
+        let [encoded, indices, values, chunk_offsets] = self.slots;
+        let encoded = encoded.vortex_expect("ALPArray encoded slot");
+        (
+            encoded,
+            self.exponents,
+            self.patches_offset,
+            self.patches_offset_within_chunk,
+            [None, indices, values, chunk_offsets],
+            self.dtype,
+        )
     }
 }
 

encodings/alp/src/alp/compute/cast.rs

@@ -29,7 +29,7 @@ impl CastReduce for ALP {
                 .patches()
                 .map(|p| {
                     if p.values().dtype() == dtype {
-                        Ok(p.clone())
+                        Ok(p)
                     } else {
                         Patches::new(
                             p.array_len(),

encodings/fastlanes/src/bitpacking/array/mod.rs

@@ -47,7 +47,7 @@ pub struct BitPackedArrayParts {
 
 #[derive(Clone, Debug)]
 pub struct BitPackedArray {
-    pub(super) slots: Vec<Option<ArrayRef>>,
+    pub(super) slots: [Option<ArrayRef>; NUM_SLOTS],
     /// The offset within the first block (created with a slice).
     /// 0 <= offset < 1024
     pub(super) offset: u16,
@@ -109,7 +109,7 @@ impl BitPackedArray {
         patches: &Option<Patches>,
         validity: &Validity,
         len: usize,
-    ) -> Vec<Option<ArrayRef>> {
+    ) -> [Option<ArrayRef>; NUM_SLOTS] {
         let (pi, pv, pco) = match patches {
             Some(p) => (
                 Some(p.indices().clone()),
@@ -119,7 +119,7 @@ impl BitPackedArray {
             None => (None, None, None),
         };
         let validity_slot = validity_to_child(validity, len);
-        vec![pi, pv, pco, validity_slot]
+        [pi, pv, pco, validity_slot]
     }
 
     /// A safe constructor for a `BitPackedArray` from its components:

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

@@ -152,12 +152,13 @@ impl VTable for BitPacked {
     }
 
     fn with_slots(array: &mut BitPackedArray, slots: Vec<Option<ArrayRef>>) -> VortexResult<()> {
-        vortex_ensure!(
-            slots.len() == NUM_SLOTS,
-            "BitPackedArray expects {} slots, got {}",
-            NUM_SLOTS,
-            slots.len()
-        );
+        let slots: [Option<ArrayRef>; NUM_SLOTS] = slots.try_into().map_err(|v: Vec<_>| {
+            vortex_err!(
+                "BitPackedArray expects {} slots, got {}",
+                NUM_SLOTS,
+                v.len()
+            )
+        })?;
 
         // Reconstruct patches from slots + existing metadata
         array.patches = match (&slots[PATCH_INDICES_SLOT], &slots[PATCH_VALUES_SLOT]) {

vortex-array/public-api.lock

@@ -15204,6 +15204,8 @@ pub fn vortex_array::patches::Patches::indices_ptype(&self) -> vortex_error::Vor
 
 pub fn vortex_array::patches::Patches::into_indices(self) -> vortex_array::ArrayRef
 
+pub fn vortex_array::patches::Patches::into_parts(self) -> (usize, usize, vortex_array::ArrayRef, vortex_array::ArrayRef, core::option::Option<vortex_array::ArrayRef>, core::option::Option<usize>)
+
 pub fn vortex_array::patches::Patches::into_values(self) -> vortex_array::ArrayRef
 
 pub fn vortex_array::patches::Patches::map_values<F>(self, f: F) -> vortex_error::VortexResult<Self> where F: core::ops::function::FnOnce(vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>

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

@@ -38,7 +38,7 @@ pub(super) const SLOT_NAMES: [&str; NUM_SLOTS] = ["codes", "values"];
 
 #[derive(Debug, Clone)]
 pub struct DictArray {
-    pub(super) slots: Vec<Option<ArrayRef>>,
+    pub(super) slots: [Option<ArrayRef>; NUM_SLOTS],
     pub(super) stats_set: ArrayStats,
     pub(super) dtype: DType,
     /// Indicates whether all dictionary values are definitely referenced by at least one code.
@@ -67,7 +67,7 @@ impl DictArray {
             .dtype()
             .union_nullability(codes.dtype().nullability());
         Self {
-            slots: vec![Some(codes), Some(values)],
+            slots: [Some(codes), Some(values)],
             stats_set: Default::default(),
             dtype,
             all_values_referenced: false,

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

@@ -179,12 +179,13 @@ impl VTable for Dict {
     }
 
     fn with_slots(array: &mut DictArray, slots: Vec<Option<ArrayRef>>) -> VortexResult<()> {
-        vortex_ensure!(
-            slots.len() == NUM_SLOTS,
-            "DictArray expects exactly {} slots, got {}",
-            NUM_SLOTS,
-            slots.len()
-        );
+        let slots: [Option<ArrayRef>; NUM_SLOTS] = slots.try_into().map_err(|v: Vec<_>| {
+            vortex_err!(
+                "DictArray expects exactly {} slots, got {}",
+                NUM_SLOTS,
+                v.len()
+            )
+        })?;
         array.slots = slots;
         Ok(())
     }

vortex-array/src/patches.rs

@@ -236,6 +236,28 @@ impl Patches {
         }
     }
 
+    /// Consume the patches and return all components.
+    #[inline]
+    pub fn into_parts(
+        self,
+    ) -> (
+        usize,
+        usize,
+        ArrayRef,
+        ArrayRef,
+        Option<ArrayRef>,
+        Option<usize>,
+    ) {
+        (
+            self.array_len,
+            self.offset,
+            self.indices,
+            self.values,
+            self.chunk_offsets,
+            self.offset_within_chunk,
+        )
+    }
+
     #[inline]
     pub fn array_len(&self) -> usize {
         self.array_len

vortex-btrblocks/src/compressor/float/mod.rs

@@ -341,7 +341,7 @@ impl Scheme for ALPScheme {
             Excludes::int_only(&int_excludes),
         )?;
 
-        let patches = alp.patches().map(compress_patches).transpose()?;
+        let patches = alp.patches().as_ref().map(compress_patches).transpose()?;
 
         Ok(ALPArray::new(compressed_alp_ints, alp.exponents(), patches).into_array())
     }