Struct AggregateSpec 

pub struct AggregateSpec {
    pub op: String,
    pub column: Option<String>,
    pub alias: String,
    pub group_by: Vec<String>,
}

What to reduce, how, and what to call the result.

Conditions are not here. Narrow the source vista first, then aggregate it — the order SQL uses, where the filter belongs to the inner query and the aggregate selects from the result. Narrowing already reports its own failure (add_condition_eq returns Err on a driver that can’t express a term), so a caller knows to fall back before it asks for a reduction, and no driver is ever handed a filter it will silently ignore.

Fields

op: String

The reduction: count, sum, avg, min, max, distinct, or whatever else a driver understands. A driver that doesn’t recognise the name answers None.

column: Option<String>

Column being reduced. None for reductions over whole rows (count).

alias: String

Column name the result is published under — the single column of a scalar aggregate’s single row.

group_by: Vec<String>

Group keys. Empty means one row out; otherwise one row per distinct combination, carrying the key columns alongside alias.

Implementations

impl AggregateSpec

pub fn new(op: impl Into<String>, alias: impl Into<String>) -> Self

A scalar reduction over whole rows, e.g. count.

pub fn column(self, column: impl Into<String>) -> Self

Reduce column rather than whole rows.

pub fn group_by(self, column: impl Into<String>) -> Self

Emit one row per distinct value of column.

pub fn cache_key(&self, source_key: &str) -> String

A stable, unique name for the set this spec derives from a source.

source_key identifies the source as narrowed — pass Vista::index_key, which already renders a vista’s conditions and sort in a canonical, order-independent form. That is what keeps two differently-filtered aggregates apart without this type knowing anything about conditions.

Two things depend on the result. A derived Dio caches under it, so it must not collide with the source or with a differently-shaped aggregate over the same source. And the same question asked twice must produce the same key, so a page showing one number in two places shares one engine instead of computing it twice.

# separates a source from its derivation: it has no other meaning here (dots are column paths, / already separates datasource from table), and it sorts each derived table next to its origin in a cache directory.

let spec = AggregateSpec::new("sum", "bytes").column("Size");
assert_eq!(spec.cache_key("events|c:Event=opened|s:"),
           "events|c:Event=opened|s:#sum(Size)");

Trait Implementations

impl Clone for AggregateSpec

fn clone(&self) -> AggregateSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AggregateSpec

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

Formats the value using the given formatter.

impl PartialEq for AggregateSpec

fn eq(&self, other: &AggregateSpec) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for AggregateSpec