Enum FactorizedAggregate 

pub enum FactorizedAggregate {
    Count,
    CountColumn {
        column_idx: usize,
    },
    Sum {
        column_idx: usize,
    },
    Avg {
        column_idx: usize,
    },
    Min {
        column_idx: usize,
    },
    Max {
        column_idx: usize,
    },
}

Types of aggregates that can be computed on factorized data.

Variants

Count

COUNT(*) - total logical row count.

CountColumn

COUNT(column) - count non-null values in a column at deepest level.

Fields

column_idx: usize

Column index within the deepest level.

Sum

SUM(column) - sum of values at deepest level, weighted by multiplicity.

Fields

column_idx: usize

Column index within the deepest level.

Avg

AVG(column) - average of values at deepest level.

Fields

column_idx: usize

Column index within the deepest level.

Min

MIN(column) - minimum value at deepest level.

Fields

column_idx: usize

Column index within the deepest level.

Max

MAX(column) - maximum value at deepest level.

Fields

column_idx: usize

Column index within the deepest level.

Implementations

impl FactorizedAggregate

pub fn count() -> Self

Creates a COUNT(*) aggregate.

pub fn count_column(column_idx: usize) -> Self

Creates a COUNT(column) aggregate.

pub fn sum(column_idx: usize) -> Self

Creates a SUM aggregate.

pub fn avg(column_idx: usize) -> Self

Creates an AVG aggregate.

pub fn min(column_idx: usize) -> Self

Creates a MIN aggregate.

pub fn max(column_idx: usize) -> Self

Creates a MAX aggregate.

pub fn compute(&self, chunk: &FactorizedChunk) -> Value

Computes this aggregate on a factorized chunk.

Arguments

• chunk - The factorized chunk to aggregate

Returns

The aggregate result as a Value.

Note

For multiple aggregates on the same chunk, prefer using compute_with_multiplicities with precomputed multiplicities to avoid O(levels) recomputation per aggregate.

pub fn compute_with_multiplicities( &self, chunk: &FactorizedChunk, multiplicities: Option<&[usize]>, ) -> Value

Computes this aggregate using precomputed multiplicities.

This is more efficient when computing multiple aggregates on the same chunk, as multiplicities only need to be computed once.

Arguments

• chunk - The factorized chunk to aggregate
• multiplicities - Precomputed path multiplicities (from chunk.path_multiplicities_cached())

Returns

The aggregate result as a Value.

Example

let mut chunk = FactorizedChunk::empty();
let mults = chunk.path_multiplicities_cached();

// Compute multiple aggregates with O(1) cached lookup each
let count = FactorizedAggregate::count().compute_with_multiplicities(&chunk, Some(&mults));
let sum = FactorizedAggregate::sum(0).compute_with_multiplicities(&chunk, Some(&mults));

pub fn output_type(&self) -> LogicalType

Returns the output type for this aggregate.

Trait Implementations

impl Clone for FactorizedAggregate

fn clone(&self) -> FactorizedAggregate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FactorizedAggregate

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

Formats the value using the given formatter.