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
466        let value = match &value {
467            JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
468            JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
469            JsonValue::Array(arr) => {
470                JsonValue::Array(
471                    arr.iter().map(|v| match v {
472                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
473                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
474                        _ => v.clone(),
475                    }).collect()
476                )
477            }
478            JsonValue::Object(obj) => {
479                let mut new_obj = object::Object::new();
480                for (k, v) in obj.iter() {
481                    let vv = match v {
482                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
483                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
484                        _ => v.clone(),
485                    };
486                    new_obj.insert(k, vv);
487                }
488                JsonValue::Object(new_obj)
489            }
490            _ => value.clone(),
491        };
492        match self {
493            #[cfg(feature = "db-mysql")]
494            Db::Mysql(db) => {
495                db.where_and(field, compare, value);
496            }
497            #[cfg(feature = "db-sqlite")]
498            Db::Sqlite(db) => {
499                db.where_and(field, compare, value);
500            }
501            #[cfg(feature = "db-mssql")]
502            Db::Mssql(db) => {
503                db.where_and(field, compare, value);
504            }
505            #[cfg(feature = "db-pgsql")]
506            Db::Pgsql(db) => {
507                db.where_and(field, compare, value);
508            }
509            _ => {}
510        };
511        self
512    }
513
514    pub fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
515        if field.contains("|") {
516            let fields: Vec<&str> = field.split("|").collect();
517            for field in fields.iter() {
518                self.where_or(field.to_string().as_str(), compare, value.clone());
519            }
520            return self;
521        }
522        let compare = compare.to_lowercase();
523        let compare = compare.replace(" ", "");
524        let compare = compare.as_str();
525
526        let value = match &value {
527            JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
528            JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
529            JsonValue::Array(arr) => {
530                JsonValue::Array(
531                    arr.iter().map(|v| match v {
532                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
533                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
534                        _ => v.clone(),
535                    }).collect()
536                )
537            }
538            JsonValue::Object(obj) => {
539                let mut new_obj = object::Object::new();
540                for (k, v) in obj.iter() {
541                    let vv = match v {
542                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
543                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
544                        _ => v.clone(),
545                    };
546                    new_obj.insert(k, vv);
547                }
548                JsonValue::Object(new_obj)
549            }
550            _ => value.clone(),
551        };
552        match self {
553            #[cfg(feature = "db-mysql")]
554            Db::Mysql(db) => {
555                db.where_or(field, compare, value);
556            }
557            #[cfg(feature = "db-sqlite")]
558            Db::Sqlite(db) => {
559                db.where_or(field, compare, value);
560            }
561            #[cfg(feature = "db-mssql")]
562            Db::Mssql(db) => {
563                db.where_or(field, compare, value);
564            }
565            #[cfg(feature = "db-pgsql")]
566            Db::Pgsql(db) => {
567                db.where_or(field, compare, value);
568            }
569            _ => {}
570        };
571        self
572    }
573    pub fn where_column(&mut self, field_a: &str, compare: &str, field_b: &str) -> &mut Self {
574        match self {
575            #[cfg(feature = "db-mysql")]
576            Db::Mysql(db) => {
577                db.where_column(field_a, compare, field_b);
578            }
579            #[cfg(feature = "db-sqlite")]
580            Db::Sqlite(db) => {
581                db.where_column(field_a, compare, field_b);
582            }
583            #[cfg(feature = "db-mssql")]
584            Db::Mssql(db) => {
585                db.where_column(field_a, compare, field_b);
586            }
587            #[cfg(feature = "db-pgsql")]
588            Db::Pgsql(db) => {
589                db.where_column(field_a, compare, field_b);
590            }
591            _ => {}
592        };
593        self
594    }
595    pub fn update_column(&mut self, field_a: &str, compare: &str) -> &mut Self {
596        match self {
597            #[cfg(feature = "db-mysql")]
598            Db::Mysql(db) => {
599                db.update_column(field_a, compare);
600            }
601            #[cfg(feature = "db-sqlite")]
602            Db::Sqlite(db) => {
603                db.update_column(field_a, compare);
604            }
605            #[cfg(feature = "db-mssql")]
606            Db::Mssql(db) => {
607                db.update_column(field_a, compare);
608            }
609            #[cfg(feature = "db-pgsql")]
610            Db::Pgsql(db) => {
611                db.update_column(field_a, compare);
612            }
613            _ => {}
614        };
615        self
616    }
617    pub fn count(&mut self) -> JsonValue {
618        match self {
619            #[cfg(feature = "db-mysql")]
620            Db::Mysql(db) => db.count(),
621            #[cfg(feature = "db-sqlite")]
622            Db::Sqlite(db) => db.count(),
623            #[cfg(feature = "db-mssql")]
624            Db::Mssql(db) => db.count(),
625            #[cfg(feature = "db-pgsql")]
626            Db::Pgsql(db) => db.count(),
627            _ => JsonValue::from(0),
628        }
629    }
630    pub fn max(&mut self, field: &str) -> JsonValue {
631        match self {
632            #[cfg(feature = "db-mysql")]
633            Db::Mysql(db) => db.max(field),
634            #[cfg(feature = "db-sqlite")]
635            Db::Sqlite(db) => db.max(field),
636            #[cfg(feature = "db-mssql")]
637            Db::Mssql(db) => db.max(field),
638            #[cfg(feature = "db-pgsql")]
639            Db::Pgsql(db) => db.max(field),
640            _ => object! {},
641        }
642    }
643
644    pub fn min(&mut self, field: &str) -> JsonValue {
645        match self {
646            #[cfg(feature = "db-mysql")]
647            Db::Mysql(db) => db.min(field),
648            #[cfg(feature = "db-sqlite")]
649            Db::Sqlite(db) => db.min(field),
650            #[cfg(feature = "db-mssql")]
651            Db::Mssql(db) => db.min(field),
652            #[cfg(feature = "db-pgsql")]
653            Db::Pgsql(db) => db.min(field),
654            _ => object! {},
655        }
656    }
657
658    pub fn sum(&mut self, field: &str) -> JsonValue {
659        match self {
660            #[cfg(feature = "db-mysql")]
661            Db::Mysql(db) => db.sum(field),
662            #[cfg(feature = "db-sqlite")]
663            Db::Sqlite(db) => db.sum(field),
664            #[cfg(feature = "db-mssql")]
665            Db::Mssql(db) => db.sum(field),
666            #[cfg(feature = "db-pgsql")]
667            Db::Pgsql(db) => db.sum(field),
668            _ => object! {},
669        }
670    }
671
672    pub fn avg(&mut self, field: &str) -> JsonValue {
673        match self {
674            #[cfg(feature = "db-mysql")]
675            Db::Mysql(db) => db.avg(field),
676            #[cfg(feature = "db-sqlite")]
677            Db::Sqlite(db) => db.avg(field),
678            #[cfg(feature = "db-mssql")]
679            Db::Mssql(db) => db.avg(field),
680            #[cfg(feature = "db-pgsql")]
681            Db::Pgsql(db) => db.avg(field),
682            _ => object! {},
683        }
684    }
685
686    pub fn select(&mut self) -> JsonValue {
687        match self {
688            #[cfg(feature = "db-mysql")]
689            Db::Mysql(db) => db.select(),
690            #[cfg(feature = "db-sqlite")]
691            Db::Sqlite(db) => db.select(),
692            #[cfg(feature = "db-mssql")]
693            Db::Mssql(db) => db.select(),
694            #[cfg(feature = "db-pgsql")]
695            Db::Pgsql(db) => db.select(),
696            _ => object! {},
697        }
698    }
699
700    pub fn find(&mut self) -> JsonValue {
701        match self {
702            #[cfg(feature = "db-mysql")]
703            Db::Mysql(db) => db.find(),
704            #[cfg(feature = "db-sqlite")]
705            Db::Sqlite(db) => db.find(),
706            #[cfg(feature = "db-mssql")]
707            Db::Mssql(db) => db.find(),
708            #[cfg(feature = "db-pgsql")]
709            Db::Pgsql(db) => db.find(),
710            _ => object! {},
711        }
712    }
713
714    pub fn value(&mut self, field: &str) -> JsonValue {
715        match self {
716            #[cfg(feature = "db-mysql")]
717            Db::Mysql(db) => db.value(field),
718            #[cfg(feature = "db-sqlite")]
719            Db::Sqlite(db) => db.value(field),
720            #[cfg(feature = "db-mssql")]
721            Db::Mssql(db) => db.value(field),
722            #[cfg(feature = "db-pgsql")]
723            Db::Pgsql(db) => db.value(field),
724            _ => Null,
725        }
726    }
727
728    pub fn insert(&mut self, data: JsonValue) -> JsonValue {
729        match self {
730            #[cfg(feature = "db-mysql")]
731            Db::Mysql(db) => db.insert(data.clone()),
732            #[cfg(feature = "db-sqlite")]
733            Db::Sqlite(db) => db.insert(data.clone()),
734            #[cfg(feature = "db-mssql")]
735            Db::Mssql(db) => db.insert(data.clone()),
736            #[cfg(feature = "db-pgsql")]
737            Db::Pgsql(db) => db.insert(data.clone()),
738            _ => JsonValue::from(""),
739        }
740    }
741
742    pub fn insert_all(&mut self, data: JsonValue) -> JsonValue {
743        let data = if data.is_object() {
744            JsonValue::from(vec![data])
745        } else {
746            data
747        };
748        match self {
749            #[cfg(feature = "db-mysql")]
750            Db::Mysql(db) => db.insert_all(data.clone()),
751            #[cfg(feature = "db-sqlite")]
752            Db::Sqlite(db) => db.insert_all(data.clone()),
753            #[cfg(feature = "db-mssql")]
754            Db::Mssql(db) => db.insert_all(data.clone()),
755            #[cfg(feature = "db-pgsql")]
756            Db::Pgsql(db) => db.insert_all(data.clone()),
757            _ => object! {},
758        }
759    }
760
761    pub fn page(&mut self, mut page: i32, limit: i32) -> &mut Self {
762        if page <= 0 {
763            page = 1;
764        }
765        match self {
766            #[cfg(feature = "db-mysql")]
767            Db::Mysql(db) => {
768                db.page(page, limit);
769            }
770            #[cfg(feature = "db-sqlite")]
771            Db::Sqlite(db) => {
772                db.page(page, limit);
773            }
774            #[cfg(feature = "db-mssql")]
775            Db::Mssql(db) => {
776                db.page(page, limit);
777            }
778            #[cfg(feature = "db-pgsql")]
779            Db::Pgsql(db) => {
780                db.page(page, limit);
781            }
782            _ => {}
783        };
784        self
785    }
786
787    pub fn update(&mut self, data: JsonValue) -> JsonValue {
788        match self {
789            #[cfg(feature = "db-mysql")]
790            Db::Mysql(db) => db.update(data.clone()),
791            #[cfg(feature = "db-sqlite")]
792            Db::Sqlite(db) => db.update(data.clone()),
793            #[cfg(feature = "db-mssql")]
794            Db::Mssql(db) => db.update(data.clone()),
795            #[cfg(feature = "db-pgsql")]
796            Db::Pgsql(db) => db.update(data.clone()),
797            _ => JsonValue::from(0),
798        }
799    }
800
801    pub fn update_all(&mut self, data: JsonValue) -> JsonValue {
802        match self {
803            #[cfg(feature = "db-mysql")]
804            Db::Mysql(db) => db.update_all(data.clone()),
805            #[cfg(feature = "db-sqlite")]
806            Db::Sqlite(db) => db.update_all(data.clone()),
807            #[cfg(feature = "db-mssql")]
808            Db::Mssql(db) => db.update_all(data.clone()),
809            #[cfg(feature = "db-pgsql")]
810            Db::Pgsql(db) => db.update_all(data.clone()),
811            _ => JsonValue::from(0),
812        }
813    }
814
815    pub fn get_connection(&mut self) -> Connection {
816        match self {
817            #[cfg(feature = "db-mysql")]
818            Db::Mysql(db) => db.connection.clone(),
819            #[cfg(feature = "db-sqlite")]
820            Db::Sqlite(db) => db.connection.clone(),
821            #[cfg(feature = "db-mssql")]
822            Db::Mssql(db) => db.connection.clone(),
823            #[cfg(feature = "db-pgsql")]
824            Db::Pgsql(db) => db.connection.clone(),
825            _ => Connection::new(""),
826        }
827    }
828    pub fn database_tables(&mut self) -> JsonValue {
829        match self {
830            #[cfg(feature = "db-mysql")]
831            Db::Mysql(db) => db.database_tables(),
832            #[cfg(feature = "db-sqlite")]
833            Db::Sqlite(db) => db.database_tables(),
834            #[cfg(feature = "db-mssql")]
835            Db::Mssql(db) => db.database_tables(),
836            #[cfg(feature = "db-pgsql")]
837            Db::Pgsql(db) => db.database_tables(),
838            _ => JsonValue::Array(vec![]),
839        }
840    }
841    pub fn database_create(&mut self, name: &str) -> bool {
842        match self {
843            #[cfg(feature = "db-mysql")]
844            Db::Mysql(db) => db.database_create(name),
845            #[cfg(feature = "db-sqlite")]
846            Db::Sqlite(db) => db.database_create(name),
847            #[cfg(feature = "db-mssql")]
848            Db::Mssql(db) => db.database_create(name),
849            #[cfg(feature = "db-pgsql")]
850            Db::Pgsql(db) => db.database_create(name),
851            _ => false,
852        }
853    }
854    pub fn backups(&mut self, filename: &str) -> bool {
855        match self {
856            #[cfg(feature = "db-mysql")]
857            Db::Mysql(db) => {
858                // 定义要执行的命令
859                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() {
860                    Ok(output) => {
861                        if output.status.success() {
862                            // 将备份写入文件
863                            info!("数据库备份完成！");
864                            return true;
865                        }
866                        true
867                    }
868                    Err(e) => {
869                        // 打印错误信息
870                        error!("mysqldump 命令执行失败：{e}");
871                        false
872                    }
873                }
874            }
875            #[cfg(feature = "db-sqlite")]
876            Db::Sqlite(_db) => false,
877            #[cfg(feature = "db-mssql")]
878            Db::Mssql(_db) => false,
879            #[cfg(feature = "db-pgsql")]
880            Db::Pgsql(_db) => false,
881            _ => false,
882        }
883    }
884
885    pub fn delete(&mut self) -> JsonValue {
886        match self {
887            #[cfg(feature = "db-mysql")]
888            Db::Mysql(db) => db.delete(),
889            #[cfg(feature = "db-sqlite")]
890            Db::Sqlite(db) => db.delete(),
891            #[cfg(feature = "db-mssql")]
892            Db::Mssql(db) => db.delete(),
893            #[cfg(feature = "db-pgsql")]
894            Db::Pgsql(db) => db.delete(),
895            _ => JsonValue::from(0),
896        }
897    }
898    pub fn field(&mut self, name: &str) -> &mut Self {
899        match self {
900            #[cfg(feature = "db-mysql")]
901            Db::Mysql(db) => {
902                db.field(name);
903            }
904            #[cfg(feature = "db-sqlite")]
905            Db::Sqlite(db) => {
906                db.field(name);
907            }
908            #[cfg(feature = "db-mssql")]
909            Db::Mssql(db) => {
910                db.field(name);
911            }
912            #[cfg(feature = "db-pgsql")]
913            Db::Pgsql(db) => {
914                db.field(name);
915            }
916            _ => {}
917        };
918        self
919    }
920    pub fn hidden(&mut self, name: &str) -> &mut Self {
921        match self {
922            #[cfg(feature = "db-mysql")]
923            Db::Mysql(db) => {
924                db.hidden(name);
925            }
926            #[cfg(feature = "db-sqlite")]
927            Db::Sqlite(db) => {
928                db.hidden(name);
929            }
930            #[cfg(feature = "db-mssql")]
931            Db::Mssql(db) => {
932                db.hidden(name);
933            }
934            #[cfg(feature = "db-pgsql")]
935            Db::Pgsql(db) => {
936                db.hidden(name);
937            }
938            _ => {}
939        };
940        self
941    }
942
943    pub fn transaction(&mut self) -> bool {
944        match self {
945            #[cfg(feature = "db-mysql")]
946            Db::Mysql(db) => db.transaction(),
947            #[cfg(feature = "db-sqlite")]
948            Db::Sqlite(db) => db.transaction(),
949            #[cfg(feature = "db-mssql")]
950            Db::Mssql(db) => db.transaction(),
951            #[cfg(feature = "db-pgsql")]
952            Db::Pgsql(db) => db.transaction(),
953            _ => false,
954        }
955    }
956
957    pub fn commit(&mut self) -> bool {
958        match self {
959            #[cfg(feature = "db-mysql")]
960            Db::Mysql(db) => db.commit(),
961            #[cfg(feature = "db-sqlite")]
962            Db::Sqlite(db) => db.commit(),
963            #[cfg(feature = "db-mssql")]
964            Db::Mssql(db) => db.commit(),
965            #[cfg(feature = "db-pgsql")]
966            Db::Pgsql(db) => db.commit(),
967            _ => false,
968        }
969    }
970
971    pub fn rollback(&mut self) -> bool {
972        match self {
973            #[cfg(feature = "db-mysql")]
974            Db::Mysql(db) => db.rollback(),
975            #[cfg(feature = "db-sqlite")]
976            Db::Sqlite(db) => db.rollback(),
977            #[cfg(feature = "db-mssql")]
978            Db::Mssql(db) => db.rollback(),
979            #[cfg(feature = "db-pgsql")]
980            Db::Pgsql(db) => db.rollback(),
981            _ => false,
982        }
983    }
984
985    pub fn sql(&mut self, sql: &str) -> Result<JsonValue, String> {
986        match self {
987            #[cfg(feature = "db-mysql")]
988            Db::Mysql(db) => db.sql(sql),
989            #[cfg(feature = "db-sqlite")]
990            Db::Sqlite(db) => db.sql(sql),
991            #[cfg(feature = "db-mssql")]
992            Db::Mssql(db) => db.sql(sql),
993            #[cfg(feature = "db-pgsql")]
994            Db::Pgsql(db) => db.sql(sql),
995            _ => Err("".to_string()),
996        }
997    }
998
999    pub fn sql_execute(&mut self, sql: &str) -> Result<JsonValue, String> {
1000        match self {
1001            #[cfg(feature = "db-mysql")]
1002            Db::Mysql(db) => db.sql_execute(sql),
1003            #[cfg(feature = "db-sqlite")]
1004            Db::Sqlite(db) => db.sql_execute(sql),
1005            #[cfg(feature = "db-mssql")]
1006            Db::Mssql(db) => db.sql_execute(sql),
1007            #[cfg(feature = "db-pgsql")]
1008            Db::Pgsql(db) => db.sql_execute(sql),
1009            _ => Err("".to_string()),
1010        }
1011    }
1012
1013    /// 自增
1014    pub fn inc(&mut self, field: &str, num: f64) -> &mut Self {
1015        match self {
1016            #[cfg(feature = "db-mysql")]
1017            Db::Mysql(db) => {
1018                db.inc(field, num);
1019            }
1020            #[cfg(feature = "db-sqlite")]
1021            Db::Sqlite(db) => {
1022                db.inc(field, num);
1023            }
1024            #[cfg(feature = "db-mssql")]
1025            Db::Mssql(db) => {
1026                db.inc(field, num);
1027            }
1028            #[cfg(feature = "db-pgsql")]
1029            Db::Pgsql(db) => {
1030                db.inc(field, num);
1031            }
1032            _ => {}
1033        }
1034        self
1035    }
1036    /// 自减
1037    pub fn dec(&mut self, field: &str, num: f64) -> &mut Self {
1038        match self {
1039            #[cfg(feature = "db-mysql")]
1040            Db::Mysql(db) => {
1041                db.dec(field, num);
1042            }
1043            #[cfg(feature = "db-sqlite")]
1044            Db::Sqlite(db) => {
1045                db.dec(field, num);
1046            }
1047            #[cfg(feature = "db-mssql")]
1048            Db::Mssql(db) => {
1049                db.dec(field, num);
1050            }
1051            #[cfg(feature = "db-pgsql")]
1052            Db::Pgsql(db) => {
1053                db.dec(field, num);
1054            }
1055            _ => {}
1056        }
1057        self
1058    }
1059
1060    pub fn buildsql(&mut self) -> String {
1061        match self {
1062            #[cfg(feature = "db-mysql")]
1063            Db::Mysql(db) => db.buildsql(),
1064            #[cfg(feature = "db-sqlite")]
1065            Db::Sqlite(db) => db.buildsql(),
1066            #[cfg(feature = "db-mssql")]
1067            Db::Mssql(db) => db.buildsql(),
1068            #[cfg(feature = "db-pgsql")]
1069            Db::Pgsql(db) => db.buildsql(),
1070            _ => "".to_string(),
1071        }
1072    }
1073    pub fn join_fields(&mut self, fields: Vec<&str>) -> &mut Self {
1074        match self {
1075            #[cfg(feature = "db-mysql")]
1076            Db::Mysql(db) => {
1077                db.join_fields(fields);
1078            }
1079            #[cfg(feature = "db-sqlite")]
1080            Db::Sqlite(db) => {
1081                db.join_fields(fields);
1082            }
1083            #[cfg(feature = "db-mssql")]
1084            Db::Mssql(db) => {
1085                db.join_fields(fields);
1086            }
1087            #[cfg(feature = "db-pgsql")]
1088            Db::Pgsql(db) => {
1089                db.join_fields(fields);
1090            }
1091            _ => {}
1092        }
1093        self
1094    }
1095    /// 连接
1096    ///
1097    /// * main_table 主表表名
1098    /// * main_fields 主表字段名
1099    /// * right_table 关联主表名
1100    /// * right_fields 关联字段名
1101    pub fn join(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self {
1102        match self {
1103            #[cfg(feature = "db-mysql")]
1104            Db::Mysql(db) => {
1105                db.join(main_table, main_fields, right_table, right_fields);
1106            }
1107            #[cfg(feature = "db-sqlite")]
1108            Db::Sqlite(db) => {
1109                db.join(main_table, main_fields, right_table, right_fields);
1110            }
1111            #[cfg(feature = "db-mssql")]
1112            Db::Mssql(db) => {
1113                db.join(main_table, main_fields, right_table, right_fields);
1114            }
1115            #[cfg(feature = "db-pgsql")]
1116            Db::Pgsql(db) => {
1117                db.join(main_table, main_fields, right_table, right_fields);
1118            }
1119            _ => {}
1120        }
1121        self
1122    }
1123
1124    /// 内连接--用来取交集
1125    ///
1126    /// * table 链表表名
1127    /// * main_fields 主表字段
1128    /// * second_fields 附表关联字段
1129    pub fn join_inner(&mut self, table: &str, main_fields: &str, second_fields: &str) -> &mut Self {
1130        match self {
1131            #[cfg(feature = "db-mysql")]
1132            Db::Mysql(db) => {
1133                db.join_inner(table, main_fields, second_fields);
1134            }
1135            #[cfg(feature = "db-sqlite")]
1136            Db::Sqlite(db) => {
1137                db.join_inner(table, main_fields, second_fields);
1138            }
1139            #[cfg(feature = "db-mssql")]
1140            Db::Mssql(db) => {
1141                db.join_inner(table, main_fields, second_fields);
1142            }
1143            #[cfg(feature = "db-pgsql")]
1144            Db::Pgsql(db) => {
1145                db.join_inner(table, main_fields, second_fields);
1146            }
1147            _ => {}
1148        }
1149        self
1150    }
1151}
1152
1153/// 模型数据库字段模型
1154#[derive(Clone, Debug)]
1155pub struct Table {
1156    pub version: String,
1157    pub table: String,
1158    pub title: String,
1159    pub primary_key: String,
1160    pub unique: Vec<String>,
1161    pub index: Vec<Vec<String>>,
1162    pub fields: JsonValue,
1163    pub partition: bool,
1164    pub partition_columns: JsonValue,
1165}
1166
1167impl Table {
1168    pub fn to_str(self) -> String {
1169        let data = object! {
1170            version:self.version,
1171            table:self.table,
1172            title:self.title,
1173            primary_key:self.primary_key,
1174            unique:self.unique,
1175            index:self.index,
1176            fields:self.fields,
1177            partition:self.partition,
1178            partition_columns:self.partition_columns,
1179        };
1180        data.to_string()
1181    }
1182    pub fn parse(mut data: JsonValue) -> Table {
1183        let mut unique = vec![];
1184        for item in 0..data["unique"].len() {
1185            let str = data["unique"][item].clone().to_string();
1186            unique.push(str);
1187        }
1188        let mut index = vec![];
1189        for item in data["index"].members_mut() {
1190            let mut row = vec![];
1191            for col in item.members_mut() {
1192                row.push(col.to_string());
1193            }
1194            if !row.is_empty() {
1195                index.push(row);
1196            }
1197        }
1198        Self {
1199            version: data["version"].to_string(),
1200            table: data["table"].to_string(),
1201            title: data["title"].to_string(),
1202            primary_key: data["primary_key"].to_string(),
1203            unique,
1204            index,
1205            fields: data["fields"].clone(),
1206            partition: data["partition"].as_bool().unwrap_or(false),
1207            partition_columns: data["partition_columns"].clone(),
1208        }
1209    }
1210}
br_db/lib.rs

br_db/
lib.rs
