Enum Aggregation

#[non_exhaustive]
pub enum Aggregation<E: Entity> {
    Count(E::Column, bool),
    Sum(E::Column),
    Avg(E::Column),
    Min(E::Column),
    Max(E::Column),
    Stddev(E::Column),
    Variance(E::Column),
    JsonArrayagg(E::Column),
    JsonObjectagg(E::Column, E::Column),
}

SQL aggregate functions.

Examples

use crate::model::{Task, TaskColumn};
use zino_core::Map;
use zino_orm::{Aggregation, QueryBuilder, Schema};

let query = QueryBuilder::<Task>::new()
    .aggregate(Aggregation::Count(TaskColumn::Id, false), Some("num_tasks"))
    .aggregate(Aggregation::Sum(TaskColumn::Manhours), Some("total_manhours"))
    .aggregate(Aggregation::Avg(TaskColumn::Manhours), Some("average_manhours"))
    .and_eq(TaskColumn::Status, "Completed")
    .group_by(TaskColumn::ProjectId)
    .having_ge(Aggregation::Avg(TaskColumn::Manhours), 50)
    .order_desc("total_manhours")
    .limit(10)
    .build();
let entries = Task::aggregate::<Map>(&query).await?;

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Count(E::Column, bool)

The COUNT function with the DISTINCT modifier.

Sum(E::Column)

The SUM function.

Avg(E::Column)

The AVG function.

Min(E::Column)

The MIN function.

Max(E::Column)

The MAX function.

Stddev(E::Column)

The STDDEV function.

Variance(E::Column)

The VARIANCE function.

JsonArrayagg(E::Column)

The JSON_ARRAYAGG function.

JsonObjectagg(E::Column, E::Column)

The JSON_OBJECTAGG function.

Trait Implementations

impl<E: Clone + Entity> Clone for Aggregation<E>

where E::Column: Clone,

fn clone(&self) -> Aggregation<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Entity> Debug for Aggregation<E>

where E::Column: Debug,

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

Formats the value using the given formatter.

impl<E: Copy + Entity> Copy for Aggregation<E>

where E::Column: Copy,