rjango 0.1.1

use sea_orm::sea_query::SimpleExpr;

use super::custom_function;

/// SQL ABS(expr).
pub fn abs(expr: SimpleExpr) -> SimpleExpr {
    custom_function("ABS", vec![expr])
}

/// SQL CEIL(expr).
pub fn ceil(expr: SimpleExpr) -> SimpleExpr {
    custom_function("CEIL", vec![expr])
}

/// SQL FLOOR(expr).
pub fn floor(expr: SimpleExpr) -> SimpleExpr {
    custom_function("FLOOR", vec![expr])
}

/// SQL ROUND(expr).
pub fn round(expr: SimpleExpr) -> SimpleExpr {
    custom_function("ROUND", vec![expr])
}

/// SQL SQRT(expr).
pub fn sqrt(expr: SimpleExpr) -> SimpleExpr {
    custom_function("SQRT", vec![expr])
}

/// SQL POWER(base, exponent).
pub fn power(base: SimpleExpr, exponent: SimpleExpr) -> SimpleExpr {
    custom_function("POWER", vec![base, exponent])
}

/// SQL MOD(dividend, divisor).
pub fn r#mod(dividend: SimpleExpr, divisor: SimpleExpr) -> SimpleExpr {
    custom_function("MOD", vec![dividend, divisor])
}

/// SQL RANDOM().
pub fn random() -> SimpleExpr {
    custom_function("RANDOM", Vec::new())
}

/// SQL SIGN(expr).
pub fn sign(expr: SimpleExpr) -> SimpleExpr {
    custom_function("SIGN", vec![expr])
}

/// SQL LOG(base, value).
pub fn log(base: SimpleExpr, value: SimpleExpr) -> SimpleExpr {
    custom_function("LOG", vec![base, value])
}

/// SQL LN(expr).
pub fn ln(expr: SimpleExpr) -> SimpleExpr {
    custom_function("LN", vec![expr])
}

/// SQL EXP(expr).
pub fn exp(expr: SimpleExpr) -> SimpleExpr {
    custom_function("EXP", vec![expr])
}

/// SQL PI().
pub fn pi() -> SimpleExpr {
    custom_function("PI", Vec::new())
}

/// SQL DEGREES(expr).
pub fn degrees(expr: SimpleExpr) -> SimpleExpr {
    custom_function("DEGREES", vec![expr])
}

/// SQL RADIANS(expr).
pub fn radians(expr: SimpleExpr) -> SimpleExpr {
    custom_function("RADIANS", vec![expr])
}

/// SQL SIN(expr).
pub fn sin(expr: SimpleExpr) -> SimpleExpr {
    custom_function("SIN", vec![expr])
}

/// SQL COS(expr).
pub fn cos(expr: SimpleExpr) -> SimpleExpr {
    custom_function("COS", vec![expr])
}

/// SQL TAN(expr).
pub fn tan(expr: SimpleExpr) -> SimpleExpr {
    custom_function("TAN", vec![expr])
}

#[cfg(test)]
mod tests {
    use super::{
        abs, ceil, cos, degrees, exp, floor, ln, log, r#mod, pi, power, radians, random, round,
        sign, sin, sqrt, tan,
    };
    use sea_orm::sea_query::{Alias, Expr, PostgresQueryBuilder, Query, SimpleExpr};

    fn column(name: &str) -> SimpleExpr {
        Expr::col(Alias::new(name)).into()
    }

    fn render_select_expr(expr: SimpleExpr, alias: &str) -> String {
        Query::select()
            .expr_as(expr, Alias::new(alias))
            .from(Alias::new("widgets"))
            .to_owned()
            .to_string(PostgresQueryBuilder)
    }

    #[test]
    fn test_abs() {
        let sql = render_select_expr(abs(column("delta")), "abs_delta");
        assert!(sql.contains("ABS"), "expected ABS SQL, got: {sql}");
    }

    #[test]
    fn test_ceil() {
        let sql = render_select_expr(ceil(column("ratio")), "ceil_ratio");
        assert!(sql.contains("CEIL"), "expected CEIL SQL, got: {sql}");
    }

    #[test]
    fn test_floor() {
        let sql = render_select_expr(floor(column("ratio")), "floor_ratio");
        assert!(sql.contains("FLOOR"), "expected FLOOR SQL, got: {sql}");
    }

    #[test]
    fn test_round() {
        let sql = render_select_expr(round(column("ratio")), "rounded_ratio");
        assert!(sql.contains("ROUND"), "expected ROUND SQL, got: {sql}");
    }

    #[test]
    fn test_sqrt() {
        let sql = render_select_expr(sqrt(column("variance")), "stddev");
        assert!(sql.contains("SQRT"), "expected SQRT SQL, got: {sql}");
    }

    #[test]
    fn test_power() {
        let sql = render_select_expr(power(column("base"), Expr::value(3)), "cubed");
        assert!(sql.contains("POWER"), "expected POWER SQL, got: {sql}");
    }

    #[test]
    fn test_mod() {
        let sql = render_select_expr(r#mod(column("counter"), Expr::value(2)), "parity");
        assert!(sql.contains("MOD"), "expected MOD SQL, got: {sql}");
    }

    #[test]
    fn test_random() {
        let sql = render_select_expr(random(), "random_value");
        assert!(sql.contains("RANDOM"), "expected RANDOM SQL, got: {sql}");
    }

    #[test]
    fn test_sign() {
        let sql = render_select_expr(sign(column("delta")), "delta_sign");
        assert!(sql.contains("SIGN"), "expected SIGN SQL, got: {sql}");
    }

    #[test]
    fn test_log() {
        let sql = render_select_expr(log(Expr::value(10), column("magnitude")), "log_value");
        assert!(sql.contains("LOG"), "expected LOG SQL, got: {sql}");
    }

    #[test]
    fn test_ln() {
        let sql = render_select_expr(ln(column("magnitude")), "natural_log");
        assert!(sql.contains("LN"), "expected LN SQL, got: {sql}");
    }

    #[test]
    fn test_exp() {
        let sql = render_select_expr(exp(column("magnitude")), "exp_value");
        assert!(sql.contains("EXP"), "expected EXP SQL, got: {sql}");
    }

    #[test]
    fn test_pi() {
        let sql = render_select_expr(pi(), "pi_value");
        assert!(sql.contains("PI"), "expected PI SQL, got: {sql}");
    }

    #[test]
    fn test_degrees() {
        let sql = render_select_expr(degrees(column("angle_radians")), "angle_degrees");
        assert!(sql.contains("DEGREES"), "expected DEGREES SQL, got: {sql}");
    }

    #[test]
    fn test_radians() {
        let sql = render_select_expr(radians(column("angle_degrees")), "angle_radians");
        assert!(sql.contains("RADIANS"), "expected RADIANS SQL, got: {sql}");
    }

    #[test]
    fn test_sin() {
        let sql = render_select_expr(sin(column("angle")), "sine");
        assert!(sql.contains("SIN"), "expected SIN SQL, got: {sql}");
    }

    #[test]
    fn test_cos() {
        let sql = render_select_expr(cos(column("angle")), "cosine");
        assert!(sql.contains("COS"), "expected COS SQL, got: {sql}");
    }

    #[test]
    fn test_tan() {
        let sql = render_select_expr(tan(column("angle")), "tangent");
        assert!(sql.contains("TAN"), "expected TAN SQL, got: {sql}");
    }
}