Hardcode constant detection into the cascading compressor

vortex-btrblocks/src/builder.rs

@@ -11,7 +11,6 @@ use crate::Scheme;
 use crate::SchemeExt;
 use crate::SchemeId;
 use crate::schemes::binary;
-use crate::schemes::bool;
 use crate::schemes::decimal;
 use crate::schemes::float;
 use crate::schemes::integer;
@@ -23,14 +22,9 @@ use crate::schemes::temporal;
 /// This list is order-sensitive: the builder preserves this order when constructing
 /// the final scheme list, so that tie-breaking is deterministic.
 pub const ALL_SCHEMES: &[&dyn Scheme] = &[
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    // Bool schemes.
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    &bool::BoolConstantScheme,
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Integer schemes.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    &integer::IntConstantScheme,
     // NOTE: FoR must precede BitPacking to avoid unnecessary patches.
     &integer::FoRScheme,
     // NOTE: ZigZag should precede BitPacking because we don't want negative numbers.
@@ -47,7 +41,6 @@ pub const ALL_SCHEMES: &[&dyn Scheme] = &[
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Float schemes.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    &float::FloatConstantScheme,
     &float::ALPScheme,
     &float::ALPRDScheme,
     &float::FloatDictScheme,
@@ -62,13 +55,11 @@ pub const ALL_SCHEMES: &[&dyn Scheme] = &[
     &string::FSSTScheme,
     #[cfg(feature = "unstable_encodings")]
     &string::OnPairScheme,
-    &string::StringConstantScheme,
     &string::NullDominatedSparseScheme,
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Binary schemes.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     &binary::BinaryDictScheme,
-    &binary::BinaryConstantScheme,
     // Decimal schemes.
     &decimal::DecimalScheme,
     // Temporal schemes.

vortex-btrblocks/src/schemes/binary/mod.rs

@@ -9,7 +9,6 @@ mod zstd;
 mod zstd_buffers;
 
 // Re-export builtin schemes from vortex-compressor.
-pub use vortex_compressor::builtins::BinaryConstantScheme;
 pub use vortex_compressor::builtins::BinaryDictScheme;
 #[cfg(feature = "zstd")]
 pub use zstd::ZstdScheme;

vortex-btrblocks/src/schemes/float/mod.rs

@@ -18,7 +18,6 @@ pub use pco::PcoScheme;
 pub use rle::FloatRLEScheme;
 pub use sparse::NullDominatedSparseScheme;
 // Re-export builtin schemes from vortex-compressor.
-pub use vortex_compressor::builtins::FloatConstantScheme;
 pub use vortex_compressor::builtins::FloatDictScheme;
 pub use vortex_compressor::stats::FloatStats;
 

vortex-btrblocks/src/schemes/integer/mod.rs

@@ -30,7 +30,6 @@ pub use runend::RunEndScheme;
 pub use sequence::SequenceScheme;
 pub use sparse::SparseScheme;
 // Re-export builtin schemes from vortex-compressor.
-pub use vortex_compressor::builtins::IntConstantScheme;
 pub use vortex_compressor::builtins::IntDictScheme;
 pub use vortex_compressor::stats::IntegerStats;
 pub use zigzag::ZigZagScheme;

vortex-btrblocks/src/schemes/mod.rs

@@ -4,7 +4,6 @@
 //! Compression scheme implementations.
 
 pub mod binary;
-pub mod bool;
 pub mod float;
 pub mod integer;
 pub mod string;

vortex-btrblocks/src/schemes/string/mod.rs

@@ -19,7 +19,6 @@ pub use fsst::FSSTScheme;
 pub use onpair::OnPairScheme;
 pub use sparse::NullDominatedSparseScheme;
 // Re-export builtin schemes from vortex-compressor.
-pub use vortex_compressor::builtins::StringConstantScheme;
 pub use vortex_compressor::builtins::StringDictScheme;
 pub use vortex_compressor::stats::StringStats;
 #[cfg(feature = "zstd")]

vortex-btrblocks/src/schemes/temporal.rs

@@ -7,8 +7,6 @@ use vortex_array::ArrayRef;
 use vortex_array::Canonical;
 use vortex_array::ExecutionCtx;
 use vortex_array::IntoArray;
-use vortex_array::aggregate_fn::fns::is_constant::is_constant;
-use vortex_array::arrays::ConstantArray;
 use vortex_array::arrays::ExtensionArray;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::TemporalArray;
@@ -79,17 +77,7 @@ impl Scheme for TemporalScheme {
     ) -> VortexResult<ArrayRef> {
         let array = data.array().clone();
         let ext_array = array.execute::<ExtensionArray>(exec_ctx)?;
-        let temporal_array = TemporalArray::try_from(ext_array.clone().into_array())?;
-
-        // Check for constant array and return early if so.
-        let is_constant = is_constant(&ext_array.clone().into_array(), exec_ctx)?;
-
-        if is_constant {
-            return Ok(
-                ConstantArray::new(ext_array.execute_scalar(0, exec_ctx)?, ext_array.len())
-                    .into_array(),
-            );
-        }
+        let temporal_array = TemporalArray::try_from(ext_array.into_array())?;
 
         let dtype = temporal_array.dtype().clone();
         let TemporalParts {