Struct AvgGroupsAccumulator 

struct AvgGroupsAccumulator<T, F>
where
    T: ArrowNumericType + Send,
    F: Fn(T::Native, u64) -> Result<T::Native> + Send,
{
    sum_data_type: DataType,
    return_data_type: DataType,
    counts: Vec<u64>,
    sums: Vec<T::Native>,
    null_state: NullState,
    avg_fn: F,
}

An accumulator to compute the average of [PrimitiveArray<T>]. Stores values as native types, and does overflow checking

F: Function that calculates the average value from a sum of T::Native and a total count

Fields

sum_data_type: DataType

The type of the internal sum

return_data_type: DataType

The type of the returned sum

counts: Vec<u64>

Count per group (use u64 to make UInt64Array)

sums: Vec<T::Native>

Sums per group, stored as the native type

null_state: NullState

Track nulls in the input / filters

avg_fn: F

Function that computes the final average (value / count)

Implementations

impl<T, F> AvgGroupsAccumulator<T, F>

where T: ArrowNumericType + Send, F: Fn(T::Native, u64) -> Result<T::Native> + Send,

pub fn new( sum_data_type: &DataType, return_data_type: &DataType, avg_fn: F, ) -> Self

Trait Implementations

impl<T, F> Debug for AvgGroupsAccumulator<T, F>

where T: ArrowNumericType + Send + Debug, F: Fn(T::Native, u64) -> Result<T::Native> + Send + Debug, T::Native: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, F> GroupsAccumulator for AvgGroupsAccumulator<T, F>

where T: ArrowNumericType + Send, F: Fn(T::Native, u64) -> Result<T::Native> + Send,

fn update_batch( &mut self, values: &[ArrayRef], group_indices: &[usize], opt_filter: Option<&BooleanArray>, total_num_groups: usize, ) -> Result<()>

Updates the accumulator’s state from its arguments, encoded as a vector of [ArrayRef]s.

fn evaluate(&mut self, emit_to: EmitTo) -> Result<ArrayRef>

Returns the final aggregate value for each group as a single RecordBatch, resetting the internal state.

fn state(&mut self, emit_to: EmitTo) -> Result<Vec<ArrayRef>>

Returns the intermediate aggregate state for this accumulator, used for multi-phase grouping, resetting its internal state.

fn merge_batch( &mut self, values: &[ArrayRef], group_indices: &[usize], opt_filter: Option<&BooleanArray>, total_num_groups: usize, ) -> Result<()>

Merges intermediate state (the output from [Self::state]) into this accumulator’s current state.

fn convert_to_state( &self, values: &[ArrayRef], opt_filter: Option<&BooleanArray>, ) -> Result<Vec<ArrayRef>>

Converts an input batch directly to the intermediate aggregate state.

fn supports_convert_to_state(&self) -> bool

Returns true if [Self::convert_to_state] is implemented to support intermediate aggregate state conversion.

fn size(&self) -> usize

Amount of memory used to store the state of this accumulator, in bytes.