br_db/
lib.rs

1use json::Null;
2use lazy_static::lazy_static;
3use std::collections::HashMap;
4use std::fs;
5#[cfg(any(feature = "db-mysql", feature = "db-sqlite", feature = "db-mssql"))]
6use std::process::Command;
7use std::sync::{Mutex};
8use std::vec;
9
10use crate::config::{Config, Connection};
11#[cfg(feature = "db-mssql")]
12use crate::types::mssql::Mssql;
13#[cfg(feature = "db-mysql")]
14use crate::types::mysql::Mysql;
15#[cfg(feature = "db-pgsql")]
16use crate::types::pgsql::Pgsql;
17#[cfg(feature = "db-sqlite")]
18use crate::types::sqlite::Sqlite;
19use crate::types::{DbMode, TableOptions};
20use crate::types::{Mode};
21use json::object;
22use json::JsonValue;
23use log::{error, info};
24
25pub mod config;
26pub mod error;
27pub mod pools;
28pub mod types;
29pub mod fields;
30
31pub use error::{DbError, DbResult};
32
33lazy_static! {
34    pub static ref DB: Mutex<HashMap<String,Db>> =Mutex::new(HashMap::new());
35    static ref CONNECTION: Mutex<HashMap<String,Connection>> =Mutex::new(HashMap::new());
36    static ref DEFAULT: Mutex<HashMap<usize,String>> =Mutex::new(HashMap::new());
37    static ref TABLE_FIELDS: Mutex<HashMap<String,JsonValue>> =Mutex::new(HashMap::new());
38}
39#[derive(Clone)]
40pub enum Db {
41    #[cfg(feature = "db-mysql")]
42    Mysql(Mysql),
43    #[cfg(feature = "db-sqlite")]
44    Sqlite(Sqlite),
45    #[cfg(feature = "db-mssql")]
46    Mssql(Mssql),
47    #[cfg(feature = "db-pgsql")]
48    Pgsql(Pgsql),
49    None,
50}
51
52impl Db {
53    pub fn load(path: &str) -> Result<Db, String> {
54        let conf = fs::read_to_string(path);
55        let t = match conf {
56            Ok(str) => match json::parse(str.as_str()) {
57                Ok(config) => Db::new(Config::from(config))?,
58                Err(_) => Db::new(Config::create(path.into(), false))?,
59            },
60            Err(_) => Db::new(Config::create(path.into(), false))?,
61        };
62        Ok(t)
63    }
64    pub fn new(config: Config) -> Result<Db, String> {
65        let connection = match config.connections.get(&*config.default) {
66            None => return Err(format!("无此配置: {}", config.default)),
67            Some(e) => e,
68        };
69        for (name, conn) in config.connections.clone() {
70            let mut conn_guard = match CONNECTION.lock() {
71                Ok(g) => g,
72                Err(e) => e.into_inner(),
73            };
74            if conn_guard.get(&name).is_none() {
75                conn_guard.insert(name, conn);
76            }
77        }
78        {
79            let mut default_guard = match DEFAULT.lock() {
80                Ok(g) => g,
81                Err(e) => e.into_inner(),
82            };
83            default_guard.insert(0, config.default.clone());
84        }
85        let db = Db::setlist(connection.clone(), config.default.clone());
86        match db {
87            Ok(db) => {
88                let mut db_guard = match DB.lock() {
89                    Ok(g) => g,
90                    Err(e) => e.into_inner(),
91                };
92                db_guard.insert(config.default.clone(), db);
93                match db_guard.get(&*config.default.clone()) {
94                    Some(r) => Ok(r.clone()),
95                    None => Err("数据库初始化失败".to_string()),
96                }
97            }
98            Err(e) => Err(e),
99        }
100    }
101
102    fn setlist(mut connection: Connection, default: String) -> Result<Db, String> {
103        match connection.mode.str().as_str() {
104            #[cfg(feature = "db-mysql")]
105            "mysql" => match Mysql::connect(connection.clone(), default.clone()) {
106                Ok(e) => Ok(Db::Mysql(e)),
107                Err(e) => Err(e),
108            },
109            #[cfg(feature = "db-sqlite")]
110            "sqlite" => match Sqlite::connect(connection.clone(), default.clone()) {
111                Ok(e) => Ok(Db::Sqlite(e)),
112                Err(e) => Err(e),
113            },
114            #[cfg(feature = "db-mssql")]
115            "mssql" => match Mssql::connect(connection.clone(), default.clone()) {
116                Ok(e) => Ok(Db::Mssql(e)),
117                Err(e) => Err(e),
118            },
119            #[cfg(feature = "db-pgsql")]
120            "pgsql" => match Pgsql::connect(connection.clone(), default.clone()) {
121                Ok(e) => Ok(Db::Pgsql(e)),
122                Err(e) => Err(e),
123            },
124            _ => Err("未匹配数据库".to_string()),
125        }
126    }
127    pub fn get_config_default(&mut self) -> String {
128        let default_guard = match DEFAULT.lock() {
129            Ok(g) => g,
130            Err(e) => e.into_inner(),
131        };
132        match default_guard.get(&0) {
133            Some(d) => d.clone(),
134            None => String::new(),
135        }
136    }
137    pub fn get_config_list(&mut self) -> Vec<String> {
138        let conn_guard = match CONNECTION.lock() {
139            Ok(g) => g,
140            Err(e) => e.into_inner(),
141        };
142        conn_guard.iter().map(|x| x.0.clone()).collect::<Vec<String>>()
143    }
144    pub fn connection(&mut self, name: &str) -> Db {
145        let default_guard = match DEFAULT.lock() {
146            Ok(g) => g,
147            Err(e) => e.into_inner(),
148        };
149        let default = match default_guard.get(&0) {
150            Some(d) => d.clone(),
151            None => String::new(),
152        };
153        drop(default_guard);
154        
155        let name = if name.is_empty() { &default } else { name };
156
157        let db_guard = match DB.lock() {
158            Ok(g) => g,
159            Err(e) => e.into_inner(),
160        };
161        if let Some(db) = db_guard.get(name) {
162            return db.clone();
163        }
164        drop(db_guard);
165        
166        let conn_guard = match CONNECTION.lock() {
167            Ok(g) => g,
168            Err(e) => e.into_inner(),
169        };
170        let connection = match conn_guard.get(name) {
171            Some(c) => c.clone(),
172            None => {
173                drop(conn_guard);
174                return self.clone();
175            }
176        };
177        drop(conn_guard);
178        
179        let db = match Db::setlist(connection, name.to_string()) {
180            Ok(e) => e,
181            Err(_) => {
182                let db_guard = match DB.lock() {
183                    Ok(g) => g,
184                    Err(e) => e.into_inner(),
185                };
186                match db_guard.get(name) {
187                    Some(db) => return db.clone(),
188                    None => return self.clone(),
189                }
190            }
191        };
192        let mut db_guard = match DB.lock() {
193            Ok(g) => g,
194            Err(e) => e.into_inner(),
195        };
196        db_guard.insert(name.to_string(), db.clone());
197        db
198    }
199    /// 增加配置
200    pub fn connection_add(&mut self, config_name: &str, connection: Connection) -> Db {
201        let name = if config_name.is_empty() {
202            let default_guard = match DEFAULT.lock() {
203                Ok(g) => g,
204                Err(e) => e.into_inner(),
205            };
206            match default_guard.get(&0) {
207                Some(d) => d.clone(),
208                None => String::new(),
209            }
210        } else {
211            config_name.to_string()
212        };
213        
214        let db_guard = match DB.lock() {
215            Ok(g) => g,
216            Err(e) => e.into_inner(),
217        };
218        if let Some(db) = db_guard.get(&name) {
219            return db.clone();
220        }
221        drop(db_guard);
222        
223        {
224            let mut conn_guard = match CONNECTION.lock() {
225                Ok(g) => g,
226                Err(e) => e.into_inner(),
227            };
228            conn_guard.insert(name.clone(), connection.clone());
229        }
230
231        let db = match Db::setlist(connection, name.clone()) {
232            Ok(e) => e,
233            Err(_) => {
234                let db_guard = match DB.lock() {
235                    Ok(g) => g,
236                    Err(e) => e.into_inner(),
237                };
238                match db_guard.get(&name) {
239                    Some(db) => return db.clone(),
240                    None => return self.clone(),
241                }
242            }
243        };
244        let mut db_guard = match DB.lock() {
245            Ok(g) => g,
246            Err(e) => e.into_inner(),
247        };
248        db_guard.insert(name, db.clone());
249        db
250    }
251
252    /// 具体功能
253    pub fn table_create(&mut self, options: TableOptions) -> JsonValue {
254        match self {
255            #[cfg(feature = "db-mysql")]
256            Db::Mysql(db) => db.table_create(options),
257            #[cfg(feature = "db-sqlite")]
258            Db::Sqlite(db) => db.table_create(options),
259            #[cfg(feature = "db-mssql")]
260            Db::Mssql(_) => JsonValue::from(false),
261            #[cfg(feature = "db-pgsql")]
262            Db::Pgsql(db) => db.table_create(options),
263            _ => JsonValue::from(false),
264        }
265    }
266    pub fn table_update(&mut self, options: TableOptions) -> JsonValue {
267        match self {
268            #[cfg(feature = "db-mysql")]
269            Db::Mysql(db) => db.table_update(options),
270            #[cfg(feature = "db-sqlite")]
271            Db::Sqlite(db) => db.table_update(options),
272            #[cfg(feature = "db-mssql")]
273            Db::Mssql(_) => JsonValue::from(false),
274            #[cfg(feature = "db-pgsql")]
275            Db::Pgsql(db) => db.table_update(options),
276            _ => JsonValue::from(false),
277        }
278    }
279    pub fn table_info(&mut self, table: &str) -> JsonValue {
280        match self {
281            #[cfg(feature = "db-mysql")]
282            Db::Mysql(db) => db.table_info(table),
283            #[cfg(feature = "db-sqlite")]
284            Db::Sqlite(db) => db.table_info(table),
285            #[cfg(feature = "db-mssql")]
286            Db::Mssql(db) => db.table_info(table),
287            #[cfg(feature = "db-pgsql")]
288            Db::Pgsql(db) => db.table_info(table),
289            _ => object! {},
290        }
291    }
292    pub fn table_is_exist(&mut self, name: &str) -> bool {
293        match self {
294            #[cfg(feature = "db-mysql")]
295            Db::Mysql(db) => db.table_is_exist(name),
296            #[cfg(feature = "db-sqlite")]
297            Db::Sqlite(db) => db.table_is_exist(name),
298            #[cfg(feature = "db-mssql")]
299            Db::Mssql(db) => db.table_is_exist(name),
300            #[cfg(feature = "db-pgsql")]
301            Db::Pgsql(db) => db.table_is_exist(name),
302            _ => false,
303        }
304    }
305    pub fn table(&mut self, name: &str) -> &mut Self {
306        match self {
307            #[cfg(feature = "db-mysql")]
308            Db::Mysql(db) => {
309                db.table(name);
310            }
311            #[cfg(feature = "db-sqlite")]
312            Db::Sqlite(db) => {
313                db.table(name);
314            }
315            #[cfg(feature = "db-mssql")]
316            Db::Mssql(db) => {
317                db.table(name);
318            }
319            #[cfg(feature = "db-pgsql")]
320            Db::Pgsql(db) => {
321                db.table(name);
322            }
323            _ => {}
324        };
325        self
326    }
327
328    pub fn change_table(&mut self, name: &str) -> &mut Self {
329        match self {
330            #[cfg(feature = "db-mysql")]
331            Db::Mysql(db) => {
332                db.change_table(name);
333            }
334            #[cfg(feature = "db-sqlite")]
335            Db::Sqlite(db) => {
336                db.change_table(name);
337            }
338            #[cfg(feature = "db-mssql")]
339            Db::Mssql(db) => {
340                db.change_table(name);
341            }
342            #[cfg(feature = "db-pgsql")]
343            Db::Pgsql(db) => {
344                db.change_table(name);
345            }
346            _ => {}
347        };
348        self
349    }
350
351    pub fn autoinc(&mut self) -> &mut Self {
352        match self {
353            #[cfg(feature = "db-mysql")]
354            Db::Mysql(db) => {
355                db.autoinc();
356            }
357            #[cfg(feature = "db-sqlite")]
358            Db::Sqlite(db) => {
359                db.autoinc();
360            }
361            #[cfg(feature = "db-mssql")]
362            Db::Mssql(db) => {
363                db.autoinc();
364            }
365            #[cfg(feature = "db-pgsql")]
366            Db::Pgsql(db) => {
367                db.autoinc();
368            }
369            _ => {}
370        };
371        self
372    }
373
374    pub fn fetch_sql(&mut self) -> &mut Self {
375        match self {
376            #[cfg(feature = "db-mysql")]
377            Db::Mysql(db) => {
378                db.fetch_sql();
379            }
380            #[cfg(feature = "db-sqlite")]
381            Db::Sqlite(db) => {
382                db.fetch_sql();
383            }
384            #[cfg(feature = "db-mssql")]
385            Db::Mssql(db) => {
386                db.fetch_sql();
387            }
388            #[cfg(feature = "db-pgsql")]
389            Db::Pgsql(db) => {
390                db.fetch_sql();
391            }
392            _ => {}
393        };
394        self
395    }
396    /// 排序
397    ///
398    /// * field 排序字段
399    /// * by 排序方法 true 降序 false 升序
400    pub fn order(&mut self, field: &str, by: bool) -> &mut Self {
401        match self {
402            #[cfg(feature = "db-mysql")]
403            Db::Mysql(db) => {
404                db.order(field, by);
405            }
406            #[cfg(feature = "db-sqlite")]
407            Db::Sqlite(db) => {
408                db.order(field, by);
409            }
410            #[cfg(feature = "db-mssql")]
411            Db::Mssql(db) => {
412                db.order(field, by);
413            }
414            #[cfg(feature = "db-pgsql")]
415            Db::Pgsql(db) => {
416                db.order(field, by);
417            }
418            _ => {}
419        }
420        self
421    }
422
423    pub fn group(&mut self, field: &str) -> &mut Self {
424        match self {
425            #[cfg(feature = "db-mysql")]
426            Db::Mysql(db) => {
427                db.group(field);
428            }
429            #[cfg(feature = "db-sqlite")]
430            Db::Sqlite(db) => {
431                db.group(field);
432            }
433            #[cfg(feature = "db-mssql")]
434            Db::Mssql(db) => {
435                db.group(field);
436            }
437            #[cfg(feature = "db-pgsql")]
438            Db::Pgsql(db) => {
439                db.group(field);
440            }
441            _ => {}
442        }
443        self
444    }
445
446    pub fn distinct(&mut self) -> &mut Self {
447        match self {
448            #[cfg(feature = "db-mysql")]
449            Db::Mysql(db) => {
450                db.distinct();
451            }
452            #[cfg(feature = "db-sqlite")]
453            Db::Sqlite(db) => {
454                db.distinct();
455            }
456            #[cfg(feature = "db-mssql")]
457            Db::Mssql(db) => {
458                db.distinct();
459            }
460            #[cfg(feature = "db-pgsql")]
461            Db::Pgsql(db) => {
462                db.distinct();
463            }
464            _ => {}
465        }
466        self
467    }
468
469    pub fn json(&mut self, field: &str) -> &mut Self {
470        match self {
471            #[cfg(feature = "db-mysql")]
472            Db::Mysql(db) => {
473                db.json(field);
474            }
475            #[cfg(feature = "db-sqlite")]
476            Db::Sqlite(db) => {
477                db.json(field);
478            }
479            #[cfg(feature = "db-mssql")]
480            Db::Mssql(db) => {
481                db.json(field);
482            }
483            #[cfg(feature = "db-pgsql")]
484            Db::Pgsql(db) => {
485                db.json(field);
486            }
487            _ => {}
488        }
489        self
490    }
491    /// 坐标系
492    pub fn location(&mut self, field: &str) -> &mut Self {
493        match self {
494            #[cfg(feature = "db-mysql")]
495            Db::Mysql(db) => {
496                db.location(field);
497            }
498            #[cfg(feature = "db-sqlite")]
499            Db::Sqlite(db) => {
500                db.location(field);
501            }
502            #[cfg(feature = "db-mssql")]
503            Db::Mssql(db) => {
504                db.location(field);
505            }
506            #[cfg(feature = "db-pgsql")]
507            Db::Pgsql(db) => {
508                db.location(field);
509            }
510            _ => {}
511        }
512        self
513    }
514
515    pub fn column(&mut self, field: &str) -> JsonValue {
516        match self {
517            #[cfg(feature = "db-mysql")]
518            Db::Mysql(db) => db.column(field),
519            #[cfg(feature = "db-sqlite")]
520            Db::Sqlite(db) => db.column(field),
521            #[cfg(feature = "db-mssql")]
522            Db::Mssql(db) => db.column(field),
523            #[cfg(feature = "db-pgsql")]
524            Db::Pgsql(db) => db.column(field),
525            _ => object! {},
526        }
527    }
528
529    pub fn where_and(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
530        if field.contains("|") {
531            let fields: Vec<&str> = field.split("|").collect();
532            for field in fields.iter() {
533                self.where_or(field.to_string().as_str(), compare, value.clone());
534            }
535            return self;
536        }
537        let compare = compare.to_lowercase();
538        let compare = compare.replace(" ", "");
539        let compare = compare.as_str();
540
541        let value = match &value {
542            JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
543            JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
544            JsonValue::Array(arr) => {
545                JsonValue::Array(
546                    arr.iter().map(|v| match v {
547                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
548                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
549                        _ => v.clone(),
550                    }).collect()
551                )
552            }
553            JsonValue::Object(obj) => {
554                let mut new_obj = object::Object::new();
555                for (k, v) in obj.iter() {
556                    let vv = match v {
557                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
558                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
559                        _ => v.clone(),
560                    };
561                    new_obj.insert(k, vv);
562                }
563                JsonValue::Object(new_obj)
564            }
565            _ => value.clone(),
566        };
567        match self {
568            #[cfg(feature = "db-mysql")]
569            Db::Mysql(db) => {
570                db.where_and(field, compare, value);
571            }
572            #[cfg(feature = "db-sqlite")]
573            Db::Sqlite(db) => {
574                db.where_and(field, compare, value);
575            }
576            #[cfg(feature = "db-mssql")]
577            Db::Mssql(db) => {
578                db.where_and(field, compare, value);
579            }
580            #[cfg(feature = "db-pgsql")]
581            Db::Pgsql(db) => {
582                db.where_and(field, compare, value);
583            }
584            _ => {}
585        };
586        self
587    }
588
589    pub fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
590        if field.contains("|") {
591            let fields: Vec<&str> = field.split("|").collect();
592            for field in fields.iter() {
593                self.where_or(field.to_string().as_str(), compare, value.clone());
594            }
595            return self;
596        }
597        let compare = compare.to_lowercase();
598        let compare = compare.replace(" ", "");
599        let compare = compare.as_str();
600
601        let value = match &value {
602            JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
603            JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
604            JsonValue::Array(arr) => {
605                JsonValue::Array(
606                    arr.iter().map(|v| match v {
607                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
608                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
609                        _ => v.clone(),
610                    }).collect()
611                )
612            }
613            JsonValue::Object(obj) => {
614                let mut new_obj = object::Object::new();
615                for (k, v) in obj.iter() {
616                    let vv = match v {
617                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
618                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
619                        _ => v.clone(),
620                    };
621                    new_obj.insert(k, vv);
622                }
623                JsonValue::Object(new_obj)
624            }
625            _ => value.clone(),
626        };
627        match self {
628            #[cfg(feature = "db-mysql")]
629            Db::Mysql(db) => {
630                db.where_or(field, compare, value);
631            }
632            #[cfg(feature = "db-sqlite")]
633            Db::Sqlite(db) => {
634                db.where_or(field, compare, value);
635            }
636            #[cfg(feature = "db-mssql")]
637            Db::Mssql(db) => {
638                db.where_or(field, compare, value);
639            }
640            #[cfg(feature = "db-pgsql")]
641            Db::Pgsql(db) => {
642                db.where_or(field, compare, value);
643            }
644            _ => {}
645        };
646        self
647    }
648    pub fn where_column(&mut self, field_a: &str, compare: &str, field_b: &str) -> &mut Self {
649        match self {
650            #[cfg(feature = "db-mysql")]
651            Db::Mysql(db) => {
652                db.where_column(field_a, compare, field_b);
653            }
654            #[cfg(feature = "db-sqlite")]
655            Db::Sqlite(db) => {
656                db.where_column(field_a, compare, field_b);
657            }
658            #[cfg(feature = "db-mssql")]
659            Db::Mssql(db) => {
660                db.where_column(field_a, compare, field_b);
661            }
662            #[cfg(feature = "db-pgsql")]
663            Db::Pgsql(db) => {
664                db.where_column(field_a, compare, field_b);
665            }
666            _ => {}
667        };
668        self
669    }
670    pub fn update_column(&mut self, field_a: &str, compare: &str) -> &mut Self {
671        match self {
672            #[cfg(feature = "db-mysql")]
673            Db::Mysql(db) => {
674                db.update_column(field_a, compare);
675            }
676            #[cfg(feature = "db-sqlite")]
677            Db::Sqlite(db) => {
678                db.update_column(field_a, compare);
679            }
680            #[cfg(feature = "db-mssql")]
681            Db::Mssql(db) => {
682                db.update_column(field_a, compare);
683            }
684            #[cfg(feature = "db-pgsql")]
685            Db::Pgsql(db) => {
686                db.update_column(field_a, compare);
687            }
688            _ => {}
689        };
690        self
691    }
692    pub fn count(&mut self) -> JsonValue {
693        match self {
694            #[cfg(feature = "db-mysql")]
695            Db::Mysql(db) => db.count(),
696            #[cfg(feature = "db-sqlite")]
697            Db::Sqlite(db) => db.count(),
698            #[cfg(feature = "db-mssql")]
699            Db::Mssql(db) => db.count(),
700            #[cfg(feature = "db-pgsql")]
701            Db::Pgsql(db) => db.count(),
702            _ => JsonValue::from(0),
703        }
704    }
705    pub fn max(&mut self, field: &str) -> JsonValue {
706        match self {
707            #[cfg(feature = "db-mysql")]
708            Db::Mysql(db) => db.max(field),
709            #[cfg(feature = "db-sqlite")]
710            Db::Sqlite(db) => db.max(field),
711            #[cfg(feature = "db-mssql")]
712            Db::Mssql(db) => db.max(field),
713            #[cfg(feature = "db-pgsql")]
714            Db::Pgsql(db) => db.max(field),
715            _ => object! {},
716        }
717    }
718
719    pub fn min(&mut self, field: &str) -> JsonValue {
720        match self {
721            #[cfg(feature = "db-mysql")]
722            Db::Mysql(db) => db.min(field),
723            #[cfg(feature = "db-sqlite")]
724            Db::Sqlite(db) => db.min(field),
725            #[cfg(feature = "db-mssql")]
726            Db::Mssql(db) => db.min(field),
727            #[cfg(feature = "db-pgsql")]
728            Db::Pgsql(db) => db.min(field),
729            _ => object! {},
730        }
731    }
732
733    pub fn sum(&mut self, field: &str) -> JsonValue {
734        match self {
735            #[cfg(feature = "db-mysql")]
736            Db::Mysql(db) => db.sum(field),
737            #[cfg(feature = "db-sqlite")]
738            Db::Sqlite(db) => db.sum(field),
739            #[cfg(feature = "db-mssql")]
740            Db::Mssql(db) => db.sum(field),
741            #[cfg(feature = "db-pgsql")]
742            Db::Pgsql(db) => db.sum(field),
743            _ => object! {},
744        }
745    }
746
747    pub fn avg(&mut self, field: &str) -> JsonValue {
748        match self {
749            #[cfg(feature = "db-mysql")]
750            Db::Mysql(db) => db.avg(field),
751            #[cfg(feature = "db-sqlite")]
752            Db::Sqlite(db) => db.avg(field),
753            #[cfg(feature = "db-mssql")]
754            Db::Mssql(db) => db.avg(field),
755            #[cfg(feature = "db-pgsql")]
756            Db::Pgsql(db) => db.avg(field),
757            _ => object! {},
758        }
759    }
760
761    pub fn select(&mut self) -> JsonValue {
762        match self {
763            #[cfg(feature = "db-mysql")]
764            Db::Mysql(db) => db.select(),
765            #[cfg(feature = "db-sqlite")]
766            Db::Sqlite(db) => db.select(),
767            #[cfg(feature = "db-mssql")]
768            Db::Mssql(db) => db.select(),
769            #[cfg(feature = "db-pgsql")]
770            Db::Pgsql(db) => db.select(),
771            _ => object! {},
772        }
773    }
774
775    pub fn find(&mut self) -> JsonValue {
776        match self {
777            #[cfg(feature = "db-mysql")]
778            Db::Mysql(db) => db.find(),
779            #[cfg(feature = "db-sqlite")]
780            Db::Sqlite(db) => db.find(),
781            #[cfg(feature = "db-mssql")]
782            Db::Mssql(db) => db.find(),
783            #[cfg(feature = "db-pgsql")]
784            Db::Pgsql(db) => db.find(),
785            _ => object! {},
786        }
787    }
788
789    pub fn value(&mut self, field: &str) -> JsonValue {
790        match self {
791            #[cfg(feature = "db-mysql")]
792            Db::Mysql(db) => db.value(field),
793            #[cfg(feature = "db-sqlite")]
794            Db::Sqlite(db) => db.value(field),
795            #[cfg(feature = "db-mssql")]
796            Db::Mssql(db) => db.value(field),
797            #[cfg(feature = "db-pgsql")]
798            Db::Pgsql(db) => db.value(field),
799            _ => Null,
800        }
801    }
802
803    pub fn insert(&mut self, data: JsonValue) -> JsonValue {
804        match self {
805            #[cfg(feature = "db-mysql")]
806            Db::Mysql(db) => db.insert(data.clone()),
807            #[cfg(feature = "db-sqlite")]
808            Db::Sqlite(db) => db.insert(data.clone()),
809            #[cfg(feature = "db-mssql")]
810            Db::Mssql(db) => db.insert(data.clone()),
811            #[cfg(feature = "db-pgsql")]
812            Db::Pgsql(db) => db.insert(data.clone()),
813            _ => JsonValue::from(""),
814        }
815    }
816
817    pub fn insert_all(&mut self, data: JsonValue) -> JsonValue {
818        let data = if data.is_object() {
819            JsonValue::from(vec![data])
820        } else {
821            data
822        };
823        match self {
824            #[cfg(feature = "db-mysql")]
825            Db::Mysql(db) => db.insert_all(data.clone()),
826            #[cfg(feature = "db-sqlite")]
827            Db::Sqlite(db) => db.insert_all(data.clone()),
828            #[cfg(feature = "db-mssql")]
829            Db::Mssql(db) => db.insert_all(data.clone()),
830            #[cfg(feature = "db-pgsql")]
831            Db::Pgsql(db) => db.insert_all(data.clone()),
832            _ => object! {},
833        }
834    }
835
836    pub fn page(&mut self, mut page: i32, limit: i32) -> &mut Self {
837        if page <= 0 {
838            page = 1;
839        }
840        match self {
841            #[cfg(feature = "db-mysql")]
842            Db::Mysql(db) => {
843                db.page(page, limit);
844            }
845            #[cfg(feature = "db-sqlite")]
846            Db::Sqlite(db) => {
847                db.page(page, limit);
848            }
849            #[cfg(feature = "db-mssql")]
850            Db::Mssql(db) => {
851                db.page(page, limit);
852            }
853            #[cfg(feature = "db-pgsql")]
854            Db::Pgsql(db) => {
855                db.page(page, limit);
856            }
857            _ => {}
858        };
859        self
860    }
861
862    pub fn update(&mut self, data: JsonValue) -> JsonValue {
863        match self {
864            #[cfg(feature = "db-mysql")]
865            Db::Mysql(db) => db.update(data.clone()),
866            #[cfg(feature = "db-sqlite")]
867            Db::Sqlite(db) => db.update(data.clone()),
868            #[cfg(feature = "db-mssql")]
869            Db::Mssql(db) => db.update(data.clone()),
870            #[cfg(feature = "db-pgsql")]
871            Db::Pgsql(db) => db.update(data.clone()),
872            _ => JsonValue::from(0),
873        }
874    }
875
876    pub fn update_all(&mut self, data: JsonValue) -> JsonValue {
877        match self {
878            #[cfg(feature = "db-mysql")]
879            Db::Mysql(db) => db.update_all(data.clone()),
880            #[cfg(feature = "db-sqlite")]
881            Db::Sqlite(db) => db.update_all(data.clone()),
882            #[cfg(feature = "db-mssql")]
883            Db::Mssql(db) => db.update_all(data.clone()),
884            #[cfg(feature = "db-pgsql")]
885            Db::Pgsql(db) => db.update_all(data.clone()),
886            _ => JsonValue::from(0),
887        }
888    }
889
890    pub fn get_connection(&mut self) -> Connection {
891        match self {
892            #[cfg(feature = "db-mysql")]
893            Db::Mysql(db) => db.connection.clone(),
894            #[cfg(feature = "db-sqlite")]
895            Db::Sqlite(db) => db.connection.clone(),
896            #[cfg(feature = "db-mssql")]
897            Db::Mssql(db) => db.connection.clone(),
898            #[cfg(feature = "db-pgsql")]
899            Db::Pgsql(db) => db.connection.clone(),
900            _ => Connection::new(""),
901        }
902    }
903    pub fn database_tables(&mut self) -> JsonValue {
904        match self {
905            #[cfg(feature = "db-mysql")]
906            Db::Mysql(db) => db.database_tables(),
907            #[cfg(feature = "db-sqlite")]
908            Db::Sqlite(db) => db.database_tables(),
909            #[cfg(feature = "db-mssql")]
910            Db::Mssql(db) => db.database_tables(),
911            #[cfg(feature = "db-pgsql")]
912            Db::Pgsql(db) => db.database_tables(),
913            _ => JsonValue::Array(vec![]),
914        }
915    }
916    pub fn database_create(&mut self, name: &str) -> bool {
917        match self {
918            #[cfg(feature = "db-mysql")]
919            Db::Mysql(db) => db.database_create(name),
920            #[cfg(feature = "db-sqlite")]
921            Db::Sqlite(db) => db.database_create(name),
922            #[cfg(feature = "db-mssql")]
923            Db::Mssql(db) => db.database_create(name),
924            #[cfg(feature = "db-pgsql")]
925            Db::Pgsql(db) => db.database_create(name),
926            _ => false,
927        }
928    }
929    pub fn backups(&mut self, filename: &str) -> bool {
930        match self {
931            #[cfg(feature = "db-mysql")]
932            Db::Mysql(db) => {
933                // 定义要执行的命令
934                match Command::new("mysqldump").arg("-u").arg(db.connection.username.clone()).arg("-p").arg(db.connection.userpass.clone()).arg(db.connection.database.clone()).arg(">").arg(filename).output() {
935                    Ok(output) => {
936                        if output.status.success() {
937                            // 将备份写入文件
938                            info!("数据库备份完成！");
939                            return true;
940                        }
941                        true
942                    }
943                    Err(e) => {
944                        // 打印错误信息
945                        error!("mysqldump 命令执行失败：{e}");
946                        false
947                    }
948                }
949            }
950            #[cfg(feature = "db-sqlite")]
951            Db::Sqlite(_db) => false,
952            #[cfg(feature = "db-mssql")]
953            Db::Mssql(_db) => false,
954            #[cfg(feature = "db-pgsql")]
955            Db::Pgsql(_db) => false,
956            _ => false,
957        }
958    }
959
960    pub fn delete(&mut self) -> JsonValue {
961        match self {
962            #[cfg(feature = "db-mysql")]
963            Db::Mysql(db) => db.delete(),
964            #[cfg(feature = "db-sqlite")]
965            Db::Sqlite(db) => db.delete(),
966            #[cfg(feature = "db-mssql")]
967            Db::Mssql(db) => db.delete(),
968            #[cfg(feature = "db-pgsql")]
969            Db::Pgsql(db) => db.delete(),
970            _ => JsonValue::from(0),
971        }
972    }
973    pub fn field(&mut self, name: &str) -> &mut Self {
974        match self {
975            #[cfg(feature = "db-mysql")]
976            Db::Mysql(db) => {
977                db.field(name);
978            }
979            #[cfg(feature = "db-sqlite")]
980            Db::Sqlite(db) => {
981                db.field(name);
982            }
983            #[cfg(feature = "db-mssql")]
984            Db::Mssql(db) => {
985                db.field(name);
986            }
987            #[cfg(feature = "db-pgsql")]
988            Db::Pgsql(db) => {
989                db.field(name);
990            }
991            _ => {}
992        };
993        self
994    }
995    pub fn hidden(&mut self, name: &str) -> &mut Self {
996        match self {
997            #[cfg(feature = "db-mysql")]
998            Db::Mysql(db) => {
999                db.hidden(name);
1000            }
1001            #[cfg(feature = "db-sqlite")]
1002            Db::Sqlite(db) => {
1003                db.hidden(name);
1004            }
1005            #[cfg(feature = "db-mssql")]
1006            Db::Mssql(db) => {
1007                db.hidden(name);
1008            }
1009            #[cfg(feature = "db-pgsql")]
1010            Db::Pgsql(db) => {
1011                db.hidden(name);
1012            }
1013            _ => {}
1014        };
1015        self
1016    }
1017
1018    pub fn transaction(&mut self) -> bool {
1019        match self {
1020            #[cfg(feature = "db-mysql")]
1021            Db::Mysql(db) => db.transaction(),
1022            #[cfg(feature = "db-sqlite")]
1023            Db::Sqlite(db) => db.transaction(),
1024            #[cfg(feature = "db-mssql")]
1025            Db::Mssql(db) => db.transaction(),
1026            #[cfg(feature = "db-pgsql")]
1027            Db::Pgsql(db) => db.transaction(),
1028            _ => false,
1029        }
1030    }
1031
1032    pub fn commit(&mut self) -> bool {
1033        match self {
1034            #[cfg(feature = "db-mysql")]
1035            Db::Mysql(db) => db.commit(),
1036            #[cfg(feature = "db-sqlite")]
1037            Db::Sqlite(db) => db.commit(),
1038            #[cfg(feature = "db-mssql")]
1039            Db::Mssql(db) => db.commit(),
1040            #[cfg(feature = "db-pgsql")]
1041            Db::Pgsql(db) => db.commit(),
1042            _ => false,
1043        }
1044    }
1045
1046    pub fn rollback(&mut self) -> bool {
1047        match self {
1048            #[cfg(feature = "db-mysql")]
1049            Db::Mysql(db) => db.rollback(),
1050            #[cfg(feature = "db-sqlite")]
1051            Db::Sqlite(db) => db.rollback(),
1052            #[cfg(feature = "db-mssql")]
1053            Db::Mssql(db) => db.rollback(),
1054            #[cfg(feature = "db-pgsql")]
1055            Db::Pgsql(db) => db.rollback(),
1056            _ => false,
1057        }
1058    }
1059
1060    pub fn sql(&mut self, sql: &str) -> Result<JsonValue, String> {
1061        match self {
1062            #[cfg(feature = "db-mysql")]
1063            Db::Mysql(db) => db.sql(sql),
1064            #[cfg(feature = "db-sqlite")]
1065            Db::Sqlite(db) => db.sql(sql),
1066            #[cfg(feature = "db-mssql")]
1067            Db::Mssql(db) => db.sql(sql),
1068            #[cfg(feature = "db-pgsql")]
1069            Db::Pgsql(db) => db.sql(sql),
1070            _ => Err("".to_string()),
1071        }
1072    }
1073
1074    pub fn sql_execute(&mut self, sql: &str) -> Result<JsonValue, String> {
1075        match self {
1076            #[cfg(feature = "db-mysql")]
1077            Db::Mysql(db) => db.sql_execute(sql),
1078            #[cfg(feature = "db-sqlite")]
1079            Db::Sqlite(db) => db.sql_execute(sql),
1080            #[cfg(feature = "db-mssql")]
1081            Db::Mssql(db) => db.sql_execute(sql),
1082            #[cfg(feature = "db-pgsql")]
1083            Db::Pgsql(db) => db.sql_execute(sql),
1084            _ => Err("".to_string()),
1085        }
1086    }
1087
1088    /// 自增
1089    pub fn inc(&mut self, field: &str, num: f64) -> &mut Self {
1090        match self {
1091            #[cfg(feature = "db-mysql")]
1092            Db::Mysql(db) => {
1093                db.inc(field, num);
1094            }
1095            #[cfg(feature = "db-sqlite")]
1096            Db::Sqlite(db) => {
1097                db.inc(field, num);
1098            }
1099            #[cfg(feature = "db-mssql")]
1100            Db::Mssql(db) => {
1101                db.inc(field, num);
1102            }
1103            #[cfg(feature = "db-pgsql")]
1104            Db::Pgsql(db) => {
1105                db.inc(field, num);
1106            }
1107            _ => {}
1108        }
1109        self
1110    }
1111    /// 自减
1112    pub fn dec(&mut self, field: &str, num: f64) -> &mut Self {
1113        match self {
1114            #[cfg(feature = "db-mysql")]
1115            Db::Mysql(db) => {
1116                db.dec(field, num);
1117            }
1118            #[cfg(feature = "db-sqlite")]
1119            Db::Sqlite(db) => {
1120                db.dec(field, num);
1121            }
1122            #[cfg(feature = "db-mssql")]
1123            Db::Mssql(db) => {
1124                db.dec(field, num);
1125            }
1126            #[cfg(feature = "db-pgsql")]
1127            Db::Pgsql(db) => {
1128                db.dec(field, num);
1129            }
1130            _ => {}
1131        }
1132        self
1133    }
1134
1135    pub fn buildsql(&mut self) -> String {
1136        match self {
1137            #[cfg(feature = "db-mysql")]
1138            Db::Mysql(db) => db.buildsql(),
1139            #[cfg(feature = "db-sqlite")]
1140            Db::Sqlite(db) => db.buildsql(),
1141            #[cfg(feature = "db-mssql")]
1142            Db::Mssql(db) => db.buildsql(),
1143            #[cfg(feature = "db-pgsql")]
1144            Db::Pgsql(db) => db.buildsql(),
1145            _ => "".to_string(),
1146        }
1147    }
1148    pub fn join_fields(&mut self, fields: Vec<&str>) -> &mut Self {
1149        match self {
1150            #[cfg(feature = "db-mysql")]
1151            Db::Mysql(db) => {
1152                db.join_fields(fields);
1153            }
1154            #[cfg(feature = "db-sqlite")]
1155            Db::Sqlite(db) => {
1156                db.join_fields(fields);
1157            }
1158            #[cfg(feature = "db-mssql")]
1159            Db::Mssql(db) => {
1160                db.join_fields(fields);
1161            }
1162            #[cfg(feature = "db-pgsql")]
1163            Db::Pgsql(db) => {
1164                db.join_fields(fields);
1165            }
1166            _ => {}
1167        }
1168        self
1169    }
1170    /// 连接
1171    ///
1172    /// * main_table 主表表名
1173    /// * main_fields 主表字段名
1174    /// * right_table 关联主表名
1175    /// * right_fields 关联字段名
1176    pub fn join(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self {
1177        match self {
1178            #[cfg(feature = "db-mysql")]
1179            Db::Mysql(db) => {
1180                db.join(main_table, main_fields, right_table, right_fields);
1181            }
1182            #[cfg(feature = "db-sqlite")]
1183            Db::Sqlite(db) => {
1184                db.join(main_table, main_fields, right_table, right_fields);
1185            }
1186            #[cfg(feature = "db-mssql")]
1187            Db::Mssql(db) => {
1188                db.join(main_table, main_fields, right_table, right_fields);
1189            }
1190            #[cfg(feature = "db-pgsql")]
1191            Db::Pgsql(db) => {
1192                db.join(main_table, main_fields, right_table, right_fields);
1193            }
1194            _ => {}
1195        }
1196        self
1197    }
1198
1199    /// 内连接--用来取交集
1200    ///
1201    /// * table 链表表名
1202    /// * main_fields 主表字段
1203    /// * second_fields 附表关联字段
1204    pub fn join_inner(&mut self, table: &str, main_fields: &str, second_fields: &str) -> &mut Self {
1205        match self {
1206            #[cfg(feature = "db-mysql")]
1207            Db::Mysql(db) => {
1208                db.join_inner(table, main_fields, second_fields);
1209            }
1210            #[cfg(feature = "db-sqlite")]
1211            Db::Sqlite(db) => {
1212                db.join_inner(table, main_fields, second_fields);
1213            }
1214            #[cfg(feature = "db-mssql")]
1215            Db::Mssql(db) => {
1216                db.join_inner(table, main_fields, second_fields);
1217            }
1218            #[cfg(feature = "db-pgsql")]
1219            Db::Pgsql(db) => {
1220                db.join_inner(table, main_fields, second_fields);
1221            }
1222            _ => {}
1223        }
1224        self
1225    }
1226}
1227
1228/// 模型数据库字段模型
1229#[derive(Clone, Debug)]
1230pub struct Table {
1231    pub version: String,
1232    pub table: String,
1233    pub title: String,
1234    pub primary_key: String,
1235    pub unique: Vec<String>,
1236    pub index: Vec<Vec<String>>,
1237    pub fields: JsonValue,
1238    pub partition: bool,
1239    pub partition_columns: JsonValue,
1240}
1241
1242impl Table {
1243    pub fn to_str(self) -> String {
1244        let data = object! {
1245            version:self.version,
1246            table:self.table,
1247            title:self.title,
1248            primary_key:self.primary_key,
1249            unique:self.unique,
1250            index:self.index,
1251            fields:self.fields,
1252            partition:self.partition,
1253            partition_columns:self.partition_columns,
1254        };
1255        data.to_string()
1256    }
1257    pub fn parse(mut data: JsonValue) -> Table {
1258        let mut unique = vec![];
1259        for item in 0..data["unique"].len() {
1260            let str = data["unique"][item].clone().to_string();
1261            unique.push(str);
1262        }
1263        let mut index = vec![];
1264        for item in data["index"].members_mut() {
1265            let mut row = vec![];
1266            for col in item.members_mut() {
1267                row.push(col.to_string());
1268            }
1269            if !row.is_empty() {
1270                index.push(row);
1271            }
1272        }
1273        Self {
1274            version: data["version"].to_string(),
1275            table: data["table"].to_string(),
1276            title: data["title"].to_string(),
1277            primary_key: data["primary_key"].to_string(),
1278            unique,
1279            index,
1280            fields: data["fields"].clone(),
1281            partition: data["partition"].as_bool().unwrap_or(false),
1282            partition_columns: data["partition_columns"].clone(),
1283        }
1284    }
1285}
br_db/lib.rs

br_db/
lib.rs
