rustorm 0.0.8

An ORM for rust
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use r2d2::Pool;
use r2d2_postgres::{PostgresConnectionManager};
use r2d2::Config;
use postgres::SslMode;
use config::DbConfig;
use database::{Database, DatabaseDDL, DatabaseDev};
use platform::Postgres;
use platform::Sqlite;
use platform::Mysql;
use mysql::conn::pool::{MyPool, MyPooledConn};
use mysql::conn::MyOpts;


/// the sql builder for each of the database platform
pub enum Platform{
    Postgres(Postgres),
    Sqlite(Sqlite),
    Oracle,
    Mysql(Mysql),
}


impl Platform{
    
    pub fn as_ref(&self)->&Database{
        match *self{
            Platform::Postgres(ref pg) => pg,
            Platform::Sqlite(ref lite) => lite,
            _ => panic!("others not yet..")
        }
    }
    pub fn as_ref_mut(&mut self)->&mut Database{
        match *self{
            Platform::Postgres(ref mut pg) => pg,
            Platform::Sqlite(ref mut lite) => lite,
            Platform::Mysql(ref mut my) => my,
            _ => panic!("others not yet..")
        }
    }
    pub fn as_ddl(&self)->&DatabaseDDL{
        match *self{
            Platform::Postgres(ref pg) => pg,
            Platform::Sqlite(ref lite) => lite,
            Platform::Mysql(ref my) => my,
            _ => panic!("others not yet..")
        }
    }
    pub fn as_ddl_mut(&mut self)->&mut DatabaseDDL{
        match *self{
            Platform::Postgres(ref mut pg) => pg,
            Platform::Sqlite(ref mut lite) => lite,
            Platform::Mysql(ref mut my) => my,
            _ => panic!("others not yet..")
        }
    }
    
    pub fn as_dev(&self)->&DatabaseDev{
        match *self{
            Platform::Postgres(ref pg) => pg,
            _ => panic!("others not yet..")
        }
    }
    pub fn as_dev_mut(&mut self)->&mut DatabaseDev{
        match *self{
            Platform::Postgres(ref mut pg) => pg,
            _ => panic!("others not yet..")
        }
    }
}

pub enum ManagedPool{
    Postgres(Pool<PostgresConnectionManager>),
    Sqlite,
    Oracle,
    Mysql(MyPool),
}

impl ManagedPool{
    
    /// initialize the pool
    /// TODO: return result instead of unwrap
    pub fn init(url: &str, pool_size: usize)->Self{
        let config = DbConfig::from_url(url);
        let platform:&str = &config.platform;
        match platform{
            "postgres" => {
                let manager = PostgresConnectionManager::new(url, SslMode::None).unwrap();
                let config = Config::builder().pool_size(pool_size as u32).build();
                let pool = Pool::new(config, manager).unwrap();
                ManagedPool::Postgres(pool)
            }
            "sqlite" => {
                panic!("sqlite soon!");
            }
            "mysql" => {
                let config = DbConfig::from_url(url);
                let opts = MyOpts {
                    user: config.username,
                    pass: config.password,
                    db_name: Some(config.database),
                    tcp_addr: Some(config.host.unwrap().to_string()),
                    tcp_port: config.port.unwrap_or(3306),
                    ..Default::default()
                };
                let pool = MyPool::new_manual(0, pool_size, opts).unwrap();
                ManagedPool::Mysql(pool)
            }
            _ => panic!("not yet")
        }
    }
    
    /// a conection is created here
    pub fn connect(&self)->Result<Platform, String>{
        match *self{
            ManagedPool::Postgres(ref pool) => {
                let conn = pool.get();//the connection is created here
                match conn{
                    Ok(conn) => {
                        let pg = Postgres::with_pooled_connection(conn);
                        Ok(Platform::Postgres(pg))
                    },
                    Err(e) => {
                        Err(format!("Unable to connect {}", e))
                    }
                }
            },
            ManagedPool::Sqlite => {
                Err("Sqlite is not supported yet".to_string())
            },
            ManagedPool::Mysql(ref pool) => {
                let conn = pool.get_conn();//the connection is created here
                match conn{
                    Ok(conn) => {
                        let my = Mysql::with_connection(conn.unwrap());
                        Ok(Platform::Mysql(my))
                    },
                    Err(e) => {
                        Err(format!("Unable to connect {}", e))
                    }
                }
            },
            _ => Err("Any other database is not yet supported".to_string())
        }
    }
}