Struct datafusion_physical_expr_common::aggregate::groups_accumulator::prim_op::PrimitiveGroupsAccumulator

pub struct PrimitiveGroupsAccumulator<T, F>
where
    T: ArrowPrimitiveType + Send,
    F: Fn(&mut T::Native, T::Native) + Send + Sync,
{ /* private fields */ }

An accumulator that implements a single operation over ArrowPrimitiveType where the accumulated state is the same as the input type (such as Sum)

F: The function to apply to two elements. The first argument is the existing value and should be updated with the second value (e.g. BitAndAssign style).

Implementations

impl<T, F> PrimitiveGroupsAccumulator<T, F>

where T: ArrowPrimitiveType + Send, F: Fn(&mut T::Native, T::Native) + Send + Sync,

pub fn new(data_type: &DataType, prim_fn: F) -> Self

pub fn with_starting_value(self, starting_value: T::Native) -> Self

Set the starting values for new groups

Trait Implementations

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

where T: ArrowPrimitiveType + Send + Debug, F: Fn(&mut T::Native, T::Native) + Send + Sync + Debug, T::Native: Debug,

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

Formats the value using the given formatter.

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

where T: ArrowPrimitiveType + Send, F: Fn(&mut T::Native, T::Native) + Send + Sync,

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 is:

• self.prim_fn for all non null, non filtered values
• null otherwise

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

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