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

use super::separator_optional;
use crate::{ArgumentBuffer, WriteSql};

/// Writes a LIMIT clause into a sql writer.
///
/// LIMIT <count>
///
/// # Example
///
/// ```
/// # use sqlstr::{SqlCommand, Void, SqlExpr, expr::limit};
/// # use core::convert::Infallible;
/// # fn main() -> Result<(), Infallible> {
/// let mut sql: SqlCommand<Void> = SqlCommand::default();
/// limit(&mut sql, 10);
///
/// assert_eq!(sql.as_command(), "LIMIT $1");
/// # Ok(())
/// # }
/// ```
pub fn limit<Sql, Arg>(sql: &mut Sql, count: usize) -> Result<(), Arg::Error>
where
    Sql: WriteSql<Arg>,
    Arg: ArgumentBuffer<usize>,
{
    separator_optional(sql);
    sql.push_cmd("LIMIT ");
    sql.push_value(count)
}

/// Writes a offset clause into a sql writer.
///
/// OFFSET <start>
///
/// # Example
///
/// ```
/// # use sqlstr::{SqlCommand, Void, SqlExpr, expr::offset};
/// # use core::convert::Infallible;
/// # fn main() -> Result<(), Infallible> {
/// let mut sql: SqlCommand<Void> = SqlCommand::default();
/// offset(&mut sql, 30);
///
/// assert_eq!(sql.as_command(), "OFFSET $1");
/// # Ok(())
/// # }
/// ```
pub fn offset<Sql, Arg>(sql: &mut Sql, start: usize) -> Result<(), Arg::Error>
where
    Sql: WriteSql<Arg>,
    Arg: ArgumentBuffer<usize>,
{
    separator_optional(sql);
    sql.push_cmd("OFFSET ");
    sql.push_value(start)
}

#[macro_export]
macro_rules! static_limit {
    (LIMIT $count:literal) => {
        concat!("LIMIT ", $count)
    };
}

pub use static_limit;

#[macro_export]
macro_rules! static_offset {
    (OFFSET $start:literal) => {
        concat!("OFFSET ", $start)
    };
}

pub use static_offset;

#[cfg(test)]
mod test {
    #[test]
    fn static_limit_macro() {
        assert_eq!(static_limit!(LIMIT 15), "LIMIT 15");
        assert_eq!(static_limit!(LIMIT 20), "LIMIT 20");
        assert_eq!(static_limit!(LIMIT "0"), "LIMIT 0");
        assert_eq!(static_limit!(LIMIT "ALL"), "LIMIT ALL");
        assert_eq!(static_limit!(LIMIT "INVALID"), "LIMIT INVALID");
    }

    #[test]
    fn static_offset_macro() {
        assert_eq!(static_offset!(OFFSET 15), "OFFSET 15");
        assert_eq!(static_offset!(OFFSET 20), "OFFSET 20");
        assert_eq!(static_offset!(OFFSET "0"), "OFFSET 0");
        assert_eq!(static_offset!(OFFSET "ALL"), "OFFSET ALL");
        assert_eq!(static_offset!(OFFSET "INVALID"), "OFFSET INVALID");
    }
}