@@ -8,8 +8,8 @@ use crate::array::ArrayView;
 use crate::arrays::Constant;
 use crate::arrays::Widen;
 use crate::arrays::widen::WidenArraySlotsExt;
-use crate::arrays::widen::compute::compare::constant_fits_child;
-use crate::arrays::widen::compute::constant_values;
+use crate::arrays::widen::compute::constant_fits_values;
+use crate::arrays::widen::compute::constant_in_values_ptype;
 use crate::builtins::ArrayBuiltins;
 use crate::scalar_fn::fns::between::BetweenOptions;
 use crate::scalar_fn::fns::between::BetweenReduce;
@@ -25,11 +25,11 @@ impl BetweenReduce for Widen {
         let values = array.values();
 
         if let (Some(lower), Some(upper)) = (lower.as_constant(), upper.as_constant())
-            && constant_fits_child(lower, values.dtype()) == Some(true)
-            && constant_fits_child(upper, values.dtype()) == Some(true)
+            && constant_fits_values(lower, values.dtype()) == Some(true)
+            && constant_fits_values(upper, values.dtype()) == Some(true)
         {
-            let lower = constant_values(lower, values, array.len())?;
-            let upper = constant_values(upper, values, array.len())?;
+            let lower = constant_in_values_ptype(lower, values, array.len())?;
+            let upper = constant_in_values_ptype(upper, values, array.len())?;
             return values
                 .clone()
                 .between(lower, upper, options.clone())
 
@@ -22,7 +22,7 @@ impl CastReduce for Widen {
             return Ok(None);
         };
 
-        let cast_ptype = match cast_values_ptype(*values_ptype, *target_ptype) {
+        let cast_ptype = match values_ptype_for_cast(*values_ptype, *target_ptype) {
             Some(cast_ptype) if target_ptype.byte_width() > cast_ptype.byte_width() => cast_ptype,
             // A float target, or an integer target no wider than `cast_ptype`, goes to the values,
             // whose cast checks every value and every null.
@@ -43,7 +43,7 @@ impl CastReduce for Widen {
 /// The result has the signedness of `target`. An unsigned type fits a signed type only one width
 /// up, so unsigned values with a signed target widen one step. Signed values with an unsigned
 /// target keep their width, and the cast of the values rejects a negative value.
-fn cast_values_ptype(values: PType, target: PType) -> Option<PType> {
+fn values_ptype_for_cast(values: PType, target: PType) -> Option<PType> {
     if target.is_float() {
         return None;
     }
 
@@ -13,12 +13,11 @@ use crate::arrays::BoolArray;
 use crate::arrays::ConstantArray;
 use crate::arrays::Widen;
 use crate::arrays::widen::WidenArraySlotsExt;
-use crate::arrays::widen::compute::cast_to_ptype;
-use crate::arrays::widen::compute::constant_values;
-use crate::arrays::widen::compute::wider_values_ptype;
+use crate::arrays::widen::compute::cast_keeping_nullability;
+use crate::arrays::widen::compute::constant_fits_values;
+use crate::arrays::widen::compute::constant_in_values_ptype;
+use crate::arrays::widen::compute::ptype_holding_both_values;
 use crate::builtins::ArrayBuiltins;
-use crate::dtype::DType;
-use crate::scalar::PValue;
 use crate::scalar::Scalar;
 use crate::scalar_fn::fns::binary::CompareKernel;
 use crate::scalar_fn::fns::operators::CompareOperator;
@@ -44,54 +43,31 @@ impl CompareKernel for Widen {
             return Ok(None);
         };
         let values = lhs.values();
-        let Some(fits) = constant_fits_child(constant, values.dtype()) else {
+        let Some(fits) = constant_fits_values(constant, values.dtype()) else {
             return Ok(None);
         };
         if !fits {
             return compare_out_of_range(lhs, constant, operator, ctx).map(Some);
         }
 
-        let constant = constant_values(constant, values, lhs.len())?;
+        let constant = constant_in_values_ptype(constant, values, lhs.len())?;
 
         values.binary(constant, Operator::from(operator)).map(Some)
     }
 }
 
-/// Returns whether the range of the integer dtype `child` holds `constant`.
-///
-/// Returns `None` when `child` is not an integer dtype, when `constant` is null, and when
-/// `constant` is not an integer with the signedness of `child`.
-pub(super) fn constant_fits_child(constant: &Scalar, child: &DType) -> Option<bool> {
-    let DType::Primitive(ptype, _) = child else {
-        return None;
-    };
-    let value = constant.as_primitive_opt()?.pvalue()?;
-
-    // `PValue` compares an integer with another value through `i64` or `u64`, and it panics when
-    // the other value does not convert. So only integers of the same signedness compare here.
-    let value_ptype = value.ptype();
-    if !ptype.is_int() || !value_ptype.is_int() {
-        return None;
-    }
-    if ptype.is_signed_int() != value_ptype.is_signed_int() {
-        return None;
-    }
-
-    Some(PValue::min_value(*ptype) <= value && value <= PValue::max_value(*ptype))
-}
-
 /// Compares the values of two `Widen` arrays at the wider of the two value types.
 fn compare_narrow_values(
     lhs: ArrayView<'_, Widen>,
     rhs: ArrayView<'_, Widen>,
     operator: CompareOperator,
 ) -> VortexResult<Option<ArrayRef>> {
-    let Some(ptype) = wider_values_ptype(lhs, rhs) else {
+    let Some(ptype) = ptype_holding_both_values(lhs, rhs) else {
         return Ok(None);
     };
 
-    let lhs_values = cast_to_ptype(lhs.values(), ptype)?;
-    let rhs_values = cast_to_ptype(rhs.values(), ptype)?;
+    let lhs_values = cast_keeping_nullability(lhs.values(), ptype)?;
+    let rhs_values = cast_keeping_nullability(rhs.values(), ptype)?;
 
     lhs_values
         .binary(rhs_values, Operator::from(operator))
 
@@ -7,8 +7,8 @@ use crate::ArrayRef;
 use crate::array::ArrayView;
 use crate::arrays::Widen;
 use crate::arrays::widen::WidenArraySlotsExt;
-use crate::arrays::widen::compute::cast_to_ptype;
-use crate::arrays::widen::compute::values_ptype_holding;
+use crate::arrays::widen::compute::cast_keeping_nullability;
+use crate::arrays::widen::compute::ptype_holding_values_and_scalar;
 use crate::arrays::widen::compute::wrap_values;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
@@ -20,13 +20,13 @@ impl FillNullReduce for Widen {
         array: ArrayView<'_, Self>,
         fill_value: &Scalar,
     ) -> VortexResult<Option<ArrayRef>> {
-        let Some(ptype) = values_ptype_holding(array, fill_value)? else {
+        let Some(ptype) = ptype_holding_values_and_scalar(array, fill_value)? else {
             return Ok(None);
         };
 
         // The values widen to a type that holds the fill value. When only the logical type holds
         // it, the result is a plain array of the logical type.
-        let widened = cast_to_ptype(array.values(), ptype)?;
+        let widened = cast_keeping_nullability(array.values(), ptype)?;
         let fill_value =
             fill_value.cast(&DType::Primitive(ptype, fill_value.dtype().nullability()))?;
         let filled = widened.fill_null(fill_value)?;
 
@@ -9,6 +9,10 @@
 //! and extrema carry over from the values, and every value in a result widens exactly to the
 //! logical dtype.
 //!
+//! Most of these operations decide from dtypes and constants alone. The arithmetic kernel also
+//! needs the min and max of each operand, which come from cached statistics or from one scan of the
+//! operand. That scan is the one hidden cost in this module.
+//!
 //! [`AggregateFnSession::default`] registers the aggregate kernel, not
 //! [`initialize`](super::initialize), because the kernel session runs `initialize` on a temporary
 //! session and drops its aggregate registry.
@@ -42,6 +46,7 @@ use crate::arrays::widen::encode::smallest_integer_ptype;
 use crate::builtins::ArrayBuiltins;
 use crate::dtype::DType;
 use crate::dtype::PType;
+use crate::scalar::PValue;
 use crate::scalar::Scalar;
 
 /// Returns `values` when it has `dtype`, and a `Widen` of `dtype` over `values` otherwise.
@@ -62,7 +67,7 @@ pub(super) fn wrap_values(values: ArrayRef, dtype: DType) -> VortexResult<ArrayR
 ///
 /// A null `scalar` keeps the type of the values. Returns `None` when `scalar` does not have the
 /// logical dtype, or when the values or the logical dtype is not an integer (a decimal `Widen`).
-pub(super) fn values_ptype_holding(
+pub(super) fn ptype_holding_values_and_scalar(
     array: ArrayView<'_, Widen>,
     scalar: &Scalar,
 ) -> VortexResult<Option<PType>> {
@@ -92,16 +97,39 @@ pub(super) fn values_ptype_holding(
 }
 
 /// Casts the integer array `array` to `ptype`, keeping its nullability.
-pub(super) fn cast_to_ptype(array: &ArrayRef, ptype: PType) -> VortexResult<ArrayRef> {
+pub(super) fn cast_keeping_nullability(array: &ArrayRef, ptype: PType) -> VortexResult<ArrayRef> {
     array.cast(DType::Primitive(ptype, array.dtype().nullability()))
 }
 
+/// Returns whether the range of the integer dtype `values` holds `constant`.
+///
+/// Returns `None` when `values` is not an integer dtype, when `constant` is null, and when
+/// `constant` is not an integer with the signedness of `values`.
+pub(super) fn constant_fits_values(constant: &Scalar, values: &DType) -> Option<bool> {
+    let DType::Primitive(ptype, _) = values else {
+        return None;
+    };
+    let value = constant.as_primitive_opt()?.pvalue()?;
+
+    // `PValue` compares an integer with another value through `i64` or `u64`, and it panics when
+    // the other value does not convert. So only integers of the same signedness compare here.
+    let value_ptype = value.ptype();
+    if !ptype.is_int() || !value_ptype.is_int() {
+        return None;
+    }
+    if ptype.is_signed_int() != value_ptype.is_signed_int() {
+        return None;
+    }
+
+    Some(PValue::min_value(*ptype) <= value && value <= PValue::max_value(*ptype))
+}
+
 /// Returns the wider of the value types of two [`Widen`] arrays, or `None` when a value type is
 /// not primitive.
 ///
 /// The logical dtypes **must** have the same signedness, which a debug build asserts. The value
 /// types then have that signedness too, so the wider one holds every value of the narrower one.
-pub(super) fn wider_values_ptype(
+pub(super) fn ptype_holding_both_values(
     lhs: ArrayView<'_, Widen>,
     rhs: ArrayView<'_, Widen>,
 ) -> Option<PType> {
@@ -120,7 +148,7 @@ pub(super) fn wider_values_ptype(
 
 /// Returns `constant`, which **must** fit the type of `values`, as a constant array of that type
 /// with the nullability of `constant`.
-pub(super) fn constant_values(
+pub(super) fn constant_in_values_ptype(
     constant: &Scalar,
     values: &ArrayRef,
     len: usize,
 
@@ -23,7 +23,7 @@ use crate::arrays::scalar_fn::ExactScalarFn;
 use crate::arrays::scalar_fn::ScalarFnArrayExt;
 use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::arrays::widen::WidenArraySlotsExt;
-use crate::arrays::widen::compute::cast_to_ptype;
+use crate::arrays::widen::compute::cast_keeping_nullability;
 use crate::arrays::widen::compute::wrap_values;
 use crate::arrays::widen::encode::integer_value;
 use crate::arrays::widen::encode::smallest_integer_ptype;
@@ -39,11 +39,17 @@ use crate::scalar_fn::fns::operators::Operator;
 /// Runs checked add, subtract, multiply and divide of a [`Widen`] with another `Widen` or a
 /// constant at the smallest integer type that holds both operands and every result.
 ///
-/// Narrow values read and write less memory. [`arithmetic_ptype`] picks the type from the extrema
-/// of the valid rows, so the type can be too wide but never too narrow. When no narrower type is
-/// known to hold the result, the operation runs at the logical type, where the checked kernel
-/// reports an overflow or a division by zero with the same error as canonical execution. Any other
-/// operand declines, so the default path widens it once.
+/// Narrow values read and write less memory. [`smallest_arithmetic_ptype`] picks the type from the
+/// extrema of the valid rows, so the type can be too wide but never too narrow. When no narrower
+/// type is known to hold the result, the operation runs at the logical type, where the checked
+/// kernel reports an overflow or a division by zero with the same error as canonical execution. Any
+/// other operand declines, so the default path widens it once.
+///
+/// **Cost:** the extrema come from statistics. [`valid_value_interval`] reads the exact cached
+/// `Min` and `Max` of each executed operand when they exist, and otherwise scans it once before the
+/// operation runs. Executing `Primitive` values returns the same array, so its cached statistics
+/// count and the result stays cached. Encoded values execute to a new array, so neither their
+/// cached statistics nor the new result carry over.
 #[derive(Debug)]
 pub(crate) struct WidenNumericKernel;
 
@@ -77,7 +83,7 @@ impl ExecuteParentKernel<Widen> for WidenNumericKernel {
             1 => binary.get_child(0),
             _ => return Ok(None),
         };
-        let other_stored = if let Some(other) = other.as_opt::<Widen>() {
+        let other_values = if let Some(other) = other.as_opt::<Widen>() {
             other.values().clone()
         } else if other.is::<Constant>() {
             other.clone()
@@ -90,33 +96,35 @@ impl ExecuteParentKernel<Widen> for WidenNumericKernel {
             return Ok(Some(Canonical::empty(dtype).into_array()));
         }
 
-        // Execute each stored operand once. `Columnar` keeps a constant constant.
-        let stored = array
+        // Execute the values of each operand once. `Columnar` keeps a constant constant.
+        let values = array
             .values()
             .clone()
             .execute::<Columnar>(ctx)?
             .into_array();
-        let other_stored = other_stored.execute::<Columnar>(ctx)?.into_array();
+        let other_values = other_values.execute::<Columnar>(ctx)?.into_array();
         let (lhs, rhs) = if child_idx == 0 {
-            (stored, other_stored)
+            (values, other_values)
         } else {
-            (other_stored, stored)
+            (other_values, values)
         };
 
         // An operand without a valid row makes every row null.
-        let (Some(lhs_bounds), Some(rhs_bounds)) =
-            (valid_bounds(&lhs, ctx)?, valid_bounds(&rhs, ctx)?)
-        else {
+        let (Some(lhs_interval), Some(rhs_interval)) = (
+            valid_value_interval(&lhs, ctx)?,
+            valid_value_interval(&rhs, ctx)?,
+        ) else {
             let null = Scalar::null(dtype.clone());
             return Ok(Some(ConstantArray::new(null, parent.len()).into_array()));
         };
 
-        let ptype = arithmetic_ptype(&lhs_bounds, &rhs_bounds, operator, *logical_ptype);
-        let lhs = cast_to_ptype(&lhs, ptype)?;
-        let rhs = cast_to_ptype(&rhs, ptype)?;
-        let values = execute_numeric(&lhs, &rhs, operator, ctx)?;
+        let ptype =
+            smallest_arithmetic_ptype(&lhs_interval, &rhs_interval, operator, *logical_ptype);
+        let lhs = cast_keeping_nullability(&lhs, ptype)?;
+        let rhs = cast_keeping_nullability(&rhs, ptype)?;
+        let result = execute_numeric(&lhs, &rhs, operator, ctx)?;
 
-        wrap_values(values, dtype.clone()).map(Some)
+        wrap_values(result, dtype.clone()).map(Some)
     }
 }
 
@@ -126,7 +134,7 @@ impl ExecuteParentKernel<Widen> for WidenNumericKernel {
 ///
 /// Null rows do not count. A cast to the narrower type can change their payloads, and the checked
 /// kernel skips them.
-fn arithmetic_ptype(
+fn smallest_arithmetic_ptype(
     lhs: &RangeInclusive<i128>,
     rhs: &RangeInclusive<i128>,
     operator: NumericOperator,
@@ -143,7 +151,10 @@ fn arithmetic_ptype(
 }
 
 /// Returns the extrema of the valid values of an integer array, or `None` when no row is valid.
-fn valid_bounds(
+///
+/// [`min_max`] reads the exact cached `Min` and `Max` statistics of `array`. Without them it scans
+/// `array` once and caches the result on it.
+fn valid_value_interval(
     array: &ArrayRef,
     ctx: &mut ExecutionCtx,
 ) -> VortexResult<Option<RangeInclusive<i128>>> {
 
@@ -13,9 +13,9 @@ use crate::arrays::scalar_fn::ExactScalarFn;
 use crate::arrays::scalar_fn::ScalarFnArrayExt;
 use crate::arrays::scalar_fn::ScalarFnArrayView;
 use crate::arrays::widen::WidenArraySlotsExt;
-use crate::arrays::widen::compute::cast_to_ptype;
-use crate::arrays::widen::compute::values_ptype_holding;
-use crate::arrays::widen::compute::wider_values_ptype;
+use crate::arrays::widen::compute::cast_keeping_nullability;
+use crate::arrays::widen::compute::ptype_holding_both_values;
+use crate::arrays::widen::compute::ptype_holding_values_and_scalar;
 use crate::arrays::widen::compute::wrap_values;
 use crate::builtins::ArrayBuiltins;
 use crate::kernel::ExecuteParentKernel;
@@ -79,21 +79,21 @@ fn zip_values(
 ) -> VortexResult<Option<ArrayRef>> {
     let values = array.values();
     let (other_values, ptype) = if let Some(other) = other.as_opt::<Widen>() {
-        let Some(ptype) = wider_values_ptype(array, other) else {
+        let Some(ptype) = ptype_holding_both_values(array, other) else {
             return Ok(None);
         };
         (other.values().clone(), ptype)
     } else if let Some(constant) = other.as_constant() {
-        let Some(ptype) = values_ptype_holding(array, constant)? else {
+        let Some(ptype) = ptype_holding_values_and_scalar(array, constant)? else {
             return Ok(None);
         };
         (other.clone(), ptype)
     } else {
         return Ok(None);
     };
 
-    let values = cast_to_ptype(values, ptype)?;
-    let other_values = cast_to_ptype(&other_values, ptype)?;
+    let values = cast_keeping_nullability(values, ptype)?;
+    let other_values = cast_keeping_nullability(&other_values, ptype)?;
 
     let zipped = match branch {
         Branch::IfTrue => mask.zip(values, other_values)?,