drizzle_core/expr/

agg.rs

//! Type-safe aggregate functions.
//!
//! These functions return expressions marked as aggregates, which can be used
//! to enforce GROUP BY rules at compile time.
//!
//! # Type Safety
//!
//! - `sum`, `avg`: Require `Numeric` types (Int, `BigInt`, Float, Double)
//! - `count`: Works with any type
//! - `min`, `max`: Work with any type (ordered types in SQL)

use crate::dialect::{Dialect, DialectTypes};
use crate::sql::SQL;
use crate::traits::SQLParam;
use crate::types::{Array, Numeric};
use crate::{MySQLDialect, PostgresDialect, SQLiteDialect};
use drizzle_types::mysql::types::{
    BigInt as MyBigInt, BigIntUnsigned as MyBigIntUnsigned, Decimal as MyDecimal,
    Double as MyDouble, Float as MyFloat, Int as MyInt, IntUnsigned as MyIntUnsigned,
    MediumInt as MyMediumInt, MediumIntUnsigned as MyMediumIntUnsigned, SmallInt as MySmallInt,
    SmallIntUnsigned as MySmallIntUnsigned, TinyInt as MyTinyInt,
    TinyIntUnsigned as MyTinyIntUnsigned, Year as MyYear,
};
use drizzle_types::postgres::types::{
    Boolean as PgBoolean, Float4, Float8, Int2, Int4, Int8, Numeric as PgNumeric,
};
use drizzle_types::sqlite::types::{
    Integer as SqliteInteger, Numeric as SqliteNumeric, Real as SqliteReal,
};

use super::math::pg_double;
use super::{Agg, Expr, NonNull, Null, SQLExpr, Scalar};

// =============================================================================
// Dialect Aggregate Policy
// =============================================================================

/// Dialect-specific aggregate output mapping.
///
/// Keeps aggregate output typing in one place so all aggregate functions
/// follow the same per-dialect policy.
#[diagnostic::on_unimplemented(
    message = "no aggregate policy for `{Self}` on this dialect",
    label = "aggregate result type is not defined for this SQL type/dialect"
)]
pub trait AggregatePolicy<D>: Numeric {
    type Sum: crate::types::DataType;
    type Avg: crate::types::DataType;
}

#[diagnostic::on_unimplemented(
    message = "no statistical aggregate policy for `{Self}` on this dialect",
    label = "stddev/variance result type is not defined for this SQL type/dialect"
)]
pub trait StatisticalAggregatePolicy<D>: Numeric {
    type StddevPop: crate::types::DataType;
    type StddevSamp: crate::types::DataType;
    type VarPop: crate::types::DataType;
    type VarSamp: crate::types::DataType;
}

#[diagnostic::on_unimplemented(
    message = "boolean aggregates are not supported for `{Self}` on this dialect",
    label = "use a boolean expression with a dialect that supports BOOL_AND/BOOL_OR"
)]
pub trait BooleanAggregatePolicy<D>: crate::types::DataType {}

#[diagnostic::on_unimplemented(
    message = "this aggregate is not available for this dialect",
    label = "use a dialect-specific alternative"
)]
pub trait PostgresAggregateSupport {}

#[diagnostic::on_unimplemented(
    message = "this aggregate is not available for this dialect",
    label = "use a dialect-specific alternative"
)]
pub trait SQLiteAggregateSupport {}

#[diagnostic::on_unimplemented(
    message = "GROUP_CONCAT is not available for this dialect",
    label = "use the dialect's native string aggregate"
)]
pub trait GroupConcatSupport {}

#[diagnostic::on_unimplemented(
    message = "no COUNT return type defined for this dialect",
    label = "COUNT result type is not configured for this dialect marker"
)]
pub trait CountPolicy {
    /// The integer type returned by COUNT (e.g. Integer on `SQLite`, Int8 on `PostgreSQL`).
    type Count: crate::types::DataType;
}

mod count_arg_private {
    use super::SQLParam;

    pub trait Sealed<'a, V: SQLParam> {}

    impl<'a, V: SQLParam> Sealed<'a, V> for () {}

    impl<'a, V, E> Sealed<'a, V> for E
    where
        V: SQLParam + 'a,
        E: crate::traits::ToSQL<'a, V> + crate::row::ExprValueType,
    {
    }
}

