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

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

impl<'a> ToSql<'a> for crate::value::Value<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        args.push(self);
        D::bind_param(args.len(), self, sql);
    }
}

impl<'a> ToSql<'a> for crate::item::Ident<'a> {
    fn build<D: Dialect>(self, sql: &mut String, _: &mut Vec<crate::value::Value<'a>>) {
        D::quote_ident(self.0, sql);
    }
}

impl<'a> ToSql<'a> for crate::item::Sort {
    #[inline]
    fn build<D: Dialect>(self, sql: &mut String, _: &mut Vec<crate::value::Value<'a>>) {
        match self {
            crate::item::Sort::Asc => sql.push_str("ASC"),
            crate::item::Sort::Desc => sql.push_str("DESC"),
        }
    }
}

impl<'a> ToSql<'a> for crate::item::Order<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        self.0.build::<D>(sql, args);
        if let Some(sort) = self.1 {
            sql.push(' ');
            sort.build::<D>(sql, args);
        }
    }
}

impl<'a> ToSql<'a> for crate::item::Field<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        self.expr.build::<D>(sql, args);
        if let Some(alias) = self.alias {
            sql.push_str(" AS ");
            alias.build::<D>(sql, args);
        }
    }
}

impl<'a> ToSql<'a> for crate::item::Table<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        self.table.build::<D>(sql, args);
        if let Some(alias) = self.alias {
            sql.push_str(" AS ");
            alias.build::<D>(sql, args);
        }
    }
}

impl<'a> ToSql<'a> for crate::item::ColumnRef<'a> {
    #[inline]
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        match self {
            crate::item::ColumnRef::Column(col) => col.build::<D>(sql, args),
            crate::item::ColumnRef::TableColumn(tbl, col) => join!(D, sql, args, ".", [tbl, col]),
            crate::item::ColumnRef::SchemaTableColumn(sch, tbl, col) => {
                join!(D, sql, args, ".", [sch, tbl, col])
            }
        }
    }
}

impl<'a> ToSql<'a> for crate::item::FuncRef<'a> {
    #[inline]
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        match self {
            crate::item::FuncRef::Func(fun) => fun.build::<D>(sql, args),
            crate::item::FuncRef::SchemaFunc(sch, fun) => join!(D, sql, args, ".", [sch, fun]),
        }
    }
}

impl<'a> ToSql<'a> for crate::item::TableRef<'a> {
    #[inline]
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        match self {
            crate::item::TableRef::Table(tbl) => tbl.build::<D>(sql, args),
            crate::item::TableRef::SchemaTable(sch, tbl) => join!(D, sql, args, ".", [sch, tbl]),
        }
    }
}

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

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

impl<'a> ToSql<'a> for crate::item::Cte<'a> {
    fn build<D: Dialect>(self, sql: &mut String, args: &mut Vec<crate::value::Value<'a>>) {
        self.name.build::<D>(sql, args);
        if !self.columns.is_empty() {
            sql.push('(');
            join!(D, sql, args, ", ", self.columns);
            sql.push(')');
        }
        sql.push_str(" AS ");
        sql.push('(');
        self.stmt.build::<D>(sql, args);
        sql.push(')');
    }
}