halo-sqlbuilder 1.0.0

Composable SQL builder and argument collector
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
122
123
124
125
126
127
128

//! WhereClause: reusable WHERE clause builder.

use crate::args::Args;
use crate::flavor::Flavor;
use crate::macros::{IntoStrings, collect_into_strings};
use crate::modifiers::{Arg, Builder};
use crate::string_builder::{StringBuilder, filter_empty_strings};
use std::cell::RefCell;
use std::rc::Rc;

pub type ArgsRef = Rc<RefCell<Args>>;
pub type WhereClauseRef = Rc<RefCell<WhereClause>>;

/// CopyWhereClause: deep clone a WhereClause.
pub fn copy_where_clause(wc: &WhereClauseRef) -> WhereClauseRef {
    Rc::new(RefCell::new(wc.borrow().clone()))
}

#[derive(Debug, Clone)]
struct Clause {
    args: ArgsRef,
    and_exprs: Vec<String>,
}

impl Clause {
    fn build(&self, flavor: Flavor, initial: &[Arg]) -> (String, Vec<Arg>) {
        let exprs = filter_empty_strings(self.and_exprs.clone());
        if exprs.is_empty() {
            return (String::new(), initial.to_vec());
        }
        let mut buf = StringBuilder::new();
        buf.write_strings(&exprs, " AND ");
        self.args
            .borrow()
            .compile_with_flavor(&buf.into_string(), flavor, initial)
    }
}

/// WhereClause: shareable but not thread-safe.
#[derive(Debug, Default, Clone)]
pub struct WhereClause {
    flavor: Flavor,
    clauses: Vec<Clause>,
}

impl WhereClause {
    pub fn new() -> WhereClauseRef {
        Rc::new(RefCell::new(Self::default()))
    }

    pub fn set_flavor(&mut self, flavor: Flavor) -> Flavor {
        let old = self.flavor;
        self.flavor = flavor;
        old
    }

    pub fn flavor(&self) -> Flavor {
        self.flavor
    }

    /// AddWhereExpr: append AND expressions to the where clause (same ArgsRef merges into one clause).
    pub fn add_where_expr<T>(&mut self, args: ArgsRef, exprs: T)
    where
        T: IntoStrings,
    {
        let exprs = collect_into_strings(exprs);
        if exprs.is_empty() || exprs.iter().all(|s| s.is_empty()) {
            return;
        }

        if let Some(last) = self.clauses.last_mut()
            && Rc::ptr_eq(&last.args, &args)
        {
            last.and_exprs.extend(exprs);
            return;
        }

        self.clauses.push(Clause {
            args,
            and_exprs: exprs,
        });
    }

    pub fn add_where_clause(&mut self, other: &WhereClause) {
        self.clauses.extend(other.clauses.clone());
    }
}

/// WhereClause as a Builder: builds `WHERE ...`.
#[derive(Clone)]
pub struct WhereClauseBuilder {
    wc: WhereClauseRef,
}

impl WhereClauseBuilder {
    pub fn new(wc: WhereClauseRef) -> Self {
        Self { wc }
    }
}

impl Builder for WhereClauseBuilder {
    fn build_with_flavor(&self, flavor: Flavor, initial_arg: &[Arg]) -> (String, Vec<Arg>) {
        let wc = self.wc.borrow();
        if wc.clauses.is_empty() {
            return (String::new(), initial_arg.to_vec());
        }

        let mut buf = StringBuilder::new();
        buf.write_str("WHERE ");

        let (sql0, args0) = wc.clauses[0].build(flavor, initial_arg);
        buf.write_str(&sql0);
        let mut args = args0;

        for clause in &wc.clauses[1..] {
            buf.write_str(" AND ");
            let (s, a) = clause.build(flavor, &args);
            buf.write_str(&s);
            args = a;
        }

        (buf.into_string(), args)
    }

    fn flavor(&self) -> Flavor {
        self.wc.borrow().flavor
    }
}