/// Argument accepted by [`count`].
///
/// This trait is sealed and exists only to support `count(())` for `COUNT(*)`
/// and `count(expr)` for `COUNT(expr)` without making `()` a general SQL
/// expression.
#[doc(hidden)]
pub trait CountArg<'a, V: SQLParam>: count_arg_private::Sealed<'a, V> {
    fn count_sql(self) -> SQL<'a, V>;
}

impl<'a, V: SQLParam + 'a> CountArg<'a, V> for () {
    fn count_sql(self) -> SQL<'a, V> {
        SQL::raw("COUNT(*)")
    }
}

impl<'a, V, E> CountArg<'a, V> for E
where
    V: SQLParam + 'a,
    E: crate::traits::ToSQL<'a, V> + crate::row::ExprValueType,
{
    fn count_sql(self) -> SQL<'a, V> {
        SQL::func("COUNT", self.into_sql().parens_if_subquery())
    }
}

impl CountPolicy for SQLiteDialect {
    type Count = drizzle_types::sqlite::types::Integer;
}

impl CountPolicy for PostgresDialect {
    type Count = drizzle_types::postgres::types::Int8;
}

impl CountPolicy for MySQLDialect {
    type Count = drizzle_types::mysql::types::BigInt;
}

#[diagnostic::on_unimplemented(
    message = "no floating-point return type defined for this dialect",
    label = "PERCENT_RANK/CUME_DIST result type is not configured for this dialect marker"
)]
pub trait FloatPolicy {
    /// The floating-point type returned by distribution window functions
    /// like `PERCENT_RANK` and `CUME_DIST` (Real on `SQLite`, Float8 on `PostgreSQL`).
    type Float: crate::types::DataType;
}

impl FloatPolicy for SQLiteDialect {
    type Float = drizzle_types::sqlite::types::Real;
}

impl FloatPolicy for PostgresDialect {
    type Float = drizzle_types::postgres::types::Float8;
}

impl FloatPolicy for MySQLDialect {
    type Float = drizzle_types::mysql::types::Double;
}

macro_rules! mysql_aggregate_policy {
    ($output:ty; $($ty:ty),+ $(,)?) => {
        $(
            impl AggregatePolicy<MySQLDialect> for $ty {
                type Sum = $output;
                type Avg = $output;
            }
        )+
    };
}

mysql_aggregate_policy!(MyDecimal;
    MyTinyInt,
    MyTinyIntUnsigned,
    MySmallInt,
    MySmallIntUnsigned,
    MyMediumInt,
    MyMediumIntUnsigned,
    MyInt,
    MyIntUnsigned,
    MyBigInt,
    MyBigIntUnsigned,
    MyYear,
    MyDecimal,
);

mysql_aggregate_policy!(MyDouble; MyFloat, MyDouble);

macro_rules! mysql_statistical_aggregate_policy {
    ($($ty:ty),+ $(,)?) => {
        $(
            impl StatisticalAggregatePolicy<MySQLDialect> for $ty {
                type StddevPop = MyDouble;
                type StddevSamp = MyDouble;
                type VarPop = MyDouble;
                type VarSamp = MyDouble;
            }
        )+
    };
}

mysql_statistical_aggregate_policy!(
    MyTinyInt,
    MyTinyIntUnsigned,
    MySmallInt,
    MySmallIntUnsigned,
    MyMediumInt,
    MyMediumIntUnsigned,
    MyInt,
    MyIntUnsigned,
    MyBigInt,
    MyBigIntUnsigned,
    MyYear,
    MyDecimal,
    MyFloat,
    MyDouble,
);

impl AggregatePolicy<SQLiteDialect> for SqliteInteger {
    type Sum = Self;
    type Avg = SqliteReal;
}
impl AggregatePolicy<SQLiteDialect> for SqliteReal {
    type Sum = Self;
    type Avg = Self;
}
impl AggregatePolicy<SQLiteDialect> for SqliteNumeric {
    type Sum = Self;
    type Avg = SqliteReal;
}
impl AggregatePolicy<SQLiteDialect> for drizzle_types::sqlite::types::Any {
    type Sum = Self;
    type Avg = SqliteReal;
}

