vantage-table 0.4.3

//! Generic operation trait for building conditions from any `Expressive` type.
//!
//! A blanket impl provides `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, and `in_` for
//! every type that implements `Expressive<T>`. This includes table columns, fields,
//! scalar values, and expressions across all backends.

use vantage_expressions::traits::expressive::ExpressiveEnum;
use vantage_expressions::{Expression, Expressive};

/// Trait for building condition expressions.
///
/// Blanket-implemented for all `Expressive<T>` types using standard SQL templates.
pub trait Operation<T>: Expressive<T> {
    /// Creates an equality condition: field = value
    fn eq(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} = {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a not-equal condition: field != value
    fn ne(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} != {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a greater-than condition: field > value
    fn gt(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} > {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a greater-than-or-equal condition: field >= value
    fn gte(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} >= {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a less-than condition: field < value
    fn lt(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} < {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a less-than-or-equal condition: field <= value
    fn lte(&self, value: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} <= {}",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(value.expr()),
            ],
        )
    }

    /// Creates a membership condition: field IN (values_expression)
    fn in_(&self, values: impl Expressive<T>) -> Expression<T> {
        Expression::new(
            "{} IN ({})",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(values.expr()),
            ],
        )
    }

    /// Creates a membership condition from a list of scalar values: field IN (a, b, c)
    fn in_list<V: Into<T> + Clone>(&self, values: &[V]) -> Expression<T> {
        let params: Vec<Expression<T>> = values
            .iter()
            .map(|v| Expression::new("{}", vec![ExpressiveEnum::Scalar(v.clone().into())]))
            .collect();
        Expression::new(
            "{} IN ({})",
            vec![
                ExpressiveEnum::Nested(self.expr()),
                ExpressiveEnum::Nested(Expression::from_vec(params, ", ")),
            ],
        )
    }

    /// Casts the expression to a SQL type: `CAST(expr AS type_name)`
    fn cast(&self, type_name: &str) -> Expression<T> {
        Expression::new(
            format!("CAST({{}} AS {type_name})"),
            vec![ExpressiveEnum::Nested(self.expr())],
        )
    }

    /// Creates a NULL check condition: field IS NULL
    fn is_null(&self) -> Expression<T> {
        Expression::new("{} IS NULL", vec![ExpressiveEnum::Nested(self.expr())])
    }

    /// Creates a NOT NULL check condition: field IS NOT NULL
    fn is_not_null(&self) -> Expression<T> {
        Expression::new("{} IS NOT NULL", vec![ExpressiveEnum::Nested(self.expr())])
    }
}

/// Blanket implementation: any type that implements `Expressive<T>` gets `Operation<T>` for free.
impl<T, S: Expressive<T>> Operation<T> for S {}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::column::core::Column;

    #[test]
    fn test_is_null() {
        let deleted_at = Column::<String>::new("deleted_at");
        let expr = deleted_at.is_null();
        assert_eq!(expr.preview(), "deleted_at IS NULL");
    }

    #[test]
    fn test_is_not_null() {
        let email = Column::<String>::new("email");
        let expr = email.is_not_null();
        assert_eq!(expr.preview(), "email IS NOT NULL");
    }
}