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

br_db/
lib.rs