impl StatisticalAggregatePolicy<PostgresDialect> for Int2 {
    type StddevPop = Float8;
    type StddevSamp = Float8;
    type VarPop = Float8;
    type VarSamp = Float8;
}
impl StatisticalAggregatePolicy<PostgresDialect> for Int4 {
    type StddevPop = Float8;
    type StddevSamp = Float8;
    type VarPop = Float8;
    type VarSamp = Float8;
}
impl StatisticalAggregatePolicy<PostgresDialect> for Int8 {
    type StddevPop = Float8;
    type StddevSamp = Float8;
    type VarPop = Float8;
    type VarSamp = Float8;
}
impl StatisticalAggregatePolicy<PostgresDialect> for Float4 {
    type StddevPop = Float8;
    type StddevSamp = Float8;
    type VarPop = Float8;
    type VarSamp = Float8;
}
impl StatisticalAggregatePolicy<PostgresDialect> for Float8 {
    type StddevPop = Self;
    type StddevSamp = Self;
    type VarPop = Self;
    type VarSamp = Self;
}
impl StatisticalAggregatePolicy<PostgresDialect> for PgNumeric {
    type StddevPop = Float8;
    type StddevSamp = Float8;
    type VarPop = Float8;
    type VarSamp = Float8;
}

impl BooleanAggregatePolicy<PostgresDialect> for PgBoolean {}

impl PostgresAggregateSupport for PostgresDialect {}
impl SQLiteAggregateSupport for SQLiteDialect {}
impl GroupConcatSupport for SQLiteDialect {}
impl GroupConcatSupport for MySQLDialect {}

impl AggregatePolicy<PostgresDialect> for Int2 {
    type Sum = Int8;
    type Avg = Float8;
}
impl AggregatePolicy<PostgresDialect> for Int4 {
    type Sum = Int8;
    type Avg = Float8;
}
impl AggregatePolicy<PostgresDialect> for Int8 {
    type Sum = Self;
    type Avg = Float8;
}
impl AggregatePolicy<PostgresDialect> for Float4 {
    type Sum = Float8;
    type Avg = Float8;
}
impl AggregatePolicy<PostgresDialect> for Float8 {
    type Sum = Self;
    type Avg = Self;
}
impl AggregatePolicy<PostgresDialect> for PgNumeric {
    type Sum = Self;
    type Avg = Self;
}

// =============================================================================
// COUNT
// =============================================================================

/// COUNT aggregate.
///
/// Pass `()` for `COUNT(*)`, or a column/expression for `COUNT(expr)`.
///
/// Returns a `BigInt`, `NonNull` (count is never NULL), Aggregate expression.
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::count;
///
/// let all_rows = count(());
/// // Generates: COUNT(*)
///
/// let email_count = count(users.email);
/// // Generates: COUNT("users"."email")
/// # "####;
/// ```
pub fn count<'a, V, A>(
    arg: A,
) -> SQLExpr<'a, V, <V::DialectMarker as CountPolicy>::Count, NonNull, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: CountPolicy,
    A: CountArg<'a, V>,
{
    SQLExpr::new(arg.count_sql())
}

/// COUNT(DISTINCT expr) - counts distinct non-null values.
///
/// Returns a `BigInt`, `NonNull`, Aggregate expression.
/// Works with any expression type.
pub fn count_distinct<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as CountPolicy>::Count, NonNull, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: CountPolicy,
    E: Expr<'a, V>,
{
    SQLExpr::new(SQL::func(
        "COUNT",
        SQL::raw("DISTINCT").append(expr.into_expr_sql()),
    ))
}

// =============================================================================
// SUM
// =============================================================================

/// SUM(expr) - sums numeric values.
///
/// Requires the expression to be `Numeric` (Int, `BigInt`, Float, Double).
/// Result type is dialect-aware.
/// Returns a nullable expression (empty set returns NULL).
///
/// # Type Safety
///
/// ```rust
/// # let _ = r####"
/// // ✅ OK: Numeric column
/// sum(orders.amount);
/// // SQLite: same width for integer sums
/// // PostgreSQL: Int/SmallInt promote to BigInt
///
/// // ❌ Compile error: Text is not Numeric
/// sum(users.name);
/// # "####;
/// ```
pub fn sum<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <E::SQLType as AggregatePolicy<V::DialectMarker>>::Sum, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: AggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(SQL::func("SUM", expr.into_expr_sql()))
}

