deuterium 0.2.1

Deuterium is a fancy SQL builder for Rust. It's designed to provide a DSL to easily build SQL queries in safe and *typed* way.
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


use time::Timespec;

use predicate::{Predicate, ToAbstractPredicate, RcPredicate};
use expression::{ToExpression};

use expression::{RawExpr};
use field::{
    I8Field,
    I16Field,
    I32Field,
    I64Field,
    F32Field,
    F64Field,
    TimespecField,

    OptionalI8Field,
    OptionalI16Field,
    OptionalI32Field,
    OptionalI64Field,
    OptionalF32Field,
    OptionalF64Field,
    OptionalTimespecField,
};

use sql::{ToPredicateValue};

#[deriving(Clone, Copy)]
pub enum Inequality {
    LessThan,
    LessThanEqual,
    GreaterThan,
    GreaterThanEqual
}

#[deriving(Clone)]
pub struct InequalityPredicate<F, T> {
    pub field: F,
    pub value: T,
    pub inequality: Inequality
}

pub trait ToInequalityPredicate<F, T> {
    fn lt(&self, val: T) -> RcPredicate;
    fn lte(&self, val: T) -> RcPredicate;
    fn gt(&self, val: T) -> RcPredicate;
    fn gte(&self, val: T) -> RcPredicate;
}

macro_rules! inequality_methods(
    ($v:ty) => (
        fn lt(&self, val: $v) -> RcPredicate {
            InequalityPredicate {
                field: self.clone(),
                value: val,
                inequality: Inequality::LessThan
            }.upcast()
        }

        fn lte(&self, val: $v) -> RcPredicate {
            InequalityPredicate {
                field: self.clone(),
                value: val,
                inequality: Inequality::LessThanEqual
            }.upcast()
        }

        fn gt(&self, val: $v) -> RcPredicate {
            InequalityPredicate {
                field: self.clone(),
                value: val,
                inequality: Inequality::GreaterThan
            }.upcast()
        }

        fn gte(&self, val: $v) -> RcPredicate {
            InequalityPredicate {
                field: self.clone(),
                value: val,
                inequality: Inequality::GreaterThanEqual
            }.upcast()
        }
    )
)

macro_rules! impl_for(
    ($field:ty, $v:ty) => (
        impl<T: ToExpression<$v> + ToPredicateValue + Clone> Predicate for InequalityPredicate<$field, T> { }

        impl<T: ToExpression<$v> + ToPredicateValue + Clone> ToInequalityPredicate<$field, T> for $field {
            inequality_methods!(T)    
        }
    )
)

impl_for!(I8Field, i8)
impl_for!(I16Field, i16)
impl_for!(I32Field, i32)
impl_for!(I64Field, i64)
impl_for!(F32Field, f32)
impl_for!(F64Field, f64)
impl_for!(TimespecField, Timespec)

impl_for!(OptionalI8Field, Option<i8>)
impl_for!(OptionalI16Field, Option<i16>)
impl_for!(OptionalI32Field, Option<i32>)
impl_for!(OptionalI64Field, Option<i64>)
impl_for!(OptionalF32Field, Option<f32>)
impl_for!(OptionalF64Field, Option<f64>)
impl_for!(OptionalTimespecField, Option<Timespec>)

impl_for!(RawExpr, RawExpr)