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

br_db/
lib.rs
