@@ -4,6 +4,7 @@
 use vortex_array::ArrayRef;
 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::PrimitiveArray;
 use vortex_array::arrays::primitive::PrimitiveArrayExt;
@@ -23,11 +24,7 @@ pub fn compress_patches(patches: Patches, ctx: &mut ExecutionCtx) -> VortexResul
 
     // Check if the values are constant.
     let values = patches.values();
-    let values = if values
-        .statistics()
-        .compute_is_constant(ctx)
-        .unwrap_or_default()
-    {
+    let values = if is_constant(values, ctx).unwrap_or_default() {
         ConstantArray::new(values.execute_scalar(0, ctx)?, values.len()).into_array()
     } else {
         values.clone()
 
@@ -16,7 +16,6 @@ use vortex_array::dtype::PType;
 use vortex_array::dtype::half::f16;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_err;
 use vortex_error::vortex_panic;
 use vortex_mask::AllOr;
 use vortex_utils::aliases::hash_set::HashSet;
@@ -196,10 +195,7 @@ where
         });
     }
 
-    let null_count = array
-        .statistics()
-        .compute_null_count(ctx)
-        .ok_or_else(|| vortex_err!("Failed to compute null_count"))?;
+    let null_count = array.invalid_count(ctx)?;
     let value_count = array.len() - null_count;
 
     // Keep a HashMap of T, then convert the keys into PValue afterward since value is
 
@@ -8,10 +8,11 @@ use std::hash::Hash;
 use num_traits::PrimInt;
 use rustc_hash::FxBuildHasher;
 use vortex_array::ExecutionCtx;
+use vortex_array::aggregate_fn::NumericalAggregateOpts;
+use vortex_array::aggregate_fn::fns::min_max::min_max;
 use vortex_array::arrays::PrimitiveArray;
 use vortex_array::arrays::primitive::NativeValue;
 use vortex_array::dtype::IntegerPType;
-use vortex_array::expr::stats::Stat;
 use vortex_array::match_each_integer_ptype;
 use vortex_array::scalar::PValue;
 use vortex_array::scalar::Scalar;
@@ -363,16 +364,10 @@ where
     let null_count = validity.false_count();
     let value_count = validity.true_count();
 
-    let array_ref = array.as_ref();
-    let min = array_ref
-        .statistics()
-        .compute_as::<T>(Stat::Min, ctx)
-        .vortex_expect("min should be computed");
-
-    let max = array_ref
-        .statistics()
-        .compute_as::<T>(Stat::Max, ctx)
-        .vortex_expect("max should be computed");
+    let extrema = min_max(array.as_ref(), ctx, NumericalAggregateOpts::skip_nans())?
+        .vortex_expect("nonempty integer array with valid values has extrema");
+    let min = T::try_from(&extrema.min)?;
+    let max = T::try_from(&extrema.max)?;
 
     // Initialize loop state.
     let head_idx = validity
 
@@ -7,7 +7,6 @@ use vortex_array::ExecutionCtx;
 use vortex_array::arrays::VarBinViewArray;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
-use vortex_error::vortex_err;
 use vortex_utils::aliases::hash_set::HashSet;
 
 use super::GenerateStatsOptions;
@@ -50,10 +49,7 @@ impl StringStats {
         opts: GenerateStatsOptions,
         ctx: &mut ExecutionCtx,
     ) -> VortexResult<Self> {
-        let null_count = input
-            .statistics()
-            .compute_null_count(ctx)
-            .ok_or_else(|| vortex_err!("Failed to compute null_count"))?;
+        let null_count = input.invalid_count(ctx)?;
         let value_count = input.len() - null_count;
         let estimated_distinct_count = opts
             .count_distinct_values
 
@@ -213,18 +213,16 @@ fn render_array(app: &AppState, area: Rect, buf: &mut Buffer, is_stats_table: bo
             .style(Style::new().bold())
             .height(1);
 
-        let rows = array.statistics().with_iter(|iter| {
-            iter.map(|(stat, value)| {
-                let value = value.clone().into_scalar(
-                    stat.dtype(array.dtype())
-                        .vortex_expect("stat invalid for dtype"),
-                );
-                let stat = Cell::from(Text::from(format!("{stat}")));
+        let results = array.aggregations().snapshot_results();
+        let rows = results
+            .iter()
+            .filter(|(_, value)| !value.is_absent())
+            .map(|(aggregate, value)| {
+                let aggregate = Cell::from(Text::from(format!("{aggregate}")));
                 let value = Cell::from(Text::from(format!("{value}")));
-                Row::new(vec![stat, value])
+                Row::new(vec![aggregate, value])
             })
-            .collect::<Vec<_>>()
-        });
+            .collect::<Vec<_>>();
 
         let layout = Layout::default()
             .direction(Direction::Horizontal)