Remove legacy stat expression hooks

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

Author: gatesn

vortex-array/src/expr/expression.rs

@@ -15,9 +15,7 @@ use vortex_error::vortex_ensure;
 use vortex_session::VortexSession;
 
 use crate::dtype::DType;
-use crate::expr::StatsCatalog;
 use crate::expr::display::DisplayTreeExpr;
-use crate::expr::stats::Stat;
 use crate::scalar_fn::ScalarFnRef;
 use crate::scalar_fn::fns::root::Root;
 
@@ -142,28 +140,6 @@ impl Expression {
         crate::stats::rewrite::StatsRewriteCtx::new(session, scope).satisfy(self)
     }
 
-    /// Returns an expression representing the zoned statistic for the given stat, if available.
-    ///
-    /// The [`StatsCatalog`] returns expressions that can be evaluated using the zone map as a
-    /// scope. Expressions can implement this function to propagate such statistics through the
-    /// expression tree. For example, the `a + 10` expression could propagate `min: min(a) + 10`.
-    ///
-    /// NOTE(gatesn): we currently cannot represent statistics over nested fields. Please file an
-    /// issue to discuss a solution to this.
-    pub fn stat_expression(&self, stat: Stat, catalog: &dyn StatsCatalog) -> Option<Expression> {
-        self.scalar_fn().stat_expression(self, stat, catalog)
-    }
-
-    /// Returns an expression representing the zoned maximum statistic, if available.
-    pub fn stat_min(&self, catalog: &dyn StatsCatalog) -> Option<Expression> {
-        self.stat_expression(Stat::Min, catalog)
-    }
-
-    /// Returns an expression representing the zoned maximum statistic, if available.
-    pub fn stat_max(&self, catalog: &dyn StatsCatalog) -> Option<Expression> {
-        self.stat_expression(Stat::Max, catalog)
-    }
-
     /// Format the expression as a compact string.
     ///
     /// Since this is a recursive formatter, it is exposed on the public Expression type.

vortex-array/src/expr/mod.rs

@@ -42,7 +42,6 @@ pub mod traversal;
 pub use analysis::*;
 pub use expression::*;
 pub use exprs::*;
