Struct FactorizedAggregateOperator 

pub struct FactorizedAggregateOperator { /* private fields */ }

An aggregate operator that works directly on factorized data.

This operator takes a LazyFactorizedChainOperator as input and computes aggregates without flattening. This is the key to achieving 10-100x speedups for aggregate queries on multi-hop traversals.

Example

// Query: MATCH (a)->(b)->(c) RETURN COUNT(*)
let expand_chain = LazyFactorizedChainOperator::new(store, scan, steps);
let agg = FactorizedAggregateOperator::new(expand_chain, vec![FactorizedAggregate::count()]);
// Returns a single row with the count, computed in O(n) instead of O(n²)

Implementations

impl FactorizedAggregateOperator

pub fn new( input: LazyFactorizedChainOperator, aggregates: Vec<FactorizedAggregate>, ) -> Self

Creates a new factorized aggregate operator.

Arguments

• input - The input operator (typically a LazyFactorizedChainOperator)
• aggregates - The aggregates to compute

Trait Implementations

impl Operator for FactorizedAggregateOperator

fn next(&mut self) -> OperatorResult

Pulls the next batch of data. Returns None when exhausted.

fn reset(&mut self)

Resets to initial state so you can iterate again.

fn name(&self) -> &'static str

Returns a name for debugging/explain output.