Engine

Signed-off-by: Nicholas Gates <nick@nickgates.com>

Author: gatesn

encodings/alp/src/alp/array.rs

@@ -432,11 +432,7 @@ impl ALPData {
     ///
     /// See [`ALPData::try_new`] for information about the preconditions that should be checked
     /// **before** calling this method.
-    pub(crate) unsafe fn new_unchecked(
-        _encoded: ArrayRef,
-        exponents: Exponents,
-        patches: Option<Patches>,
-    ) -> Self {
+    pub(crate) unsafe fn new_unchecked(exponents: Exponents, patches: Option<Patches>) -> Self {
         let (patch_offset, patch_offset_within_chunk) = match &patches {
             Some(p) => (Some(p.offset()), p.offset_within_chunk()),
             None => (None, None),
@@ -488,7 +484,7 @@ impl ALP {
         let dtype = ALPData::logical_dtype(&encoded).vortex_expect("ALP encoded dtype");
         let len = encoded.len();
         let slots = ALPData::make_slots(&encoded, &patches);
-        let data = unsafe { ALPData::new_unchecked(encoded, exponents, patches) };
+        let data = unsafe { ALPData::new_unchecked(exponents, patches) };
         unsafe {
             Array::from_parts_unchecked(ArrayParts::new(ALP, dtype, len, data).with_slots(slots))
         }

encodings/alp/src/alp_rd/array.rs

@@ -373,22 +373,12 @@ impl ALPRD {
         left_parts_patches: Option<Patches>,
     ) -> ALPRDArray {
         let len = left_parts.len();
-        let logical_dtype = dtype.clone();
         let slots = ALPRDData::make_slots(&left_parts, &right_parts, &left_parts_patches);
         let data = unsafe {
-            ALPRDData::new_unchecked(
-                dtype,
-                left_parts,
-                left_parts_dictionary,
-                right_parts,
-                right_bit_width,
-                left_parts_patches,
-            )
+            ALPRDData::new_unchecked(left_parts_dictionary, right_bit_width, left_parts_patches)
         };
         unsafe {
-            Array::from_parts_unchecked(
-                ArrayParts::new(ALPRD, logical_dtype, len, data).with_slots(slots),
-            )
+            Array::from_parts_unchecked(ArrayParts::new(ALPRD, dtype, len, data).with_slots(slots))
         }
     }
 }
@@ -535,10 +525,7 @@ impl ALPRDData {
     /// Build a new `ALPRDArray` from components. This does not perform any validation, and instead
     /// it constructs it from parts.
     pub(crate) unsafe fn new_unchecked(
-        _dtype: DType,
-        _left_parts: ArrayRef,
         left_parts_dictionary: Buffer<u16>,
-        _right_parts: ArrayRef,
         right_bit_width: u8,
         left_parts_patches: Option<Patches>,
     ) -> Self {

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

@@ -97,7 +97,7 @@ impl DeltaData {
         Self::validate_parts(&bases, &deltas, offset, len)?;
 
         // SAFETY: validation done above
-        Ok(unsafe { Self::new_unchecked(bases, deltas, offset) })
+        Ok(unsafe { Self::new_unchecked(offset) })
     }
 
     pub(crate) fn validate_against_slots(
@@ -156,7 +156,7 @@ impl DeltaData {
         Ok(())
     }
 
-    pub(crate) unsafe fn new_unchecked(_bases: ArrayRef, _deltas: ArrayRef, offset: usize) -> Self {
+    pub(crate) unsafe fn new_unchecked(offset: usize) -> Self {
         Self { offset }
     }
 }

vortex-array/public-api.lock

@@ -1082,10 +1082,6 @@ pub struct vortex_array::arrays::chunked::ChunkedData
 
 impl vortex_array::arrays::chunked::ChunkedData
 
-pub unsafe fn vortex_array::arrays::chunked::ChunkedData::new_unchecked(_chunks: alloc::vec::Vec<vortex_array::ArrayRef>, _dtype: vortex_array::dtype::DType) -> Self
-
-pub fn vortex_array::arrays::chunked::ChunkedData::try_new(chunks: alloc::vec::Vec<vortex_array::ArrayRef>, dtype: vortex_array::dtype::DType) -> vortex_error::VortexResult<Self>
-
 pub fn vortex_array::arrays::chunked::ChunkedData::validate(chunks: &[vortex_array::ArrayRef], dtype: &vortex_array::dtype::DType) -> vortex_error::VortexResult<()>
 
 impl core::clone::Clone for vortex_array::arrays::chunked::ChunkedData
@@ -1760,7 +1756,7 @@ impl vortex_array::arrays::dict::DictData
 
 pub fn vortex_array::arrays::dict::DictData::new(codes: vortex_array::ArrayRef, values: vortex_array::ArrayRef) -> Self
 
-pub unsafe fn vortex_array::arrays::dict::DictData::new_unchecked(_codes: vortex_array::ArrayRef, _values: vortex_array::ArrayRef) -> Self
+pub unsafe fn vortex_array::arrays::dict::DictData::new_unchecked() -> Self
 
 pub unsafe fn vortex_array::arrays::dict::DictData::set_all_values_referenced(self, all_values_referenced: bool) -> Self
 

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

@@ -198,34 +198,6 @@ impl ChunkedData {
         slots
     }
 
-    /// Constructs a new `ChunkedArray`.
-    ///
-    /// See `ChunkedArray::new_unchecked` for more information.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the provided components do not satisfy the invariants documented in
-    /// `ChunkedArray::new_unchecked`.
-    pub fn try_new(chunks: Vec<ArrayRef>, dtype: DType) -> VortexResult<Self> {
-        Self::validate(&chunks, &dtype)?;
-        Ok(Self)
-    }
-
-    /// Creates a new `ChunkedArray` without validation from these components:
-    ///
-    /// * `chunks` is a vector of arrays to be concatenated logically.
-    /// * `dtype` is the common data type of all chunks.
-    ///
-    /// # Safety
-    ///
-    /// All chunks must have exactly the same [`DType`] as the provided `dtype`.
-    pub unsafe fn new_unchecked(_chunks: Vec<ArrayRef>, _dtype: DType) -> Self {
-        #[cfg(debug_assertions)]
-        Self::validate(&_chunks, &_dtype)
-            .vortex_expect("[Debug Assertion]: Invalid `ChunkedArray` parameters");
-        Self
-    }
-
     /// Validates the components that would be used to create a `ChunkedArray`.
     ///
     /// This function checks all the invariants required by `ChunkedArray::new_unchecked`.
@@ -302,10 +274,6 @@ impl Array<Chunked> {
     }
 
     /// Creates a new `ChunkedArray` without validation.
-    ///
-    /// # Safety
-    ///
-    /// See [`ChunkedData::new_unchecked`].
     pub unsafe fn new_unchecked(chunks: Vec<ArrayRef>, dtype: DType) -> Self {
         let len = chunks.iter().map(|chunk| chunk.len()).sum();
         unsafe {

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

@@ -58,7 +58,7 @@ impl DictData {
     /// This should be called only when you can guarantee the invariants checked
     /// by the safe `DictArray::try_new` constructor are valid, for example when
     /// you are filtering or slicing an existing valid `DictArray`.
-    pub unsafe fn new_unchecked(_codes: ArrayRef, _values: ArrayRef) -> Self {
+    pub unsafe fn new_unchecked() -> Self {
         Self {
             all_values_referenced: false,
         }
@@ -97,12 +97,12 @@ impl DictData {
     /// of the `values` array. Otherwise, this constructor returns an error.
     ///
     /// It is an error to provide a nullable `codes` with non-nullable `values`.
-    pub(crate) fn try_new(codes: ArrayRef, values: ArrayRef) -> VortexResult<Self> {
+    pub(crate) fn try_new(codes: ArrayRef, _values: ArrayRef) -> VortexResult<Self> {
         if !codes.dtype().is_int() {
             vortex_bail!(MismatchedTypes: "int", codes.dtype());
         }
 
-        Ok(unsafe { Self::new_unchecked(codes, values) })
+        Ok(unsafe { Self::new_unchecked() })
     }
 }
 
@@ -249,7 +249,7 @@ impl Array<Dict> {
             .dtype()
             .union_nullability(codes.dtype().nullability());
         let len = codes.len();
-        let data = unsafe { DictData::new_unchecked(codes.clone(), values.clone()) };
+        let data = unsafe { DictData::new_unchecked() };
         unsafe {
             Array::from_parts_unchecked(
                 ArrayParts::new(Dict, dtype, len, data).with_slots(vec![Some(codes), Some(values)]),

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

@@ -159,8 +159,7 @@ impl VTable for Dict {
 
         Ok(
             crate::array::ArrayParts::new(self.clone(), dtype.clone(), len, unsafe {
-                DictData::new_unchecked(codes.clone(), values.clone())
-                    .set_all_values_referenced(all_values_referenced)
+                DictData::new_unchecked().set_all_values_referenced(all_values_referenced)
             })
             .with_slots(vec![Some(codes), Some(values)]),
         )