clicktype_query/

builder.rs

//! Query builder implementation

use std::marker::PhantomData;
use clicktype_core::traits::{ClickTable, TypedColumn};
use crate::join::{JoinSpec, JoinType};

/// Supported SQL operators for filtering
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Operator {
    /// Equals `=`
    Eq,
    /// Not equals `!=`
    Ne,
    /// Greater than `>`
    Gt,
    /// Less than `<`
    Lt,
    /// Greater than or equals `>=`
    Gte,
    /// Less than or equals `<=`
    Lte,
    /// LIKE matching
    Like,
    /// ILIKE (Case insensitive)
    ILike,
}

impl Operator {
    fn as_str(&self) -> &'static str {
        match self {
            Operator::Eq => "=",
            Operator::Ne => "!=",
            Operator::Gt => ">",
            Operator::Lt => "<",
            Operator::Gte => ">=",
            Operator::Lte => "<=",
            Operator::Like => "LIKE",
            Operator::ILike => "ILIKE",
        }
    }
}

/// Trait for safely serializing values to SQL.
pub trait SqlValue {
    fn to_sql_value(&self) -> String;
}

impl SqlValue for String {
    fn to_sql_value(&self) -> String {
        format!("'{}'", self.replace('`', "`"))
    }
}

impl SqlValue for &str {
    fn to_sql_value(&self) -> String {
        format!("'{}'", self.replace('`', "`"))
    }
}

macro_rules! impl_sql_value_for_numeric {
    ($($t:ty),*) => {
        $( 
            impl SqlValue for $t {
                fn to_sql_value(&self) -> String {
                    self.to_string()
                }
            }
        )*
    };
}

impl_sql_value_for_numeric!(i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, bool);

/// Simplified query builder for ClickHouse.
///
/// Provides a fluent API to construct SQL queries safely, ensuring column names
/// belong to the specified table.
///
/// # Example
///
/// ```rust,ignore
/// let sql = QueryBuilder::<User>::new()
///     .select(User::NAME)
///     .filter(User::AGE, Operator::Gt, 18)
///     .to_sql();
/// ```
#[derive(Debug, Clone)]
pub struct QueryBuilder<T> {
    table_name: &'static str,
    select_exprs: Vec<String>,
    joins: Vec<String>,
    where_exprs: Vec<String>,
    group_by_exprs: Vec<String>,
    having_exprs: Vec<String>,
    order_by_exprs: Vec<String>,
    limit_val: Option<u64>,
    offset_val: Option<u64>,
    _phantom: PhantomData<T>,
}

impl<T: ClickTable> QueryBuilder<T> {
    /// Create a new query builder for the given table.
    pub fn new() -> Self {
        Self {
            table_name: T::table_name(),
            select_exprs: Vec::new(),
            joins: Vec::new(),
            where_exprs: Vec::new(),
            group_by_exprs: Vec::new(),
            having_exprs: Vec::new(),
            order_by_exprs: Vec::new(),
            limit_val: None,
            offset_val: None,
            _phantom: PhantomData,
        }
    }

    /// Add a typed column to the SELECT clause.
    pub fn select<C: TypedColumn<Table = T>>(mut self, _col: C) -> Self {
        self.select_exprs.push(C::name().to_string());
        self
    }

    /// Add a raw expression string to the SELECT clause.
    /// Useful for aggregate functions like `count()`, `sum(field)`, etc.
    pub fn select_raw(mut self, expr: impl Into<String>) -> Self {
        self.select_exprs.push(expr.into());
        self
    }

    /// Add a JOIN clause using a JoinSpec.
    ///
    /// # Example
    /// ```rust,ignore
    /// use clicktype::query::{QueryBuilder, inner_join};
    ///
    /// let query = QueryBuilder::<User>::new()
    ///     .select(User::NAME)
    ///     .join(inner_join::<User, Order>().on(User::ID, Order::USER_ID))
    ///     .to_sql();
    /// ```
    pub fn join<T2: ClickTable, J: JoinType>(mut self, join_spec: JoinSpec<T, T2, J>) -> Self {
        self.joins.push(join_spec.to_sql());
        self
    }

