Function sum_array_checked

arrow-arith/src/aggregate.rs:584–616

Returns the sum of values in the array. This detects overflow and returns an `Err` for that. For an non-overflow-checking variant, use [`sum_array`] instead. Additionally returns an `Err` on run-end-encoded arrays with a provided values type parameter that is incorrect.

(
    array: A,
)

/// Additionally returns an `Err` on run-end-encoded arrays with a provided
/// values type parameter that is incorrect.
pub fn sum_array_checked<T: ArrowNumericType, A: ArrayAccessor<Item = T::Native>>(
    array: A,
) -> Result<Option<T::Native>, ArrowError> {
    match array.data_type() {
        DataType::Dictionary(_, _) => {
            let null_count = array.null_count();

            if null_count == array.len() {
                return Ok(None);
            }

            let iter = ArrayIter::new(array);
            let sum = iter
                .into_iter()
                .try_fold(T::default_value(), |accumulator, value| {
                    if let Some(value) = value {
                        accumulator.add_checked(value)
                    } else {
                        Ok(accumulator)
                    }
                })?;

            Ok(Some(sum))
        }
        DataType::RunEndEncoded(run_ends, _) => match run_ends.data_type() {
            DataType::Int16 => ree::sum_checked::<types::Int16Type, T>(&array),
            DataType::Int32 => ree::sum_checked::<types::Int32Type, T>(&array),
            DataType::Int64 => ree::sum_checked::<types::Int64Type, T>(&array),
            _ => unreachable!(),
        },
        _ => sum_checked::<T>(as_primitive_array(&array)),
    }
}

// Logic for summing run-end-encoded arrays.
mod ree {