/// SUM(DISTINCT expr) - sums distinct numeric values.
///
/// Requires the expression to be `Numeric`.
/// Result type is dialect-aware.
pub fn sum_distinct<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <E::SQLType as AggregatePolicy<V::DialectMarker>>::Sum, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: AggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(SQL::func(
        "SUM",
        SQL::raw("DISTINCT").append(expr.into_expr_sql()),
    ))
}

// =============================================================================
// AVG
// =============================================================================

/// AVG(expr) - calculates average of numeric values.
///
/// Requires the expression to be `Numeric`.
/// Always returns Double (SQL standard behavior), nullable.
///
/// # Type Safety
///
/// ```rust
/// # let _ = r####"
/// // ✅ OK: Numeric column
/// avg(products.price);
///
/// // ❌ Compile error: Text is not Numeric
/// avg(users.name);
/// # "####;
/// ```
pub fn avg<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <E::SQLType as AggregatePolicy<V::DialectMarker>>::Avg, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: AggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(SQL::func("AVG", expr.into_expr_sql()))
}

/// AVG(DISTINCT expr) - calculates average of distinct numeric values.
///
/// Requires the expression to be `Numeric`.
pub fn avg_distinct<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <E::SQLType as AggregatePolicy<V::DialectMarker>>::Avg, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: AggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(SQL::func(
        "AVG",
        SQL::raw("DISTINCT").append(expr.into_expr_sql()),
    ))
}

// =============================================================================
// MIN / MAX
// =============================================================================

/// MIN(expr) - finds minimum value.
///
/// Works with any expression type (ordered types in SQL).
/// Preserves the input expression's SQL type.
/// Result is nullable (empty set returns NULL).
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::min;
///
/// let cheapest = min(products.price);
/// // Generates: MIN("products"."price")
/// // Returns the same SQL type as products.price
/// # "####;
/// ```
pub fn min<'a, V, E>(expr: E) -> SQLExpr<'a, V, E::SQLType, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
{
    SQLExpr::new(SQL::func("MIN", expr.into_expr_sql()))
}

/// MAX(expr) - finds maximum value.
///
/// Works with any expression type (ordered types in SQL).
/// Preserves the input expression's SQL type.
/// Result is nullable (empty set returns NULL).
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::max;
///
/// let most_expensive = max(products.price);
/// // Generates: MAX("products"."price")
/// // Returns the same SQL type as products.price
/// # "####;
/// ```
pub fn max<'a, V, E>(expr: E) -> SQLExpr<'a, V, E::SQLType, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
{
    SQLExpr::new(SQL::func("MAX", expr.into_expr_sql()))
}

// =============================================================================
// STATISTICAL FUNCTIONS
// =============================================================================

/// `STDDEV_POP` - population standard deviation.
///
/// Calculates the population standard deviation of numeric values.
/// Requires the expression to be `Numeric`.
/// Returns Double, nullable (empty set returns NULL).
///
/// Note: This function is available in `PostgreSQL`. `SQLite` does not have it built-in.
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::stddev_pop;
///
/// let deviation = stddev_pop(measurements.value);
/// // Generates: STDDEV_POP("measurements"."value")
/// # "####;
/// ```
pub fn stddev_pop<'a, V, E>(
    expr: E,
) -> SQLExpr<
    'a,
    V,
    <E::SQLType as StatisticalAggregatePolicy<V::DialectMarker>>::StddevPop,
    Null,
    Agg,
>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: StatisticalAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(pg_double(SQL::func("STDDEV_POP", expr.into_expr_sql())))
}

/// `STDDEV_SAMP` / STDDEV - sample standard deviation.
///
/// Calculates the sample standard deviation of numeric values.
/// Requires the expression to be `Numeric`.
/// Returns Double, nullable (empty set returns NULL).
///
/// Note: This function is available in `PostgreSQL`. `SQLite` does not have it built-in.
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::stddev_samp;
///
/// let deviation = stddev_samp(measurements.value);
/// // Generates: STDDEV_SAMP("measurements"."value")
/// # "####;
/// ```
pub fn stddev_samp<'a, V, E>(
    expr: E,
) -> SQLExpr<
    'a,
    V,
    <E::SQLType as StatisticalAggregatePolicy<V::DialectMarker>>::StddevSamp,
    Null,
    Agg,