-pub use pruning::StatsCatalog;
 
 pub trait VortexExprExt {
     /// Accumulate all field references from this expression and its children in a set

vortex-array/src/expr/pruning/mod.rs

@@ -8,20 +8,3 @@ pub use pruning_expr::RequiredStats;
 pub use pruning_expr::checked_pruning_expr;
 pub use pruning_expr::field_path_stat_field_name;
 pub use relation::Relation;
-
-use crate::dtype::FieldPath;
-use crate::expr::Expression;
-use crate::expr::stats::Stat;
-
-/// A catalog of available stats that are associated with field paths.
-pub trait StatsCatalog {
-    /// Given a field path and statistic, return an expression that when evaluated over the catalog
-    /// will return that stat for the referenced field.
-    ///
-    /// This is likely to be a column expression, or a literal.
-    ///
-    /// Returns `None` if the stat is not available for the field path.
-    fn stats_ref(&self, _field_path: &FieldPath, _stat: Stat) -> Option<Expression> {
-        None
-    }
-}

vortex-array/src/scalar_fn/erased.rs

@@ -20,8 +20,6 @@ use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::dtype::DType;
 use crate::expr::Expression;
-use crate::expr::StatsCatalog;
-use crate::expr::stats::Stat;
 use crate::scalar_fn::EmptyOptions;
 use crate::scalar_fn::ExecutionArgs;
 use crate::scalar_fn::ReduceCtx;
@@ -180,16 +178,6 @@ impl ScalarFnRef {
     pub(crate) fn simplify_untyped(&self, expr: &Expression) -> VortexResult<Option<Expression>> {
         self.0.simplify_untyped(expr)
     }
-
-    /// Compute stat expression.
-    pub(crate) fn stat_expression(
-        &self,
-        expr: &Expression,
-        stat: Stat,
-        catalog: &dyn StatsCatalog,
-    ) -> Option<Expression> {
-        self.0.stat_expression(expr, stat, catalog)
-    }
 }
 
 impl Debug for ScalarFnRef {

vortex-array/src/scalar_fn/fns/cast/mod.rs

@@ -32,11 +32,8 @@ use crate::arrays::VarBinView;
 use crate::arrays::struct_::compute::cast::struct_cast;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
-use crate::expr::StatsCatalog;
-use crate::expr::cast;
 use crate::expr::expression::Expression;
 use crate::expr::lit;
-use crate::expr::stats::Stat;
 use crate::scalar_fn::Arity;
 use crate::scalar_fn::ChildName;
 use crate::scalar_fn::ExecutionArgs;
@@ -152,39 +149,6 @@ impl ScalarFnVTable for Cast {
         Ok(None)
     }
 
-    fn stat_expression(
-        &self,
-        dtype: &DType,
-        expr: &Expression,
-        stat: Stat,
-        catalog: &dyn StatsCatalog,
-    ) -> Option<Expression> {
-        match stat {
-            Stat::IsConstant
-            | Stat::IsSorted
-            | Stat::IsStrictSorted
-            | Stat::NaNCount
-            | Stat::Sum
-            | Stat::UncompressedSizeInBytes => expr.child(0).stat_expression(stat, catalog),
-            Stat::Max | Stat::Min => {
-                // We cast min/max to the new type
-                expr.child(0)
-                    .stat_expression(stat, catalog)
-                    .map(|x| cast(x, dtype.clone()))
-            }
-            Stat::NullCount => {
-                // if !expr.data().is_nullable() {
-                // NOTE(ngates): we should decide on the semantics here. In theory, the null
-                //  count of something cast to non-nullable will be zero. But if we return
-                //  that we know this to be zero, then a pruning predicate may eliminate data
-                //  that would otherwise have caused the cast to error.
-                // return Some(lit(0u64));
-                // }
-                None
-            }
-        }
-    }
-
     fn validity(&self, dtype: &DType, expression: &Expression) -> VortexResult<Option<Expression>> {
         Ok(Some(if dtype.is_nullable() {
             expression.child(0).validity()?

vortex-array/src/scalar_fn/fns/get_item.rs

@@ -18,12 +18,9 @@ use crate::builtins::ArrayBuiltins;
 use crate::builtins::ExprBuiltins;
 use crate::dtype::DType;
 use crate::dtype::FieldName;
-use crate::dtype::FieldPath;
 use crate::dtype::Nullability;
 use crate::expr::Expression;
-use crate::expr::StatsCatalog;
 use crate::expr::lit;
-use crate::expr::stats::Stat;
 use crate::scalar_fn::Arity;
 use crate::scalar_fn::ChildName;
 use crate::scalar_fn::EmptyOptions;
@@ -188,24 +185,6 @@ impl ScalarFnVTable for GetItem {
         Ok(None)
     }
 
-    fn stat_expression(
-        &self,
-        field_name: &FieldName,
-        _expr: &Expression,
-        stat: Stat,
-        catalog: &dyn StatsCatalog,
-    ) -> Option<Expression> {
-        // TODO(ngates): I think we can do better here and support stats over nested fields.
-        //  It would be nice if delegating to our child would return a struct of statistics
-        //  matching the nested DType such that we can write:
-        //    `get_item(expr.child(0).stat_expression(...), expr.data().field_name())`
-
-        // TODO(ngates): this is a bug whereby we may return stats for a nested field of the same
-        //  name as a field in the root struct. This should be resolved with upcoming change to
-        //  falsify expressions, but for now I'm preserving the existing buggy behavior.
-        catalog.stats_ref(&FieldPath::from_name(field_name.clone()), stat)
-    }
-
     // This will apply struct nullability field. We could add a dtype??
     fn is_null_sensitive(&self, _field_name: &FieldName) -> bool {
         true

vortex-array/src/scalar_fn/fns/literal.rs

@@ -16,9 +16,6 @@ use crate::IntoArray;
 use crate::arrays::ConstantArray;
 use crate::dtype::DType;
 use crate::expr::Expression;
-use crate::expr::StatsCatalog;
-use crate::expr::stats::Stat;
-use crate::match_each_float_ptype;
 use crate::scalar::Scalar;
 use crate::scalar_fn::Arity;
 use crate::scalar_fn::ChildName;
@@ -96,50 +93,6 @@ impl ScalarFnVTable for Literal {
         Ok(ConstantArray::new(scalar.clone(), args.row_count()).into_array())
     }
 
-    fn stat_expression(
-        &self,
-        scalar: &Scalar,
-        _expr: &Expression,
-        stat: Stat,
-        _catalog: &dyn StatsCatalog,
-    ) -> Option<Expression> {
-        // NOTE(ngates): we return incorrect `1` values for counts here since we don't have
-        //  row-count information. We could resolve this in the future by introducing a `count()`
-        //  expression that evaluates to the row count of the provided scope. But since this is
-        //  only currently used for pruning, it doesn't change the outcome.
-
-        match stat {
-            Stat::Min | Stat::Max => Some(lit(scalar.clone())),
-            Stat::IsConstant => Some(lit(true)),
-            Stat::NaNCount => {
-                // The NaNCount for a non-float literal is not defined.
-                // For floating point types, the NaNCount is 1 for lit(NaN), and 0 otherwise.
-                let value = scalar.as_primitive_opt()?;
-                if !value.ptype().is_float() {
-                    return None;
-                }
-
-                match_each_float_ptype!(value.ptype(), |T| {
-                    if value.typed_value::<T>().is_some_and(|v| v.is_nan()) {
-                        Some(lit(1u64))
-                    } else {
-                        Some(lit(0u64))
-                    }
-                })
-            }
-            Stat::NullCount => {
-                if scalar.is_null() {
-                    Some(lit(1u64))
-                } else {
-                    Some(lit(0u64))
-                }
-            }
-            Stat::IsSorted | Stat::IsStrictSorted | Stat::Sum | Stat::UncompressedSizeInBytes => {
-                None
-            }
-        }
-    }
-
     fn validity(
         &self,
         scalar: &Scalar,

vortex-array/src/scalar_fn/fns/root.rs

@@ -11,10 +11,7 @@ use vortex_session::registry::CachedId;
 use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::dtype::DType;
-use crate::dtype::FieldPath;
-use crate::expr::StatsCatalog;
 use crate::expr::expression::Expression;
-use crate::expr::stats::Stat;
 use crate::scalar_fn::Arity;
 use crate::scalar_fn::ChildName;
 use crate::scalar_fn::EmptyOptions;
@@ -80,16 +77,6 @@ impl ScalarFnVTable for Root {
         vortex_bail!("Root expression is not executable")
     }
 
-    fn stat_expression(
-        &self,
-        _options: &Self::Options,
-        _expr: &Expression,
-        stat: Stat,
-        catalog: &dyn StatsCatalog,
-    ) -> Option<Expression> {
-        catalog.stats_ref(&FieldPath::root(), stat)
-    }
-
     fn is_null_sensitive(&self, _options: &Self::Options) -> bool {
         false
     }

vortex-array/src/scalar_fn/typed.rs

@@ -22,8 +22,6 @@ use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::dtype::DType;
 use crate::expr::Expression;
-use crate::expr::StatsCatalog;
-use crate::expr::stats::Stat;
 use crate::scalar_fn::Arity;
 use crate::scalar_fn::ChildName;
 use crate::scalar_fn::ExecutionArgs;
@@ -101,12 +99,6 @@ pub(super) trait DynScalarFn: 'static + Send + Sync + super::sealed::Sealed {
     ) -> VortexResult<Option<Expression>>;
     fn simplify_untyped(&self, expression: &Expression) -> VortexResult<Option<Expression>>;
     fn validity(&self, expression: &Expression) -> VortexResult<Option<Expression>>;
-    fn stat_expression(
-        &self,
-        expression: &Expression,
-        stat: Stat,
-        catalog: &dyn StatsCatalog,
-    ) -> Option<Expression>;
 
     // Options operations — self-contained
     fn options_serialize(&self) -> VortexResult<Option<Vec<u8>>>;
@@ -218,15 +210,6 @@ impl<V: ScalarFnVTable> DynScalarFn for TypedScalarFnInstance<V> {
         V::validity(&self.vtable, &self.options, expression)
     }
 
-    fn stat_expression(
-        &self,
-        expression: &Expression,
-        stat: Stat,
-        catalog: &dyn StatsCatalog,
-    ) -> Option<Expression> {
-        V::stat_expression(&self.vtable, &self.options, expression, stat, catalog)
-    }
-
     fn options_serialize(&self) -> VortexResult<Option<Vec<u8>>> {
         V::serialize(&self.vtable, &self.options)
     }

vortex-array/src/scalar_fn/vtable.rs

@@ -20,8 +20,6 @@ use crate::ArrayRef;
 use crate::ExecutionCtx;
 use crate::dtype::DType;
 use crate::expr::Expression;
-use crate::expr::StatsCatalog;
-use crate::expr::stats::Stat;
 use crate::expr::traversal::Node;
 use crate::scalar_fn::ScalarFnId;
 use crate::scalar_fn::ScalarFnRef;
@@ -179,21 +177,6 @@ pub trait ScalarFnVTable: 'static + Sized + Clone + Send + Sync {
         Ok(None)
     }
 
-    /// See [`Expression::stat_expression`].
-    fn stat_expression(
-        &self,
-        options: &Self::Options,
-        expr: &Expression,
-        stat: Stat,
-        catalog: &dyn StatsCatalog,
-    ) -> Option<Expression> {
-        _ = options;
-        _ = expr;
-        _ = stat;
-        _ = catalog;
-        None
-    }
-
     /// Returns an expression that evaluates to the validity of the result of this expression.
     ///
     /// If a validity expression cannot be constructed, returns `None` and the expression will