clicktype_query/

aggregate.rs

//! Aggregate functions for ClickHouse

use std::marker::PhantomData;
use clicktype_core::traits::{ClickHouseType, Numeric};
use crate::expr::Expression;

/// Trait for aggregate functions
pub trait AggregateFn {
    /// Input type
    type Input: ClickHouseType;
    /// Output type
    type Output: ClickHouseType;
    /// Function name in SQL
    fn name() -> &'static str;
}

/// Aggregate expression wrapper
pub struct AggregateExpr<F: AggregateFn, E: Expression> {
    inner: E,
    _fn: PhantomData<F>,
}

impl<F: AggregateFn, E: Expression> AggregateExpr<F, E> {
    pub fn new(inner: E) -> Self {
        Self {
            inner,
            _fn: PhantomData,
        }
    }
}

impl<F: AggregateFn, E: Expression> Expression for AggregateExpr<F, E> {
    type Output = F::Output;

    fn render(&self) -> String {
        format!("{}({})", F::name(), self.inner.render())
    }

    fn is_aggregate(&self) -> bool {
        true
    }
}

// === STANDARD AGGREGATE FUNCTIONS ===

/// COUNT function
pub struct Count;

impl AggregateFn for Count {
    type Input = u64;
    type Output = u64;

    fn name() -> &'static str {
        "count"
    }
}

/// SUM function
pub struct Sum<T: Numeric>(PhantomData<T>);

impl<T: Numeric> AggregateFn for Sum<T> {
    type Input = T;
    type Output = T;

    fn name() -> &'static str {
        "sum"
    }
}

/// AVG function
pub struct Avg<T: Numeric>(PhantomData<T>);

impl<T: Numeric> AggregateFn for Avg<T> {
    type Input = T;
    type Output = f64;

    fn name() -> &'static str {
        "avg"
    }
}

/// MIN function
pub struct Min<T: ClickHouseType>(PhantomData<T>);

impl<T: ClickHouseType> AggregateFn for Min<T> {
    type Input = T;
    type Output = T;

    fn name() -> &'static str {
        "min"
    }
}

/// MAX function
pub struct Max<T: ClickHouseType>(PhantomData<T>);

impl<T: ClickHouseType> AggregateFn for Max<T> {
    type Input = T;
    type Output = T;

    fn name() -> &'static str {
        "max"
    }
}

/// ANY function
pub struct Any<T: ClickHouseType>(PhantomData<T>);

impl<T: ClickHouseType> AggregateFn for Any<T> {
    type Input = T;
    type Output = T;

    fn name() -> &'static str {
        "any"
    }
}

/// ANY_LAST function
pub struct AnyLast<T: ClickHouseType>(PhantomData<T>);

impl<T: ClickHouseType> AggregateFn for AnyLast<T> {
    type Input = T;
    type Output = T;

    fn name() -> &'static str {
        "anyLast"
    }
}

// === ADVANCED CLICKHOUSE FUNCTIONS ===

/// UNIQ function (HyperLogLog approximate)
pub struct Uniq<T: ClickHouseType>(PhantomData<T>);

impl<T: ClickHouseType> AggregateFn for Uniq<T> {
    type Input = T;
    type Output = u64;

    fn name() -> &'static str {
        "uniq"
    }
}

/// UNIQ_EXACT function (exact unique count)
pub struct UniqExact<T: ClickHouseType>(PhantomData<T>);

impl<T: ClickHouseType> AggregateFn for UniqExact<T> {
    type Input = T;
    type Output = u64;

    fn name() -> &'static str {
        "uniqExact"
    }
}

/// GROUP_ARRAY function
pub struct GroupArray<T: ClickHouseType>(PhantomData<T>);

impl<T: ClickHouseType> AggregateFn for GroupArray<T> {
    type Input = T;
    type Output = Vec<T>;

    fn name() -> &'static str {
        "groupArray"
    }
}

// === ERGONOMIC API ===

/// Star expression for COUNT(*)
pub struct Star;

impl Expression for Star {
    type Output = u64;

    fn render(&self) -> String {
        "*".to_string()
    }
}

/// count(*) - count all rows
pub fn count_all() -> AggregateExpr<Count, Star> {
    AggregateExpr::new(Star)
}

/// count(expr) - count non-null values
pub fn count<E: Expression>(expr: E) -> AggregateExpr<Count, E> {
    AggregateExpr::new(expr)
}

/// sum(expr) - sum of values
pub fn sum<E: Expression>(expr: E) -> AggregateExpr<Sum<E::Output>, E>
where
    E::Output: Numeric,
{
    AggregateExpr::new(expr)
}

/// avg(expr) - average of values
pub fn avg<E: Expression>(expr: E) -> AggregateExpr<Avg<E::Output>, E>
where
    E::Output: Numeric,
{
    AggregateExpr::new(expr)
}

