Remove compute vtable (#3250)

gatesn · web-flow · commit 3b978bc81814 · 2025-05-08T13:31:29.000+01:00
diff --git a/encodings/alp/src/alp/compute/mod.rs b/encodings/alp/src/alp/compute/mod.rs
@@ -3,14 +3,11 @@ mod compare;
 mod nan_count;
 
 use vortex_array::compute::{TakeKernel, TakeKernelAdapter, take};
-use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayRef, register_kernel};
 use vortex_error::VortexResult;
 
 use crate::{ALPArray, ALPEncoding};
 
-impl ComputeVTable for ALPEncoding {}
-
 impl TakeKernel for ALPEncoding {
     fn take(&self, array: &ALPArray, indices: &dyn Array) -> VortexResult<ArrayRef> {
         let taken_encoded = take(array.encoded(), indices)?;
diff --git a/encodings/alp/src/alp_rd/compute/mod.rs b/encodings/alp/src/alp_rd/compute/mod.rs
@@ -1,9 +1,3 @@
-use vortex_array::vtable::ComputeVTable;
-
-use crate::ALPRDEncoding;
-
 mod filter;
 mod mask;
 mod take;
-
-impl ComputeVTable for ALPRDEncoding {}
diff --git a/encodings/bytebool/src/compute.rs b/encodings/bytebool/src/compute.rs
@@ -1,16 +1,13 @@
 use num_traits::AsPrimitive;
 use vortex_array::compute::{MaskKernel, MaskKernelAdapter, TakeKernel, TakeKernelAdapter};
 use vortex_array::variants::PrimitiveArrayTrait;
-use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayRef, ToCanonical, register_kernel};
 use vortex_dtype::match_each_integer_ptype;
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
 use super::{ByteBoolArray, ByteBoolEncoding};
 
-impl ComputeVTable for ByteBoolEncoding {}
-
 impl MaskKernel for ByteBoolEncoding {
     fn mask(&self, array: &ByteBoolArray, mask: &Mask) -> VortexResult<ArrayRef> {
         Ok(ByteBoolArray::new(array.buffer().clone(), array.validity().mask(mask)?).into_array())
diff --git a/encodings/datetime-parts/src/compute/mod.rs b/encodings/datetime-parts/src/compute/mod.rs
@@ -3,9 +3,3 @@ mod compare;
 mod filter;
 mod is_constant;
 mod take;
-
-use vortex_array::vtable::ComputeVTable;
-
-use crate::DateTimePartsEncoding;
-
-impl ComputeVTable for DateTimePartsEncoding {}
diff --git a/encodings/dict/src/compute/mod.rs b/encodings/dict/src/compute/mod.rs
@@ -9,15 +9,12 @@ mod min_max;
 use vortex_array::compute::{
     FilterKernel, FilterKernelAdapter, TakeKernel, TakeKernelAdapter, filter, take,
 };
-use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayRef, register_kernel};
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
 use crate::{DictArray, DictEncoding};
 
-impl ComputeVTable for DictEncoding {}
-
 impl TakeKernel for DictEncoding {
     fn take(&self, array: &DictArray, indices: &dyn Array) -> VortexResult<ArrayRef> {
         let codes = take(array.codes(), indices)?;
diff --git a/encodings/fastlanes/src/bitpacking/compute/mod.rs b/encodings/fastlanes/src/bitpacking/compute/mod.rs
@@ -1,14 +1,8 @@
-use vortex_array::vtable::ComputeVTable;
-
-use crate::BitPackedEncoding;
-
 mod between;
 mod filter;
 mod is_constant;
 mod take;
 
-impl ComputeVTable for BitPackedEncoding {}
-
 fn chunked_indices<F: FnMut(usize, &[usize])>(
     mut indices: impl Iterator<Item = usize>,
     offset: usize,
diff --git a/encodings/fastlanes/src/delta/mod.rs b/encodings/fastlanes/src/delta/mod.rs
@@ -5,7 +5,7 @@ use vortex_array::arrays::PrimitiveArray;
 use vortex_array::stats::{ArrayStats, StatsSetRef};
 use vortex_array::validity::Validity;
 use vortex_array::variants::PrimitiveArrayTrait;
-use vortex_array::vtable::{ComputeVTable, VTableRef};
+use vortex_array::vtable::VTableRef;
 use vortex_array::{
     Array, ArrayCanonicalImpl, ArrayImpl, ArrayRef, ArrayStatisticsImpl, ArrayValidityImpl,
     ArrayVariantsImpl, Canonical, Encoding, ProstMetadata,
@@ -278,5 +278,3 @@ impl ArrayVariantsImpl for DeltaArray {
 }
 
 impl PrimitiveArrayTrait for DeltaArray {}
-
-impl ComputeVTable for DeltaEncoding {}
diff --git a/encodings/fastlanes/src/for/compute/mod.rs b/encodings/fastlanes/src/for/compute/mod.rs
@@ -4,15 +4,12 @@ mod is_constant;
 use vortex_array::compute::{
     FilterKernel, FilterKernelAdapter, TakeKernel, TakeKernelAdapter, filter, take,
 };
-use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayRef, register_kernel};
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
 use crate::{FoRArray, FoREncoding};
 
-impl ComputeVTable for FoREncoding {}
-
 impl TakeKernel for FoREncoding {
     fn take(&self, array: &FoRArray, indices: &dyn Array) -> VortexResult<ArrayRef> {
         FoRArray::try_new(
diff --git a/encodings/fsst/src/compute/mod.rs b/encodings/fsst/src/compute/mod.rs
@@ -3,15 +3,12 @@ mod filter;
 
 use vortex_array::arrays::VarBinArray;
 use vortex_array::compute::{TakeKernel, TakeKernelAdapter, fill_null, take};
-use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayExt, ArrayRef, register_kernel};
 use vortex_error::VortexResult;
 use vortex_scalar::{Scalar, ScalarValue};
 
 use crate::{FSSTArray, FSSTEncoding};
 
-impl ComputeVTable for FSSTEncoding {}
-
 impl TakeKernel for FSSTEncoding {
     // Take on an FSSTArray is a simple take on the codes array.
     fn take(&self, array: &FSSTArray, indices: &dyn Array) -> VortexResult<ArrayRef> {
diff --git a/encodings/runend/src/compute/mod.rs b/encodings/runend/src/compute/mod.rs
@@ -8,12 +8,6 @@ mod min_max;
 pub(crate) mod take;
 mod take_from;
 
-use vortex_array::vtable::ComputeVTable;
-
-use crate::RunEndEncoding;
-
-impl ComputeVTable for RunEndEncoding {}
-
 #[cfg(test)]
 mod test {
     use vortex_array::Array;
diff --git a/encodings/sparse/src/compute/mod.rs b/encodings/sparse/src/compute/mod.rs
@@ -1,6 +1,5 @@
 use vortex_array::arrays::ConstantArray;
 use vortex_array::compute::{FilterKernel, FilterKernelAdapter};
-use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayRef, register_kernel};
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
@@ -11,8 +10,6 @@ mod binary_numeric;
 mod invert;
 mod take;
 
-impl ComputeVTable for SparseEncoding {}
-
 impl FilterKernel for SparseEncoding {
     fn filter(&self, array: &SparseArray, mask: &Mask) -> VortexResult<ArrayRef> {
         let new_length = mask.true_count();
diff --git a/encodings/zigzag/src/compute.rs b/encodings/zigzag/src/compute.rs
@@ -1,15 +1,12 @@
 use vortex_array::compute::{
     FilterKernel, FilterKernelAdapter, TakeKernel, TakeKernelAdapter, filter, take,
 };
-use vortex_array::vtable::ComputeVTable;
 use vortex_array::{Array, ArrayRef, register_kernel};
 use vortex_error::VortexResult;
 use vortex_mask::Mask;
 
 use crate::{ZigZagArray, ZigZagEncoding};
 
-impl ComputeVTable for ZigZagEncoding {}
-
 impl FilterKernel for ZigZagEncoding {
     fn filter(&self, array: &ZigZagArray, mask: &Mask) -> VortexResult<ArrayRef> {
         let encoded = filter(array.encoded(), mask)?;
diff --git a/pyvortex/src/arrays/py/encoding.rs b/pyvortex/src/arrays/py/encoding.rs
@@ -7,7 +7,7 @@ use pyo3::{Bound, FromPyObject, Py, PyAny, PyResult};
 use vortex::dtype::DType;
 use vortex::error::{VortexError, VortexResult};
 use vortex::serde::ArrayParts;
-use vortex::vtable::{ComputeVTable, EncodingVTable};
+use vortex::vtable::EncodingVTable;
 use vortex::{ArrayContext, ArrayRef, EmptyMetadata, Encoding, EncodingId};
 
 use crate::arrays::py::array::PyArrayInstance;
@@ -81,5 +81,3 @@ impl EncodingVTable for PyEncodingClass {
         })
     }
 }
-
-impl ComputeVTable for PyEncodingClass {}
diff --git a/vortex-array/src/arrays/bool/compute/mod.rs b/vortex-array/src/arrays/bool/compute/mod.rs
@@ -1,6 +1,3 @@
-use crate::arrays::BoolEncoding;
-use crate::vtable::ComputeVTable;
-
 mod cast;
 mod fill_null;
 pub mod filter;
@@ -12,5 +9,3 @@ mod mask;
 mod min_max;
 mod sum;
 mod take;
-
-impl ComputeVTable for BoolEncoding {}
diff --git a/vortex-array/src/arrays/chunked/compute/mod.rs b/vortex-array/src/arrays/chunked/compute/mod.rs
@@ -1,6 +1,3 @@
-use crate::arrays::ChunkedEncoding;
-use crate::vtable::ComputeVTable;
-
 mod cast;
 mod compare;
 mod elementwise;
@@ -13,5 +10,3 @@ mod mask;
 mod min_max;
 mod sum;
 mod take;
-
-impl ComputeVTable for ChunkedEncoding {}
diff --git a/vortex-array/src/arrays/constant/compute/mod.rs b/vortex-array/src/arrays/constant/compute/mod.rs
@@ -7,11 +7,6 @@ mod invert;
 mod sum;
 mod take;
 
-use crate::arrays::ConstantEncoding;
-use crate::vtable::ComputeVTable;
-
-impl ComputeVTable for ConstantEncoding {}
-
 #[cfg(test)]
 mod test {
     use vortex_dtype::half::f16;
diff --git a/vortex-array/src/arrays/decimal/compute/mod.rs b/vortex-array/src/arrays/decimal/compute/mod.rs
@@ -5,8 +5,3 @@ mod is_sorted;
 mod min_max;
 mod sum;
 mod take;
-
-use crate::arrays::DecimalEncoding;
-use crate::vtable::ComputeVTable;
-
-impl ComputeVTable for DecimalEncoding {}
diff --git a/vortex-array/src/arrays/extension/compute/mod.rs b/vortex-array/src/arrays/extension/compute/mod.rs
@@ -13,11 +13,8 @@ use crate::compute::{
     is_sorted, is_strict_sorted, min_max, sum, take,
 };
 use crate::variants::ExtensionArrayTrait;
-use crate::vtable::ComputeVTable;
 use crate::{Array, ArrayRef, register_kernel};
 
-impl ComputeVTable for ExtensionEncoding {}
-
 impl FilterKernel for ExtensionEncoding {
     fn filter(&self, array: &ExtensionArray, mask: &Mask) -> VortexResult<ArrayRef> {
         Ok(
diff --git a/vortex-array/src/arrays/list/compute/mod.rs b/vortex-array/src/arrays/list/compute/mod.rs
@@ -8,9 +8,6 @@ use crate::compute::{
     IsSortedKernelAdapter, MinMaxKernel, MinMaxKernelAdapter, MinMaxResult,
 };
 use crate::register_kernel;
-use crate::vtable::ComputeVTable;
-
-impl ComputeVTable for ListEncoding {}
 
 impl IsConstantKernel for ListEncoding {
     fn is_constant(
diff --git a/vortex-array/src/arrays/null/compute.rs b/vortex-array/src/arrays/null/compute.rs
@@ -9,11 +9,8 @@ use crate::compute::{
     MinMaxKernelAdapter, MinMaxResult, TakeKernel, TakeKernelAdapter,
 };
 use crate::variants::PrimitiveArrayTrait;
-use crate::vtable::ComputeVTable;
 use crate::{Array, ArrayRef, ToCanonical, register_kernel};
 
-impl ComputeVTable for NullEncoding {}
-
 impl FilterKernel for NullEncoding {
     fn filter(&self, _array: &Self::Array, mask: &Mask) -> VortexResult<ArrayRef> {
         Ok(NullArray::new(mask.true_count()).into_array())
diff --git a/vortex-array/src/arrays/primitive/compute/mod.rs b/vortex-array/src/arrays/primitive/compute/mod.rs
@@ -1,6 +1,3 @@
-use crate::arrays::PrimitiveEncoding;
-use crate::vtable::ComputeVTable;
-
 mod between;
 mod cast;
 mod fill_null;
@@ -14,5 +11,3 @@ mod sum;
 mod take;
 
 pub use is_constant::*;
-
-impl ComputeVTable for PrimitiveEncoding {}
diff --git a/vortex-array/src/arrays/struct_/compute/mod.rs b/vortex-array/src/arrays/struct_/compute/mod.rs
@@ -12,11 +12,8 @@ use crate::compute::{
     MinMaxKernel, MinMaxKernelAdapter, MinMaxResult, TakeKernel, TakeKernelAdapter, filter,
     is_constant_opts, take,
 };
-use crate::vtable::ComputeVTable;
 use crate::{Array, ArrayRef, ArrayVisitor, register_kernel};
 
-impl ComputeVTable for StructEncoding {}
-
 impl TakeKernel for StructEncoding {
     fn take(&self, array: &StructArray, indices: &dyn Array) -> VortexResult<ArrayRef> {
         StructArray::try_new_with_dtype(
diff --git a/vortex-array/src/arrays/varbin/compute/mod.rs b/vortex-array/src/arrays/varbin/compute/mod.rs
@@ -1,8 +1,5 @@
 pub use min_max::compute_min_max;
 
-use crate::arrays::VarBinEncoding;
-use crate::vtable::ComputeVTable;
-
 mod cast;
 mod compare;
 mod filter;
@@ -11,5 +8,3 @@ mod is_sorted;
 mod mask;
 mod min_max;
 mod take;
-
-impl ComputeVTable for VarBinEncoding {}
diff --git a/vortex-array/src/arrays/varbinview/compute/mod.rs b/vortex-array/src/arrays/varbinview/compute/mod.rs
@@ -5,11 +5,6 @@ mod mask;
 mod min_max;
 mod take;
 
-use crate::arrays::VarBinViewEncoding;
-use crate::vtable::ComputeVTable;
-
-impl ComputeVTable for VarBinViewEncoding {}
-
 #[cfg(test)]
 mod tests {
     use vortex_buffer::buffer;
diff --git a/vortex-array/src/arrow/array.rs b/vortex-array/src/arrow/array.rs
@@ -9,7 +9,7 @@ use vortex_mask::Mask;
 use vortex_scalar::Scalar;
 
 use crate::stats::StatsSetRef;
-use crate::vtable::{ComputeVTable, EncodingVTable, VTableRef};
+use crate::vtable::{EncodingVTable, VTableRef};
 use crate::{
     Array, ArrayCanonicalImpl, ArrayImpl, ArrayOperationsImpl, ArrayRef, ArrayStatisticsImpl,
     ArrayValidityImpl, ArrayVariantsImpl, ArrayVisitorImpl, Canonical, EmptyMetadata, Encoding,
@@ -31,8 +31,6 @@ impl EncodingVTable for ArrowArrayEncoding {
     }
 }
 
-impl ComputeVTable for ArrowArrayEncoding {}
-
 #[derive(Clone, Debug)]
 pub struct ArrowArray {
     inner: ArrowArrayRef,
diff --git a/vortex-array/src/vtable.rs b/vortex-array/src/vtable.rs
@@ -3,10 +3,7 @@
 use std::fmt::{Debug, Display, Formatter};
 use std::hash::{Hash, Hasher};
 
-mod compute;
-
 use arcref::ArcRef;
-pub use compute::*;
 use vortex_dtype::DType;
 use vortex_error::{VortexExpect, VortexResult, vortex_bail};
 
@@ -23,7 +20,7 @@ pub type VTableRef = ArcRef<dyn EncodingVTable>;
 /// It is split into multiple sub-traits to make it easier for consumers to break up the
 /// implementation, as well as to allow for optional implementation of certain features, for example
 /// compute functions.
-pub trait EncodingVTable: 'static + Sync + Send + ComputeVTable {
+pub trait EncodingVTable: 'static + Sync + Send {
     /// Return the ID for this encoding implementation.
     fn id(&self) -> EncodingId;
 
diff --git a/vortex-array/src/vtable/compute.rs b/vortex-array/src/vtable/compute.rs
