feat[btrblocks]: add a dynamic btr blocks compressor

vortex-btrblocks/Cargo.toml

@@ -14,6 +14,7 @@ rust-version = { workspace = true }
 version = { workspace = true }
 
 [dependencies]
+enum-iterator = { workspace = true }
 getrandom_v03 = { workspace = true }
 itertools = { workspace = true }
 num-traits = { workspace = true }
@@ -40,6 +41,7 @@ vortex-zigzag = { workspace = true }
 [dev-dependencies]
 divan = { workspace = true }
 test-with = { workspace = true }
+tracing-subscriber = { workspace = true }
 vortex-array = { workspace = true, features = ["_test-harness"] }
 
 [features]

vortex-btrblocks/benches/compress.rs

@@ -15,8 +15,7 @@ mod benchmarks {
     use vortex_array::ArrayRef;
     use vortex_array::IntoArray;
     use vortex_array::ToCanonical;
-    use vortex_btrblocks::Compressor;
-    use vortex_btrblocks::IntCompressor;
+    use vortex_btrblocks::BtrBlocksCompressor;
     use vortex_buffer::buffer_mut;
     use vortex_utils::aliases::hash_set::HashSet;
 
@@ -42,11 +41,12 @@ mod benchmarks {
     #[divan::bench]
     fn btrblocks(bencher: Bencher) {
         let array = make_clickbench_window_name().to_primitive();
+        let compressor = BtrBlocksCompressor::default();
         bencher
             .with_inputs(|| &array)
             .input_counter(|array| ItemsCount::new(array.len()))
             .input_counter(|array| BytesCount::of_many::<i32>(array.len()))
-            .bench_refs(|array| IntCompressor::compress(array, false, 3, &[]).unwrap());
+            .bench_refs(|array| compressor.compress(array.as_ref()).unwrap());
     }
 }
 

vortex-btrblocks/src/builder.rs

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+//! Builder for configuring `BtrBlocksCompressor` instances.
+
+use itertools::Itertools;
+use vortex_utils::aliases::hash_set::HashSet;
+
+use crate::BtrBlocksCompressor;
+use crate::FloatCode;
+use crate::IntCode;
+use crate::StringCode;
+use crate::compressor::float::ALL_FLOAT_SCHEMES;
+use crate::compressor::float::FloatScheme;
+use crate::compressor::integer::ALL_INT_SCHEMES;
+use crate::compressor::integer::IntegerScheme;
+use crate::compressor::string::ALL_STRING_SCHEMES;
+use crate::compressor::string::StringScheme;
+
+/// Builder for creating configured [`BtrBlocksCompressor`] instances.
+///
+/// Use this builder to configure which compression schemes are allowed for each data type.
+/// By default, all schemes are enabled.
+///
+/// # Examples
+///
+/// ```rust
+/// use vortex_btrblocks::{BtrBlocksCompressorBuilder, IntCode, FloatCode};
+///
+/// // Default compressor - all schemes allowed
+/// let compressor = BtrBlocksCompressorBuilder::default().build();
+///
+/// // Exclude specific schemes
+/// let compressor = BtrBlocksCompressorBuilder::default()
+///     .exclude_int([IntCode::Dict])
+///     .build();
+///
+/// // Exclude then re-include
+/// let compressor = BtrBlocksCompressorBuilder::default()
+///     .exclude_int([IntCode::Dict, IntCode::Rle])
+///     .include_int([IntCode::Dict])
+///     .build();
+/// ```
+#[derive(Debug, Clone)]
+pub struct BtrBlocksCompressorBuilder {
+    int_schemes: HashSet<&'static dyn IntegerScheme>,
+    float_schemes: HashSet<&'static dyn FloatScheme>,
+    string_schemes: HashSet<&'static dyn StringScheme>,
+}
+
+impl Default for BtrBlocksCompressorBuilder {
+    fn default() -> Self {
+        Self {
+            int_schemes: ALL_INT_SCHEMES.iter().copied().collect(),
+            float_schemes: ALL_FLOAT_SCHEMES.iter().copied().collect(),
+            string_schemes: ALL_STRING_SCHEMES.iter().copied().collect(),
+        }
+    }
+}
+
+impl BtrBlocksCompressorBuilder {
+    /// Excludes the specified integer compression schemes.
+    pub fn exclude_int(mut self, codes: impl IntoIterator<Item = IntCode>) -> Self {
+        let codes: HashSet<_> = codes.into_iter().collect();
+        self.int_schemes.retain(|s| !codes.contains(&s.code()));
+        self
+    }
+
+    /// Excludes the specified float compression schemes.
+    pub fn exclude_float(mut self, codes: impl IntoIterator<Item = FloatCode>) -> Self {
+        let codes: HashSet<_> = codes.into_iter().collect();
+        self.float_schemes.retain(|s| !codes.contains(&s.code()));
+        self
+    }
+
+    /// Excludes the specified string compression schemes.
+    pub fn exclude_string(mut self, codes: impl IntoIterator<Item = StringCode>) -> Self {
+        let codes: HashSet<_> = codes.into_iter().collect();
+        self.string_schemes.retain(|s| !codes.contains(&s.code()));
+        self
+    }
+
+    /// Includes the specified integer compression schemes.
+    pub fn include_int(mut self, codes: impl IntoIterator<Item = IntCode>) -> Self {
+        let codes: HashSet<_> = codes.into_iter().collect();
+        for scheme in ALL_INT_SCHEMES {
+            if codes.contains(&scheme.code()) {
+                self.int_schemes.insert(*scheme);
+            }
+        }
+        self
+    }
+
+    /// Includes the specified float compression schemes.
+    pub fn include_float(mut self, codes: impl IntoIterator<Item = FloatCode>) -> Self {
+        let codes: HashSet<_> = codes.into_iter().collect();
+        for scheme in ALL_FLOAT_SCHEMES {
+            if codes.contains(&scheme.code()) {
+                self.float_schemes.insert(*scheme);
+            }
+        }
+        self
+    }
+
+    /// Includes the specified string compression schemes.
+    pub fn include_string(mut self, codes: impl IntoIterator<Item = StringCode>) -> Self {
+        let codes: HashSet<_> = codes.into_iter().collect();
+        for scheme in ALL_STRING_SCHEMES {
+            if codes.contains(&scheme.code()) {
+                self.string_schemes.insert(*scheme);
+            }
+        }
+        self
+    }
+
+    /// Builds the configured `BtrBlocksCompressor`.
+    pub fn build(self) -> BtrBlocksCompressor {
+        BtrBlocksCompressor {
+            int_schemes: self.int_schemes.into_iter().collect_vec(),
+            float_schemes: self.float_schemes.into_iter().collect_vec(),
+            string_schemes: self.string_schemes.into_iter().collect_vec(),
+        }
+    }
+}