sqlstr 0.1.0

Sql string builder
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

use core::marker::PhantomData;

use crate::WriteSql;

pub struct Group<'cmd, Sql: WriteSql<Arg>, Arg>(&'cmd mut Sql, PhantomData<Arg>);

impl<'cmd, Sql, Arg> Group<'cmd, Sql, Arg>
where
    Sql: WriteSql<Arg>,
{
    pub fn open(command: &'cmd mut Sql) -> Self {
        command.push_cmd("(");
        Self(command, PhantomData)
    }

    pub fn close(self) {
        core::mem::drop(self)
    }

    pub fn sql(&mut self) -> &mut Sql {
        self.0
    }
}

impl<'cmd, Sql, Arg> WriteSql<Arg> for Group<'cmd, Sql, Arg>
where
    Sql: WriteSql<Arg>,
{
    fn push_expr<T>(&mut self, operand: crate::SqlExpr<'_, T>) -> Result<(), <Arg>::Error>
    where
        Arg: crate::ArgumentBuffer<T>,
    {
        self.0.push_expr(operand)
    }

    fn push_value<T>(&mut self, value: T) -> Result<(), <Arg>::Error>
    where
        Arg: crate::ArgumentBuffer<T>,
    {
        self.0.push_value(value)
    }

    fn push_cmd(&mut self, expr: &str) {
        self.0.push_cmd(expr)
    }

    fn as_command(&self) -> &str {
        self.0.as_command()
    }
}

impl<'cmd, Sql, Arg> Drop for Group<'cmd, Sql, Arg>
where
    Sql: WriteSql<Arg>,
{
    fn drop(&mut self) {
        self.0.push_cmd(")");
    }
}

#[cfg(test)]
mod test {
    use alloc::string::String;

    use super::Group;
    use crate::{test::TestArgs, SqlCommand};

    #[test]
    fn group_condition() {
        let mut sql = SqlCommand::new(String::new(), TestArgs::new());
        let mut group = Group::open(&mut sql);
        group.sql().push_cmd("user.name = ");
        group.sql().push_value("Rust").unwrap();
        group.sql().push_cmd(" AND user.active = ");
        group.sql().push_value(true).unwrap();
        group.close();

        assert_eq!(sql.as_command(), "(user.name = $1 AND user.active = $2)");
        assert_eq!(sql.arguments.as_str(), "Rust;true;");
    }

    #[test]
    fn group_scope() {
        let mut sql: SqlCommand<TestArgs> = SqlCommand::default();
        {
            let mut group = Group::open(&mut sql);
            group.sql().push_cmd("user.name = ");
            group.sql().push_value("Rust").unwrap();
            group.sql().push_cmd(" AND user.active = ");
            group.sql().push_value(true).unwrap();
        }

        assert_eq!(sql.as_command(), "(user.name = $1 AND user.active = $2)");
        assert_eq!(sql.arguments.as_str(), "Rust;true;");
    }
}