Enum AggregateState 

pub enum AggregateState {
    Count(i64),
    CountDistinct(i64, HashSet<HashableValue>),
    SumInt(i64, i64),
    SumIntDistinct(i64, i64, HashSet<HashableValue>),
    SumFloat(f64, f64, i64),
    SumFloatDistinct(f64, f64, i64, HashSet<HashableValue>),
    Avg(f64, i64),
    AvgDistinct(f64, i64, HashSet<HashableValue>),
    Min(Option<Value>),
    Max(Option<Value>),
    First(Option<Value>),
    Last(Option<Value>),
    Collect(Vec<Value>),
    CollectDistinct(Vec<Value>, HashSet<HashableValue>),
    StdDev {
        count: i64,
        mean: f64,
        m2: f64,
    },
    StdDevPop {
        count: i64,
        mean: f64,
        m2: f64,
    },
    PercentileDisc {
        values: Vec<f64>,
        percentile: f64,
    },
    PercentileCont {
        values: Vec<f64>,
        percentile: f64,
    },
    GroupConcat(Vec<String>, String),
    GroupConcatDistinct(Vec<String>, String, HashSet<HashableValue>),
    Sample(Option<Value>),
    Variance {
        count: i64,
        mean: f64,
        m2: f64,
    },
    VariancePop {
        count: i64,
        mean: f64,
        m2: f64,
    },
    Bivariate {
        kind: AggregateFunction,
        count: i64,
        mean_x: f64,
        mean_y: f64,
        m2_x: f64,
        m2_y: f64,
        c_xy: f64,
    },
    Frozen(Value),
}

State for a single aggregation computation.

Used by both the pull-based HashAggregateOperator and the push-based AggregatePushOperator. Supports all AggregateFunction variants including Welford’s algorithm for online statistics, Kahan summation, distinct tracking, and bivariate regression functions.

Variants

Count(i64)

Count state.

CountDistinct(i64, HashSet<HashableValue>)

Count distinct state (count, seen values).

SumInt(i64, i64)

Sum state (integer sum, count of values added).

SumIntDistinct(i64, i64, HashSet<HashableValue>)

Sum distinct state (integer sum, count, seen values).

SumFloat(f64, f64, i64)

Sum state (float sum, count of values added).

SumFloatDistinct(f64, f64, i64, HashSet<HashableValue>)

Sum distinct state (float sum, compensation, count, seen values).

Avg(f64, i64)

Average state (sum, count).

AvgDistinct(f64, i64, HashSet<HashableValue>)

Average distinct state (sum, count, seen values).

Min(Option<Value>)

Min state.

Max(Option<Value>)

Max state.

First(Option<Value>)

First state.

Last(Option<Value>)

Last state.

Collect(Vec<Value>)

Collect state.

CollectDistinct(Vec<Value>, HashSet<HashableValue>)

Collect distinct state (values, seen).

StdDev

Sample standard deviation state using Welford’s algorithm (count, mean, M2).

Fields

count: i64

mean: f64

m2: f64

StdDevPop

Population standard deviation state using Welford’s algorithm (count, mean, M2).

Fields

count: i64

mean: f64

m2: f64

PercentileDisc

Discrete percentile state (values, percentile).

Fields

values: Vec<f64>

percentile: f64

PercentileCont

Continuous percentile state (values, percentile).

Fields

values: Vec<f64>

percentile: f64

GroupConcat(Vec<String>, String)

GROUP_CONCAT / LISTAGG state (collected string values, separator).

GroupConcatDistinct(Vec<String>, String, HashSet<HashableValue>)

GROUP_CONCAT / LISTAGG distinct state (collected string values, separator, seen).

Sample(Option<Value>)

SAMPLE state (first non-null value encountered).

Variance

Sample variance state using Welford’s algorithm (count, mean, M2).

Fields

count: i64

mean: f64

m2: f64

VariancePop

Population variance state using Welford’s algorithm (count, mean, M2).

Fields

count: i64

mean: f64

m2: f64

Bivariate

Two-variable online statistics (Welford generalization for covariance/regression).

Fields

kind: AggregateFunction

Which binary set function this state will finalize to.

count: i64

mean_x: f64

mean_y: f64

m2_x: f64

m2_y: f64

c_xy: f64

Frozen(Value)

Immutable finalized value restored from spill. Ignores further updates so that reloaded groups that were serialized via the FINALIZED fallback do not silently corrupt their result when more rows arrive.

Implementations

impl AggregateState

pub fn new( function: AggregateFunction, distinct: bool, percentile: Option<f64>, separator: Option<&str>, ) -> Self

Creates initial state for an aggregation function.

pub fn update(&mut self, value: Option<Value>)

Updates the state with a new value.

For COUNT(*), pass None to count all rows. For column-specific aggregates, pass Some(value) (nulls are skipped by most functions).

pub fn update_bivariate(&mut self, y_val: Option<Value>, x_val: Option<Value>)

Updates a bivariate (two-variable) aggregate state with a pair of values.

Uses the two-variable Welford online algorithm for numerically stable computation of covariance and related statistics. Skips the update if either value is null.

pub fn finalize(&self) -> Value

Finalizes the state and returns the result value.

Trait Implementations

impl Clone for AggregateState

fn clone(&self) -> AggregateState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AggregateState

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

Formats the value using the given formatter.