ngb_sqlbuilder/

lib.rs

use tokio_postgres::types::ToSql;

// type Parameter = (dyn ToSql + Sync);

mod builder;
mod clause;
mod condition;
mod delete;
mod insert;
#[allow(dead_code)]
mod select;
mod update;

mod column;
#[cfg(feature = "execution")]
pub mod execution;

// pub use builder::*;
pub use clause::*;
pub use condition::*;
pub use delete::*;
pub use insert::*;
pub use select::*;
pub use update::*;
// pub use column::*;

pub struct Raw;
// #[derive(Debug)]
pub struct Column;
// #[derive(Debug)]
pub struct Select;
// #[derive(Debug)]
pub struct From;
// #[derive(Debug)]
pub struct Table;
// #[derive(Debug)]
// pub struct Final;
// #[derive(Debug)]
pub struct Join;
pub struct Condition;
pub struct Paging;

pub trait SqlClause<'q> {
    fn unwrap(self) -> (String, Vec<&'q (dyn ToSql + Sync)>);
    fn unwrap_ref(&self) -> (&str, &[&'q (dyn ToSql + Sync)]);
}
pub trait Build<'q> {
    fn build(self) -> (String, Vec<&'q (dyn ToSql + Sync)>);
    // fn build_ref(&self) -> (&str, &[&'q (dyn ToSql + Sync)]);
    // fn inspect(&self);
}

fn format_col(name: &str) -> String {
    let mut cast_split = name.split("::");
    let name = cast_split.next().unwrap_or_default();
    let mut result = match name.chars().position(|c| c == '.') {
        Some(dot) => format!("{}.\"{}\"", &name[..dot], name[dot + 1..].trim()),
        None => format!("\"{}\"", name),
    };
    if let Some(cast) = cast_split.next() {
        result.push_str("::");
        result.push_str(&cast);
        // result.push_str(&format!("::{}", cast).as_str())
    }
    result
}
fn append_wrap(sql: &mut String, value: &str) {
    sql.push('"');
    sql.push_str(value);
    sql.push('"');
}
fn append_col(sql: &mut String, expr: &str) {
    let mut cast_split = expr.split("::");
    let name = cast_split.next().unwrap_or_default();
    match name.chars().position(|c| c == '.') {
        Some(dot) => {
            sql.push_str(&name[..dot]);
            sql.push('.');
            append_wrap(sql, &name[dot + 1..]);
            // format!("{}.\"{}\"", &name[..dot], name[dot + 1..].trim())
        }
        None => {
            append_wrap(sql, name);
            // format!("\"{}\"", name)
        }
    };
    if let Some(cast) = cast_split.next() {
        sql.push_str("::");
        sql.push_str(cast);
        // result.push_str(&format!("::{}", cast).as_str())
    }
}
fn split_alias(value: &str) -> (&str, Option<&str>) {
    let mut split_as = value.split(" as ");
    let col_name = split_as.next().unwrap_or_default();
    let alias = split_as.next();
    (col_name, alias)
}
fn format_prim(expr: &str) -> String {
    // let name = name.trim();
    // let (col, alias) = {
    //     let mut split_as = name.split(" as ");
    //     let col_name = split_as.next().unwrap_or_default();
    //     let alias = split_as.next();
    //     (col_name, alias)
    // };
    let (col, alias) = split_alias(expr.trim());

    let mut col_name = format_col(col);

    if let Some(a) = alias {
        // col_name.push_str(" as ");
        col_name.push(' ');
        if a.chars().any(char::is_uppercase) {
            col_name.push_str(&wrap(a));
            // col_name.push_str(&format!(" as \"{}\"", a));
        } else {
            col_name.push_str(&a);
            // col_name.push_str(&format!(" as {}", a));
        }
    }
    col_name
}
fn append_prim(sql: &mut String, expr: &str) {
    let (col, alias) = split_alias(expr.trim());

    append_col(sql, col.trim());

    if let Some(a) = alias {
        // sql.push_str(" as ");
        sql.push(' ');
        if a.chars().any(char::is_uppercase) {
            append_wrap(sql, a.trim());
        } else {
            sql.push_str(a.trim());
        }
    }
}
fn __cols(sql: &mut String, columns: &[&str]) {
    let mut not_first = false;
    for col in columns {
        if not_first {
            sql.push_str(", ");
        }
        not_first = true;
        append_prim(sql, col);
        // sql.push_str(&format_prim(col));
    }
}
pub fn cols<'q>(columns: &[&str]) -> Clause<'q, Column> {
    let mut sql = String::new();
    __cols(&mut sql, columns);
    Clause::new(sql, vec![])
}
pub fn func<'q, T, C>(name: &str, clause: Clause<'q, T>) -> Clause<'q, C> {
    let mut sql = String::from(name);
    let (cl_sql, cl_params) = clause.unwrap();
    sql.push('(');
    sql.push_str(&cl_sql);
    sql.push(')');
    Clause::new(sql, cl_params)
}
pub fn func_col<'q>(func_name: &str, column: &str) -> Clause<'q, Column> {
    func(func_name, col(column))
}
pub fn avg_col(column: &str) -> Clause<'_, Column> {
    func("avg", col(column))
}
pub fn max_col(column: &str) -> Clause<'_, Column> {
    func("max", col(column))
}
pub fn min_col(column: &str) -> Clause<'_, Column> {
    func("min", col(column))
}
pub fn sum_col(column: &str) -> Clause<'_, Column> {
    func("sum", col(column))
}
fn wrap(s: &str) -> String {
    format!("\"{}\"", s)
}
pub fn extract_col<'q>(field: &str, from: &str) -> Clause<'q, Column> {
    let mut sql = String::from("extract(");
    sql.push_str(field);
    sql.push_str(" from ");
    sql.push_str(&format_col(from));
    sql.push(')');
    Clause::new(sql, vec![])
}

