arel 0.0.6

arel: a sql orm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::methods::{quote_table_name};
use crate::traits::ArelAble;
use crate::collectors::SqlString;
use crate::table::{SelectManager, update_manager::{UpdateManager, UpdateStatement}, insert_manager::{InsertManager, InsertStatement}, delete_manager::{DeleteManager, DeleteStatement}};
use crate::table::select_manager::select_statement::{SelectCore, SelectStatement};
use crate::methods;

pub fn accept_select_manager<'a, M: ArelAble>(select_manager: &'a SelectManager<M>, collector: &'a mut SqlString) -> anyhow::Result<&'a mut SqlString> {
    let ast: &SelectStatement<M> = &select_manager.ast;
    let cores: &Vec<SelectCore<M>> = &ast.cores;
    for core in cores {
        visit_arel_select_core(core, collector)?;
    }
    // SelectOptions
    if let Some(sql_literal) = ast.get_order_sql()? {
        collector.push_str(" ORDER BY ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = ast.get_limit_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = ast.get_offset_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = ast.get_lock_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    Ok(collector)
}

fn visit_arel_select_core<'a, M: ArelAble>(core: &'a SelectCore<M>, collector: &'a mut SqlString) -> anyhow::Result<&'a mut SqlString> {
    collector.push_str(&core.get_select_sql()?.raw_sql);
    collector.push_str(" FROM ");
    collector.push_str(&quote_table_name(&M::table_name()));
    if let Some(sql_literal) = core.get_joins_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = core.get_where_sql()? {
        collector.push_str(" WHERE ").push_str(&sql_literal.raw_sql);
    }
    // core.groups
    if let Some(sql_literal) = core.get_group_sql()? {
        collector.push_str(" GROUP BY ").push_str(&sql_literal.raw_sql);
    }
    // core.havings
    if let Some(sql_literal) = core.get_having_sql()? {
        collector.push_str(" HAVING ").push_str(&sql_literal.raw_sql);
    }
    Ok(collector)
}

pub fn accept_update_manager<'a, M: ArelAble>(update_manager: &'a UpdateManager<M>, for_update_select_manager: Option<&mut SelectManager<M>>, collector: &'a mut SqlString) -> anyhow::Result<&'a mut SqlString> {
    let ast: &UpdateStatement<M> = &update_manager.ast;
    if let Some(sql_literal) = ast.get_update_sql()? {
        collector.push_str(&sql_literal.raw_sql);
    }

    let mut exists_where = false;
    if let Some(sql_literal) = ast.get_where_sql()? {
        collector.push_str(" WHERE ").push_str(&sql_literal.raw_sql);
        exists_where = true;
    }
    if let Some(sql_literal) = ast.get_order_sql()? {
        collector.push_str(" ORDER BY ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = ast.get_limit_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = ast.get_offset_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    if let Some(subquery) = accept_subquery_select_manager(for_update_select_manager)? {
        collector.push_str(if exists_where { " AND " } else { " WHERE " });
        collector.push_str(&subquery);
    }
    Ok(collector)
}

pub fn accept_insert_manager<'a, M: ArelAble>(insert_manager: &'a InsertManager<M>, collector: &'a mut SqlString) -> anyhow::Result<&'a mut SqlString> {
    let ast: &InsertStatement<M> = &insert_manager.ast;
    if let Some(sql_literal) = ast.get_insert_sql()? {
        collector.push_str(&sql_literal.raw_sql);
    }
    Ok(collector)
}

pub fn accept_delete_manager<'a, M: ArelAble>(delete_manager: &'a DeleteManager<M>, for_delete_select_manager: Option<&mut SelectManager<M>>, collector: &'a mut SqlString) -> anyhow::Result<&'a mut SqlString> {
    let ast: &DeleteStatement<M> = &delete_manager.ast;
    collector.push_str("DELETE FROM ");
    collector.push_str(&quote_table_name(&M::table_name()));

    let mut exists_where = false;
    if let Some(sql_literal) = ast.get_where_sql()? {
        collector.push_str(" WHERE ").push_str(&sql_literal.raw_sql);
        exists_where = true;
    }
    if let Some(sql_literal) = ast.get_order_sql()? {
        collector.push_str(" ORDER BY ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = ast.get_limit_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    if let Some(sql_literal) = ast.get_offset_sql()? {
        collector.push_str(" ").push_str(&sql_literal.raw_sql);
    }
    if let Some(subquery) = accept_subquery_select_manager(for_delete_select_manager)? {
        collector.push_str(if exists_where { " AND " } else { " WHERE " });
        collector.push_str(&subquery);
    }
    Ok(collector)
}

fn accept_subquery_select_manager<M: ArelAble>(subquery_select_manager: Option<&mut SelectManager<M>>) -> anyhow::Result<Option<String>> {
    if let Some(subquery_select_manager) = subquery_select_manager {
        let mut select_collector = SqlString::default();
        let subquery = format!("SELECT `{}` FROM ({}) AS __arel_subquery_temp", M::primary_key(), accept_select_manager(subquery_select_manager, &mut select_collector)?.value);
        Ok(Some(format!("{} IN ({})", methods::table_column_name::<M>(M::primary_key()), subquery)))
    } else {
        Ok(None)
    }

}