Fix canonical vtable (#2118)

Author: gatesn

encodings/alp/src/alp/array.rs

@@ -8,11 +8,11 @@ use vortex_array::validity::ArrayValidity;
 use vortex_array::variants::PrimitiveArrayTrait;
 use vortex_array::visitor::ArrayVisitor;
 use vortex_array::vtable::{
-    StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable,
+    CanonicalVTable, StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable,
+    VisitorVTable,
 };
 use vortex_array::{
-    impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoArrayData, IntoCanonical,
-    SerdeMetadata,
+    impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoArrayData, SerdeMetadata,
 };
 use vortex_dtype::{DType, PType};
 use vortex_error::{vortex_bail, vortex_panic, VortexExpect as _, VortexResult};
@@ -131,9 +131,9 @@ impl ValidityVTable<ALPArray> for ALPEncoding {
     }
 }
 
-impl IntoCanonical for ALPArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        decompress(self).map(Canonical::Primitive)
+impl CanonicalVTable<ALPArray> for ALPEncoding {
+    fn into_canonical(&self, array: ALPArray) -> VortexResult<Canonical> {
+        decompress(array).map(Canonical::Primitive)
     }
 }
 

encodings/alp/src/alp_rd/array.rs

@@ -7,7 +7,9 @@ use vortex_array::patches::{Patches, PatchesMetadata};
 use vortex_array::stats::StatsSet;
 use vortex_array::validity::{ArrayValidity, Validity};
 use vortex_array::visitor::ArrayVisitor;
-use vortex_array::vtable::{StatisticsVTable, ValidateVTable, ValidityVTable, VisitorVTable};
+use vortex_array::vtable::{
+    CanonicalVTable, StatisticsVTable, ValidateVTable, ValidityVTable, VisitorVTable,
+};
 use vortex_array::{
     impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoCanonical, SerdeMetadata,
 };
@@ -194,35 +196,35 @@ impl ALPRDArray {
     }
 }
 
