Struct CountGroupsAccumulator 

struct CountGroupsAccumulator {
    counts: Vec<i64>,
}

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

Unlike most other accumulators, COUNT never produces NULLs. If no non-null values are seen in any group the output is 0. Thus, this accumulator has no additional null or seen filter tracking.

Fields

counts: Vec<i64>

Count per group.

Note this is an i64 and not a u64 (or usize) because the output type of count is DataType::Int64. Thus by using i64 for the counts, the output [Int64Array] can be created without copy.

Implementations

impl CountGroupsAccumulator

pub fn new() -> Self

Trait Implementations

impl Debug for CountGroupsAccumulator

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

Formats the value using the given formatter.

impl GroupsAccumulator for CountGroupsAccumulator

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

Converts an input batch directly to a state batch

The state of COUNT is always a single Int64Array:

• 1 (for non-null, non filtered values)
• 0 (for null values)

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 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 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 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.