From bbdb949e608f4ecb3ad0a1e8cb42bf4e32460774 Mon Sep 17 00:00:00 2001 From: Nicholas Gates Date: Fri, 29 Nov 2024 12:18:50 -0500 Subject: [PATCH] Remove with_dyn and ArrayDef (#1503) Waiting on #1501 --- .../src/bitpacking/compute/search_sorted.rs | 10 +-- encodings/fsst/src/array.rs | 10 ++- encodings/fsst/tests/fsst_tests.rs | 9 +-- vortex-array/src/data/mod.rs | 28 +------- vortex-array/src/encoding/mod.rs | 33 +--------- vortex-array/src/encoding/opaque.rs | 13 +--- vortex-array/src/lib.rs | 1 - vortex-array/src/macros.rs | 64 ++++--------------- .../src/compressors/alp.rs | 8 +-- .../src/compressors/alp_rd.rs | 8 +-- .../src/compressors/chunked.rs | 10 +-- .../src/compressors/constant.rs | 8 +-- .../src/compressors/date_time_parts.rs | 8 +-- .../src/compressors/delta.rs | 8 +-- .../src/compressors/dict.rs | 24 +++---- .../src/compressors/for.rs | 8 +-- .../src/compressors/fsst.rs | 31 ++++----- .../src/compressors/roaring_bool.rs | 12 ++-- .../src/compressors/roaring_int.rs | 8 +-- .../src/compressors/runend.rs | 12 ++-- .../src/compressors/runend_bool.rs | 12 ++-- .../src/compressors/sparse.rs | 10 +-- .../src/compressors/struct_.rs | 11 ++-- .../src/compressors/varbin.rs | 10 +-- .../src/compressors/zigzag.rs | 8 +-- .../src/sampling_compressor.rs | 8 +-- vortex-sampling-compressor/tests/smoketest.rs | 25 ++++---- 27 files changed, 151 insertions(+), 246 deletions(-) diff --git a/encodings/fastlanes/src/bitpacking/compute/search_sorted.rs b/encodings/fastlanes/src/bitpacking/compute/search_sorted.rs index 1bfba943b6..a7cfe4059c 100644 --- a/encodings/fastlanes/src/bitpacking/compute/search_sorted.rs +++ b/encodings/fastlanes/src/bitpacking/compute/search_sorted.rs @@ -10,6 +10,7 @@ use vortex_array::compute::{ search_sorted_usize, IndexOrd, Len, SearchResult, SearchSorted, SearchSortedFn, SearchSortedSide, }; +use vortex_array::stats::ArrayStatistics; use vortex_array::validity::Validity; use vortex_array::variants::PrimitiveArrayTrait; use vortex_array::{ArrayDType, ArrayLen}; @@ -156,11 +157,10 @@ impl<'a, T: BitPacking + NativePType> BitPackedSearch<'a, T> { Validity::AllInvalid => 0, Validity::Array(varray) => { // In sorted order, nulls come after all the non-null values. - varray.with_dyn(|a| { - a.statistics() - .compute_true_count() - .vortex_expect("Failed to compute true count") - }) + varray + .statistics() + .compute_true_count() + .vortex_expect("Failed to compute true count") } }; diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs index 44fc5d197a..68cf4a5f51 100644 --- a/encodings/fsst/src/array.rs +++ b/encodings/fsst/src/array.rs @@ -3,15 +3,13 @@ use std::sync::Arc; use fsst::{Decompressor, Symbol}; use serde::{Deserialize, Serialize}; -use vortex_array::array::{VarBin, VarBinArray}; -use vortex_array::encoding::ids; +use vortex_array::array::{VarBinArray, VarBinEncoding}; +use vortex_array::encoding::{ids, Encoding}; use vortex_array::stats::{StatisticsVTable, StatsSet}; use vortex_array::validity::{ArrayValidity, LogicalValidity, Validity, ValidityVTable}; use vortex_array::variants::{BinaryArrayTrait, Utf8ArrayTrait, VariantsVTable}; use vortex_array::visitor::{ArrayVisitor, VisitorVTable}; -use vortex_array::{ - impl_encoding, ArrayDType, ArrayData, ArrayDef, ArrayLen, ArrayTrait, IntoCanonical, -}; +use vortex_array::{impl_encoding, ArrayDType, ArrayData, ArrayLen, ArrayTrait, IntoCanonical}; use vortex_dtype::{DType, Nullability, PType}; use vortex_error::{vortex_bail, VortexExpect, VortexResult}; @@ -75,7 +73,7 @@ impl FSSTArray { vortex_bail!(InvalidArgument: "uncompressed_lengths must have integer type and cannot be nullable"); } - if codes.encoding().id() != VarBin::ID { + if codes.encoding().id() != VarBinEncoding::ID { vortex_bail!( InvalidArgument: "codes must have varbin encoding, was {}", codes.encoding().id() diff --git a/encodings/fsst/tests/fsst_tests.rs b/encodings/fsst/tests/fsst_tests.rs index 37fdb48cd7..98641285ab 100644 --- a/encodings/fsst/tests/fsst_tests.rs +++ b/encodings/fsst/tests/fsst_tests.rs @@ -3,10 +3,11 @@ use vortex_array::array::builder::VarBinBuilder; use vortex_array::array::PrimitiveArray; use vortex_array::compute::{filter, scalar_at, slice, take, FilterMask, TakeOptions}; +use vortex_array::encoding::Encoding; use vortex_array::validity::Validity; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData, IntoCanonical}; +use vortex_array::{ArrayData, IntoArrayData, IntoCanonical}; use vortex_dtype::{DType, Nullability}; -use vortex_fsst::{fsst_compress, fsst_train_compressor, FSST}; +use vortex_fsst::{fsst_compress, fsst_train_compressor, FSSTEncoding}; macro_rules! assert_nth_scalar { ($arr:expr, $n:expr, $expected:expr) => { @@ -55,7 +56,7 @@ fn test_fsst_array_ops() { // test slice let fsst_sliced = slice(&fsst_array, 1, 3).unwrap(); - assert_eq!(fsst_sliced.encoding().id(), FSST::ENCODING.id()); + assert_eq!(fsst_sliced.encoding().id(), FSSTEncoding::ID); assert_eq!(fsst_sliced.len(), 2); assert_nth_scalar!( fsst_sliced, @@ -87,7 +88,7 @@ fn test_fsst_array_ops() { let mask = FilterMask::from_iter([false, true, false]); let fsst_filtered = filter(&fsst_array, mask).unwrap(); - assert_eq!(fsst_filtered.encoding().id(), FSST::ENCODING.id()); + assert_eq!(fsst_filtered.encoding().id(), FSSTEncoding::ID); assert_eq!(fsst_filtered.len(), 1); assert_nth_scalar!( fsst_filtered, diff --git a/vortex-array/src/data/mod.rs b/vortex-array/src/data/mod.rs index 4d9bf05d2e..4763c9c762 100644 --- a/vortex-array/src/data/mod.rs +++ b/vortex-array/src/data/mod.rs @@ -8,7 +8,7 @@ use owned::OwnedArrayData; use viewed::ViewedArrayData; use vortex_buffer::Buffer; use vortex_dtype::DType; -use vortex_error::{vortex_err, vortex_panic, VortexExpect, VortexResult}; +use vortex_error::{vortex_err, VortexExpect, VortexResult}; use vortex_scalar::Scalar; use crate::array::{ @@ -22,7 +22,7 @@ use crate::stats::{ArrayStatistics, Stat, Statistics, StatsSet}; use crate::stream::{ArrayStream, ArrayStreamAdapter}; use crate::validity::{ArrayValidity, LogicalValidity, ValidityVTable}; use crate::{ - ArrayChildrenIterator, ArrayDType, ArrayLen, ArrayMetadata, ArrayTrait, Context, + ArrayChildrenIterator, ArrayDType, ArrayLen, ArrayMetadata, Context, TryDeserializeArrayMetadata, }; @@ -335,30 +335,6 @@ impl ArrayData { pub fn is_encoding(&self, id: EncodingId) -> bool { self.encoding().id() == id } - - #[inline] - pub fn with_dyn(&self, mut f: F) -> R - where - F: FnMut(&dyn ArrayTrait) -> R, - { - let mut result = None; - - self.encoding() - .with_dyn(self, &mut |array| { - result = Some(f(array)); - Ok(()) - }) - .unwrap_or_else(|err| { - vortex_panic!( - err, - "Failed to convert Array to {}", - std::any::type_name::() - ) - }); - - // Now we unwrap the optional, which we know to be populated by the closure. - result.vortex_expect("Failed to get result from Array::with_dyn") - } } impl Display for ArrayData { diff --git a/vortex-array/src/encoding/mod.rs b/vortex-array/src/encoding/mod.rs index fe111b69cf..ccb04879f9 100644 --- a/vortex-array/src/encoding/mod.rs +++ b/vortex-array/src/encoding/mod.rs @@ -4,14 +4,12 @@ use std::any::Any; use std::fmt::{Debug, Display, Formatter}; use std::hash::{Hash, Hasher}; -use vortex_error::{vortex_panic, VortexResult}; - use crate::compute::ComputeVTable; use crate::stats::StatisticsVTable; use crate::validity::ValidityVTable; use crate::variants::VariantsVTable; use crate::visitor::VisitorVTable; -use crate::{ArrayData, ArrayDef, ArrayMetadata, ArrayTrait, IntoCanonicalVTable, MetadataVTable}; +use crate::{ArrayData, ArrayMetadata, IntoCanonicalVTable, MetadataVTable}; pub mod opaque; @@ -63,6 +61,8 @@ impl AsRef for EncodingId { /// Marker trait for array encodings with their associated Array type. pub trait Encoding: 'static { + const ID: EncodingId; + type Array; type Metadata: ArrayMetadata; } @@ -86,13 +86,6 @@ pub trait EncodingVTable: fn id(&self) -> EncodingId; fn as_any(&self) -> &dyn Any; - - /// Unwrap the provided array into an implementation of ArrayTrait - fn with_dyn( - &self, - array: &ArrayData, - f: &mut dyn for<'b> FnMut(&'b (dyn ArrayTrait + 'b)) -> VortexResult<()>, - ) -> VortexResult<()>; } impl PartialEq for dyn EncodingVTable + '_ { @@ -107,26 +100,6 @@ impl Hash for dyn EncodingVTable + '_ { } } -/// Non-object-safe extensions to the ArrayEncoding trait. -pub trait ArrayEncodingExt { - type D: ArrayDef; - - fn with_dyn(array: &ArrayData, mut f: F) -> R - where - F: for<'b> FnMut(&'b (dyn ArrayTrait + 'b)) -> R, - { - let typed = <::Array as TryFrom>::try_from(array.clone()) - .unwrap_or_else(|err| { - vortex_panic!( - err, - "Failed to convert array to {}", - std::any::type_name::<::Array>() - ) - }); - f(&typed) - } -} - pub trait ArrayEncodingRef { fn encoding(&self) -> EncodingRef; } diff --git a/vortex-array/src/encoding/opaque.rs b/vortex-array/src/encoding/opaque.rs index 166a58da04..6b00b97809 100644 --- a/vortex-array/src/encoding/opaque.rs +++ b/vortex-array/src/encoding/opaque.rs @@ -11,7 +11,7 @@ use crate::validity::{LogicalValidity, ValidityVTable}; use crate::variants::VariantsVTable; use crate::visitor::{ArrayVisitor, VisitorVTable}; use crate::{ - ArrayData, ArrayMetadata, ArrayTrait, Canonical, IntoCanonicalVTable, MetadataVTable, + ArrayData, ArrayMetadata, Canonical, IntoCanonicalVTable, MetadataVTable, TrySerializeArrayMetadata, }; @@ -38,17 +38,6 @@ impl EncodingVTable for OpaqueEncoding { fn as_any(&self) -> &dyn Any { self } - - fn with_dyn( - &self, - _array: &ArrayData, - _f: &mut dyn for<'b> FnMut(&'b (dyn ArrayTrait + 'b)) -> VortexResult<()>, - ) -> VortexResult<()> { - vortex_bail!( - "OpaqueEncoding: with_dyn cannot be called for opaque array ({})", - self.0 - ) - } } impl IntoCanonicalVTable for OpaqueEncoding { diff --git a/vortex-array/src/lib.rs b/vortex-array/src/lib.rs index f9d6f0e0b5..4fd5c5643a 100644 --- a/vortex-array/src/lib.rs +++ b/vortex-array/src/lib.rs @@ -14,7 +14,6 @@ pub use canonical::*; pub use context::*; pub use data::*; -pub use macros::*; pub use metadata::*; pub use paste; use vortex_dtype::DType; diff --git a/vortex-array/src/macros.rs b/vortex-array/src/macros.rs index 99cc3b90e1..9a363b2bdc 100644 --- a/vortex-array/src/macros.rs +++ b/vortex-array/src/macros.rs @@ -1,22 +1,7 @@ //! The core Vortex macro to create new encodings and array types. -use vortex_error::VortexError; - -use crate::encoding::{ - ArrayEncodingExt, ArrayEncodingRef, EncodingId, EncodingRef, EncodingVTable, -}; -use crate::{ArrayData, ArrayMetadata, ArrayTrait, ToArrayData, TryDeserializeArrayMetadata}; - -/// Trait the defines the set of types relating to an array. -/// Because it has associated types it can't be used as a trait object. -pub trait ArrayDef { - const ID: EncodingId; - const ENCODING: EncodingRef; - - type Array: ArrayTrait + TryFrom; - type Metadata: ArrayMetadata + Clone + for<'m> TryDeserializeArrayMetadata<'m>; - type Encoding: EncodingVTable + ArrayEncodingExt; -} +use crate::encoding::{ArrayEncodingRef, EncodingRef}; +use crate::{ArrayData, ToArrayData}; impl> ToArrayData for A { fn to_array(&self) -> ArrayData { @@ -32,22 +17,6 @@ impl> ToArrayData for A { macro_rules! impl_encoding { ($id:literal, $code:expr, $Name:ident) => { $crate::paste::paste! { - /// The array definition trait - #[derive(std::fmt::Debug, Clone)] - pub struct $Name; - impl $crate::ArrayDef for $Name { - const ID: $crate::encoding::EncodingId = $crate::encoding::EncodingId::new($id, $code); - const ENCODING: $crate::encoding::EncodingRef = &[<$Name Encoding>]; - type Array = [<$Name Array>]; - type Metadata = [<$Name Metadata>]; - type Encoding = [<$Name Encoding>]; - } - - impl $crate::encoding::Encoding for [<$Name Encoding>] { - type Array = [<$Name Array>]; - type Metadata = [<$Name Metadata>]; - } - #[derive(std::fmt::Debug, Clone)] #[repr(transparent)] pub struct [<$Name Array>]($crate::ArrayData); @@ -95,11 +64,11 @@ macro_rules! impl_encoding { type Error = vortex_error::VortexError; fn try_from(data: $crate::ArrayData) -> vortex_error::VortexResult { - if data.encoding().id() != <$Name as $crate::ArrayDef>::ID { + if data.encoding().id() != <[<$Name Encoding>] as $crate::encoding::Encoding>::ID { vortex_error::vortex_bail!( "Mismatched encoding {}, expected {}", data.encoding().id().as_ref(), - <$Name as $crate::ArrayDef>::ID, + <[<$Name Encoding>] as $crate::encoding::Encoding>::ID, ); } Ok(Self(data)) @@ -112,11 +81,11 @@ macro_rules! impl_encoding { type Error = vortex_error::VortexError; fn try_from(data: &'a $crate::ArrayData) -> vortex_error::VortexResult { - if data.encoding().id() != <$Name as $crate::ArrayDef>::ID { + if data.encoding().id() != <[<$Name Encoding>] as $crate::encoding::Encoding>::ID { vortex_error::vortex_bail!( "Mismatched encoding {}, expected {}", data.encoding().id().as_ref(), - <$Name as $crate::ArrayDef>::ID, + <[<$Name Encoding>] as $crate::encoding::Encoding>::ID, ); } Ok(unsafe { std::mem::transmute::<&$crate::ArrayData, &[<$Name Array>]>(data) }) @@ -126,27 +95,22 @@ macro_rules! impl_encoding { /// The array encoding #[derive(std::fmt::Debug)] pub struct [<$Name Encoding>]; + + impl $crate::encoding::Encoding for [<$Name Encoding>] { + const ID: $crate::encoding::EncodingId = $crate::encoding::EncodingId::new($id, $code); + type Array = [<$Name Array>]; + type Metadata = [<$Name Metadata>]; + } + impl $crate::encoding::EncodingVTable for [<$Name Encoding>] { #[inline] fn id(&self) -> $crate::encoding::EncodingId { - <$Name as $crate::ArrayDef>::ID + <[<$Name Encoding>] as $crate::encoding::Encoding>::ID } fn as_any(&self) -> &dyn std::any::Any { self } - - #[inline] - fn with_dyn( - &self, - array: &$crate::ArrayData, - f: &mut dyn for<'b> FnMut(&'b (dyn $crate::ArrayTrait + 'b)) -> vortex_error::VortexResult<()>, - ) -> vortex_error::VortexResult<()> { - ::with_dyn(array, f) - } - } - impl $crate::encoding::ArrayEncodingExt for [<$Name Encoding>] { - type D = $Name; } /// Implement ArrayMetadata diff --git a/vortex-sampling-compressor/src/compressors/alp.rs b/vortex-sampling-compressor/src/compressors/alp.rs index 2be5cb3eaa..de3985029f 100644 --- a/vortex-sampling-compressor/src/compressors/alp.rs +++ b/vortex-sampling-compressor/src/compressors/alp.rs @@ -1,10 +1,10 @@ -use vortex_alp::{alp_encode_components, match_each_alp_float_ptype, ALPArray, ALPEncoding, ALP}; +use vortex_alp::{alp_encode_components, match_each_alp_float_ptype, ALPArray, ALPEncoding}; use vortex_array::aliases::hash_set::HashSet; use vortex_array::array::PrimitiveArray; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; use vortex_array::variants::PrimitiveArrayTrait; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData, IntoArrayVariant}; +use vortex_array::{ArrayData, IntoArrayData, IntoArrayVariant}; use vortex_dtype::PType; use vortex_error::VortexResult; @@ -17,7 +17,7 @@ pub struct ALPCompressor; impl EncodingCompressor for ALPCompressor { fn id(&self) -> &str { - ALP::ID.as_ref() + ALPEncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/compressors/alp_rd.rs b/vortex-sampling-compressor/src/compressors/alp_rd.rs index 855e1a3efc..96f44473ca 100644 --- a/vortex-sampling-compressor/src/compressors/alp_rd.rs +++ b/vortex-sampling-compressor/src/compressors/alp_rd.rs @@ -1,13 +1,13 @@ use std::any::Any; use std::sync::Arc; -use vortex_alp::{match_each_alp_float_ptype, ALPRDEncoding, RDEncoder as ALPRDEncoder, ALPRD}; +use vortex_alp::{match_each_alp_float_ptype, ALPRDEncoding, RDEncoder as ALPRDEncoder}; use vortex_array::aliases::hash_set::HashSet; use vortex_array::array::PrimitiveArray; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; use vortex_array::variants::PrimitiveArrayTrait; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData, IntoArrayVariant}; +use vortex_array::{ArrayData, IntoArrayData, IntoArrayVariant}; use vortex_dtype::PType; use vortex_error::{vortex_bail, VortexResult}; use vortex_fastlanes::BitPackedEncoding; @@ -26,7 +26,7 @@ impl EncoderMetadata for ALPRDEncoder { impl EncodingCompressor for ALPRDCompressor { fn id(&self) -> &str { - ALPRD::ID.as_ref() + ALPRDEncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/compressors/chunked.rs b/vortex-sampling-compressor/src/compressors/chunked.rs index 6442d2f2b0..7ccb11ef3a 100644 --- a/vortex-sampling-compressor/src/compressors/chunked.rs +++ b/vortex-sampling-compressor/src/compressors/chunked.rs @@ -3,11 +3,11 @@ use std::sync::Arc; use log::info; use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{Chunked, ChunkedArray}; +use vortex_array::array::{ChunkedArray, ChunkedEncoding}; use vortex_array::compress::compute_precompression_stats; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayDType, ArrayData, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayDType, ArrayData, IntoArrayData}; use vortex_error::{vortex_bail, VortexExpect, VortexResult}; use super::EncoderMetadata; @@ -33,7 +33,7 @@ impl EncoderMetadata for ChunkedCompressorMetadata { impl EncodingCompressor for ChunkedCompressor { fn id(&self) -> &str { - Chunked::ID.as_ref() + ChunkedEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -41,7 +41,7 @@ impl EncodingCompressor for ChunkedCompressor { } fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { - array.is_encoding(Chunked::ID).then_some(self) + array.is_encoding(ChunkedEncoding::ID).then_some(self) } fn compress<'a>( diff --git a/vortex-sampling-compressor/src/compressors/constant.rs b/vortex-sampling-compressor/src/compressors/constant.rs index c9564733ba..711bc23aa1 100644 --- a/vortex-sampling-compressor/src/compressors/constant.rs +++ b/vortex-sampling-compressor/src/compressors/constant.rs @@ -1,8 +1,8 @@ use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{Constant, ConstantArray, ConstantEncoding}; -use vortex_array::encoding::EncodingRef; +use vortex_array::array::{ConstantArray, ConstantEncoding}; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayData, IntoArrayData}; use vortex_error::{VortexExpect, VortexResult}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; @@ -13,7 +13,7 @@ pub struct ConstantCompressor; impl EncodingCompressor for ConstantCompressor { fn id(&self) -> &str { - Constant::ID.as_ref() + ConstantEncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/compressors/date_time_parts.rs b/vortex-sampling-compressor/src/compressors/date_time_parts.rs index c5d09489b3..fbb9938a41 100644 --- a/vortex-sampling-compressor/src/compressors/date_time_parts.rs +++ b/vortex-sampling-compressor/src/compressors/date_time_parts.rs @@ -1,11 +1,11 @@ use vortex_array::aliases::hash_set::HashSet; use vortex_array::array::TemporalArray; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayDType, ArrayData, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayDType, ArrayData, IntoArrayData}; use vortex_datetime_dtype::TemporalMetadata; use vortex_datetime_parts::{ - split_temporal, DateTimeParts, DateTimePartsArray, DateTimePartsEncoding, TemporalParts, + split_temporal, DateTimePartsArray, DateTimePartsEncoding, TemporalParts, }; use vortex_error::VortexResult; @@ -17,7 +17,7 @@ pub struct DateTimePartsCompressor; impl EncodingCompressor for DateTimePartsCompressor { fn id(&self) -> &str { - DateTimeParts::ID.as_ref() + DateTimePartsEncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/compressors/delta.rs b/vortex-sampling-compressor/src/compressors/delta.rs index a4f0acbd71..74c0124cf5 100644 --- a/vortex-sampling-compressor/src/compressors/delta.rs +++ b/vortex-sampling-compressor/src/compressors/delta.rs @@ -1,11 +1,11 @@ use vortex_array::aliases::hash_set::HashSet; use vortex_array::array::PrimitiveArray; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; use vortex_array::variants::PrimitiveArrayTrait; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayData, IntoArrayData}; use vortex_error::VortexResult; -use vortex_fastlanes::{delta_compress, Delta, DeltaArray, DeltaEncoding}; +use vortex_fastlanes::{delta_compress, DeltaArray, DeltaEncoding}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; use crate::{constants, SamplingCompressor}; @@ -15,7 +15,7 @@ pub struct DeltaCompressor; impl EncodingCompressor for DeltaCompressor { fn id(&self) -> &str { - Delta::ID.as_ref() + DeltaEncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/compressors/dict.rs b/vortex-sampling-compressor/src/compressors/dict.rs index 846874844a..c088edbce6 100644 --- a/vortex-sampling-compressor/src/compressors/dict.rs +++ b/vortex-sampling-compressor/src/compressors/dict.rs @@ -1,13 +1,13 @@ use vortex_array::aliases::hash_set::HashSet; use vortex_array::array::{ - Primitive, PrimitiveArray, VarBin, VarBinArray, VarBinView, VarBinViewArray, + PrimitiveArray, PrimitiveEncoding, VarBinArray, VarBinEncoding, VarBinViewArray, + VarBinViewEncoding, }; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayData, IntoArrayData}; use vortex_dict::{ - dict_encode_primitive, dict_encode_varbin, dict_encode_varbinview, Dict, DictArray, - DictEncoding, + dict_encode_primitive, dict_encode_varbin, dict_encode_varbinview, DictArray, DictEncoding, }; use vortex_error::VortexResult; @@ -19,7 +19,7 @@ pub struct DictCompressor; impl EncodingCompressor for DictCompressor { fn id(&self) -> &str { - Dict::ID.as_ref() + DictEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -27,9 +27,9 @@ impl EncodingCompressor for DictCompressor { } fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { - if !array.is_encoding(Primitive::ID) - && !array.is_encoding(VarBin::ID) - && !array.is_encoding(VarBinView::ID) + if !array.is_encoding(PrimitiveEncoding::ID) + && !array.is_encoding(VarBinEncoding::ID) + && !array.is_encoding(VarBinViewEncoding::ID) { return None; }; @@ -53,15 +53,15 @@ impl EncodingCompressor for DictCompressor { like: Option>, ctx: SamplingCompressor<'a>, ) -> VortexResult> { - let (codes, values) = if array.is_encoding(Primitive::ID) { + let (codes, values) = if array.is_encoding(PrimitiveEncoding::ID) { let p = PrimitiveArray::try_from(array.clone())?; let (codes, values) = dict_encode_primitive(&p); (codes.into_array(), values.into_array()) - } else if array.is_encoding(VarBin::ID) { + } else if array.is_encoding(VarBinEncoding::ID) { let vb = VarBinArray::try_from(array.clone())?; let (codes, values) = dict_encode_varbin(&vb); (codes.into_array(), values.into_array()) - } else if array.is_encoding(VarBinView::ID) { + } else if array.is_encoding(VarBinViewEncoding::ID) { let vb = VarBinViewArray::try_from(array.clone())?; let (codes, values) = dict_encode_varbinview(&vb); (codes.into_array(), values.into_array()) diff --git a/vortex-sampling-compressor/src/compressors/for.rs b/vortex-sampling-compressor/src/compressors/for.rs index 7940461f6c..f309787e62 100644 --- a/vortex-sampling-compressor/src/compressors/for.rs +++ b/vortex-sampling-compressor/src/compressors/for.rs @@ -1,13 +1,13 @@ use vortex_array::aliases::hash_set::HashSet; use vortex_array::array::PrimitiveArray; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::{trailing_zeros, ArrayStatistics}; use vortex_array::validity::ArrayValidity; use vortex_array::variants::PrimitiveArrayTrait; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData, IntoArrayVariant}; +use vortex_array::{ArrayData, IntoArrayData, IntoArrayVariant}; use vortex_dtype::match_each_integer_ptype; use vortex_error::VortexResult; -use vortex_fastlanes::{for_compress, FoR, FoRArray, FoREncoding}; +use vortex_fastlanes::{for_compress, FoRArray, FoREncoding}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; use crate::{constants, SamplingCompressor}; @@ -17,7 +17,7 @@ pub struct FoRCompressor; impl EncodingCompressor for FoRCompressor { fn id(&self) -> &str { - FoR::ID.as_ref() + FoREncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/compressors/fsst.rs b/vortex-sampling-compressor/src/compressors/fsst.rs index 84ecec7daa..f144357477 100644 --- a/vortex-sampling-compressor/src/compressors/fsst.rs +++ b/vortex-sampling-compressor/src/compressors/fsst.rs @@ -4,13 +4,13 @@ use std::sync::Arc; use fsst::Compressor; use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{VarBin, VarBinView}; -use vortex_array::encoding::EncodingRef; +use vortex_array::array::{VarBinEncoding, VarBinViewEncoding}; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayDType, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayDType, IntoArrayData}; use vortex_dtype::DType; use vortex_error::{vortex_bail, VortexResult}; -use vortex_fsst::{fsst_compress, fsst_train_compressor, FSSTArray, FSSTEncoding, FSST}; +use vortex_fsst::{fsst_compress, fsst_train_compressor, FSSTArray, FSSTEncoding}; use super::bitpacked::BITPACK_WITH_PATCHES; use super::delta::DeltaCompressor; @@ -33,7 +33,7 @@ impl EncoderMetadata for Compressor { impl EncodingCompressor for FSSTCompressor { fn id(&self) -> &str { - FSST::ID.as_ref() + FSSTEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -49,7 +49,7 @@ impl EncodingCompressor for FSSTCompressor { } // FSST can be applied on top of VarBin and VarBinView - if array.is_encoding(VarBin::ID) || array.is_encoding(VarBinView::ID) { + if array.is_encoding(VarBinEncoding::ID) || array.is_encoding(VarBinViewEncoding::ID) { return Some(self); } @@ -81,15 +81,16 @@ impl EncodingCompressor for FSSTCompressor { vortex_bail!("Could not downcast metadata as FSST Compressor") }; - let fsst_array = if array.is_encoding(VarBin::ID) || array.is_encoding(VarBinView::ID) { - // For a VarBinArray or VarBinViewArray, compress directly. - fsst_compress(array, fsst_compressor)? - } else { - vortex_bail!( - "Unsupported encoding for FSSTCompressor: {}", - array.encoding().id() - ) - }; + let fsst_array = + if array.is_encoding(VarBinEncoding::ID) || array.is_encoding(VarBinViewEncoding::ID) { + // For a VarBinArray or VarBinViewArray, compress directly. + fsst_compress(array, fsst_compressor)? + } else { + vortex_bail!( + "Unsupported encoding for FSSTCompressor: {}", + array.encoding().id() + ) + }; let codes = fsst_array.codes(); let compressed_codes = ctx diff --git a/vortex-sampling-compressor/src/compressors/roaring_bool.rs b/vortex-sampling-compressor/src/compressors/roaring_bool.rs index 4080d6f9a2..7951b2ceb7 100644 --- a/vortex-sampling-compressor/src/compressors/roaring_bool.rs +++ b/vortex-sampling-compressor/src/compressors/roaring_bool.rs @@ -1,12 +1,12 @@ use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::Bool; -use vortex_array::encoding::EncodingRef; +use vortex_array::array::BoolEncoding; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayDType, ArrayData, ArrayDef, IntoArrayData, IntoArrayVariant}; +use vortex_array::{ArrayDType, ArrayData, IntoArrayData, IntoArrayVariant}; use vortex_dtype::DType; use vortex_dtype::Nullability::NonNullable; use vortex_error::VortexResult; -use vortex_roaring::{roaring_bool_encode, RoaringBool, RoaringBoolEncoding}; +use vortex_roaring::{roaring_bool_encode, RoaringBoolEncoding}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; use crate::{constants, SamplingCompressor}; @@ -16,7 +16,7 @@ pub struct RoaringBoolCompressor; impl EncodingCompressor for RoaringBoolCompressor { fn id(&self) -> &str { - RoaringBool::ID.as_ref() + RoaringBoolEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -25,7 +25,7 @@ impl EncodingCompressor for RoaringBoolCompressor { fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { // Only support bool arrays - if array.encoding().id() != Bool::ID { + if array.encoding().id() != BoolEncoding::ID { return None; } diff --git a/vortex-sampling-compressor/src/compressors/roaring_int.rs b/vortex-sampling-compressor/src/compressors/roaring_int.rs index 993d264077..ae4351c607 100644 --- a/vortex-sampling-compressor/src/compressors/roaring_int.rs +++ b/vortex-sampling-compressor/src/compressors/roaring_int.rs @@ -1,9 +1,9 @@ use vortex_array::aliases::hash_set::HashSet; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayDType, ArrayData, ArrayDef, IntoArrayData, IntoArrayVariant}; +use vortex_array::{ArrayDType, ArrayData, IntoArrayData, IntoArrayVariant}; use vortex_error::VortexResult; -use vortex_roaring::{roaring_int_encode, RoaringInt, RoaringIntEncoding}; +use vortex_roaring::{roaring_int_encode, RoaringIntEncoding}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; use crate::{constants, SamplingCompressor}; @@ -13,7 +13,7 @@ pub struct RoaringIntCompressor; impl EncodingCompressor for RoaringIntCompressor { fn id(&self) -> &str { - RoaringInt::ID.as_ref() + RoaringIntEncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/compressors/runend.rs b/vortex-sampling-compressor/src/compressors/runend.rs index 689cea4d14..e53f09e63b 100644 --- a/vortex-sampling-compressor/src/compressors/runend.rs +++ b/vortex-sampling-compressor/src/compressors/runend.rs @@ -1,11 +1,11 @@ use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::Primitive; -use vortex_array::encoding::EncodingRef; +use vortex_array::array::PrimitiveEncoding; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData, IntoArrayVariant}; +use vortex_array::{ArrayData, IntoArrayData, IntoArrayVariant}; use vortex_error::VortexResult; use vortex_runend::compress::runend_encode; -use vortex_runend::{RunEnd, RunEndArray, RunEndEncoding}; +use vortex_runend::{RunEndArray, RunEndEncoding}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; use crate::{constants, SamplingCompressor}; @@ -19,7 +19,7 @@ pub struct RunEndCompressor { impl EncodingCompressor for RunEndCompressor { fn id(&self) -> &str { - RunEnd::ID.as_ref() + RunEndEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -27,7 +27,7 @@ impl EncodingCompressor for RunEndCompressor { } fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { - if !array.is_encoding(Primitive::ID) { + if !array.is_encoding(PrimitiveEncoding::ID) { return None; } diff --git a/vortex-sampling-compressor/src/compressors/runend_bool.rs b/vortex-sampling-compressor/src/compressors/runend_bool.rs index f3675e7e12..bc1fef4d8e 100644 --- a/vortex-sampling-compressor/src/compressors/runend_bool.rs +++ b/vortex-sampling-compressor/src/compressors/runend_bool.rs @@ -1,11 +1,11 @@ use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{Bool, PrimitiveArray}; -use vortex_array::encoding::EncodingRef; +use vortex_array::array::{BoolEncoding, PrimitiveArray}; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics as _; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData, IntoArrayVariant}; +use vortex_array::{ArrayData, IntoArrayData, IntoArrayVariant}; use vortex_error::VortexResult; use vortex_runend_bool::compress::runend_bool_encode_slice; -use vortex_runend_bool::{RunEndBool, RunEndBoolArray, RunEndBoolEncoding}; +use vortex_runend_bool::{RunEndBoolArray, RunEndBoolEncoding}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; use crate::{constants, SamplingCompressor}; @@ -15,7 +15,7 @@ pub struct RunEndBoolCompressor; impl EncodingCompressor for RunEndBoolCompressor { fn id(&self) -> &str { - RunEndBool::ID.as_ref() + RunEndBoolEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -24,7 +24,7 @@ impl EncodingCompressor for RunEndBoolCompressor { fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { // Only support bool arrays - if !array.is_encoding(Bool::ID) { + if !array.is_encoding(BoolEncoding::ID) { return None; } diff --git a/vortex-sampling-compressor/src/compressors/sparse.rs b/vortex-sampling-compressor/src/compressors/sparse.rs index 1181468a98..b482b1231f 100644 --- a/vortex-sampling-compressor/src/compressors/sparse.rs +++ b/vortex-sampling-compressor/src/compressors/sparse.rs @@ -1,8 +1,8 @@ use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{Sparse, SparseArray, SparseEncoding}; -use vortex_array::encoding::EncodingRef; +use vortex_array::array::{SparseArray, SparseEncoding}; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayData, ArrayDef, ArrayLen, IntoArrayData}; +use vortex_array::{ArrayData, ArrayLen, IntoArrayData}; use vortex_error::VortexResult; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; @@ -13,7 +13,7 @@ pub struct SparseCompressor; impl EncodingCompressor for SparseCompressor { fn id(&self) -> &str { - Sparse::ID.as_ref() + SparseEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -21,7 +21,7 @@ impl EncodingCompressor for SparseCompressor { } fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { - array.is_encoding(Sparse::ID).then_some(self) + array.is_encoding(SparseEncoding::ID).then_some(self) } fn compress<'a>( diff --git a/vortex-sampling-compressor/src/compressors/struct_.rs b/vortex-sampling-compressor/src/compressors/struct_.rs index d6a650ade3..454943594f 100644 --- a/vortex-sampling-compressor/src/compressors/struct_.rs +++ b/vortex-sampling-compressor/src/compressors/struct_.rs @@ -1,11 +1,11 @@ use itertools::Itertools; use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{Struct, StructArray, StructEncoding}; +use vortex_array::array::{StructArray, StructEncoding}; use vortex_array::compress::compute_precompression_stats; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; use vortex_array::variants::StructArrayTrait; -use vortex_array::{ArrayDType, ArrayData, ArrayDef, ArrayLen, IntoArrayData}; +use vortex_array::{ArrayDType, ArrayData, ArrayLen, IntoArrayData}; use vortex_dtype::DType; use vortex_error::VortexResult; @@ -17,7 +17,7 @@ pub struct StructCompressor; impl EncodingCompressor for StructCompressor { fn id(&self) -> &str { - Struct::ID.as_ref() + StructEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -25,7 +25,8 @@ impl EncodingCompressor for StructCompressor { } fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { - let is_struct = matches!(array.dtype(), DType::Struct(..)) && array.is_encoding(Struct::ID); + let is_struct = + matches!(array.dtype(), DType::Struct(..)) && array.is_encoding(StructEncoding::ID); is_struct.then_some(self) } diff --git a/vortex-sampling-compressor/src/compressors/varbin.rs b/vortex-sampling-compressor/src/compressors/varbin.rs index bff2b40564..984f08e0b5 100644 --- a/vortex-sampling-compressor/src/compressors/varbin.rs +++ b/vortex-sampling-compressor/src/compressors/varbin.rs @@ -1,8 +1,8 @@ use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{VarBin, VarBinArray, VarBinEncoding}; -use vortex_array::encoding::EncodingRef; +use vortex_array::array::{VarBinArray, VarBinEncoding}; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::ArrayStatistics; -use vortex_array::{ArrayDType, ArrayData, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayDType, ArrayData, IntoArrayData}; use vortex_error::VortexResult; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; @@ -13,7 +13,7 @@ pub struct VarBinCompressor; impl EncodingCompressor for VarBinCompressor { fn id(&self) -> &str { - VarBin::ID.as_ref() + VarBinEncoding::ID.as_ref() } fn cost(&self) -> u8 { @@ -21,7 +21,7 @@ impl EncodingCompressor for VarBinCompressor { } fn can_compress(&self, array: &ArrayData) -> Option<&dyn EncodingCompressor> { - array.is_encoding(VarBin::ID).then_some(self) + array.is_encoding(VarBinEncoding::ID).then_some(self) } fn compress<'a>( diff --git a/vortex-sampling-compressor/src/compressors/zigzag.rs b/vortex-sampling-compressor/src/compressors/zigzag.rs index df5e656c76..b5b3e0759c 100644 --- a/vortex-sampling-compressor/src/compressors/zigzag.rs +++ b/vortex-sampling-compressor/src/compressors/zigzag.rs @@ -1,11 +1,11 @@ use vortex_array::aliases::hash_set::HashSet; use vortex_array::array::PrimitiveArray; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::stats::{ArrayStatistics, Stat}; use vortex_array::variants::PrimitiveArrayTrait; -use vortex_array::{ArrayData, ArrayDef, IntoArrayData}; +use vortex_array::{ArrayData, IntoArrayData}; use vortex_error::VortexResult; -use vortex_zigzag::{zigzag_encode, ZigZag, ZigZagArray, ZigZagEncoding}; +use vortex_zigzag::{zigzag_encode, ZigZagArray, ZigZagEncoding}; use crate::compressors::{CompressedArray, CompressionTree, EncodingCompressor}; use crate::{constants, SamplingCompressor}; @@ -15,7 +15,7 @@ pub struct ZigZagCompressor; impl EncodingCompressor for ZigZagCompressor { fn id(&self) -> &str { - ZigZag::ID.as_ref() + ZigZagEncoding::ID.as_ref() } fn cost(&self) -> u8 { diff --git a/vortex-sampling-compressor/src/sampling_compressor.rs b/vortex-sampling-compressor/src/sampling_compressor.rs index 023ae501a1..3e9ba6071e 100644 --- a/vortex-sampling-compressor/src/sampling_compressor.rs +++ b/vortex-sampling-compressor/src/sampling_compressor.rs @@ -5,15 +5,15 @@ use log::{debug, info, warn}; use rand::rngs::StdRng; use rand::SeedableRng as _; use vortex_array::aliases::hash_set::HashSet; -use vortex_array::array::{ChunkedArray, Constant}; +use vortex_array::array::{ChunkedArray, ConstantEncoding}; use vortex_array::compress::{ check_dtype_unchanged, check_statistics_unchanged, check_validity_unchanged, CompressionStrategy, }; use vortex_array::compute::slice; -use vortex_array::encoding::EncodingRef; +use vortex_array::encoding::{Encoding, EncodingRef}; use vortex_array::validity::Validity; -use vortex_array::{ArrayDType, ArrayData, ArrayDef, IntoCanonical}; +use vortex_array::{ArrayDType, ArrayData, IntoCanonical}; use vortex_error::{VortexExpect as _, VortexResult}; use super::compressors::chunked::DEFAULT_CHUNKED_COMPRESSOR; @@ -170,7 +170,7 @@ impl<'a> SamplingCompressor<'a> { pub(crate) fn compress_array(&self, array: &ArrayData) -> VortexResult> { let mut rng = StdRng::seed_from_u64(self.options.rng_seed); - if array.is_encoding(Constant::ID) { + if array.is_encoding(ConstantEncoding::ID) { // Not much better we can do than constant! return Ok(CompressedArray::uncompressed(array.clone())); } diff --git a/vortex-sampling-compressor/tests/smoketest.rs b/vortex-sampling-compressor/tests/smoketest.rs index 0b6632e476..db626ed5c6 100644 --- a/vortex-sampling-compressor/tests/smoketest.rs +++ b/vortex-sampling-compressor/tests/smoketest.rs @@ -11,15 +11,15 @@ use vortex_sampling_compressor::{CompressConfig, SamplingCompressor}; #[cfg(test)] mod tests { - use vortex_array::array::{Bool, BooleanBuffer, ChunkedArray, VarBin}; + use vortex_array::array::{BoolEncoding, BooleanBuffer, ChunkedArray, VarBinEncoding}; + use vortex_array::encoding::Encoding; use vortex_array::stats::{ArrayStatistics, Stat}; use vortex_array::variants::StructArrayTrait; - use vortex_array::ArrayDef; use vortex_datetime_dtype::TimeUnit; - use vortex_datetime_parts::DateTimeParts; - use vortex_dict::Dict; - use vortex_fastlanes::FoR; - use vortex_fsst::FSST; + use vortex_datetime_parts::DateTimePartsEncoding; + use vortex_dict::DictEncoding; + use vortex_fastlanes::FoREncoding; + use vortex_fsst::FSSTEncoding; use vortex_sampling_compressor::ALL_COMPRESSORS; use vortex_scalar::Scalar; @@ -122,7 +122,7 @@ mod tests { .unwrap(); println!("prim_col num chunks: {}", prim_col.nchunks()); for chunk in prim_col.chunks() { - assert_eq!(chunk.encoding().id(), FoR::ID); + assert_eq!(chunk.encoding().id(), FoREncoding::ID); assert_eq!( chunk.statistics().get(Stat::UncompressedSizeInBytes), Some(Scalar::from((chunk.len() * 8) as u64)) @@ -135,7 +135,7 @@ mod tests { .try_into() .unwrap(); for chunk in bool_col.chunks() { - assert_eq!(chunk.encoding().id(), Bool::ID); + assert_eq!(chunk.encoding().id(), BoolEncoding::ID); assert_eq!( chunk.statistics().get(Stat::UncompressedSizeInBytes), Some(Scalar::from(chunk.len().div_ceil(8) as u64)) @@ -148,7 +148,10 @@ mod tests { .try_into() .unwrap(); for chunk in varbin_col.chunks() { - assert!(chunk.encoding().id() == Dict::ID || chunk.encoding().id() == FSST::ID); + assert!( + chunk.encoding().id() == DictEncoding::ID + || chunk.encoding().id() == FSSTEncoding::ID + ); assert_eq!( chunk.statistics().get(Stat::UncompressedSizeInBytes), Some(Scalar::from(1392640u64)) @@ -161,7 +164,7 @@ mod tests { .try_into() .unwrap(); for chunk in binary_col.chunks() { - assert_eq!(chunk.encoding().id(), VarBin::ID); + assert_eq!(chunk.encoding().id(), VarBinEncoding::ID); assert_eq!( chunk.statistics().get(Stat::UncompressedSizeInBytes), Some(Scalar::from(134357000u64)) @@ -174,7 +177,7 @@ mod tests { .try_into() .unwrap(); for chunk in timestamp_col.chunks() { - assert_eq!(chunk.encoding().id(), DateTimeParts::ID); + assert_eq!(chunk.encoding().id(), DateTimePartsEncoding::ID); assert_eq!( chunk.statistics().get(Stat::UncompressedSizeInBytes), Some((chunk.len() * 8).into())