rustorm 0.0.3

A simple ORM and code generator 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

use filter::Filter;
use query::Query;
use table::Table;
use types::Dao;
use database::Database;

pub trait EntityManager{

    /// begin transaction
    fn begin(&self);

    /// commit transaction
    fn commit(&self);

    /// count the number of results based on this query
    fn count(&self, query:&Query)->usize;

    /// create a database table aligned to this model definition
    fn create_table(&self, model: &Table);

    /// create a schema or namespace in the database
    fn create_schema(&self, schema:String);

    /// delete records of this table
    fn delete(&self, table:String, filters:&Vec<Filter>)->usize;

    /// drop the database table
    fn drop_table(&self, schema:String, table:String, forced:bool);

    /// drop the database schema
    fn drop_schema(&self, schema:String, forced:bool);

    /// empty the database table
    fn truncate_table(&self, schema:String, table:String, forced:bool) ->usize;

    /// determine if the table exist
    fn exist_table(&self, schema: String, table:String)->bool;
    
    /// determine if the schema exist
    fn exist_schema(&self, schema: String)->bool;

    /// get all the records of this table
    fn get_all(&self, table:String)->Vec<Dao>;

    /// get all the distinct records of this table
    fn get_all_distinct(&self, table:String)->Vec<Dao>;

    /// get all the records on this table which passed thru the filters
    /// any query that specified more than the parameters should use the query api
    fn get_all_with_filter(&self, table:String, filters:Vec<Filter>)->Vec<Dao>;

    /// get the first records of this table that passed thru the filters
    fn get_one(&self, table:String, filter:Vec<Filter>)->Dao;

    /// insert this records to the database
    fn insert(&self, dao:Dao);
    
    /// this is called when there is a problem with the transaction
    fn reset(&self);

    /// retrieve records from query object
    fn retrieve(&self, query:&Query)->Vec<Dao>;

    /// when there is a problem with the transaction process, this can be called
    fn rollback(&self, );
    
    /// update the Dao, return the updated Dao
    fn update(&self, dao:&Dao)->Dao;

    /// update the Dao with filter, return the updated Dao
    fn update_with_filter(&self, dao:&Dao, filter:Vec<Filter>)->Dao;

    
}

pub struct SyncEm<'a>{
    db:&'a Database,
}

impl <'a>SyncEm<'a>{
    
    pub fn new(db:&'a Database)->Self{
        SyncEm{db:db}
    }
}

impl <'a> EntityManager for SyncEm<'a>{
    
    fn begin(&self){
        self.db.begin();
    }

    fn commit(&self){panic!("not yet")}

    fn count(&self, query:&Query)->usize{panic!("not yet")}

    fn create_table(&self, model: &Table){panic!("not yet")}

    fn create_schema(&self, schema:String){panic!("not yet")}

    fn delete(&self, table:String, filters:&Vec<Filter>)->usize{panic!("not yet")}

    fn drop_table(&self, schema:String, table:String, forced:bool){panic!("not yet")}

    fn drop_schema(&self, schema:String, forced:bool){panic!("not yet")}

    fn truncate_table(&self, schema:String, table:String, forced:bool) ->usize{panic!("not yet")}

    fn exist_table(&self, schema: String, table:String)->bool{panic!("not yet")}
    
    fn exist_schema(&self, schema: String)->bool{panic!("not yet")}

    fn get_all(&self, table:String)->Vec<Dao>{panic!("not yet")}

    fn get_all_distinct(&self, table:String)->Vec<Dao>{panic!("not yet")}

    fn get_all_with_filter(&self, table:String, filters:Vec<Filter>)->Vec<Dao>{panic!("not yet")}

    fn get_one(&self, table:String, filter: Vec<Filter>)->Dao{panic!("not yet")}

    fn insert(&self, dao:Dao){panic!("not yet")}
    
    fn reset(&self){panic!("not yet")}

    fn retrieve(&self, query:&Query)->Vec<Dao>{panic!("not yet")}

    fn rollback(&self, ){panic!("not yet")}
    
    fn update(&self, dao:&Dao)->Dao{panic!("not yet")}

    fn update_with_filter(&self, dao:&Dao, filter:Vec<Filter>)->Dao{panic!("not yet")}
}