    /// Add a raw JOIN string.
    pub fn join_raw(mut self, join_clause: impl Into<String>) -> Self {
        self.joins.push(join_clause.into());
        self
    }

    /// Add a WHERE condition with type-safe column and operator.
    ///
    /// The `value` is automatically converted to a safe SQL string representation.
    ///
    /// # Example
    /// ```rust,ignore
    /// .filter(User::ID, Operator::Eq, 42)
    /// .filter(User::NAME, Operator::Eq, "Alice") // Automatically quoted
    /// ```
    pub fn filter<C: TypedColumn<Table = T>, V: SqlValue>(
        mut self, 
        _col: C, 
        op: Operator, 
        value: V
    ) -> Self {
        self.where_exprs.push(format!("{} {} {}", C::name(), op.as_str(), value.to_sql_value()));
        self
    }

    /// Add a raw WHERE condition string.
    pub fn filter_raw(mut self, condition: impl Into<String>) -> Self {
        self.where_exprs.push(condition.into());
        self
    }

    /// Add an ORDER BY clause for a specific column.
    pub fn order_by<C: TypedColumn<Table = T>>(mut self, _col: C, desc: bool) -> Self {
        let order = if desc {
            format!("{} DESC", C::name())
        } else {
            C::name().to_string()
        };
        self.order_by_exprs.push(order);
        self
    }

    /// Add a raw string to the ORDER BY clause.
    pub fn order_by_raw(mut self, expr: impl Into<String>) -> Self {
        self.order_by_exprs.push(expr.into());
        self
    }

    /// Add a LIMIT clause.
    pub fn limit(mut self, limit: u64) -> Self {
        self.limit_val = Some(limit);
        self
    }

    /// Add an OFFSET clause.
    pub fn offset(mut self, offset: u64) -> Self {
        self.offset_val = Some(offset);
        self
    }

    /// Add a GROUP BY clause for a typed column.
    pub fn group_by<C: TypedColumn<Table = T>>(mut self, _col: C) -> Self {
        self.group_by_exprs.push(C::name().to_string());
        self
    }

    /// Add a raw string to the GROUP BY clause.
    pub fn group_by_raw(mut self, expr: impl Into<String>) -> Self {
        self.group_by_exprs.push(expr.into());
        self
    }

    /// Add a raw HAVING clause.
    pub fn having(mut self, expr: impl Into<String>) -> Self {
        self.having_exprs.push(expr.into());
        self
    }

    /// Render the final SQL query string.
    pub fn to_sql(&self) -> String {
        let mut sql = String::from("SELECT ");

        if self.select_exprs.is_empty() {
            sql.push('*');
        } else {
            sql.push_str(&self.select_exprs.join(", "));
        }

        sql.push_str(" FROM ");
        sql.push_str(self.table_name);

        if !self.joins.is_empty() {
            sql.push(' ');
            sql.push_str(&self.joins.join(" "));
        }

        if !self.where_exprs.is_empty() {
            sql.push_str(" WHERE ");
            sql.push_str(&self.where_exprs.join(" AND "));
        }

        if !self.group_by_exprs.is_empty() {
            sql.push_str(" GROUP BY ");
            sql.push_str(&self.group_by_exprs.join(", "));
        }

        if !self.having_exprs.is_empty() {
            sql.push_str(" HAVING ");
            sql.push_str(&self.having_exprs.join(" AND "));
        }

        if !self.order_by_exprs.is_empty() {
            sql.push_str(" ORDER BY ");
            sql.push_str(&self.order_by_exprs.join(", "));
        }

        if let Some(limit) = self.limit_val {
            sql.push_str(" LIMIT ");
            sql.push_str(&limit.to_string());
        }

        if let Some(offset) = self.offset_val {
            sql.push_str(" OFFSET ");
            sql.push_str(&offset.to_string());
        }

        sql
    }
}