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

//! The `LIKE` operation.

use Result;
use grammar::definition::Column;
use grammar::{Condition, Expression, Operation};

/// A `LIKE` operation.
#[derive(Debug)]
pub struct Like(Box<Expression>, String);

/// An object that can be matched.
pub trait Likable {
    /// Set a matcher.
    fn like<T: ToString>(self, T) -> Like;
}

impl Condition for Like {
    #[inline]
    fn compile(&self) -> Result<String> {
        Operation::compile(self)
    }
}

impl Operation for Like {
    #[inline]
    fn compile(&self) -> Result<String> {
        Ok(format!("{} LIKE '{}'", try!(self.0.compile()), self.1))
    }
}

impl Likable for Column {
    #[inline]
    fn like<T: ToString>(self, pattern: T) -> Like {
        Like(Box::new(self), pattern.to_string())
    }
}

impl<'l> Likable for &'l str {
    #[inline]
    fn like<T: ToString>(self, pattern: T) -> Like {
        Like(Box::new(self.to_string()), pattern.to_string())
    }
}

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

    #[test]
    fn from_column() {
        assert_eq!(column("foo").like("bar").compile().unwrap(), "`foo` LIKE 'bar'");
    }

    #[test]
    fn from_string() {
        assert_eq!("foo".like("bar").compile().unwrap(), "foo LIKE 'bar'");
    }
}