extend Stat with from_aggregate_fn_partial

Author: thorfour

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

@@ -25,6 +25,7 @@ pub use stat_bound::*;
 
 use crate::aggregate_fn;
 use crate::aggregate_fn::AggregateFnRef;
+use crate::aggregate_fn::AggregateFnSatisfaction;
 use crate::aggregate_fn::AggregateFnVTable;
 use crate::aggregate_fn::AggregateFnVTableExt;
 use crate::aggregate_fn::EmptyOptions;
@@ -239,6 +240,18 @@ impl Stat {
         None
     }
 
+    pub fn from_aggregate_fn_partial(
+        aggregate_fn: &AggregateFnRef,
+    ) -> Option<(Self, AggregateFnSatisfaction)> {
+        Self::all().find_map(|stat| {
+            let requested = stat.aggregate_fn()?;
+            match aggregate_fn.can_satisfy(&requested) {
+                AggregateFnSatisfaction::No => None,
+                satisfaction => Some((stat, satisfaction)),
+            }
+        })
+    }
+
     pub fn name(&self) -> &str {
         match self {
             Self::IsConstant => "is_constant",

vortex-layout/src/layouts/file_stats.rs

@@ -124,20 +124,13 @@ impl StatsAccumulator {
         let mut stats_set = StatsSet::default();
 
         for (aggregate_fn, accumulator) in &self.aggregates {
-            let Some(stat) = file_stat_for_aggregate_fn(aggregate_fn) else {
+            let Some((stat, satisfaction)) = Stat::from_aggregate_fn_partial(aggregate_fn) else {
                 continue;
             };
             let Some(v) = accumulator.final_scalar()?.into_value() else {
                 continue;
             };
-
-            // `BoundedMax`/`BoundedMin` (this module's own default variable-length aggregates)
-            // can never exactly satisfy a request for the plain `Max`/`Min` they stand in for, so
-            // their result is always recorded as an approximate bound.
-            let requested = stat
-                .aggregate_fn()
-                .vortex_expect("a stat resolved from an aggregate fn has its own aggregate fn");
-            let precision = if aggregate_fn.can_satisfy(&requested).is_exact() {
+            let precision = if satisfaction.is_exact() {
                 Precision::exact(v)
             } else {
                 Precision::inexact(v)
@@ -187,21 +180,6 @@ fn default_max_variable_length_statistics_size() -> NonZeroUsize {
     unsafe { NonZeroUsize::new_unchecked(64) }
 }
 
-/// Maps `aggregate_fn` to the legacy [`Stat`] slot its result belongs in.
-///
-/// Unlike [`Stat::from_aggregate_fn`], this also recognizes [`BoundedMax`]/[`BoundedMin`] — this
-/// module's own default variable-length aggregates — which fill the `Max`/`Min` slots as an
-/// approximate bound rather than an exact value.
-fn file_stat_for_aggregate_fn(aggregate_fn: &AggregateFnRef) -> Option<Stat> {
-    if aggregate_fn.is::<BoundedMax>() {
-        return Some(Stat::Max);
-    }
-    if aggregate_fn.is::<BoundedMin>() {
-        return Some(Stat::Min);
-    }
-    Stat::from_aggregate_fn(aggregate_fn)
-}
-
 /// Computes the post-order sequence of `(FieldPath, DType)` entries that file-level statistics
 /// are stored against.
 ///
@@ -807,7 +785,11 @@ mod tests {
 
         let acc = FileStatsAccumulator::new(
             &dtype,
-            Some(Arc::from([agg(Stat::NullCount), agg(Stat::Min), agg(Stat::Max)])),
+            Some(Arc::from([
+                agg(Stat::NullCount),
+                agg(Stat::Min),
+                agg(Stat::Max),
+            ])),
             1024,
             &session,
             true,