df_db/
lib.rs

1extern crate core;
2
3use std::path::Path;
4use json::{array, JsonValue, Null, object};
5use lazy_static::lazy_static;
6use std::sync::Mutex;
7use std::collections::HashMap;
8use ::mysql::Pool;
9
10use crate::mssql::Mssql;
11use crate::mysql::Mysql;
12use crate::sqlite::Sqlite;
13
14pub mod pools;
15lazy_static! {
16   pub static ref DB: Mutex<HashMap<String,Db>> =Mutex::new(HashMap::new());
17   pub static ref CONNECTION: Mutex<HashMap<String,Connection>> =Mutex::new(HashMap::new());
18   pub static ref DEFAULT: Mutex<HashMap<usize,String>> =Mutex::new(HashMap::new());
19}
20
21mod sqlite;
22mod mysql;
23mod mssql;
24
25pub trait Mode {
26    fn table_create(&mut self, data: Table) -> bool;
27    fn table_update(&mut self, data: Table) -> bool;
28    fn table_info(&mut self, table: &str) -> JsonValue;
29    fn table_is_exist(&mut self, name: &str) -> bool;
30    /// 当前表
31    fn table(&mut self, name: &str) -> &mut Self;
32
33    /// 主键自增
34    fn autoinc(&mut self) -> &mut Self;
35    /// 返回sql语句
36    fn fetch_sql(&mut self) -> &mut Self;
37    /// 排序
38    fn order(&mut self, field: &str, by: bool) -> &mut Self;
39    /// 分组
40    fn group(&mut self, field: &str) -> &mut Self;
41    /// 消除重复记录
42    fn distinct(&mut self) -> &mut Self;
43    /// JSON 字段
44    fn json(&mut self, field: &str) -> &mut Self;
45    /// 查询指定列并返回数组
46    fn column(&mut self, field: &str) -> JsonValue;
47    /// 查询
48    fn where_and(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self;
49    fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self;
50
51    /// 比较两个列
52    fn where_column(&mut self, field_a: &str, compare: &str, field_b: &str) -> &mut Self;
53
54    /// 总数量
55    fn count(&mut self) -> JsonValue;
56    /// 最大值
57    fn max(&mut self, field: &str) -> JsonValue;
58    /// 最小值
59    fn min(&mut self, field: &str) -> JsonValue;
60    /// 合计
61    fn sum(&mut self, field: &str) -> JsonValue;
62    /// 平均值
63    fn avg(&mut self, field: &str) -> JsonValue;
64    /// 获取集合
65    fn select(&mut self) -> JsonValue;
66    /// 获取单记录
67    fn find(&mut self) -> JsonValue;
68    /// 获取单一列值
69    fn value(&mut self, field: &str) -> JsonValue;
70    /// 添加
71    fn insert(&mut self, data: JsonValue) -> JsonValue;
72    /// 批量添加
73    fn insert_all(&mut self, data: JsonValue) -> JsonValue;
74    /// 分页
75    fn page(&mut self, page: i32, limit: i32) -> &mut Self;
76    /// 更新
77    fn update(&mut self, data: JsonValue) -> JsonValue;
78    /// 删除
79    fn delete(&mut self) -> JsonValue;
80    /// 显示字段
81    fn field(&mut self, name: &str) -> &mut Self;
82    /// 隐藏字段
83    fn hidden(&mut self, name: &str) -> &mut Self;
84    /// 池子
85    fn pool(&mut self) -> Pool;
86
87    /// 事务开始
88    fn transaction(&mut self) -> bool;
89    /// 事务提交
90    fn commit(&mut self) -> bool;
91    /// 事务回滚
92    fn rollback(&mut self) -> bool;
93    /// sql语句执行
94    fn sql(&mut self, sql: String) -> JsonValue;
95}
96
97
98#[derive(Clone, Debug)]
99pub enum Db {
100    Mysql(Mysql),
101    Sqlite(Sqlite),
102    Mssql(Mssql),
103    None,
104}
105
106impl Db {
107    pub fn new(conf: JsonValue) -> Db {
108        if conf.is_empty() {
109            return Db::None;
110        }
111        let default = conf["default"].as_str().unwrap_or("").to_string();
112        let mut connections = conf["connections"].clone();
113        if connections.is_empty() {
114            connections = object! {};
115        }
116        let connection = Connection::from(connections[default.clone()].clone().into());
117        for (name, conn) in connections.entries() {
118            CONNECTION.lock().unwrap().insert(name.to_string(), Connection::from(conn.clone().into()));
119        }
120        let connections = CONNECTION.lock().unwrap().clone();
121        DEFAULT.lock().unwrap().insert(0, default.clone());
122
123        let db = Db::setlist(connections.clone(), connection.clone(), default.clone());
124        DB.lock().unwrap().insert(default.clone(), db.clone());
125        DB.lock().unwrap().get(&*default.clone()).unwrap().clone()
126    }
127    fn setlist(connections: HashMap<String, Connection>, connection: Connection, default: String) -> Db {
128        match connection.mode.as_str() {
129            "mysql" => {
130                Mysql::connect(connection.clone(), default.clone());
131                Db::Mysql(Mysql {
132                    connections: connections.clone(),
133                    connection: connection.clone(),
134                    default: default.clone(),
135                    params: Params::default("mysql"),
136                    transaction: 0,
137                })
138            }
139            "sqlite" => {
140                Sqlite::connect(connection.clone(), default.clone());
141                Db::Sqlite(Sqlite {
142                    connections: connections.clone(),
143                    connection: connection.clone(),
144                    default: default.clone(),
145                    params: Params::default("sqlite"),
146                    transaction: 0,
147                })
148            }
149            "mssql" => {
150                Db::Mssql(Mssql {
151                    connections: connections.clone(),
152                    connection: connection.clone(),
153                    default: default.clone(),
154                    params: Params::default("mssql"),
155                })
156            }
157            _ => Db::None
158        }
159    }
160    pub fn connection(&mut self, name: &str) -> Db {
161        let default = DEFAULT.lock().unwrap();
162        let default = default.get(&0).unwrap();
163        let connections = CONNECTION.lock().unwrap().clone();
164        let name = {
165            if name == "" {
166                default
167            } else {
168                name
169            }
170        }.clone();
171
172        let dbmode = DB.lock().unwrap().get(&*name.clone()).is_none();
173        if !dbmode {
174            let db = DB.lock().unwrap().get(&*name.clone()).unwrap().clone();
175            return db;
176        }
177        let connection = connections.get(&*name.clone()).unwrap().clone();
178        let db = Db::setlist(connections.clone(), connection.clone(), name.to_string().clone());
179        DB.lock().unwrap().insert((&*name.clone()).parse().unwrap(), db.clone());
180        db
181    }
182}
183
184impl Mode for Db {
185    fn table(&mut self, name: &str) -> &mut Self {
186        match self {
187            Db::Mysql(db) => {
188                db.table(name);
189            }
190            Db::Sqlite(db) => {
191                db.table(name);
192            }
193            Db::Mssql(db) => {
194                db.table(name);
195            }
196            _ => {}
197        };
198        self
199    }
200    fn table_create(&mut self, data: Table) -> bool {
201        match self {
202            Db::Mysql(db) => {
203                db.table_create(data)
204            }
205            Db::Sqlite(db) => {
206                db.table_create(data)
207            }
208            Db::Mssql(db) => {
209                db.table_create(data)
210            }
211            _ => false
212        }
213    }
214
215    fn table_update(&mut self, data: Table) -> bool {
216        match self {
217            Db::Mysql(db) => {
218                db.table_update(data)
219            }
220            Db::Sqlite(db) => {
221                db.table_update(data)
222            }
223            Db::Mssql(db) => {
224                db.table_update(data)
225            }
226            _ => false
227        }
228    }
229
230    fn table_info(&mut self, table: &str) -> JsonValue {
231        match self {
232            Db::Mysql(db) => {
233                db.table_info(table)
234            }
235            Db::Sqlite(db) => {
236                db.table_info(table)
237            }
238            Db::Mssql(db) => {
239                db.table_info(table)
240            }
241            _ => object! {}
242        }
243    }
244
245    fn table_is_exist(&mut self, name: &str) -> bool {
246        match self {
247            Db::Mysql(db) => {
248                db.table_is_exist(name)
249            }
250            Db::Sqlite(db) => {
251                db.table_is_exist(name)
252            }
253            Db::Mssql(db) => {
254                db.table_is_exist(name)
255            }
256            _ => false
257        }
258    }
259
260    /// 排序
261    ///
262    /// * field 排序字段
263    /// * by 排序方法 true 降序 false 升序
264    fn order(&mut self, field: &str, by: bool) -> &mut Self {
265        match self {
266            Db::Mysql(db) => {
267                db.order(field, by);
268            }
269            Db::Sqlite(db) => {
270                db.order(field, by);
271            }
272            Db::Mssql(db) => {
273                db.order(field, by);
274            }
275            _ => {}
276        }
277        self
278    }
279
280    fn group(&mut self, field: &str) -> &mut Self {
281        match self {
282            Db::Mysql(db) => {
283                db.group(field);
284            }
285            Db::Sqlite(db) => {
286                db.group(field);
287            }
288            Db::Mssql(db) => {
289                db.group(field);
290            }
291            _ => {}
292        }
293        self
294    }
295
296    fn distinct(&mut self) -> &mut Self {
297        match self {
298            Db::Mysql(db) => {
299                db.distinct();
300            }
301            Db::Sqlite(db) => {
302                db.distinct();
303            }
304            Db::Mssql(db) => {
305                db.distinct();
306            }
307            _ => {}
308        }
309        self
310    }
311
312    fn json(&mut self, field: &str) -> &mut Self {
313        match self {
314            Db::Mysql(db) => {
315                db.json(field);
316            }
317            Db::Sqlite(db) => {
318                db.json(field);
319            }
320            Db::Mssql(db) => {
321                db.json(field);
322            }
323            _ => {}
324        }
325        self
326    }
327
328    fn column(&mut self, field: &str) -> JsonValue {
329        match self {
330            Db::Mysql(db) => {
331                db.column(field)
332            }
333            Db::Sqlite(db) => {
334                db.column(field)
335            }
336            Db::Mssql(db) => {
337                db.column(field)
338            }
339            _ => object! {}
340        }
341    }
342
343    fn where_and(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
344        if field.contains("|") {
345            let fields: Vec<&str> = field.split("|").collect();
346            for field in fields.iter() {
347                self.where_and(field, compare, value.clone());
348            }
349            return self;
350        }
351        let compare = compare.to_lowercase();
352        let compare = compare.replace(" ", "");
353        let compare = compare.as_str();
354        match self {
355            Db::Mysql(db) => {
356                db.where_and(field.clone(), compare.clone(), value);
357            }
358            Db::Sqlite(db) => {
359                db.where_and(field.clone(), compare.clone(), value);
360            }
361            Db::Mssql(db) => {
362                db.where_and(field.clone(), compare.clone(), value);
363            }
364            _ => {}
365        };
366        self
367    }
368
369    fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
370        if field.contains("|") {
371            let fields: Vec<&str> = field.split("|").collect();
372            for field in fields.iter() {
373                self.where_or(field, compare, value.clone());
374            }
375            return self;
376        }
377        let compare = compare.to_lowercase();
378        let compare = compare.replace(" ", "");
379        let compare = compare.as_str();
380        match self {
381            Db::Mysql(db) => {
382                db.where_or(field.clone(), compare.clone(), value);
383            }
384            Db::Sqlite(db) => {
385                db.where_or(field.clone(), compare.clone(), value);
386            }
387            Db::Mssql(db) => {
388                db.where_or(field.clone(), compare.clone(), value);
389            }
390            _ => {}
391        };
392        self
393    }
394
395    fn count(&mut self) -> JsonValue {
396        match self {
397            Db::Mysql(db) => {
398                db.count()
399            }
400            Db::Sqlite(db) => {
401                db.count()
402            }
403            Db::Mssql(db) => {
404                db.count()
405            }
406            _ => JsonValue::from(0)
407        }
408    }
409
410    fn max(&mut self, field: &str) -> JsonValue {
411        match self {
412            Db::Mysql(db) => {
413                db.max(field)
414            }
415            Db::Sqlite(db) => {
416                db.max(field)
417            }
418            Db::Mssql(db) => {
419                db.max(field)
420            }
421            _ => object! {}
422        }
423    }
424
425    fn min(&mut self, field: &str) -> JsonValue {
426        match self {
427            Db::Mysql(db) => {
428                db.min(field)
429            }
430            Db::Sqlite(db) => {
431                db.min(field)
432            }
433            Db::Mssql(db) => {
434                db.min(field)
435            }
436            _ => object! {}
437        }
438    }
439
440    fn sum(&mut self, field: &str) -> JsonValue {
441        match self {
442            Db::Mysql(db) => {
443                db.sum(field)
444            }
445            Db::Sqlite(db) => {
446                db.sum(field)
447            }
448            Db::Mssql(db) => {
449                db.sum(field)
450            }
451            _ => object! {}
452        }
453    }
454    fn avg(&mut self, field: &str) -> JsonValue {
455        match self {
456            Db::Mysql(db) => {
457                db.avg(field)
458            }
459            Db::Sqlite(db) => {
460                db.avg(field)
461            }
462            Db::Mssql(db) => {
463                db.avg(field)
464            }
465            _ => object! {}
466        }
467    }
468
469    fn select(&mut self) -> JsonValue {
470        match self {
471            Db::Mysql(db) => {
472                db.select()
473            }
474            Db::Sqlite(db) => {
475                db.select()
476            }
477            Db::Mssql(db) => {
478                db.select()
479            }
480            _ => object! {}
481        }
482    }
483
484    fn find(&mut self) -> JsonValue {
485        match self {
486            Db::Mysql(db) => {
487                db.find()
488            }
489            Db::Sqlite(db) => {
490                db.find()
491            }
492            Db::Mssql(db) => {
493                db.find()
494            }
495            _ => object! {}
496        }
497    }
498
499    fn insert(&mut self, data: JsonValue) -> JsonValue {
500        match self {
501            Db::Mysql(db) => {
502                db.insert(data.clone())
503            }
504            Db::Sqlite(db) => {
505                db.insert(data.clone())
506            }
507            Db::Mssql(db) => {
508                db.insert(data.clone())
509            }
510            _ => JsonValue::from("")
511        }
512    }
513
514    fn insert_all(&mut self, mut data: JsonValue) -> JsonValue {
515        if data[0].is_empty() {
516            data = array![data].into();
517        }
518        match self {
519            Db::Mysql(db) => {
520                db.insert_all(data.clone())
521            }
522            Db::Sqlite(db) => {
523                db.insert_all(data.clone())
524            }
525            Db::Mssql(db) => {
526                db.insert_all(data.clone())
527            }
528            _ => object! {}
529        }
530    }
531
532    fn page(&mut self, mut page: i32, limit: i32) -> &mut Self {
533        match self {
534            Db::Mysql(db) => {
535                if page <= 0 {
536                    page = 1;
537                }
538                db.page(page.clone(), limit.clone());
539            }
540            Db::Sqlite(db) => {
541                db.page(page.clone(), limit.clone());
542            }
543            Db::Mssql(db) => {
544                if page <= 0 {
545                    page = 1;
546                }
547                db.page(page.clone(), limit.clone());
548            }
549            _ => {}
550        };
551        self
552    }
553
554    fn update(&mut self, data: JsonValue) -> JsonValue {
555        match self {
556            Db::Mysql(db) => {
557                db.update(data.clone())
558            }
559            Db::Sqlite(db) => {
560                db.update(data.clone())
561            }
562            Db::Mssql(db) => {
563                db.update(data.clone())
564            }
565            _ => JsonValue::from(0)
566        }
567    }
568
569    fn delete(&mut self) -> JsonValue {
570        match self {
571            Db::Mysql(db) => {
572                db.delete()
573            }
574            Db::Sqlite(db) => {
575                db.delete()
576            }
577            Db::Mssql(db) => {
578                db.delete()
579            }
580            _ => JsonValue::from(0)
581        }
582    }
583
584    fn field(&mut self, name: &str) -> &mut Self {
585        match self {
586            Db::Mysql(db) => {
587                db.field(name.clone());
588            }
589            Db::Sqlite(db) => {
590                db.field(name.clone());
591            }
592            Db::Mssql(db) => {
593                db.field(name.clone());
594            }
595            _ => {}
596        };
597        self
598    }
599
600    fn transaction(&mut self) -> bool {
601        match self {
602            Db::Mysql(db) => {
603                db.transaction()
604            }
605            Db::Sqlite(db) => {
606                db.transaction()
607            }
608            Db::Mssql(db) => {
609                db.transaction()
610            }
611            _ => false
612        }
613    }
614
615    fn commit(&mut self) -> bool {
616        match self {
617            Db::Mysql(db) => {
618                db.commit()
619            }
620            Db::Sqlite(db) => {
621                db.commit()
622            }
623            Db::Mssql(db) => {
624                db.commit()
625            }
626            _ => false
627        }
628    }
629    fn rollback(&mut self) -> bool {
630        match self {
631            Db::Mysql(db) => {
632                db.rollback()
633            }
634            Db::Sqlite(db) => {
635                db.rollback()
636            }
637            Db::Mssql(db) => {
638                db.rollback()
639            }
640            _ => false
641        }
642    }
643
644    fn sql(&mut self, sql: String) -> JsonValue {
645        match self {
646            Db::Mysql(db) => {
647                db.sql(sql)
648            }
649            Db::Sqlite(db) => {
650                db.sql(sql)
651            }
652            Db::Mssql(db) => {
653                db.sql(sql)
654            }
655            _ => object! {}
656        }
657    }
658
659    fn pool(&mut self) -> Pool {
660        match self {
661            Db::Mysql(db) => {
662                db.pool()
663            }
664            Db::Sqlite(db) => {
665                db.pool()
666            }
667            Db::Mssql(db) => {
668                db.pool()
669            }
670            _ => Pool::new("").unwrap()
671        }
672    }
673
674    fn fetch_sql(&mut self) -> &mut Self {
675        match self {
676            Db::Mysql(db) => {
677                db.fetch_sql();
678            }
679            Db::Sqlite(db) => {
680                db.fetch_sql();
681            }
682            Db::Mssql(db) => {
683                db.fetch_sql();
684            }
685            _ => {}
686        };
687        self
688    }
689
690    fn autoinc(&mut self) -> &mut Self {
691        match self {
692            Db::Mysql(db) => {
693                db.autoinc();
694            }
695            Db::Sqlite(db) => {
696                db.autoinc();
697            }
698            Db::Mssql(db) => {
699                db.autoinc();
700            }
701            _ => {}
702        };
703        self
704    }
705
706    fn where_column(&mut self, field_a: &str, compare: &str, field_b: &str) -> &mut Self {
707        match self {
708            Db::Mysql(db) => {
709                db.where_column(field_a, compare, field_b);
710            }
711            Db::Sqlite(db) => {
712                db.where_column(field_a, compare, field_b);
713            }
714            Db::Mssql(db) => {
715                db.where_column(field_a, compare, field_b);
716            }
717            _ => {}
718        };
719        self
720    }
721
722    fn value(&mut self, field: &str) -> JsonValue {
723        match self {
724            Db::Mysql(db) => {
725                db.value(field)
726            }
727            Db::Sqlite(db) => {
728                db.value(field)
729            }
730            Db::Mssql(db) => {
731                db.value(field)
732            }
733            _ => JsonValue::from(Null)
734        }
735    }
736
737    fn hidden(&mut self, name: &str) -> &mut Self {
738        match self {
739            Db::Mysql(db) => {
740                db.hidden(name.clone());
741            }
742            Db::Sqlite(db) => {
743                db.hidden(name.clone());
744            }
745            Db::Mssql(db) => {
746                db.hidden(name.clone());
747            }
748            _ => {}
749        };
750        self
751    }
752}
753
754
755#[derive(Clone, Debug)]
756pub struct Connection {
757    pub mode: String,
758    pub hostname: String,
759    pub hostport: String,
760    pub database: String,
761    pub username: String,
762    pub userpass: String,
763    pub charset: String,
764    pub prefix: String,
765    pub params: Vec<String>,
766    pub debug: bool,
767}
768
769impl Connection {
770    pub fn default() -> Self {
771        Self {
772            mode: "".to_string(),
773            hostname: "".to_string(),
774            hostport: "".to_string(),
775            database: "".to_string(),
776            username: "".to_string(),
777            userpass: "".to_string(),
778            charset: "".to_string(),
779            prefix: "".to_string(),
780            params: vec![],
781            debug: false,
782        }
783    }
784    pub fn from(connection: JsonValue) -> Self {
785        Self {
786            mode: connection["mode"].to_string(),
787            hostname: connection["hostname"].to_string(),
788            hostport: connection["hostport"].to_string(),
789            database: connection["database"].to_string(),
790            username: connection["username"].to_string(),
791            userpass: connection["userpass"].to_string(),
792            charset: connection["charset"].to_string(),
793            prefix: connection["prefix"].to_string(),
794            params: connection["params"].members().map(|x| x.to_string()).collect(),
795            debug: connection["debug"].as_bool().unwrap_or(false),
796        }
797    }
798    pub fn get_dsn(self) -> String {
799        match self.mode.as_str() {
800            "mysql" => {
801                format!("mysql://{}:{}@{}:{}/{}", self.username, self.userpass, self.hostname, self.hostport, self.database)
802            }
803            "sqlite" => {
804                let data = Path::new(self.hostname.as_str());
805                let data = data.join(format!("{}.db", self.database));
806                format!("{}", data.to_str().unwrap())
807            }
808            "mssql" => format!("sqlsrv://{}:{}@{}:{}/{}", self.username, self.userpass, self.hostname, self.hostport, self.database),
809            _ => "".to_string()
810        }
811    }
812}
813
814
815/// 模型数据库字段模型
816#[derive(Clone, Debug)]
817pub struct Table {
818    pub version: String,
819    pub table: String,
820    pub title: String,
821    pub primary_key: String,
822    pub auto: bool,
823    pub unique: Vec<String>,
824    pub index: Vec<Vec<String>>,
825    pub fields: JsonValue,
826}
827
828impl Table {
829    pub fn to_string(self) -> String {
830        let data = object! {
831            version:self.version,
832            table:self.table,
833            title:self.title,
834            primary_key:self.primary_key,
835            auto:self.auto,
836            unique:self.unique,
837            index:self.index,
838            fields:self.fields
839        };
840        data.to_string()
841    }
842    pub fn parse(mut data: JsonValue) -> Table {
843        let mut unique = vec![];
844        for item in 0..data["unique"].len() {
845            let str = data["unique"][item].clone().to_string();
846            unique.push(str);
847        }
848        let mut index = vec![];
849        for item in data["index"].members_mut() {
850            let mut row = vec![];
851            for col in item.members_mut() {
852                row.push(col.to_string());
853            }
854            if row.len() > 0 {
855                index.push(row);
856            }
857        }
858        Self {
859            version: data["version"].to_string(),
860            table: data["table"].to_string(),
861            title: data["title"].to_string(),
862            primary_key: data["primary_key"].to_string(),
863            auto: data["auto"].as_bool().unwrap(),
864            unique,
865            index,
866            fields: data["fields"].clone(),
867        }
868    }
869}
870
871
872#[derive(Clone, Debug)]
873pub struct Params {
874    pub mode: String,
875    pub autoinc: bool,
876    pub table: String,
877    pub where_and: Vec<String>,
878    pub where_or: Vec<String>,
879    pub where_column: String,
880    pub page: i32,
881    pub limit: i32,
882    pub fields: JsonValue,
883    pub top: String,
884    pub top2: String,
885    pub order: JsonValue,
886    pub group: JsonValue,
887    pub distinct: bool,
888    pub json: JsonValue,
889    pub sql: bool,
890}
891
892impl Params {
893    pub fn default(mode: &str) -> Self {
894        Self {
895            mode: mode.to_string(),
896            autoinc: false,
897            table: "".to_string(),
898            where_and: vec![],
899            where_or: vec![],
900            where_column: "".to_string(),
901            page: -1,
902            limit: 10,
903            fields: object! {},
904            top: String::new(),
905            top2: String::new(),
906            order: object! {},
907            group: object! {},
908            distinct: false,
909            json: object! {},
910            sql: false,
911        }
912    }
913    pub fn where_sql(&mut self) -> String {
914        let mut where_and_sql = vec![];
915        let mut where_or_sql = vec![];
916        let mut sql = vec![];
917
918        for item in self.where_or.iter() {
919            where_or_sql.push(item.clone());
920        }
921        if where_or_sql.len() > 0 {
922            sql.push(where_or_sql.join(" OR "));
923        }
924
925        for item in self.where_and.iter() {
926            where_and_sql.push(item.clone());
927        }
928        if where_and_sql.len() > 0 {
929            sql.push(where_and_sql.join(" AND "));
930        }
931
932        if self.where_column != "" {
933            sql.push(self.where_column.clone());
934        }
935
936        if sql.len() > 0 {
937            return format!("WHERE {}", sql.join(" AND "));
938        }
939        return format!("");
940    }
941    pub fn page_limit_sql(&mut self) -> String {
942        if self.page == -1 {
943            return format!("");
944        }
945        match self.mode.as_str() {
946            "mysql" => {
947                return format!("LIMIT {},{}", self.page * self.limit - self.limit, self.limit);
948            }
949            "sqlite" => {
950                return format!("LIMIT {} OFFSET {}", self.limit, self.page * self.limit - self.limit);
951            }
952            "mssql" => return format!(""),
953            _ => return format!("")
954        }
955    }
956    pub fn fields(&mut self) -> String {
957        let mut fields = vec![];
958        for (_, value) in self.fields.entries() {
959            fields.push(value.to_string());
960        }
961        let fields = {
962            if fields.len() == 0 {
963                "*".into()
964            } else {
965                fields.join(",")
966            }
967        };
968        match self.mode.as_str() {
969            "mysql" => {
970                return format!("{}", fields);
971            }
972            "sqlite" => {
973                return format!("{}", fields);
974            }
975            "mssql" => {
976                return format!("{}", fields);
977            }
978            _ => return format!("{}", fields)
979        }
980    }
981    pub fn top(&mut self) -> String {
982        match self.mode.as_str() {
983            "mssql" => {
984                return format!("{}", self.top);
985            }
986            "mysql" | "sqlite" | _ => {
987                return format!("");
988            }
989        }
990    }
991    pub fn top2(&mut self) -> String {
992        match self.mode.as_str() {
993            "mssql" => {
994                if self.where_and.len() == 0 && self.where_or.len() == 0 {
995                    return format!("where {}", self.top2);
996                }
997                return format!("{}", self.top2);
998            }
999            "mysql" | "sqlite" | _ => {
1000                return format!("");
1001            }
1002        }
1003    }
1004    pub fn table(&mut self) -> String {
1005        match self.mode.as_str() {
1006            "mssql" => {
1007                if self.top2 != "" {
1008                    return format!("t");
1009                }
1010                return format!("{}", self.table);
1011            }
1012            "mysql" | "sqlite" | _ => {
1013                return format!("{}", self.table);
1014            }
1015        }
1016    }
1017    pub fn order(&mut self) -> String {
1018        let mut sql = vec![];
1019        for (field, item) in self.order.entries() {
1020            sql.push(format!("{} {}", field, item));
1021        }
1022        if sql.len() > 0 {
1023            return format!("ORDER BY {}", sql.join(","));
1024        }
1025        return format!("");
1026    }
1027    pub fn group(&mut self) -> String {
1028        let mut sql = vec![];
1029        for (field, _) in self.group.entries() {
1030            sql.push(format!("{}", field));
1031        }
1032        if sql.len() > 0 {
1033            return format!("GROUP BY {}", sql.join(","));
1034        }
1035        return format!("");
1036    }
1037    pub fn distinct(&self) -> String {
1038        if self.distinct {
1039            return "DISTINCT".to_string();
1040        } else {
1041            return "".to_string();
1042        }
1043    }
1044    pub fn select_sql(&mut self) -> String {
1045        return format!("SELECT {} {} FROM {} {} {} {} {} {} {}", self.distinct(), self.fields(), self.top(), self.table(), self.where_sql(), self.top2(), self.group(), self.order(), self.page_limit_sql());
1046    }
1047}
1048
1049
1050#[derive(Clone, Debug)]
1051pub enum Charset {
1052    Utf8mb4,
1053    Utf8,
1054}
1055
1056impl Charset {
1057    pub fn from(str: &str) -> Charset {
1058        match str {
1059            "utf8" => Charset::Utf8,
1060            "utf8mb4" => Charset::Utf8mb4,
1061            _ => Charset::Utf8mb4
1062        }
1063    }
1064}
df_db/lib.rs

df_db/
lib.rs
