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

br_db/
lib.rs
