xql 0.2.7

SQL query builder
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

use super::Dialect;
use super::ToSql;

impl<'a> ToSql<'a> for crate::clause::Select<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("SELECT ");
        join!(D, sql, args, ", ", self.0);
    }
}

impl<'a> ToSql<'a> for crate::clause::From<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("FROM ");
        join!(D, sql, args, ", ", self.0);
    }
}

impl<'a> ToSql<'a> for crate::clause::Where<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("WHERE ");
        self.0.build::<D>(sql, args);
    }
}

impl<'a> ToSql<'a> for crate::clause::GroupBy<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("GROUP BY ");
        join!(D, sql, args, ", ", self.0);
    }
}

impl<'a> ToSql<'a> for crate::clause::Having<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("HAVING ");
        self.0.build::<D>(sql, args);
    }
}

impl<'a> ToSql<'a> for crate::clause::OrderBy<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("ORDER BY ");
        join!(D, sql, args, ", ", self.0);
    }
}

impl<'a> ToSql<'a> for crate::clause::Insert<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("INSERT INTO ");
        self.0.build::<D>(sql, args);
        if !self.1.is_empty() {
            sql.push('(');
            join!(D, sql, args, ", ", self.1);
            sql.push(')');
        }
    }
}

impl<'a> ToSql<'a> for crate::clause::Values<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("VALUES ");
        join!(D, sql, args, ", ", self.0);
    }
}

impl<'a> ToSql<'a> for crate::clause::Returning<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("RETURNING ");
        join!(D, sql, args, ", ", self.0);
    }
}

impl<'a> ToSql<'a> for crate::clause::Update<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("UPDATE ");
        self.0.build::<D>(sql, args);
    }
}

impl<'a> ToSql<'a> for crate::clause::Delete<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("DELETE FROM ");
        self.0.build::<D>(sql, args);
    }
}

impl<'a> ToSql<'a> for crate::clause::Set<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("SET ");
        let mut elems = self.0.into_iter();
        if let Some(elem) = elems.next() {
            elem.0.build::<D>(sql, args);
            sql.push_str(" = ");
            elem.1.build::<D>(sql, args);
            for elem in elems {
                sql.push_str(", ");
                elem.0.build::<D>(sql, args);
                sql.push_str(" = ");
                elem.1.build::<D>(sql, args);
            }
        }
    }
}

impl<'a> ToSql<'a> for crate::clause::With<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        if self.0 {
            sql.push_str("WITH RECURSIVE ");
        } else {
            sql.push_str("WITH ");
        }
        join!(D, sql, args, ", ", self.1);
    }
}

impl<'a> ToSql<'a> for crate::clause::Limit {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("LIMIT ");
        crate::value::Value::from(self.0 as i64).build::<D>(sql, args);
    }
}

impl<'a> ToSql<'a> for crate::clause::Offset {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        sql.push_str("OFFSET ");
        crate::value::Value::from(self.0 as i64).build::<D>(sql, args);
    }
}