sql 0.4.3

The package provides a constructor of SQL statements.
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

//! The `ORDER BY` clause.

use Result;
use grammar::definition::Column;
use grammar::{Buffer, Clause, Expression};

/// An `ORDER BY` clause.
#[derive(Debug, Default)]
pub struct OrderBy(Vec<Box<Expression>>);

/// An order.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Order {
    /// The ascending order.
    Ascending,
    /// The descending order.
    Descending,
}

/// An object that can be ordered by.
pub trait Orderable where Self: Sized {
    /// The type produced after setting an order.
    type Output;

    /// Set the order.
    fn order(self, Option<Order>) -> Self::Output;

    /// Set the ascending order.
    fn ascend(self) -> Self::Output {
        self.order(Some(Order::Ascending))
    }

    /// Set the descending order.
    fn descend(self) -> Self::Output {
        self.order(Some(Order::Descending))
    }
}

impl OrderBy {
    #[doc(hidden)]
    pub fn append<T>(mut self, expression: T) -> Self where T: Expression + 'static {
        self.0.push(Box::new(expression));
        self
    }
}

impl Clause for OrderBy {
    fn compile(&self) -> Result<String> {
        let mut buffer = Buffer::new();
        for expression in &self.0 {
            buffer.push(try!(expression.compile()));
        }
        Ok(format!("ORDER BY {}", buffer.join(", ")))
    }
}

impl Orderable for Column {
    type Output = (Column, Option<Order>);

    #[inline]
    fn order(self, order: Option<Order>) -> Self::Output {
        (self, order)
    }
}

impl<'l> Orderable for &'l str {
    type Output = (String, Option<Order>);

    #[inline]
    fn order(self, order: Option<Order>) -> Self::Output {
        (self.to_string(), order)
    }
}

impl<T: Expression> Expression for (T, Option<Order>) {
    fn compile(&self) -> Result<String> {
        let main = try!(self.0.compile());
        Ok(match self.1 {
            Some(Order::Ascending) => format!("{} ASC", main),
            Some(Order::Descending) => format!("{} DESC", main),
            _ => main,
        })
    }
}

#[cfg(test)]
mod tests {
    use grammar::Clause;
    use prelude::*;

    macro_rules! new(
        ($first:expr) => (super::OrderBy::default().append($first));
    );

    #[test]
    fn from_column() {
        let clause = new!(column("foo"));
        assert_eq!(clause.compile().unwrap(), "ORDER BY `foo`");

        let clause = new!(column("foo").ascend());
        assert_eq!(clause.compile().unwrap(), "ORDER BY `foo` ASC");

        let clause = new!(column("foo").descend());
        assert_eq!(clause.compile().unwrap(), "ORDER BY `foo` DESC");
    }

    #[test]
    fn from_string() {
        let clause = new!("foo");
        assert_eq!(clause.compile().unwrap(), "ORDER BY foo");

        let clause = new!("foo".ascend());
        assert_eq!(clause.compile().unwrap(), "ORDER BY foo ASC");

        let clause = new!("foo".descend());
        assert_eq!(clause.compile().unwrap(), "ORDER BY foo DESC");
    }

    #[test]
    fn append() {
        let clause = new!("foo").append(column("bar").ascend())
                                .append("baz".to_string().descend());

        assert_eq!(clause.compile().unwrap(), "ORDER BY foo, `bar` ASC, baz DESC");
    }
}