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


use from::{RcFrom};
use predicate::{RcPredicate};

use self::Join::*;
use self::ConditionedJoinType::*;
use self::UnconditionedJoinType::*;

#[allow(dead_code)]
#[deriving(Clone)]
pub enum ConditionedJoinType {
    InnerJoin,
    FullOuterJoin,
    RightOuterJoin, 
    LeftOuterJoin,
    FullJoin,
    RightJoin,
    LeftJoin
}

#[allow(dead_code)]
#[deriving(Clone)]
pub enum UnconditionedJoinType {
    NaturalJoin,
    NaturalLeftJoin,
    NaturalRightJoin,
    NaturalFullJoin,
    CrossJoin
}

#[allow(dead_code)]
#[deriving(Clone)]
pub enum Join {
    ConditionedJoin {
        join_type: ConditionedJoinType,
        from: RcFrom,
        on: RcPredicate
    },

    UnconditionedJoin {
        join_type: UnconditionedJoinType,
        from: RcFrom
    }
}

impl Join {
    pub fn inner_join(from: RcFrom, predicate: RcPredicate) -> Join { 
        ConditionedJoin{ join_type: InnerJoin, from: from, on: predicate } 
    }

    pub fn full_outer_join(from: RcFrom, predicate: RcPredicate) -> Join { 
        ConditionedJoin{ join_type: FullOuterJoin, from: from, on: predicate } 
    }

    pub fn right_outer_join(from: RcFrom, predicate: RcPredicate) -> Join { 
        ConditionedJoin{ join_type: RightOuterJoin, from: from, on: predicate } 
    }

    pub fn left_outer_join(from: RcFrom, predicate: RcPredicate) -> Join { 
        ConditionedJoin{ join_type: LeftOuterJoin, from: from, on: predicate } 
    }

    pub fn full_join(from: RcFrom, predicate: RcPredicate) -> Join { 
        ConditionedJoin{ join_type: FullJoin, from: from, on: predicate } 
    }

    pub fn left_join(from: RcFrom, predicate: RcPredicate) -> Join { 
        ConditionedJoin{ join_type: LeftJoin, from: from, on: predicate } 
    }

    pub fn right_join(from: RcFrom, predicate: RcPredicate) -> Join { 
        ConditionedJoin{ join_type: RightJoin, from: from, on: predicate } 
    }

    pub fn natural_join(from: RcFrom) -> Join { 
        UnconditionedJoin{ join_type: NaturalJoin, from: from } 
    }

    pub fn natural_left_join(from: RcFrom) -> Join { 
        UnconditionedJoin{ join_type: NaturalLeftJoin, from: from } 
    }

    pub fn natural_right_join(from: RcFrom) -> Join { 
        UnconditionedJoin{ join_type: NaturalRightJoin, from: from } 
    }

    pub fn natural_full_join(from: RcFrom) -> Join { 
        UnconditionedJoin{ join_type: NaturalFullJoin, from: from } 
    }

    pub fn cross_join(from: RcFrom) -> Join { 
        UnconditionedJoin{ join_type: CrossJoin, from: from } 
    }

}