deuterium 0.0.1 

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


use join::{
    Join,
    ConditionedJoinType,
    UnconditionedJoinType
};

use join::Join::{
    ConditionedJoin,
    UnconditionedJoin,
};

use join::ConditionedJoinType::{
    InnerJoin,
    FullOuterJoin,
    RightOuterJoin, 
    LeftOuterJoin,
    FullJoin,
    RightJoin,
    LeftJoin
};

use join::UnconditionedJoinType::{
    NaturalJoin,
    NaturalLeftJoin,
    NaturalRightJoin,
    NaturalFullJoin,
    CrossJoin
};

use sql::{SqlContext, ToSql};

impl ToSql for ConditionedJoinType {
    fn to_sql(&self, _ctx: &mut SqlContext) -> String {
        match self {
            &InnerJoin => "INNER JOIN",
            &FullOuterJoin => "FULL OUTER JOIN",
            &RightOuterJoin => "RIGHT OUTER JOIN",
            &LeftOuterJoin => "LEFT OUTER JOIN",
            &FullJoin => "FULL JOIN",
            &RightJoin => "RIGHT JOIN",
            &LeftJoin => "LEFT JOIN",
        }.to_string()
    }
}

impl ToSql for UnconditionedJoinType {
    fn to_sql(&self, _ctx: &mut SqlContext) -> String {
        match self {
            &NaturalJoin => "NATURAL JOIN",
            &NaturalLeftJoin => "NATURAL LEFT JOIN",
            &NaturalRightJoin => "NATURAL RIGHT JOIN",
            &NaturalFullJoin => "NATURAL FULL JOIN",
            &CrossJoin => "CROSS JOIN",
        }.to_string()
    }
}

impl ToSql for Join {
    fn to_sql(&self, ctx: &mut SqlContext) -> String {
        match self {
            &ConditionedJoin{ref join_type, ref from, ref on} => {
                format!("{} {} ON {}", join_type.to_sql(ctx), from.as_sql().to_from_sql(ctx), on.to_sql(false, ctx))
            },
            &UnconditionedJoin{ref join_type, ref from} => {
                format!("{} {}", join_type.to_sql(ctx), from.as_sql().to_from_sql(ctx))
            }
        }
    }
}