Enum CompiledAggregate 

pub enum CompiledAggregate {
    CountStar {
        count: i64,
    },
    Count {
        count: i64,
    },
    CountDistinct {
        distinct_tracker: DistinctTracker,
    },
    Sum {
        state: SumState,
    },
    SumDistinct {
        state: SumState,
        distinct_tracker: DistinctTracker,
    },
    Avg {
        sum: f64,
        count: i64,
    },
    AvgDistinct {
        sum: f64,
        count: i64,
        distinct_tracker: DistinctTracker,
    },
    Min {
        min_value: Option<Value>,
    },
    Max {
        max_value: Option<Value>,
    },
    MinInteger {
        min_value: Option<i64>,
    },
    MaxInteger {
        max_value: Option<i64>,
    },
    MinFloat {
        min_value: Option<f64>,
    },
    MaxFloat {
        max_value: Option<f64>,
    },
    Dynamic(Box<dyn AggregateFunction>),
}

Compiled aggregate function - enum-based specialization for zero virtual dispatch

This enum provides specialized implementations for the most common aggregate functions (COUNT, SUM, AVG, MIN, MAX), with a Dynamic fallback for complex or rare aggregates (STRING_AGG, ARRAY_AGG, MEDIAN, etc.).

Variants

CountStar

COUNT(*) - counts all rows

Fields

count: i64

Count

COUNT(column) - counts non-NULL values

Fields

count: i64

CountDistinct

COUNT(DISTINCT column) - counts distinct non-NULL values

Fields

distinct_tracker: DistinctTracker

Sum

SUM(column) - sums numeric values

Fields

state: SumState

SumDistinct

SUM(DISTINCT column) - sums distinct numeric values

Fields

state: SumState

distinct_tracker: DistinctTracker

Avg

AVG(column) - average of numeric values

Fields

sum: f64

count: i64

AvgDistinct

AVG(DISTINCT column) - average of distinct numeric values

Fields

sum: f64

count: i64

distinct_tracker: DistinctTracker

Min

MIN(column) - minimum value (type-generic using Value comparison)

Fields

min_value: Option<Value>

Max

MAX(column) - maximum value (type-generic using Value comparison)

Fields

max_value: Option<Value>

MinInteger

MIN for integers only (faster path)

Fields

min_value: Option<i64>

MaxInteger

MAX for integers only (faster path)

Fields

max_value: Option<i64>

MinFloat

MIN for floats only (faster path)

Fields

min_value: Option<f64>

MaxFloat

MAX for floats only (faster path)

Fields

max_value: Option<f64>

Dynamic(Box<dyn AggregateFunction>)

Fallback to dynamic dispatch for complex aggregates

Implementations

impl CompiledAggregate

pub fn count_star() -> Self

Create a compiled COUNT(*) aggregate

pub fn count(distinct: bool) -> Self

Create a compiled COUNT(column) aggregate

pub fn sum(distinct: bool) -> Self

Create a compiled SUM aggregate

pub fn avg(distinct: bool) -> Self

Create a compiled AVG aggregate

pub fn min() -> Self

Create a compiled MIN aggregate (generic)

pub fn min_integer() -> Self

Create a compiled MIN aggregate for integers

pub fn min_float() -> Self

Create a compiled MIN aggregate for floats

pub fn max() -> Self

Create a compiled MAX aggregate (generic)

pub fn max_integer() -> Self

Create a compiled MAX aggregate for integers

pub fn max_float() -> Self

Create a compiled MAX aggregate for floats

pub fn dynamic(func: Box<dyn AggregateFunction>) -> Self

Create from a dynamic aggregate function (fallback)

pub fn compile( name: &str, is_count_star: bool, distinct: bool, dynamic_fallback: Option<Box<dyn AggregateFunction>>, ) -> Option<Self>

Compile from a function name and configuration

Returns a compiled aggregate for common functions, or wraps the provided dynamic function for complex/rare aggregates.

pub fn accumulate(&mut self, value: &Value)

Accumulate a value into the aggregate

This is the hot path - all code here should be as fast as possible.

pub fn accumulate_with_distinct(&mut self, value: &Value, distinct: bool)

Accumulate with DISTINCT flag (for dynamic fallback compatibility)

pub fn result(&self) -> Value

Get the result of the aggregation

pub fn reset(&mut self)

Reset the aggregate state

Trait Implementations

impl Debug for CompiledAggregate

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

Formats the value using the given formatter.