Struct OrderSensitiveArrayAggAccumulator 

pub(crate) struct OrderSensitiveArrayAggAccumulator {
    values: Vec<ScalarValue>,
    ordering_values: Vec<Vec<ScalarValue>>,
    datatypes: Vec<DataType>,
    ordering_req: LexOrdering,
    is_input_pre_ordered: bool,
    reverse: bool,
    ignore_nulls: bool,
}

Accumulator for a ARRAY_AGG(... ORDER BY ..., ...) aggregation. In a multi partition setting, partial aggregations are computed for every partition, and then their results are merged.

Fields

values: Vec<ScalarValue>

Stores entries in the ARRAY_AGG result.

ordering_values: Vec<Vec<ScalarValue>>

Stores values of ordering requirement expressions corresponding to each entry in values. This information is used when merging results from different partitions. For detailed information how merging is done, see merge_ordered_arrays.

datatypes: Vec<DataType>

Stores datatypes of expressions inside values and ordering requirement expressions.

ordering_req: LexOrdering

Stores the ordering requirement of the Accumulator.

is_input_pre_ordered: bool

Whether the input is known to be pre-ordered

reverse: bool

Whether the aggregation is running in reverse.

ignore_nulls: bool

Whether the aggregation should ignore null values.

Implementations

impl OrderSensitiveArrayAggAccumulator

pub fn try_new( datatype: &DataType, ordering_dtypes: &[DataType], ordering_req: LexOrdering, is_input_pre_ordered: bool, reverse: bool, ignore_nulls: bool, ) -> Result<Self>

Create a new order-sensitive ARRAY_AGG accumulator based on the given item data type.

fn sort(&mut self)

fn evaluate_orderings(&self) -> Result<ScalarValue>

Trait Implementations

impl Accumulator for OrderSensitiveArrayAggAccumulator

fn update_batch(&mut self, values: &[ArrayRef]) -> Result<()>

Updates the accumulator’s state from its input.

fn merge_batch(&mut self, states: &[ArrayRef]) -> Result<()>

Updates the accumulator’s state from an Array containing one or more intermediate values.

fn state(&mut self) -> Result<Vec<ScalarValue>>

Returns the intermediate state of the accumulator, consuming the intermediate state.

fn evaluate(&mut self) -> Result<ScalarValue>

Returns the final aggregate value, consuming the internal state.

fn size(&self) -> usize

Returns the allocated size required for this accumulator, in bytes, including Self.

fn retract_batch( &mut self, _values: &[Arc<dyn Array>], ) -> Result<(), DataFusionError>

Retracts (removed) an update (caused by the given inputs) to accumulator’s state.

fn supports_retract_batch(&self) -> bool

Does the accumulator support incrementally updating its value by removing values.

impl Debug for OrderSensitiveArrayAggAccumulator

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

Formats the value using the given formatter.