Collect slots directly into smallvec instead of using vec and into (#7847)

robert3005 · web-flow · commit f3d5f096fe98 · 2026-05-08T17:34:15.000+01:00
These copies are unnecessary

Signed-off-by: Robert Kruszewski &lt;github@robertk.io&gt;
diff --git a/encodings/datetime-parts/src/array.rs b/encodings/datetime-parts/src/array.rs
@@ -28,6 +28,7 @@ use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::require_child;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
 use vortex_array::vtable::ValidityVTableFromChild;
@@ -169,7 +170,7 @@ impl VTable for DateTimeParts {
             len,
         )?;
 
-        let slots = vec![Some(days), Some(seconds), Some(subseconds)];
+        let slots = smallvec![Some(days), Some(seconds), Some(subseconds)];
         let data = DateTimePartsData {};
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -275,7 +276,7 @@ impl DateTimeParts {
     ) -> VortexResult<DateTimePartsArray> {
         let len = days.len();
         DateTimePartsData::validate(&dtype, &days, &seconds, &subseconds, len)?;
-        let slots = vec![Some(days), Some(seconds), Some(subseconds)];
+        let slots = smallvec![Some(days), Some(seconds), Some(subseconds)];
         let data = DateTimePartsData {};
         Ok(unsafe {
             Array::from_parts_unchecked(
diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs
@@ -33,6 +33,7 @@ use vortex_array::scalar::DecimalValue;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar::ScalarValue;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
@@ -144,7 +145,7 @@ impl VTable for DecimalByteParts {
             "lower_part_count > 0 not currently supported"
         );
 
-        let slots = vec![Some(msp.clone())];
+        let slots = smallvec![Some(msp.clone())];
         let data = DecimalBytePartsData::try_new(msp.dtype(), msp.len(), *decimal_dtype)?;
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -262,7 +263,7 @@ impl DecimalByteParts {
     ) -> VortexResult<DecimalBytePartsArray> {
         let len = msp.len();
         let dtype = DType::Decimal(decimal_dtype, msp.dtype().nullability());
-        let slots = vec![Some(msp.clone())];
+        let slots = smallvec![Some(msp.clone())];
         let data = DecimalBytePartsData::try_new(msp.dtype(), msp.len(), decimal_dtype)?;
         Ok(unsafe {
             Array::from_parts_unchecked(
diff --git a/encodings/fastlanes/src/delta/vtable/mod.rs b/encodings/fastlanes/src/delta/vtable/mod.rs
@@ -23,6 +23,7 @@ use vortex_array::dtype::DType;
 use vortex_array::dtype::PType;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::vtable::VTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -168,7 +169,7 @@ impl VTable for Delta {
         let deltas = children.get(1, dtype, deltas_len)?;
 
         let data = DeltaData::try_new(metadata.offset as usize)?;
-        let slots = vec![Some(bases), Some(deltas)];
+        let slots = smallvec![Some(bases), Some(deltas)];
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
 
@@ -191,7 +192,7 @@ impl Delta {
     ) -> VortexResult<DeltaArray> {
         let dtype = bases.dtype().with_nullability(deltas.dtype().nullability());
         let data = DeltaData::try_new(offset)?;
-        let slots = vec![Some(bases), Some(deltas)];
+        let slots = smallvec![Some(bases), Some(deltas)];
         Array::try_from_parts(ArrayParts::new(Delta, dtype, len, data).with_slots(slots))
     }
 
diff --git a/encodings/fastlanes/src/for/vtable/mod.rs b/encodings/fastlanes/src/for/vtable/mod.rs
@@ -22,6 +22,7 @@ use vortex_array::dtype::DType;
 use vortex_array::scalar::Scalar;
 use vortex_array::scalar::ScalarValue;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTableFromChild;
 use vortex_error::VortexExpect;
@@ -132,7 +133,7 @@ impl VTable for FoR {
         let scalar_value = ScalarValue::from_proto_bytes(metadata, dtype, session)?;
         let reference = Scalar::try_new(dtype.clone(), scalar_value)?;
         let encoded = children.get(0, dtype, len)?;
-        let slots = vec![Some(encoded)];
+        let slots = smallvec![Some(encoded)];
 
         let data = FoRData::try_new(reference)?;
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
@@ -173,7 +174,7 @@ impl FoR {
         let reference = reference.cast(&dtype)?;
         let len = encoded.len();
         let data = FoRData::try_new(reference)?;
-        let slots = vec![Some(encoded)];
+        let slots = smallvec![Some(encoded)];
         Array::try_from_parts(ArrayParts::new(FoR, dtype, len, data).with_slots(slots))
     }
 
diff --git a/encodings/fastlanes/src/rle/vtable/mod.rs b/encodings/fastlanes/src/rle/vtable/mod.rs
@@ -22,6 +22,7 @@ use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::dtype::PType;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::vtable::VTable;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
@@ -186,7 +187,7 @@ impl VTable for RLE {
             usize::try_from(metadata.values_idx_offsets_len)?,
         )?;
 
-        let slots = vec![Some(values), Some(indices), Some(values_idx_offsets)];
+        let slots = smallvec![Some(values), Some(indices), Some(values_idx_offsets)];
         let data = RLEData::try_new(metadata.offset as usize)?;
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -219,7 +220,7 @@ impl RLE {
         length: usize,
     ) -> VortexResult<RLEArray> {
         let dtype = DType::Primitive(values.dtype().as_ptype(), indices.dtype().nullability());
-        let slots = vec![Some(values), Some(indices), Some(values_idx_offsets)];
+        let slots = smallvec![Some(values), Some(indices), Some(values_idx_offsets)];
         let data = RLEData::try_new(offset)?;
         Array::try_from_parts(ArrayParts::new(RLE, dtype, length, data).with_slots(slots))
     }
@@ -236,7 +237,7 @@ impl RLE {
         length: usize,
     ) -> RLEArray {
         let dtype = DType::Primitive(values.dtype().as_ptype(), indices.dtype().nullability());
-        let slots = vec![Some(values), Some(indices), Some(values_idx_offsets)];
+        let slots = smallvec![Some(values), Some(indices), Some(values_idx_offsets)];
         let data = unsafe { RLEData::new_unchecked(offset) };
         unsafe {
             Array::from_parts_unchecked(ArrayParts::new(RLE, dtype, length, data).with_slots(slots))
diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs
@@ -252,7 +252,7 @@ impl VTable for FSST {
                 len,
                 &mut ctx,
             )?;
-            let slots = vec![
+            let slots = smallvec![
                 Some(uncompressed_lengths),
                 Some(codes_offsets),
                 validity_to_child(&codes_validity, len),
diff --git a/encodings/parquet-variant/src/array.rs b/encodings/parquet-variant/src/array.rs
@@ -21,6 +21,7 @@ use vortex_array::arrow::FromArrowArray;
 use vortex_array::arrow::to_arrow_null_buffer;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
+use vortex_array::smallvec::smallvec;
 use vortex_array::validity::Validity;
 use vortex_array::vtable::child_to_validity;
 use vortex_array::vtable::validity_to_child;
@@ -95,7 +96,7 @@ impl ParquetVariant {
             &dtype,
             len,
         )?;
-        let slots = vec![
+        let slots = smallvec![
             validity_to_child(&validity, len),
             Some(metadata),
             value,
diff --git a/encodings/parquet-variant/src/vtable.rs b/encodings/parquet-variant/src/vtable.rs
@@ -20,6 +20,7 @@ use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::dtype::Nullability;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::validity::Validity;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::child_to_validity;
@@ -200,7 +201,7 @@ impl VTable for ParquetVariant {
             dtype,
             len,
         )?;
-        let slots = vec![
+        let slots = smallvec![
             validity_to_child(&validity, len),
             Some(variant_metadata),
             value,
diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs
@@ -37,6 +37,7 @@ use vortex_array::dtype::PType;
 use vortex_array::dtype::half;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::validity::Validity;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
@@ -206,7 +207,7 @@ impl VTable for Pco {
             .sum::<usize>();
         vortex_ensure!(pages.len() == expected_n_pages);
 
-        let slots = vec![validity_to_child(&validity, len)];
+        let slots = smallvec![validity_to_child(&validity, len)];
         let data = PcoData::new(chunk_metas, pages, dtype.as_ptype(), metadata, len);
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -291,7 +292,7 @@ impl Pco {
     ) -> VortexResult<PcoArray> {
         let len = data.len();
         data.validate(&dtype, len, &validity)?;
-        let slots = vec![validity_to_child(&validity, data.unsliced_n_rows())];
+        let slots = smallvec![validity_to_child(&validity, data.unsliced_n_rows())];
         Ok(unsafe {
             Array::from_parts_unchecked(ArrayParts::new(Pco, dtype, len, data).with_slots(slots))
         })
diff --git a/encodings/runend/src/array.rs b/encodings/runend/src/array.rs
@@ -32,6 +32,7 @@ use vortex_array::scalar::PValue;
 use vortex_array::search_sorted::SearchSorted;
 use vortex_array::search_sorted::SearchSortedSide;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::validity::Validity;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityVTable;
@@ -154,7 +155,7 @@ impl VTable for RunEnd {
 
         let values = children.get(1, dtype, runs)?;
         let offset = usize::try_from(metadata.offset).vortex_expect("Offset must be a valid usize");
-        let slots = vec![Some(ends), Some(values)];
+        let slots = smallvec![Some(ends), Some(values)];
         let data = RunEndData::new(offset);
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -258,7 +259,7 @@ impl RunEnd {
         length: usize,
     ) -> RunEndArray {
         let dtype = values.dtype().clone();
-        let slots = vec![Some(ends), Some(values)];
+        let slots = smallvec![Some(ends), Some(values)];
         let data = unsafe { RunEndData::new_unchecked(offset) };
         unsafe {
             Array::from_parts_unchecked(
@@ -276,7 +277,7 @@ impl RunEnd {
         let len = RunEndData::logical_len_from_ends(&ends, ctx)?;
         RunEndData::validate_parts(&ends, &values, 0, len, ctx)?;
         let dtype = values.dtype().clone();
-        let slots = vec![Some(ends), Some(values)];
+        let slots = smallvec![Some(ends), Some(values)];
         let data = RunEndData::new(0);
         Array::try_from_parts(ArrayParts::new(RunEnd, dtype, len, data).with_slots(slots))
     }
@@ -291,7 +292,7 @@ impl RunEnd {
     ) -> VortexResult<RunEndArray> {
         RunEndData::validate_parts(&ends, &values, offset, length, ctx)?;
         let dtype = values.dtype().clone();
-        let slots = vec![Some(ends), Some(values)];
+        let slots = smallvec![Some(ends), Some(values)];
         let data = RunEndData::new(offset);
         Array::try_from_parts(ArrayParts::new(RunEnd, dtype, length, data).with_slots(slots))
     }
@@ -308,7 +309,7 @@ impl RunEnd {
             let ends = ends.into_array();
             let len = array.len();
             let dtype = values.dtype().clone();
-            let slots = vec![Some(ends), Some(values)];
+            let slots = smallvec![Some(ends), Some(values)];
             let data = unsafe { RunEndData::new_unchecked(0) };
             Array::try_from_parts(ArrayParts::new(RunEnd, dtype, len, data).with_slots(slots))
         } else {
diff --git a/encodings/zigzag/src/array.rs b/encodings/zigzag/src/array.rs
@@ -23,6 +23,7 @@ use vortex_array::dtype::PType;
 use vortex_array::match_each_unsigned_integer_ptype;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
@@ -120,7 +121,7 @@ impl VTable for ZigZag {
         let encoded_type = DType::Primitive(ptype.to_unsigned(), dtype.nullability());
 
         let encoded = children.get(0, &encoded_type, len)?;
-        let slots = vec![Some(encoded.clone())];
+        let slots = smallvec![Some(encoded.clone())];
         let data = ZigZagData::try_new(encoded.dtype())?;
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -201,7 +202,7 @@ impl ZigZag {
     pub fn try_new(encoded: ArrayRef) -> VortexResult<ZigZagArray> {
         let dtype = ZigZagData::dtype_from_encoded_dtype(encoded.dtype())?;
         let len = encoded.len();
-        let slots = vec![Some(encoded.clone())];
+        let slots = smallvec![Some(encoded.clone())];
         let data = ZigZagData::try_new(encoded.dtype())?;
         Ok(unsafe {
             Array::from_parts_unchecked(ArrayParts::new(ZigZag, dtype, len, data).with_slots(slots))
diff --git a/encodings/zstd/src/array.rs b/encodings/zstd/src/array.rs
@@ -32,6 +32,7 @@ use vortex_array::buffer::BufferHandle;
 use vortex_array::dtype::DType;
 use vortex_array::scalar::Scalar;
 use vortex_array::serde::ArrayChildren;
+use vortex_array::smallvec::smallvec;
 use vortex_array::validity::Validity;
 use vortex_array::vtable::OperationsVTable;
 use vortex_array::vtable::VTable;
@@ -220,7 +221,7 @@ impl VTable for Zstd {
             )
         };
 
-        let slots = vec![validity_to_child(&validity, len)];
+        let slots = smallvec![validity_to_child(&validity, len)];
         let data = ZstdData::new(dictionary_buffer, compressed_buffers, metadata, len);
         Ok(ArrayParts::new(self.clone(), dtype.clone(), len, data).with_slots(slots))
     }
@@ -257,7 +258,7 @@ impl Zstd {
     pub fn try_new(dtype: DType, data: ZstdData, validity: Validity) -> VortexResult<ZstdArray> {
         let len = data.len();
         data.validate(&dtype, len, &validity)?;
-        let slots = vec![validity_to_child(&validity, data.unsliced_n_rows())];
+        let slots = smallvec![validity_to_child(&validity, data.unsliced_n_rows())];
         Ok(unsafe {
             Array::from_parts_unchecked(ArrayParts::new(Zstd, dtype, len, data).with_slots(slots))
         })
diff --git a/vortex-array/public-api.lock b/vortex-array/public-api.lock
@@ -22684,7 +22684,7 @@ impl<V: vortex_array::VTable> vortex_array::ArrayParts<V>
 
 pub fn vortex_array::ArrayParts<V>::new(V, vortex_array::dtype::DType, usize, <V as vortex_array::VTable>::TypedArrayData) -> Self
 
-pub fn vortex_array::ArrayParts<V>::with_slots(self, impl core::convert::Into<vortex_array::ArraySlots>) -> Self
+pub fn vortex_array::ArrayParts<V>::with_slots(self, vortex_array::ArraySlots) -> Self
 
 pub struct vortex_array::ArrayRef(_)
 
@@ -22790,7 +22790,7 @@ pub fn vortex_array::ArrayRef::validity(&self) -> vortex_error::VortexResult<vor
 
 pub fn vortex_array::ArrayRef::with_slot(self, usize, vortex_array::ArrayRef) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
-pub fn vortex_array::ArrayRef::with_slots(self, impl core::convert::Into<vortex_array::ArraySlots>) -> vortex_error::VortexResult<vortex_array::ArrayRef>
+pub fn vortex_array::ArrayRef::with_slots(self, vortex_array::ArraySlots) -> vortex_error::VortexResult<vortex_array::ArrayRef>
 
 impl vortex_array::ArrayRef
 
diff --git a/vortex-array/src/array/erased.rs b/vortex-array/src/array/erased.rs
@@ -556,8 +556,7 @@ impl ArrayRef {
     ///
     /// This is only valid for physical rewrites: slot count, presence, logical `DType`, and
     /// logical `len` must remain unchanged.
-    pub fn with_slots(self, slots: impl Into<ArraySlots>) -> VortexResult<ArrayRef> {
-        let slots = slots.into();
+    pub fn with_slots(self, slots: ArraySlots) -> VortexResult<ArrayRef> {
         let old_slots = self.slots();
         vortex_ensure!(
             old_slots.len() == slots.len(),
diff --git a/vortex-array/src/array/foreign.rs b/vortex-array/src/array/foreign.rs
@@ -137,16 +137,16 @@ impl VTable for ForeignArray {
         _session: &VortexSession,
     ) -> VortexResult<ArrayParts<Self>> {
         let child_arrays = (0..children.len())
-            .map(|idx| children.get(idx, dtype, len))
-            .collect::<VortexResult<Vec<_>>>()?;
+            .map(|idx| children.get(idx, dtype, len).map(Some))
+            .collect::<VortexResult<ArraySlots>>()?;
 
         Ok(ArrayParts::new(
             self.clone(),
             dtype.clone(),
             len,
             ForeignArrayData::new(metadata.to_vec(), buffers.to_vec()),
         )
-        .with_slots(child_arrays.into_iter().map(Some).collect::<ArraySlots>()))
+        .with_slots(child_arrays))
     }
 
     fn slot_name(_array: ArrayView<'_, Self>, idx: usize) -> String {
@@ -167,7 +167,7 @@ pub fn new_foreign_array(
     len: usize,
     metadata: Vec<u8>,
     buffers: Vec<BufferHandle>,
-    children: Vec<ArrayRef>,
+    children: ArraySlots,
 ) -> VortexResult<ArrayRef> {
     Ok(Array::<ForeignArray>::try_from_parts(
         ArrayParts::new(
@@ -176,7 +176,7 @@ pub fn new_foreign_array(
             len,
             ForeignArrayData::new(metadata, buffers),
         )
-        .with_slots(children.into_iter().map(Some).collect::<ArraySlots>()),
+        .with_slots(children),
     )?
     .into_array())
 }
diff --git a/vortex-array/src/array/typed.rs b/vortex-array/src/array/typed.rs
@@ -66,8 +66,8 @@ impl<V: VTable> ArrayParts<V> {
         }
     }
 
-    pub fn with_slots(mut self, slots: impl Into<ArraySlots>) -> Self {
-        self.slots = slots.into();
+    pub fn with_slots(mut self, slots: ArraySlots) -> Self {
+        self.slots = slots;
         self
     }
 }
diff --git a/vortex-array/src/serde.rs b/vortex-array/src/serde.rs