/// min(expr) - minimum value
pub fn min<E: Expression>(expr: E) -> AggregateExpr<Min<E::Output>, E> {
    AggregateExpr::new(expr)
}

/// max(expr) - maximum value
pub fn max<E: Expression>(expr: E) -> AggregateExpr<Max<E::Output>, E> {
    AggregateExpr::new(expr)
}

/// any(expr) - any value (non-deterministic)
pub fn any<E: Expression>(expr: E) -> AggregateExpr<Any<E::Output>, E> {
    AggregateExpr::new(expr)
}

/// anyLast(expr) - last value seen
pub fn any_last<E: Expression>(expr: E) -> AggregateExpr<AnyLast<E::Output>, E> {
    AggregateExpr::new(expr)
}

/// uniq(expr) - approximate unique count (HyperLogLog)
pub fn uniq<E: Expression>(expr: E) -> AggregateExpr<Uniq<E::Output>, E> {
    AggregateExpr::new(expr)
}

/// uniqExact(expr) - exact unique count
pub fn uniq_exact<E: Expression>(expr: E) -> AggregateExpr<UniqExact<E::Output>, E> {
    AggregateExpr::new(expr)
}

/// groupArray(expr) - collect values into array
pub fn group_array<E: Expression>(expr: E) -> AggregateExpr<GroupArray<E::Output>, E> {
    AggregateExpr::new(expr)
}

// === PARAMETRIC AGGREGATE FUNCTIONS ===

/// Quantile expression
pub struct QuantileExpr<E: Expression> {
    level: f64,
    inner: E,
}

impl<E: Expression> Expression for QuantileExpr<E>
where
    E::Output: Numeric,
{
    type Output = f64;

    fn render(&self) -> String {
        format!("quantile({})({})", self.level, self.inner.render())
    }

    fn is_aggregate(&self) -> bool {
        true
    }
}

/// quantile(level)(expr) - quantile at given level
pub fn quantile<E: Expression>(level: f64, expr: E) -> QuantileExpr<E>
where
    E::Output: Numeric,
{
    QuantileExpr { level, inner: expr }
}

/// ArgMax expression
pub struct ArgMaxExpr<A: Expression, V: Expression> {
    arg: A,
    val: V,
}

impl<A: Expression, V: Expression> Expression for ArgMaxExpr<A, V> {
    type Output = A::Output;

    fn render(&self) -> String {
        format!("argMax({}, {})", self.arg.render(), self.val.render())
    }

    fn is_aggregate(&self) -> bool {
        true
    }
}

/// argMax(arg, val) - value of arg where val is maximum
pub fn arg_max<A: Expression, V: Expression>(arg: A, val: V) -> ArgMaxExpr<A, V> {
    ArgMaxExpr { arg, val }
}

/// ArgMin expression
pub struct ArgMinExpr<A: Expression, V: Expression> {
    arg: A,
    val: V,
}

impl<A: Expression, V: Expression> Expression for ArgMinExpr<A, V> {
    type Output = A::Output;

    fn render(&self) -> String {
        format!("argMin({}, {})", self.arg.render(), self.val.render())
    }

    fn is_aggregate(&self) -> bool {
        true
    }
}

/// argMin(arg, val) - value of arg where val is minimum
pub fn arg_min<A: Expression, V: Expression>(arg: A, val: V) -> ArgMinExpr<A, V> {
    ArgMinExpr { arg, val }
}

/// TopK expression
pub struct TopKExpr<const N: usize, E: Expression> {
    inner: E,
}

impl<const N: usize, E: Expression> Expression for TopKExpr<N, E> {
    type Output = Vec<E::Output>;

    fn render(&self) -> String {
        format!("topK({})({})", N, self.inner.render())
    }

    fn is_aggregate(&self) -> bool {
        true
    }
}

/// topK(N)(expr) - top N most frequent values
pub fn top_k<const N: usize, E: Expression>(expr: E) -> TopKExpr<N, E> {
    TopKExpr { inner: expr }
}

/// GroupArrayIf expression
pub struct GroupArrayIfExpr<E: Expression, C: Expression<Output = bool>> {
    inner: E,
    condition: C,
}

impl<E: Expression, C: Expression<Output = bool>> Expression for GroupArrayIfExpr<E, C> {
    type Output = Vec<E::Output>;

    fn render(&self) -> String {
        format!(
            "groupArrayIf({}, {})",
            self.inner.render(),
            self.condition.render()
        )
    }

    fn is_aggregate(&self) -> bool {
        true
    }
}

/// groupArrayIf(expr, condition) - collect values where condition is true
pub fn group_array_if<E: Expression, C: Expression<Output = bool>>(
    expr: E,
    condition: C,
) -> GroupArrayIfExpr<E, C> {
    GroupArrayIfExpr {
        inner: expr,
        condition,
    }
}