Remove EncodeVTable (#6036)

Having an EncodeVTable implies the caller knows the target encoding.

Instead we want to have pluggable "compressors", where the output array
could be anything.

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

Author: gatesn

encodings/alp/src/alp/array.rs

@@ -30,7 +30,6 @@ use vortex_array::vtable::ArrayVTable;
 use vortex_array::vtable::ArrayVTableExt;
 use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::CanonicalVTable;
-use vortex_array::vtable::EncodeVTable;
 use vortex_array::vtable::NotSupported;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
@@ -47,7 +46,6 @@ use vortex_error::vortex_err;
 
 use crate::ALPFloat;
 use crate::alp::Exponents;
-use crate::alp::alp_encode;
 use crate::alp::decompress::decompress_into_array;
 use crate::alp::decompress::execute_decompress;
 
@@ -64,7 +62,6 @@ impl VTable for ALPVTable {
     type ValidityVTable = ValidityVTableFromChild;
     type VisitorVTable = Self;
     type ComputeVTable = NotSupported;
-    type EncodeVTable = Self;
 
     fn id(&self) -> ArrayId {
         ArrayId::new_ref("vortex.alp")
@@ -465,20 +462,6 @@ impl CanonicalVTable<ALPVTable> for ALPVTable {
     }
 }
 
-impl EncodeVTable<ALPVTable> for ALPVTable {
-    fn encode(
-        _vtable: &ALPVTable,
-        canonical: &Canonical,
-        like: Option<&ALPArray>,
-    ) -> VortexResult<Option<ALPArray>> {
-        let parray = canonical.clone().into_primitive();
-        let exponents = like.map(|a| a.exponents());
-        let alp = alp_encode(&parray, exponents)?;
-
-        Ok(Some(alp))
-    }
-}
-
 impl VisitorVTable<ALPVTable> for ALPVTable {
     fn visit_buffers(_array: &ALPArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 
@@ -506,6 +489,7 @@ mod tests {
     use vortex_session::VortexSession;
 
     use super::*;
+    use crate::alp_encode;
 
     static SESSION: LazyLock<VortexSession> =
         LazyLock::new(|| VortexSession::empty().with::<ArraySession>());

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

@@ -51,27 +51,24 @@ register_kernel!(CastKernelAdapter(ALPVTable).lift());
 mod tests {
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::assert_arrays_eq;
     use vortex_array::compute::cast;
     use vortex_array::compute::conformance::cast::test_cast_conformance;
-    use vortex_array::vtable::ArrayVTableExt;
     use vortex_buffer::buffer;
     use vortex_dtype::DType;
     use vortex_dtype::Nullability;
     use vortex_dtype::PType;
     use vortex_error::VortexExpect;
     use vortex_error::VortexResult;
 
-    use crate::ALPVTable;
+    use crate::alp_encode;
 
     #[test]
     fn test_cast_alp_f32_to_f64() -> VortexResult<()> {
         let values = buffer![1.5f32, 2.5, 3.5, 4.5].into_array();
-        let alp = ALPVTable
-            .as_vtable()
-            .encode(&values.to_canonical()?, None)?
-            .vortex_expect("must encode");
+        let alp = alp_encode(&values.to_primitive(), None)?;
 
         let casted = cast(
             alp.as_ref(),
@@ -94,10 +91,7 @@ mod tests {
     #[test]
     fn test_cast_alp_to_int() -> VortexResult<()> {
         let values = buffer![1.0f32, 2.0, 3.0, 4.0].into_array();
-        let alp = ALPVTable
-            .as_vtable()
-            .encode(&values.to_canonical()?, None)?
-            .vortex_expect("must encode");
+        let alp = alp_encode(&values.to_primitive(), None)?;
 
         let casted = cast(
             alp.as_ref(),
@@ -121,10 +115,7 @@ mod tests {
     #[case(buffer![42.42f64].into_array())]
     #[case(buffer![0.0f32, -1.5, 2.5, -3.5, 4.5].into_array())]
     fn test_cast_alp_conformance(#[case] array: vortex_array::ArrayRef) -> VortexResult<()> {
-        let alp = ALPVTable
-            .as_vtable()
-            .encode(&array.to_canonical()?, None)?
-            .vortex_expect("cannot fail");
+        let alp = alp_encode(&array.to_primitive(), None).vortex_expect("cannot fail");
         test_cast_conformance(alp.as_ref());
 
         Ok(())

encodings/alp/src/alp/compute/filter.rs

@@ -40,12 +40,12 @@ mod test {
     use rstest::rstest;
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
+    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::filter::test_filter_conformance;
-    use vortex_array::vtable::ArrayVTableExt;
     use vortex_buffer::buffer;
 
-    use crate::ALPVTable;
+    use crate::alp_encode;
 
     #[rstest]
     #[case(buffer![1.23f32, 4.56, 7.89, 10.11, 12.13].into_array())]
@@ -57,11 +57,7 @@ mod test {
         11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0
     ].into_array())]
     fn test_filter_alp_conformance(#[case] array: ArrayRef) {
-        let alp = ALPVTable
-            .as_vtable()
-            .encode(&array.to_canonical().unwrap(), None)
-            .unwrap()
-            .unwrap();
+        let alp = alp_encode(&array.to_primitive(), None).unwrap();
         test_filter_conformance(alp.as_ref());
     }
 }

encodings/alp/src/alp/compute/mask.rs

@@ -38,12 +38,12 @@ register_kernel!(MaskKernelAdapter(ALPVTable).lift());
 mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::mask::test_mask_conformance;
-    use vortex_array::vtable::ArrayVTableExt;
     use vortex_buffer::buffer;
 
-    use crate::ALPVTable;
+    use crate::alp_encode;
 
     #[rstest]
     #[case(buffer![10.5f32, 20.5, 30.5, 40.5, 50.5].into_array())]
@@ -55,11 +55,7 @@ mod test {
         1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0
     ].into_array())]
     fn test_mask_alp_conformance(#[case] array: vortex_array::ArrayRef) {
-        let alp = ALPVTable
-            .as_vtable()
-            .encode(&array.to_canonical().unwrap(), None)
-            .unwrap()
-            .unwrap();
+        let alp = alp_encode(&array.to_primitive(), None).unwrap();
         test_mask_conformance(alp.as_ref());
     }
 }

encodings/alp/src/alp/compute/take.rs

@@ -39,24 +39,20 @@ register_kernel!(TakeKernelAdapter(ALPVTable).lift());
 mod test {
     use rstest::rstest;
     use vortex_array::IntoArray;
+    use vortex_array::ToCanonical;
     use vortex_array::arrays::PrimitiveArray;
     use vortex_array::compute::conformance::take::test_take_conformance;
-    use vortex_array::vtable::ArrayVTableExt;
     use vortex_buffer::buffer;
 
-    use crate::ALPVTable;
+    use crate::alp_encode;
 
     #[rstest]
     #[case(buffer![1.23f32, 4.56, 7.89, 10.11, 12.13].into_array())]
     #[case(buffer![100.1f64, 200.2, 300.3, 400.4, 500.5].into_array())]
     #[case(PrimitiveArray::from_option_iter([Some(1.1f32), None, Some(2.2), Some(3.3), None]).into_array())]
     #[case(buffer![42.42f64].into_array())]
     fn test_take_alp_conformance(#[case] array: vortex_array::ArrayRef) {
-        let alp = ALPVTable
-            .as_vtable()
-            .encode(&array.to_canonical().unwrap(), None)
-            .unwrap()
-            .unwrap();
+        let alp = alp_encode(&array.to_primitive(), None).unwrap();
         test_take_conformance(alp.as_ref());
     }
 }

encodings/alp/src/alp_rd/array.rs

@@ -32,7 +32,6 @@ use vortex_array::vtable::ArrayVTable;
 use vortex_array::vtable::ArrayVTableExt;
 use vortex_array::vtable::BaseArrayVTable;
 use vortex_array::vtable::CanonicalVTable;
-use vortex_array::vtable::EncodeVTable;
 use vortex_array::vtable::NotSupported;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
@@ -78,7 +77,6 @@ impl VTable for ALPRDVTable {
     type ValidityVTable = ValidityVTableFromChild;
     type VisitorVTable = Self;
     type ComputeVTable = NotSupported;
-    type EncodeVTable = Self;
 
     fn id(&self) -> ArrayId {
         ArrayId::new_ref("vortex.alprd")
@@ -465,36 +463,6 @@ impl CanonicalVTable<ALPRDVTable> for ALPRDVTable {
     }
 }
 
-impl EncodeVTable<ALPRDVTable> for ALPRDVTable {
-    fn encode(
-        _vtable: &ALPRDVTable,
-        canonical: &Canonical,
-        like: Option<&ALPRDArray>,
-    ) -> VortexResult<Option<ALPRDArray>> {
-        let parray = canonical.clone().into_primitive();
-
-        let alprd_array = match like {
-            None => {
-                let encoder = match parray.ptype() {
-                    PType::F32 => crate::alp_rd::RDEncoder::new(parray.as_slice::<f32>()),
-                    PType::F64 => crate::alp_rd::RDEncoder::new(parray.as_slice::<f64>()),
-                    ptype => vortex_bail!("cannot ALPRD compress ptype {ptype}"),
-                };
-                encoder.encode(&parray)
-            }
-            Some(like) => {
-                let encoder = crate::alp_rd::RDEncoder::from_parts(
-                    like.right_bit_width(),
-                    like.left_parts_dictionary().to_vec(),
-                );
-                encoder.encode(&parray)
-            }
-        };
-
-        Ok(Some(alprd_array))
-    }
-}
-
 impl VisitorVTable<ALPRDVTable> for ALPRDVTable {
     fn visit_buffers(_array: &ALPRDArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 

encodings/bytebool/src/array.rs

@@ -55,7 +55,6 @@ impl VTable for ByteBoolVTable {
     type ValidityVTable = ValidityVTableFromValidityHelper;
     type VisitorVTable = Self;
     type ComputeVTable = NotSupported;
-    type EncodeVTable = NotSupported;
 
     fn id(&self) -> ArrayId {
         ArrayId::new_ref("vortex.bytebool")

encodings/datetime-parts/src/array.rs

@@ -11,13 +11,11 @@ use vortex_array::ArrayChildVisitor;
 use vortex_array::ArrayEq;
 use vortex_array::ArrayHash;
 use vortex_array::ArrayRef;
-use vortex_array::Canonical;
 use vortex_array::DeserializeMetadata;
 use vortex_array::IntoArray;
 use vortex_array::Precision;
 use vortex_array::ProstMetadata;
 use vortex_array::SerializeMetadata;
-use vortex_array::arrays::TemporalArray;
 use vortex_array::buffer::BufferHandle;
 use vortex_array::serde::ArrayChildren;
 use vortex_array::stats::ArrayStats;
@@ -27,7 +25,6 @@ use vortex_array::vtable::ArrayId;
 use vortex_array::vtable::ArrayVTable;
 use vortex_array::vtable::ArrayVTableExt;
 use vortex_array::vtable::BaseArrayVTable;
-use vortex_array::vtable::EncodeVTable;
 use vortex_array::vtable::NotSupported;
 use vortex_array::vtable::VTable;
 use vortex_array::vtable::ValidityChild;
@@ -87,7 +84,6 @@ impl VTable for DateTimePartsVTable {
     type ValidityVTable = ValidityVTableFromChild;
     type VisitorVTable = Self;
     type ComputeVTable = NotSupported;
-    type EncodeVTable = Self;
 
     fn id(&self) -> ArrayId {
         ArrayId::new_ref("vortex.datetimeparts")
@@ -308,19 +304,6 @@ impl ValidityChild<DateTimePartsVTable> for DateTimePartsVTable {
     }
 }
 
-impl EncodeVTable<DateTimePartsVTable> for DateTimePartsVTable {
-    fn encode(
-        _vtable: &DateTimePartsVTable,
-        canonical: &Canonical,
-        _like: Option<&DateTimePartsArray>,
-    ) -> VortexResult<Option<DateTimePartsArray>> {
-        let ext_array = canonical.clone().into_extension();
-        let temporal = TemporalArray::try_from(ext_array)?;
-
-        Ok(Some(DateTimePartsArray::try_from(temporal)?))
-    }
-}
-
 impl VisitorVTable<DateTimePartsVTable> for DateTimePartsVTable {
     fn visit_buffers(_array: &DateTimePartsArray, _visitor: &mut dyn ArrayBufferVisitor) {}
 

encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs

@@ -72,7 +72,6 @@ impl VTable for DecimalBytePartsVTable {
     type ValidityVTable = ValidityVTableFromChild;
     type VisitorVTable = Self;
     type ComputeVTable = NotSupported;
-    type EncodeVTable = NotSupported;
 
     fn id(&self) -> ArrayId {
         ArrayId::new_ref("vortex.decimal_byte_parts")