-impl IntoCanonical for ALPRDArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        let left_parts = self.left_parts().into_canonical()?.into_primitive()?;
-        let right_parts = self.right_parts().into_canonical()?.into_primitive()?;
+impl CanonicalVTable<ALPRDArray> for ALPRDEncoding {
+    fn into_canonical(&self, array: ALPRDArray) -> VortexResult<Canonical> {
+        let left_parts = array.left_parts().into_canonical()?.into_primitive()?;
+        let right_parts = array.right_parts().into_canonical()?.into_primitive()?;
 
         // Decode the left_parts using our builtin dictionary.
-        let left_parts_dict = &self.metadata().dict[0..self.metadata().dict_len as usize];
+        let left_parts_dict = &array.metadata().dict[0..array.metadata().dict_len as usize];
 
-        let decoded_array = if self.is_f32() {
+        let decoded_array = if array.is_f32() {
             PrimitiveArray::new(
                 alp_rd_decode::<f32>(
                     left_parts.into_buffer::<u16>(),
                     left_parts_dict,
-                    self.metadata().right_bit_width,
+                    array.metadata().right_bit_width,
                     right_parts.into_buffer_mut::<u32>(),
-                    self.left_parts_patches(),
+                    array.left_parts_patches(),
                 )?,
-                Validity::from_mask(self.logical_validity()?, self.dtype().nullability()),
+                Validity::from_mask(array.logical_validity()?, array.dtype().nullability()),
             )
         } else {
             PrimitiveArray::new(
                 alp_rd_decode::<f64>(
                     left_parts.into_buffer::<u16>(),
                     left_parts_dict,
-                    self.metadata().right_bit_width,
+                    array.metadata().right_bit_width,
                     right_parts.into_buffer_mut::<u64>(),
-                    self.left_parts_patches(),
+                    array.left_parts_patches(),
                 )?,
-                Validity::from_mask(self.logical_validity()?, self.dtype().nullability()),
+                Validity::from_mask(array.logical_validity()?, array.dtype().nullability()),
             )
         };
 

encodings/bytebool/src/array.rs

@@ -8,8 +8,10 @@ use vortex_array::stats::StatsSet;
 use vortex_array::validity::{Validity, ValidityMetadata};
 use vortex_array::variants::BoolArrayTrait;
 use vortex_array::visitor::ArrayVisitor;
-use vortex_array::vtable::{ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable};
-use vortex_array::{impl_encoding, ArrayLen, Canonical, IntoCanonical, SerdeMetadata};
+use vortex_array::vtable::{
+    CanonicalVTable, ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable,
+};
+use vortex_array::{impl_encoding, ArrayLen, Canonical, SerdeMetadata};
 use vortex_buffer::ByteBuffer;
 use vortex_dtype::DType;
 use vortex_error::{VortexExpect as _, VortexResult};
@@ -100,10 +102,10 @@ impl From<Vec<Option<bool>>> for ByteBoolArray {
     }
 }
 
-impl IntoCanonical for ByteBoolArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        let boolean_buffer = BooleanBuffer::from(self.as_slice());
-        let validity = self.validity();
+impl CanonicalVTable<ByteBoolArray> for ByteBoolEncoding {
+    fn into_canonical(&self, array: ByteBoolArray) -> VortexResult<Canonical> {
+        let boolean_buffer = BooleanBuffer::from(array.as_slice());
+        let validity = array.validity();
 
         Ok(Canonical::Bool(BoolArray::try_new(
             boolean_buffer,

encodings/datetime-parts/src/canonical.rs

@@ -1,20 +1,19 @@
 use vortex_array::array::{PrimitiveArray, TemporalArray};
 use vortex_array::compute::try_cast;
-use vortex_array::{
-    ArrayDType, Canonical, IntoArrayData as _, IntoArrayVariant as _, IntoCanonical,
-};
+use vortex_array::vtable::CanonicalVTable;
+use vortex_array::{ArrayDType, Canonical, IntoArrayData as _, IntoArrayVariant as _};
 use vortex_buffer::BufferMut;
 use vortex_datetime_dtype::{TemporalMetadata, TimeUnit};
 use vortex_dtype::Nullability::NonNullable;
 use vortex_dtype::{DType, PType};
 use vortex_error::{vortex_bail, VortexExpect as _, VortexResult};
 use vortex_scalar::PrimitiveScalar;
 
-use crate::DateTimePartsArray;
+use crate::{DateTimePartsArray, DateTimePartsEncoding};
 
-impl IntoCanonical for DateTimePartsArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        Ok(Canonical::Extension(decode_to_temporal(&self)?.into()))
+impl CanonicalVTable<DateTimePartsArray> for DateTimePartsEncoding {
+    fn into_canonical(&self, array: DateTimePartsArray) -> VortexResult<Canonical> {
+        Ok(Canonical::Extension(decode_to_temporal(&array)?.into()))
     }
 }
 

encodings/dict/src/array.rs

@@ -8,7 +8,7 @@ use vortex_array::stats::StatsSet;
 use vortex_array::validity::ArrayValidity;
 use vortex_array::variants::PrimitiveArrayTrait;
 use vortex_array::visitor::ArrayVisitor;
-use vortex_array::vtable::{ValidateVTable, ValidityVTable, VisitorVTable};
+use vortex_array::vtable::{CanonicalVTable, ValidateVTable, ValidityVTable, VisitorVTable};
 use vortex_array::{
     impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoArrayVariant, IntoCanonical,
     SerdeMetadata,
@@ -61,19 +61,19 @@ impl DictArray {
 
 impl ValidateVTable<DictArray> for DictEncoding {}
 
-impl IntoCanonical for DictArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        match self.dtype() {
+impl CanonicalVTable<DictArray> for DictEncoding {
+    fn into_canonical(&self, array: DictArray) -> VortexResult<Canonical> {
+        match array.dtype() {
             // NOTE: Utf8 and Binary will decompress into VarBinViewArray, which requires a full
             // decompression to construct the views child array.
             // For this case, it is *always* faster to decompress the values first and then create
             // copies of the view pointers.
             DType::Utf8(_) | DType::Binary(_) => {
-                let canonical_values: ArrayData = self.values().into_canonical()?.into();
-                take(canonical_values, self.codes())?.into_canonical()
+                let canonical_values: ArrayData = array.values().into_canonical()?.into();
+                take(canonical_values, array.codes())?.into_canonical()
             }
             // Non-string case: take and then canonicalize
-            _ => take(self.values(), self.codes())?.into_canonical(),
+            _ => take(array.values(), array.codes())?.into_canonical(),
         }
     }
 }

encodings/fastlanes/src/bitpacking/mod.rs

@@ -10,11 +10,10 @@ use vortex_array::validity::{Validity, ValidityMetadata};
 use vortex_array::variants::PrimitiveArrayTrait;
 use vortex_array::visitor::ArrayVisitor;
 use vortex_array::vtable::{
-    StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable,
-};
-use vortex_array::{
-    impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoCanonical, RkyvMetadata,
+    CanonicalVTable, StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable,
+    VisitorVTable,
 };
+use vortex_array::{impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, RkyvMetadata};
 use vortex_buffer::ByteBuffer;
 use vortex_dtype::{DType, NativePType, PType};
 use vortex_error::{vortex_bail, vortex_err, VortexExpect as _, VortexResult};
@@ -254,9 +253,9 @@ impl BitPackedArray {
     }
 }
 
-impl IntoCanonical for BitPackedArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        unpack(self).map(Canonical::Primitive)
+impl CanonicalVTable<BitPackedArray> for BitPackedEncoding {
+    fn into_canonical(&self, array: BitPackedArray) -> VortexResult<Canonical> {
+        unpack(array).map(Canonical::Primitive)
     }
 }
 

encodings/fastlanes/src/delta/mod.rs

@@ -8,11 +8,11 @@ use vortex_array::validity::{Validity, ValidityMetadata};
 use vortex_array::variants::PrimitiveArrayTrait;
 use vortex_array::visitor::ArrayVisitor;
 use vortex_array::vtable::{
-    StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable,
+    CanonicalVTable, StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable,
+    VisitorVTable,
 };
 use vortex_array::{
-    impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoArrayData, IntoCanonical,
-    RkyvMetadata,
+    impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoArrayData, RkyvMetadata,
 };
 use vortex_buffer::Buffer;
 use vortex_dtype::{match_each_unsigned_integer_ptype, NativePType};
@@ -235,9 +235,9 @@ impl VariantsVTable<DeltaArray> for DeltaEncoding {
 
 impl PrimitiveArrayTrait for DeltaArray {}
 
-impl IntoCanonical for DeltaArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        delta_decompress(self).map(Canonical::Primitive)
+impl CanonicalVTable<DeltaArray> for DeltaEncoding {
+    fn into_canonical(&self, array: DeltaArray) -> VortexResult<Canonical> {
+        delta_decompress(array).map(Canonical::Primitive)
     }
 }
 

encodings/fastlanes/src/for/mod.rs

@@ -8,11 +8,10 @@ use vortex_array::validity::ArrayValidity;
 use vortex_array::variants::PrimitiveArrayTrait;
 use vortex_array::visitor::ArrayVisitor;
 use vortex_array::vtable::{
-    StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable,
-};
-use vortex_array::{
-    impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoCanonical, SerdeMetadata,
+    CanonicalVTable, StatisticsVTable, ValidateVTable, ValidityVTable, VariantsVTable,
+    VisitorVTable,
 };
+use vortex_array::{impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, SerdeMetadata};
 use vortex_dtype::DType;
 use vortex_error::{vortex_bail, VortexExpect as _, VortexResult};
 use vortex_mask::Mask;
@@ -103,9 +102,9 @@ impl ValidityVTable<FoRArray> for FoREncoding {
     }
 }
 
-impl IntoCanonical for FoRArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        decompress(self).map(Canonical::Primitive)
+impl CanonicalVTable<FoRArray> for FoREncoding {
+    fn into_canonical(&self, array: FoRArray) -> VortexResult<Canonical> {
+        decompress(array).map(Canonical::Primitive)
     }
 }
 

encodings/fsst/src/canonical.rs

@@ -1,16 +1,17 @@
 use arrow_array::builder::make_view;
 use vortex_array::array::{BinaryView, VarBinArray, VarBinViewArray};
 use vortex_array::variants::PrimitiveArrayTrait;
+use vortex_array::vtable::CanonicalVTable;
 use vortex_array::{ArrayDType, ArrayLen, Canonical, IntoCanonical};
 use vortex_buffer::{BufferMut, ByteBuffer};
 use vortex_dtype::match_each_integer_ptype;
 use vortex_error::VortexResult;
 
-use crate::FSSTArray;
+use crate::{FSSTArray, FSSTEncoding};
 
-impl IntoCanonical for FSSTArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        self.with_decompressor(|decompressor| {
+impl CanonicalVTable<FSSTArray> for FSSTEncoding {
+    fn into_canonical(&self, array: FSSTArray) -> VortexResult<Canonical> {
+        array.with_decompressor(|decompressor| {
             // FSSTArray has two child arrays:
             //
             //  1. A VarBinArray, which holds the string heap of the compressed codes.
@@ -21,12 +22,12 @@ impl IntoCanonical for FSSTArray {
             // call. We then turn our uncompressed_lengths into an offsets buffer
             // necessary for a VarBinViewArray and construct the canonical array.
 
-            let bytes = VarBinArray::try_from(self.codes())?.sliced_bytes();
+            let bytes = VarBinArray::try_from(array.codes())?.sliced_bytes();
 
             // Bulk-decompress the entire array.
             let uncompressed_bytes = decompressor.decompress(bytes.as_slice());
 
-            let uncompressed_lens_array = self
+            let uncompressed_lens_array = array
                 .uncompressed_lengths()
                 .into_canonical()?
                 .into_primitive()?;
@@ -55,8 +56,8 @@ impl IntoCanonical for FSSTArray {
             VarBinViewArray::try_new(
                 views,
                 vec![uncompressed_bytes_array],
-                self.dtype().clone(),
-                self.validity(),
+                array.dtype().clone(),
+                array.validity(),
             )
             .map(Canonical::VarBinView)
         })

encodings/runend/src/array.rs

@@ -10,10 +10,12 @@ use vortex_array::stats::{ArrayStatistics, StatsSet};
 use vortex_array::validity::ArrayValidity;
 use vortex_array::variants::{BoolArrayTrait, PrimitiveArrayTrait};
 use vortex_array::visitor::ArrayVisitor;
-use vortex_array::vtable::{ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable};
+use vortex_array::vtable::{
+    CanonicalVTable, ValidateVTable, ValidityVTable, VariantsVTable, VisitorVTable,
+};
 use vortex_array::{
     impl_encoding, ArrayDType, ArrayData, ArrayLen, Canonical, IntoArrayData, IntoArrayVariant,
-    IntoCanonical, SerdeMetadata,
+    SerdeMetadata,
 };
 use vortex_buffer::Buffer;
 use vortex_dtype::{DType, PType};
@@ -200,17 +202,17 @@ impl ValidityVTable<RunEndArray> for RunEndEncoding {
     }
 }
 
-impl IntoCanonical for RunEndArray {
-    fn into_canonical(self) -> VortexResult<Canonical> {
-        let pends = self.ends().into_primitive()?;
-        match self.dtype() {
+impl CanonicalVTable<RunEndArray> for RunEndEncoding {
+    fn into_canonical(&self, array: RunEndArray) -> VortexResult<Canonical> {
+        let pends = array.ends().into_primitive()?;
+        match array.dtype() {
             DType::Bool(_) => {
-                let bools = self.values().into_bool()?;
-                runend_decode_bools(pends, bools, self.offset(), self.len()).map(Canonical::Bool)
+                let bools = array.values().into_bool()?;
+                runend_decode_bools(pends, bools, array.offset(), array.len()).map(Canonical::Bool)
             }
             DType::Primitive(..) => {
-                let pvalues = self.values().into_primitive()?;
-                runend_decode_primitive(pends, pvalues, self.offset(), self.len())
+                let pvalues = array.values().into_primitive()?;
+                runend_decode_primitive(pends, pvalues, array.offset(), array.len())
                     .map(Canonical::Primitive)
             }
             _ => vortex_bail!("Only Primitive and Bool values are supported"),