pub fn raw<'q, T>(sql: &str, values: &[&'q (dyn ToSql + Sync)]) -> Clause<'q, T> {
    Clause::new(sql.to_string(), values.to_vec())
}

fn __and_col<'q, T>(
    clause: Clause<'q, T>,
    name: &str,
    condition: Clause<'q, Condition>,
) -> Clause<'q, T> {
    let (mut sql, mut params) = clause.unwrap();
    let (cond_sql, cond_params) = condition.unwrap();
    sql.push_str(" AND ");
    // sql.push_str(&format_col(name));
    append_col(&mut sql, name);
    sql.push_str(&cond_sql);
    params.extend(cond_params);
    Clause::new(sql, params)
}
fn __or_col<'q, T>(
    clause: Clause<'q, T>,
    name: &str,
    condition: Clause<'q, Condition>,
) -> Clause<'q, T> {
    let (mut sql, mut params) = clause.unwrap();
    let (cond_sql, cond_params) = condition.unwrap();
    sql.push_str(" OR ");
    // sql.push_str(&format_col(name));
    append_col(&mut sql, name);
    sql.push_str(&cond_sql);
    params.extend(cond_params);
    Clause::new(sql, params)
}

// fn __and_cond<'q, T>(clause: Clause<'q, T>, condition: Clause<'q, Condition>) -> Clause<'q, T> {
//     let (mut sql, mut params) = clause.unwrap();
//     let (cond_sql, cond_params) = condition.unwrap();
//     sql.push_str(" AND ");
//     sql.push_str(&cond_sql);
//     params.extend(cond_params);
//     Clause::new(sql, params)
// }
// fn __or_cond<'q, T>(clause: Clause<'q, T>, condition: Clause<'q, Condition>) -> Clause<'q, T> {
//     let (mut sql, mut params) = clause.unwrap();
//     let (cond_sql, cond_params) = condition.unwrap();
//     sql.push_str(" OR ");
//     sql.push_str(&cond_sql);
//     params.extend(cond_params);
//     Clause::new(sql, params)
// }

fn __and_nest<'q, T1, T2, R>(clause: Clause<'q, T1>, condition: Clause<'q, T2>) -> Clause<'q, R> {
    let (mut sql, mut params) = clause.unwrap();
    sql.push_str(" AND (");
    sql.push_str(&condition.sql);
    sql.push(')');
    params.extend(condition.params);
    Clause::new(sql, params)
}
fn __or_nest<'q, T1, T2, R>(clause: Clause<'q, T1>, condition: Clause<'q, T2>) -> Clause<'q, R> {
    let (mut sql, mut params) = clause.unwrap();
    sql.push_str(" OR (");
    sql.push_str(&condition.sql);
    sql.push(')');
    params.extend(condition.params);
    Clause::new(sql, params)
}
fn __condition<'q, T, C>(
    connector: &str,
    clause: Clause<'q, T>,
    condition: Clause<'q, Condition>,
) -> Clause<'q, C> {
    let (mut sql, mut params) = clause.unwrap();
    let (cond_sql, cond_params) = condition.unwrap();
    sql.push_str(connector);
    sql.push_str(&cond_sql);
    params.extend_from_slice(&cond_params);
    Clause::new(sql, params)
}

const LOGIC_CONN_NONE: &str = "";
const LOGIC_CONN_AND: &str = " AND ";
const LOGIC_CONN_OR: &str = " OR ";