fix

joseph-isaacs · joseph-isaacs · commit cbeb00910e8e · 2026-03-31T10:57:33.000+01:00
Signed-off-by: Joe Isaacs &lt;joe.isaacs@live.co.uk&gt;
diff --git a/encodings/alp/src/alp/array.rs b/encodings/alp/src/alp/array.rs
@@ -478,9 +478,9 @@ impl ALPArray {
 
     /// Consumes the array and returns its parts.
     #[inline]
-    pub fn into_parts(self) -> (ArrayRef, Exponents, Option<Patches>, DType) {
+    pub fn into_parts(mut self) -> (ArrayRef, Exponents, Option<Patches>, DType) {
         let encoded = self.slots[ENCODED_SLOT]
-            .clone()
+            .take()
             .vortex_expect("ALPArray encoded slot");
         (encoded, self.exponents, self.patches, self.dtype)
     }
diff --git a/encodings/alp/src/alp_rd/array.rs b/encodings/alp/src/alp_rd/array.rs
@@ -496,12 +496,12 @@ impl ALPRDArray {
     }
 
     /// Return all the owned parts of the array
-    pub fn into_parts(self) -> ALPRDArrayParts {
+    pub fn into_parts(mut self) -> ALPRDArrayParts {
         let left_parts = self.slots[LEFT_PARTS_SLOT]
-            .clone()
+            .take()
             .vortex_expect("ALPRDArray left_parts slot");
         let right_parts = self.slots[RIGHT_PARTS_SLOT]
-            .clone()
+            .take()
             .vortex_expect("ALPRDArray right_parts slot");
         ALPRDArrayParts {
             dtype: self.dtype,
diff --git a/encodings/datetime-parts/src/array.rs b/encodings/datetime-parts/src/array.rs
@@ -316,17 +316,17 @@ impl DateTimePartsArray {
         }
     }
 
-    pub fn into_parts(self) -> DateTimePartsArrayParts {
+    pub fn into_parts(mut self) -> DateTimePartsArrayParts {
         DateTimePartsArrayParts {
             dtype: self.dtype,
             days: self.slots[DAYS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("DateTimePartsArray days slot"),
             seconds: self.slots[SECONDS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("DateTimePartsArray seconds slot"),
             subseconds: self.slots[SUBSECONDS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("DateTimePartsArray subseconds slot"),
         }
     }
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
@@ -256,10 +256,10 @@ impl DecimalBytePartsArray {
     }
 
     /// If `_lower_parts` is supported check all calls use this correctly.
-    pub fn into_parts(self) -> DecimalBytePartsArrayParts {
+    pub fn into_parts(mut self) -> DecimalBytePartsArrayParts {
         DecimalBytePartsArrayParts {
             msp: self.slots[MSP_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("DecimalBytePartsArray msp slot"),
             dtype: self.dtype,
         }
diff --git a/encodings/runend/src/array.rs b/encodings/runend/src/array.rs
@@ -448,13 +448,13 @@ impl RunEndArray {
 
     /// Split an `RunEndArray` into parts.
     #[inline]
-    pub fn into_parts(self) -> RunEndArrayParts {
+    pub fn into_parts(mut self) -> RunEndArrayParts {
         RunEndArrayParts {
             ends: self.slots[ENDS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("RunEndArray ends slot"),
             values: self.slots[VALUES_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("RunEndArray values slot"),
         }
     }
diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
@@ -22246,7 +22246,7 @@ pub fn vortex_array::vtable::DynVTable::reduce(&self, array: &vortex_array::Arra
 
 pub fn vortex_array::vtable::DynVTable::reduce_parent(&self, array: &vortex_array::ArrayRef, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn vortex_array::vtable::DynVTable::with_slots(&self, array: &vortex_array::ArrayRef, slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::vtable::DynVTable::with_slots(&self, array: vortex_array::ArrayRef, slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
 impl<V: vortex_array::vtable::VTable> vortex_array::vtable::DynVTable for V
 
@@ -22262,7 +22262,7 @@ pub fn V::reduce(&self, array: &vortex_array::ArrayRef) -> vortex_error::VortexR
 
 pub fn V::reduce_parent(&self, array: &vortex_array::ArrayRef, parent: &vortex_array::ArrayRef, child_idx: usize) -> vortex_error::VortexResult<core::option::Option<vortex_array::ArrayRef>>
 
-pub fn V::with_slots(&self, array: &vortex_array::ArrayRef, slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn V::with_slots(&self, array: vortex_array::ArrayRef, slots: alloc::vec::Vec<core::option::Option<vortex_array::ArrayRef>>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
 pub trait vortex_array::vtable::OperationsVTable<V: vortex_array::vtable::VTable>
 
diff --git a/vortex-array/src/array/mod.rs b/vortex-array/src/array/mod.rs
@@ -346,17 +346,24 @@ impl dyn DynArray + '_ {
     }
 
     /// Returns a new array with the slot at `slot_idx` replaced by `replacement`.
-    pub fn with_slot(&self, slot_idx: usize, replacement: ArrayRef) -> VortexResult<ArrayRef> {
-        let slots = self.slots();
+    ///
+    /// Takes ownership to allow in-place mutation when the refcount is 1.
+    pub fn with_slot(
+        self: ArrayRef,
+        slot_idx: usize,
+        replacement: ArrayRef,
+    ) -> VortexResult<ArrayRef> {
+        let nslots = self.slots().len();
         vortex_ensure!(
-            slot_idx < slots.len(),
+            slot_idx < nslots,
             "slot index {} out of bounds for array with {} slots",
             slot_idx,
-            slots.len()
+            nslots
         );
-        let mut slots = slots.to_vec();
+        let mut slots = self.slots().to_vec();
         slots[slot_idx] = Some(replacement);
-        self.vtable().with_slots(&self.to_array(), slots)
+        let vtable = self.vtable().clone_boxed();
+        vtable.with_slots(self, slots)
     }
 }
 
diff --git a/vortex-array/src/arrays/dict/array.rs b/vortex-array/src/arrays/dict/array.rs
@@ -123,13 +123,13 @@ impl DictArray {
         Ok(unsafe { Self::new_unchecked(codes, values) })
     }
 
-    pub fn into_parts(self) -> DictArrayParts {
+    pub fn into_parts(mut self) -> DictArrayParts {
         DictArrayParts {
             codes: self.slots[CODES_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("DictArray codes slot"),
             values: self.slots[VALUES_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("DictArray values slot"),
             dtype: self.dtype,
         }
diff --git a/vortex-array/src/arrays/filter/array.rs b/vortex-array/src/arrays/filter/array.rs
@@ -72,10 +72,10 @@ impl FilterArray {
     }
 
     /// Consume the array and return its individual components.
-    pub fn into_parts(self) -> FilterArrayParts {
+    pub fn into_parts(mut self) -> FilterArrayParts {
         FilterArrayParts {
             child: self.slots[CHILD_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("FilterArray child slot"),
             mask: self.mask,
         }
diff --git a/vortex-array/src/arrays/fixed_size_list/array.rs b/vortex-array/src/arrays/fixed_size_list/array.rs
@@ -172,10 +172,10 @@ impl FixedSizeListArray {
         }
     }
 
-    pub fn into_parts(self) -> (ArrayRef, Validity, DType) {
+    pub fn into_parts(mut self) -> (ArrayRef, Validity, DType) {
         (
             self.slots[ELEMENTS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("FixedSizeListArray elements slot"),
             self.validity,
             self.dtype,
diff --git a/vortex-array/src/arrays/list/array.rs b/vortex-array/src/arrays/list/array.rs
@@ -250,14 +250,14 @@ impl ListArray {
     }
 
     /// Splits an array into its parts
-    pub fn into_parts(self) -> ListArrayParts {
+    pub fn into_parts(mut self) -> ListArrayParts {
         ListArrayParts {
             dtype: self.dtype,
             elements: self.slots[ELEMENTS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("ListArray elements slot"),
             offsets: self.slots[OFFSETS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("ListArray offsets slot"),
             validity: self.validity,
         }
diff --git a/vortex-array/src/arrays/listview/array.rs b/vortex-array/src/arrays/listview/array.rs
@@ -338,18 +338,18 @@ impl ListViewArray {
         .is_ok()
     }
 
-    pub fn into_parts(self) -> ListViewArrayParts {
+    pub fn into_parts(mut self) -> ListViewArrayParts {
         let dtype = self.dtype.into_list_element_opt().vortex_expect("is list");
         ListViewArrayParts {
             elements_dtype: dtype,
             elements: self.slots[ELEMENTS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("ListViewArray elements slot"),
             offsets: self.slots[OFFSETS_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("ListViewArray offsets slot"),
             sizes: self.slots[SIZES_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("ListViewArray sizes slot"),
             validity: self.validity,
         }
diff --git a/vortex-array/src/arrays/slice/array.rs b/vortex-array/src/arrays/slice/array.rs
@@ -59,10 +59,10 @@ impl SliceArray {
     }
 
     /// Consume the slice array and return its components.
-    pub fn into_parts(self) -> SliceArrayParts {
+    pub fn into_parts(mut self) -> SliceArrayParts {
         SliceArrayParts {
             child: self.slots[CHILD_SLOT]
-                .clone()
+                .take()
                 .vortex_expect("SliceArray child slot"),
             range: self.range,
         }
diff --git a/vortex-array/src/arrays/varbin/array.rs b/vortex-array/src/arrays/varbin/array.rs
@@ -381,9 +381,9 @@ impl VarBinArray {
 
     /// Consumes self, returning a tuple containing the `DType`, the `bytes` array,
     /// the `offsets` array, and the `validity`.
-    pub fn into_parts(self) -> (DType, BufferHandle, ArrayRef, Validity) {
+    pub fn into_parts(mut self) -> (DType, BufferHandle, ArrayRef, Validity) {
         let offsets = self.slots[OFFSETS_SLOT]
-            .clone()
+            .take()
             .vortex_expect("VarBinArray offsets slot");
         (self.dtype, self.bytes, offsets, self.validity)
     }
diff --git a/vortex-array/src/optimizer/mod.rs b/vortex-array/src/optimizer/mod.rs
@@ -107,9 +107,8 @@ fn try_optimize_recursive(array: &ArrayRef) -> VortexResult<Option<ArrayRef>> {
     }
 
     if any_slot_optimized {
-        current_array = current_array
-            .vtable()
-            .with_slots(&current_array, new_slots)?;
+        let vtable = current_array.vtable().clone_boxed();
+        current_array = vtable.with_slots(current_array, new_slots)?;
         any_optimizations = true;
     }
 
diff --git a/vortex-array/src/vtable/dyn_.rs b/vortex-array/src/vtable/dyn_.rs
@@ -49,7 +49,7 @@ pub trait DynVTable: 'static + Send + Sync + Debug {
         session: &VortexSession,
     ) -> VortexResult<ArrayRef>;
     /// See [`VTable::with_slots`]
-    fn with_slots(&self, array: &ArrayRef, slots: Vec<Option<ArrayRef>>) -> VortexResult<ArrayRef>;
+    fn with_slots(&self, array: ArrayRef, slots: Vec<Option<ArrayRef>>) -> VortexResult<ArrayRef>;
 
     /// See [`VTable::reduce`]
     fn reduce(&self, array: &ArrayRef) -> VortexResult<Option<ArrayRef>>;
@@ -113,10 +113,11 @@ impl<V: VTable> DynVTable for V {
         Ok(array.into_array())
     }
 
-    fn with_slots(&self, array: &ArrayRef, slots: Vec<Option<ArrayRef>>) -> VortexResult<ArrayRef> {
-        let mut array = array.as_::<V>().clone();
-        V::with_slots(&mut array, slots)?;
-        Ok(array.into_array())
+    fn with_slots(&self, array: ArrayRef, slots: Vec<Option<ArrayRef>>) -> VortexResult<ArrayRef> {
+        let arc = downcast_owned::<V>(array);
+        let mut inner = Arc::try_unwrap(arc).unwrap_or_else(|arc| arc.as_ref().clone());
+        V::with_slots(&mut inner.array, slots)?;
+        Ok(inner.into_array())
     }
 
     fn reduce(&self, array: &ArrayRef) -> VortexResult<Option<ArrayRef>> {

Original file line number	Diff line number	Diff line change
`@@ -316,17 +316,17 @@ impl DateTimePartsArray {`
`316`	`316`	`}`
`317`	`317`	`}`
`318`	`318`
`319`		`- pub fn into_parts(self) -> DateTimePartsArrayParts {`
	`319`	`+ pub fn into_parts(mut self) -> DateTimePartsArrayParts {`
`320`	`320`	`DateTimePartsArrayParts {`
`321`	`321`	`dtype: self.dtype,`
`322`	`322`	`days: self.slots[DAYS_SLOT]`
`323`		`- .clone()`
	`323`	`+ .take()`
`324`	`324`	`.vortex_expect("DateTimePartsArray days slot"),`
`325`	`325`	`seconds: self.slots[SECONDS_SLOT]`
`326`		`- .clone()`
	`326`	`+ .take()`
`327`	`327`	`.vortex_expect("DateTimePartsArray seconds slot"),`
`328`	`328`	`subseconds: self.slots[SUBSECONDS_SLOT]`
`329`		`- .clone()`
	`329`	`+ .take()`
`330`	`330`	`.vortex_expect("DateTimePartsArray subseconds slot"),`
`331`	`331`	`}`
`332`	`332`	`}`
Original file line number	Diff line number	Diff line change
`@@ -256,10 +256,10 @@ impl DecimalBytePartsArray {`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	/// If `_lower_parts` is supported check all calls use this correctly.
`259`		`- pub fn into_parts(self) -> DecimalBytePartsArrayParts {`
	`259`	`+ pub fn into_parts(mut self) -> DecimalBytePartsArrayParts {`
`260`	`260`	`DecimalBytePartsArrayParts {`
`261`	`261`	`msp: self.slots[MSP_SLOT]`
`262`		`- .clone()`
	`262`	`+ .take()`
`263`	`263`	`.vortex_expect("DecimalBytePartsArray msp slot"),`
`264`	`264`	`dtype: self.dtype,`
`265`	`265`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,10 +72,10 @@ impl FilterArray {`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`/// Consume the array and return its individual components.`
`75`		`- pub fn into_parts(self) -> FilterArrayParts {`
	`75`	`+ pub fn into_parts(mut self) -> FilterArrayParts {`
`76`	`76`	`FilterArrayParts {`
`77`	`77`	`child: self.slots[CHILD_SLOT]`
`78`		`- .clone()`
	`78`	`+ .take()`
`79`	`79`	`.vortex_expect("FilterArray child slot"),`
`80`	`80`	`mask: self.mask,`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -172,10 +172,10 @@ impl FixedSizeListArray {`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`
`175`		`- pub fn into_parts(self) -> (ArrayRef, Validity, DType) {`
	`175`	`+ pub fn into_parts(mut self) -> (ArrayRef, Validity, DType) {`
`176`	`176`	`(`
`177`	`177`	`self.slots[ELEMENTS_SLOT]`
`178`		`- .clone()`
	`178`	`+ .take()`
`179`	`179`	`.vortex_expect("FixedSizeListArray elements slot"),`
`180`	`180`	`self.validity,`
`181`	`181`	`self.dtype,`