>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: StatisticalAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(pg_double(SQL::func("STDDEV_SAMP", expr.into_expr_sql())))
}

/// `VAR_POP` - population variance.
///
/// Calculates the population variance of numeric values.
/// Requires the expression to be `Numeric`.
/// Returns Double, nullable (empty set returns NULL).
///
/// Note: This function is available in `PostgreSQL`. `SQLite` does not have it built-in.
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::var_pop;
///
/// let variance = var_pop(measurements.value);
/// // Generates: VAR_POP("measurements"."value")
/// # "####;
/// ```
pub fn var_pop<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <E::SQLType as StatisticalAggregatePolicy<V::DialectMarker>>::VarPop, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: StatisticalAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(pg_double(SQL::func("VAR_POP", expr.into_expr_sql())))
}

/// `VAR_SAMP` / VARIANCE - sample variance.
///
/// Calculates the sample variance of numeric values.
/// Requires the expression to be `Numeric`.
/// Returns Double, nullable (empty set returns NULL).
///
/// Note: This function is available in `PostgreSQL`. `SQLite` does not have it built-in.
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::var_samp;
///
/// let variance = var_samp(measurements.value);
/// // Generates: VAR_SAMP("measurements"."value")
/// # "####;
/// ```
pub fn var_samp<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <E::SQLType as StatisticalAggregatePolicy<V::DialectMarker>>::VarSamp, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: StatisticalAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(pg_double(SQL::func("VAR_SAMP", expr.into_expr_sql())))
}

/// Sample variance. Emits `VARIANCE` on PostgreSQL and `VAR_SAMP` on MySQL.
pub fn variance<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <E::SQLType as StatisticalAggregatePolicy<V::DialectMarker>>::VarSamp, Null, Agg>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
    E::SQLType: StatisticalAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(pg_double(SQL::func(
        match V::DIALECT {
            Dialect::MySQL => "VAR_SAMP",
            Dialect::SQLite | Dialect::PostgreSQL => "VARIANCE",
        },
        expr.into_expr_sql(),
    )))
}

/// `BOOL_AND` - true if all non-null inputs are true (`PostgreSQL`).
pub fn bool_and<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Bool, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    E: Expr<'a, V>,
    E::SQLType: BooleanAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(SQL::func("BOOL_AND", expr.into_expr_sql()))
}

/// `BOOL_OR` - true if any non-null input is true (`PostgreSQL`).
pub fn bool_or<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Bool, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    E: Expr<'a, V>,
    E::SQLType: BooleanAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(SQL::func("BOOL_OR", expr.into_expr_sql()))
}

/// `JSON_AGG` - aggregates values into a JSON array (`PostgreSQL`).
pub fn json_agg<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Json, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    E: Expr<'a, V>,
{
    SQLExpr::new(SQL::func("JSON_AGG", expr.into_expr_sql()))
}

/// `JSONB_AGG` - aggregates values into a JSONB array (`PostgreSQL`).
pub fn jsonb_agg<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Jsonb, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    E: Expr<'a, V>,
{
    SQLExpr::new(SQL::func("JSONB_AGG", expr.into_expr_sql()))
}

/// `ARRAY_AGG` - aggregates values into a SQL array (`PostgreSQL`).
pub fn array_agg<'a, V, E>(expr: E) -> SQLExpr<'a, V, Array<E::SQLType>, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    E: Expr<'a, V>,
{
    SQLExpr::new(SQL::func("ARRAY_AGG", expr.into_expr_sql()))
}

// =============================================================================
// TOTAL (SQLite)
// =============================================================================

/// TOTAL - sums numeric values, returning 0.0 for empty sets (`SQLite`).
///
/// Unlike `SUM`, which returns NULL for an empty result set,
/// `TOTAL` always returns a floating-point value (0.0 for empty sets).
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::total;
///
/// // SELECT TOTAL(orders.amount)
/// let total_amount = total(orders.amount);
/// # "####;
/// ```
pub fn total<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Double, NonNull, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: SQLiteAggregateSupport,
    E: Expr<'a, V>,
    E::SQLType: Numeric,
{
    SQLExpr::new(SQL::func("TOTAL", expr.into_expr_sql()))
}

