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

br_db/
lib.rs
