Struct FirstPrimitiveGroupsAccumulator 

struct FirstPrimitiveGroupsAccumulator<T>
where
    T: ArrowPrimitiveType + Send,
{
    vals: Vec<T::Native>,
    orderings: Vec<Vec<ScalarValue>>,
    is_sets: BooleanBufferBuilder,
    null_builder: BooleanBufferBuilder,
    size_of_orderings: usize,
    min_of_each_group_buf: (Vec<usize>, BooleanBufferBuilder),
    ordering_req: LexOrdering,
    pick_first_in_group: bool,
    sort_options: Vec<SortOptions>,
    ignore_nulls: bool,
    data_type: DataType,
    default_orderings: Vec<ScalarValue>,
}

Fields

vals: Vec<T::Native>

orderings: Vec<Vec<ScalarValue>>

is_sets: BooleanBufferBuilder

null_builder: BooleanBufferBuilder

size_of_orderings: usize

min_of_each_group_buf: (Vec<usize>, BooleanBufferBuilder)

ordering_req: LexOrdering

pick_first_in_group: bool

sort_options: Vec<SortOptions>

ignore_nulls: bool

data_type: DataType

The output type

default_orderings: Vec<ScalarValue>

Implementations

impl<T> FirstPrimitiveGroupsAccumulator<T>

where T: ArrowPrimitiveType + Send,

fn try_new( ordering_req: LexOrdering, ignore_nulls: bool, data_type: &DataType, ordering_dtypes: &[DataType], pick_first_in_group: bool, ) -> Result<Self>

fn should_update_state( &self, group_idx: usize, new_ordering_values: &[ScalarValue], ) -> Result<bool>

fn take_orderings(&mut self, emit_to: EmitTo) -> Vec<Vec<ScalarValue>>

fn take_need( bool_buf_builder: &mut BooleanBufferBuilder, emit_to: EmitTo, ) -> BooleanBuffer

fn resize_states(&mut self, new_size: usize)

fn update_state( &mut self, group_idx: usize, orderings: &[ScalarValue], new_val: T::Native, is_null: bool, )

fn take_state( &mut self, emit_to: EmitTo, ) -> (ArrayRef, Vec<Vec<ScalarValue>>, BooleanBuffer)

fn get_filtered_min_of_each_group( &mut self, orderings: &[ArrayRef], group_indices: &[usize], opt_filter: Option<&BooleanArray>, vals: &PrimitiveArray<T>, is_set_arr: Option<&BooleanArray>, ) -> Result<Vec<(usize, usize)>>

Returns a vector of tuples (group_idx, idx_in_val) representing the index of the minimum value in orderings for each group, using lexicographical comparison. Values are filtered using opt_filter and is_set_arr if provided. TODO: rename to get_filtered_extreme_of_each_group

fn take_vals_and_null_buf(&mut self, emit_to: EmitTo) -> ArrayRef

Trait Implementations

impl<T> GroupsAccumulator for FirstPrimitiveGroupsAccumulator<T>

where T: ArrowPrimitiveType + Send,

fn update_batch( &mut self, values_and_order_cols: &[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 size(&self) -> usize

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

fn supports_convert_to_state(&self) -> bool

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

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

Converts an input batch directly to the intermediate aggregate state.