// =============================================================================
// GROUP_CONCAT / STRING_AGG
// =============================================================================

/// `GROUP_CONCAT` - concatenates values into a string (`SQLite` and `MySQL`).
///
/// Returns Text type, nullable.
pub fn group_concat<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Text, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: GroupConcatSupport,
    E: Expr<'a, V>,
    E::SQLType: crate::types::Textual,
{
    SQLExpr::new(SQL::func("GROUP_CONCAT", expr.into_expr_sql()))
}

/// `STRING_AGG` - concatenates text values using a delimiter (`PostgreSQL`).
pub fn string_agg<'a, V, E, D>(
    expr: E,
    delimiter: D,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Text, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    E: Expr<'a, V>,
    E::SQLType: crate::types::Textual,
    D: Expr<'a, V>,
    D::SQLType: crate::types::Textual,
{
    SQLExpr::new(SQL::func(
        "STRING_AGG",
        expr.into_expr_sql()
            .push(crate::Token::COMMA)
            .append(delimiter.into_expr_sql()),
    ))
}

// =============================================================================
// PostgreSQL Aggregate Functions
// =============================================================================

/// EVERY - true if all non-null inputs are true (`PostgreSQL`).
///
/// SQL standard alias for `BOOL_AND`.
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::every;
///
/// // SELECT EVERY(orders.is_paid)
/// let all_paid = every(orders.is_paid);
/// # "####;
/// ```
pub fn every<'a, V, E>(
    expr: E,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Bool, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    E: Expr<'a, V>,
    E::SQLType: BooleanAggregatePolicy<V::DialectMarker>,
{
    SQLExpr::new(SQL::func("EVERY", expr.into_expr_sql()))
}

/// `JSON_OBJECT_AGG` - aggregates key/value pairs into a JSON object (`PostgreSQL`).
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::json_object_agg;
///
/// // SELECT JSON_OBJECT_AGG(settings.key, settings.value)
/// let obj = json_object_agg(settings.key, settings.value);
/// # "####;
/// ```
pub fn json_object_agg<'a, V, K, Val>(
    key: K,
    value: Val,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Json, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    K: Expr<'a, V>,
    Val: Expr<'a, V>,
{
    SQLExpr::new(SQL::func(
        "JSON_OBJECT_AGG",
        key.into_expr_sql()
            .push(crate::Token::COMMA)
            .append(value.into_expr_sql()),
    ))
}

/// `JSONB_OBJECT_AGG` - aggregates key/value pairs into a JSONB object (`PostgreSQL`).
///
/// # Example
///
/// ```rust
/// # let _ = r####"
/// use drizzle_core::expr::jsonb_object_agg;
///
/// // SELECT JSONB_OBJECT_AGG(settings.key, settings.value)
/// let obj = jsonb_object_agg(settings.key, settings.value);
/// # "####;
/// ```
pub fn jsonb_object_agg<'a, V, K, Val>(
    key: K,
    value: Val,
) -> SQLExpr<'a, V, <V::DialectMarker as DialectTypes>::Jsonb, Null, Agg>
where
    V: SQLParam + 'a,
    V::DialectMarker: PostgresAggregateSupport,
    K: Expr<'a, V>,
    Val: Expr<'a, V>,
{
    SQLExpr::new(SQL::func(
        "JSONB_OBJECT_AGG",
        key.into_expr_sql()
            .push(crate::Token::COMMA)
            .append(value.into_expr_sql()),
    ))
}

// =============================================================================
// Distinct Wrapper
// =============================================================================

/// DISTINCT - marks an expression as DISTINCT.
///
/// Typically used inside aggregate functions.
pub fn distinct<'a, V, E>(expr: E) -> SQLExpr<'a, V, E::SQLType, E::Nullable, Scalar>
where
    V: SQLParam + 'a,
    E: Expr<'a, V>,
{
    SQLExpr::new(SQL::raw("DISTINCT").append(expr.into_expr_sql()))
}