rustorm 0.7.0

An ORM for rust
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

use std::fmt;
use table::Column;

#[derive(Clone)]
#[derive(Debug)]
#[derive(RustcEncodable, RustcDecodable)]
pub struct ColumnName {
    pub column: String,
    pub table: Option<String>,
    // //optional schema, if ever there are same tables resideing in  different schema/namespace
    pub schema: Option<String>,
}


impl <S:Into<String>>From<S> for ColumnName{
   
   fn from(s: S) -> Self {
        let column: String = s.into();
        if column.contains(".") {
            let splinters = column.split(".").collect::<Vec<&str>>();
            assert!(splinters.len() == 2, "There should only be 2 splinters");
            let table_split = splinters[0].to_owned();
            let column_split = splinters[1].to_owned();
            ColumnName {
                column: column_split.to_owned(),
                table: Some(table_split.to_owned()),
                schema: None,
            }
        } else {
            ColumnName {
                column: column.to_owned(),
                table: None,
                schema: None,
            }
        }
   }
}


impl ColumnName {


    pub fn default_rename(&self) -> String {
        match self.table {
            Some(ref s) => format!("{}.{}", s, self.column),
            None => {
                panic!("Unable to rename {} since table is not specified",
                           self.column)
            }
        }
    }

    /// table name and column name
    pub fn complete_name(&self) -> String {
        match self.table {
            Some(ref s) => format!("{}.{}", s, self.column),
            None => self.column.to_owned(),
        }
    }
    /// includes the schema, table name and column name
    pub fn super_complete_name(&self) -> String {
        match self.schema {
            Some(ref s) => format!("{}.{}", s, self.complete_name()),
            None => self.complete_name(),
        }
    }

    /// is this column conflicts the other column
    /// conflicts means, when used both in a SQL query, it will result to ambiguous columns
    pub fn is_conflicted(&self, other: &ColumnName) -> bool {
        self.column == other.column
    }
}


pub trait ToColumnName {
    fn to_column_name(&self) -> ColumnName;
}

impl ToColumnName for Column {
    fn to_column_name(&self) -> ColumnName {
        ColumnName {
            table: self.table.to_owned(),
            column: self.name.to_owned(),
            schema: None,
        }
    }
}

impl<'a> ToColumnName for &'a str {
    fn to_column_name(&self) -> ColumnName {
        ColumnName::from(*self)
    }
}


impl fmt::Display for ColumnName {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.complete_name())
    }
}

impl PartialEq for ColumnName {
    fn eq(&self, other: &Self) -> bool {
        self.column == other.column && self.table == other.table
    }

    fn ne(&self, other: &Self) -> bool {
        self.column != other.column || self.table != other.table || self.schema != other.schema
    }
}