br_db/
lib.rs

1use json::Null;
2use lazy_static::lazy_static;
3use chrono::Local;
4use std::collections::HashMap;
5use std::fs;
6#[cfg(any(feature = "db-mysql", feature = "db-sqlite", feature = "db-mssql"))]
7use std::process::Command;
8use std::sync::{Mutex};
9use std::vec;
10
11use crate::config::{Config, Connection};
12#[cfg(feature = "db-mssql")]
13use crate::types::mssql::Mssql;
14#[cfg(feature = "db-mysql")]
15use crate::types::mysql::Mysql;
16#[cfg(feature = "db-pgsql")]
17use crate::types::pgsql::Pgsql;
18#[cfg(feature = "db-sqlite")]
19use crate::types::sqlite::Sqlite;
20use crate::types::{DbMode, TableOptions};
21use crate::types::{Mode};
22use json::object;
23use json::JsonValue;
24use log::{error, info};
25
26pub mod config;
27pub mod error;
28pub mod pools;
29pub mod types;
30pub mod fields;
31
32pub use error::{DbError, DbResult};
33
34lazy_static! {
35    pub static ref DB: Mutex<HashMap<String,Db>> =Mutex::new(HashMap::new());
36    static ref CONNECTION: Mutex<HashMap<String,Connection>> =Mutex::new(HashMap::new());
37    static ref DEFAULT: Mutex<HashMap<usize,String>> =Mutex::new(HashMap::new());
38    static ref TABLE_FIELDS: Mutex<HashMap<String,JsonValue>> =Mutex::new(HashMap::new());
39}
40#[derive(Clone)]
41pub enum Db {
42    #[cfg(feature = "db-mysql")]
43    Mysql(Mysql),
44    #[cfg(feature = "db-sqlite")]
45    Sqlite(Sqlite),
46    #[cfg(feature = "db-mssql")]
47    Mssql(Mssql),
48    #[cfg(feature = "db-pgsql")]
49    Pgsql(Pgsql),
50    None,
51}
52
53impl Db {
54    pub fn load(path: &str) -> Result<Db, String> {
55        let conf = fs::read_to_string(path);
56        let t = match conf {
57            Ok(str) => match json::parse(str.as_str()) {
58                Ok(config) => Db::new(Config::from(config))?,
59                Err(_) => Db::new(Config::create(path.into(), false))?,
60            },
61            Err(_) => Db::new(Config::create(path.into(), false))?,
62        };
63        Ok(t)
64    }
65    pub fn new(config: Config) -> Result<Db, String> {
66        let connection = match config.connections.get(&*config.default) {
67            None => return Err(format!("无此配置: {}", config.default)),
68            Some(e) => e,
69        };
70        for (name, conn) in config.connections.clone() {
71            let mut conn_guard = match CONNECTION.lock() {
72                Ok(g) => g,
73                Err(e) => e.into_inner(),
74            };
75            if conn_guard.get(&name).is_none() {
76                conn_guard.insert(name, conn);
77            }
78        }
79        {
80            let mut default_guard = match DEFAULT.lock() {
81                Ok(g) => g,
82                Err(e) => e.into_inner(),
83            };
84            default_guard.insert(0, config.default.clone());
85        }
86        let db = Db::setlist(connection.clone(), config.default.clone());
87        match db {
88            Ok(db) => {
89                let mut db_guard = match DB.lock() {
90                    Ok(g) => g,
91                    Err(e) => e.into_inner(),
92                };
93                db_guard.insert(config.default.clone(), db);
94                match db_guard.get(&*config.default.clone()) {
95                    Some(r) => Ok(r.clone()),
96                    None => Err("数据库初始化失败".to_string()),
97                }
98            }
99            Err(e) => Err(e),
100        }
101    }
102
103    fn setlist(mut connection: Connection, default: String) -> Result<Db, String> {
104        match connection.mode.str().as_str() {
105            #[cfg(feature = "db-mysql")]
106            "mysql" => match Mysql::connect(connection.clone(), default.clone()) {
107                Ok(e) => Ok(Db::Mysql(e)),
108                Err(e) => Err(e),
109            },
110            #[cfg(feature = "db-sqlite")]
111            "sqlite" => match Sqlite::connect(connection.clone(), default.clone()) {
112                Ok(e) => Ok(Db::Sqlite(e)),
113                Err(e) => Err(e),
114            },
115            #[cfg(feature = "db-mssql")]
116            "mssql" => match Mssql::connect(connection.clone(), default.clone()) {
117                Ok(e) => Ok(Db::Mssql(e)),
118                Err(e) => Err(e),
119            },
120            #[cfg(feature = "db-pgsql")]
121            "pgsql" => match Pgsql::connect(connection.clone(), default.clone()) {
122                Ok(e) => Ok(Db::Pgsql(e)),
123                Err(e) => Err(e),
124            },
125            _ => Err("未匹配数据库".to_string()),
126        }
127    }
128    pub fn get_config_default(&mut self) -> String {
129        let default_guard = match DEFAULT.lock() {
130            Ok(g) => g,
131            Err(e) => e.into_inner(),
132        };
133        match default_guard.get(&0) {
134            Some(d) => d.clone(),
135            None => String::new(),
136        }
137    }
138    pub fn get_config_list(&mut self) -> Vec<String> {
139        let conn_guard = match CONNECTION.lock() {
140            Ok(g) => g,
141            Err(e) => e.into_inner(),
142        };
143        conn_guard.iter().map(|x| x.0.clone()).collect::<Vec<String>>()
144    }
145    pub fn connection(&mut self, name: &str) -> Db {
146        let default_guard = match DEFAULT.lock() {
147            Ok(g) => g,
148            Err(e) => e.into_inner(),
149        };
150        let default = match default_guard.get(&0) {
151            Some(d) => d.clone(),
152            None => String::new(),
153        };
154        drop(default_guard);
155        
156        let name = if name.is_empty() { &default } else { name };
157
158        let db_guard = match DB.lock() {
159            Ok(g) => g,
160            Err(e) => e.into_inner(),
161        };
162        if let Some(db) = db_guard.get(name) {
163            return db.clone();
164        }
165        drop(db_guard);
166        
167        let conn_guard = match CONNECTION.lock() {
168            Ok(g) => g,
169            Err(e) => e.into_inner(),
170        };
171        let connection = match conn_guard.get(name) {
172            Some(c) => c.clone(),
173            None => {
174                drop(conn_guard);
175                return self.clone();
176            }
177        };
178        drop(conn_guard);
179        
180        let db = match Db::setlist(connection, name.to_string()) {
181            Ok(e) => e,
182            Err(_) => {
183                let db_guard = match DB.lock() {
184                    Ok(g) => g,
185                    Err(e) => e.into_inner(),
186                };
187                match db_guard.get(name) {
188                    Some(db) => return db.clone(),
189                    None => return self.clone(),
190                }
191            }
192        };
193        let mut db_guard = match DB.lock() {
194            Ok(g) => g,
195            Err(e) => e.into_inner(),
196        };
197        db_guard.insert(name.to_string(), db.clone());
198        db
199    }
200    /// 增加配置
201    pub fn connection_add(&mut self, config_name: &str, connection: Connection) -> Db {
202        let name = if config_name.is_empty() {
203            let default_guard = match DEFAULT.lock() {
204                Ok(g) => g,
205                Err(e) => e.into_inner(),
206            };
207            match default_guard.get(&0) {
208                Some(d) => d.clone(),
209                None => String::new(),
210            }
211        } else {
212            config_name.to_string()
213        };
214        
215        let db_guard = match DB.lock() {
216            Ok(g) => g,
217            Err(e) => e.into_inner(),
218        };
219        if let Some(db) = db_guard.get(&name) {
220            return db.clone();
221        }
222        drop(db_guard);
223        
224        {
225            let mut conn_guard = match CONNECTION.lock() {
226                Ok(g) => g,
227                Err(e) => e.into_inner(),
228            };
229            conn_guard.insert(name.clone(), connection.clone());
230        }
231
232        let db = match Db::setlist(connection, name.clone()) {
233            Ok(e) => e,
234            Err(_) => {
235                let db_guard = match DB.lock() {
236                    Ok(g) => g,
237                    Err(e) => e.into_inner(),
238                };
239                match db_guard.get(&name) {
240                    Some(db) => return db.clone(),
241                    None => return self.clone(),
242                }
243            }
244        };
245        let mut db_guard = match DB.lock() {
246            Ok(g) => g,
247            Err(e) => e.into_inner(),
248        };
249        db_guard.insert(name, db.clone());
250        db
251    }
252
253    /// 具体功能
254    pub fn table_create(&mut self, options: TableOptions) -> JsonValue {
255        match self {
256            #[cfg(feature = "db-mysql")]
257            Db::Mysql(db) => db.table_create(options),
258            #[cfg(feature = "db-sqlite")]
259            Db::Sqlite(db) => db.table_create(options),
260            #[cfg(feature = "db-mssql")]
261            Db::Mssql(_) => JsonValue::from(false),
262            #[cfg(feature = "db-pgsql")]
263            Db::Pgsql(db) => db.table_create(options),
264            _ => JsonValue::from(false),
265        }
266    }
267    pub fn table_update(&mut self, options: TableOptions) -> JsonValue {
268        match self {
269            #[cfg(feature = "db-mysql")]
270            Db::Mysql(db) => db.table_update(options),
271            #[cfg(feature = "db-sqlite")]
272            Db::Sqlite(db) => db.table_update(options),
273            #[cfg(feature = "db-mssql")]
274            Db::Mssql(_) => JsonValue::from(false),
275            #[cfg(feature = "db-pgsql")]
276            Db::Pgsql(db) => db.table_update(options),
277            _ => JsonValue::from(false),
278        }
279    }
280    pub fn table_info(&mut self, table: &str) -> JsonValue {
281        match self {
282            #[cfg(feature = "db-mysql")]
283            Db::Mysql(db) => db.table_info(table),
284            #[cfg(feature = "db-sqlite")]
285            Db::Sqlite(db) => db.table_info(table),
286            #[cfg(feature = "db-mssql")]
287            Db::Mssql(db) => db.table_info(table),
288            #[cfg(feature = "db-pgsql")]
289            Db::Pgsql(db) => db.table_info(table),
290            _ => object! {},
291        }
292    }
293    pub fn table_is_exist(&mut self, name: &str) -> bool {
294        match self {
295            #[cfg(feature = "db-mysql")]
296            Db::Mysql(db) => db.table_is_exist(name),
297            #[cfg(feature = "db-sqlite")]
298            Db::Sqlite(db) => db.table_is_exist(name),
299            #[cfg(feature = "db-mssql")]
300            Db::Mssql(db) => db.table_is_exist(name),
301            #[cfg(feature = "db-pgsql")]
302            Db::Pgsql(db) => db.table_is_exist(name),
303            _ => false,
304        }
305    }
306    pub fn table(&mut self, name: &str) -> &mut Self {
307        match self {
308            #[cfg(feature = "db-mysql")]
309            Db::Mysql(db) => {
310                db.table(name);
311            }
312            #[cfg(feature = "db-sqlite")]
313            Db::Sqlite(db) => {
314                db.table(name);
315            }
316            #[cfg(feature = "db-mssql")]
317            Db::Mssql(db) => {
318                db.table(name);
319            }
320            #[cfg(feature = "db-pgsql")]
321            Db::Pgsql(db) => {
322                db.table(name);
323            }
324            _ => {}
325        };
326        self
327    }
328
329    pub fn change_table(&mut self, name: &str) -> &mut Self {
330        match self {
331            #[cfg(feature = "db-mysql")]
332            Db::Mysql(db) => {
333                db.change_table(name);
334            }
335            #[cfg(feature = "db-sqlite")]
336            Db::Sqlite(db) => {
337                db.change_table(name);
338            }
339            #[cfg(feature = "db-mssql")]
340            Db::Mssql(db) => {
341                db.change_table(name);
342            }
343            #[cfg(feature = "db-pgsql")]
344            Db::Pgsql(db) => {
345                db.change_table(name);
346            }
347            _ => {}
348        };
349        self
350    }
351
352    pub fn autoinc(&mut self) -> &mut Self {
353        match self {
354            #[cfg(feature = "db-mysql")]
355            Db::Mysql(db) => {
356                db.autoinc();
357            }
358            #[cfg(feature = "db-sqlite")]
359            Db::Sqlite(db) => {
360                db.autoinc();
361            }
362            #[cfg(feature = "db-mssql")]
363            Db::Mssql(db) => {
364                db.autoinc();
365            }
366            #[cfg(feature = "db-pgsql")]
367            Db::Pgsql(db) => {
368                db.autoinc();
369            }
370            _ => {}
371        };
372        self
373    }
374
375    pub fn timestamps(&mut self) -> &mut Self {
376        match self {
377            #[cfg(feature = "db-mysql")]
378            Db::Mysql(db) => {
379                db.timestamps();
380            }
381            #[cfg(feature = "db-sqlite")]
382            Db::Sqlite(db) => {
383                db.timestamps();
384            }
385            #[cfg(feature = "db-mssql")]
386            Db::Mssql(db) => {
387                db.timestamps();
388            }
389            #[cfg(feature = "db-pgsql")]
390            Db::Pgsql(db) => {
391                db.timestamps();
392            }
393            _ => {}
394        };
395        self
396    }
397
398    pub fn fetch_sql(&mut self) -> &mut Self {
399        match self {
400            #[cfg(feature = "db-mysql")]
401            Db::Mysql(db) => {
402                db.fetch_sql();
403            }
404            #[cfg(feature = "db-sqlite")]
405            Db::Sqlite(db) => {
406                db.fetch_sql();
407            }
408            #[cfg(feature = "db-mssql")]
409            Db::Mssql(db) => {
410                db.fetch_sql();
411            }
412            #[cfg(feature = "db-pgsql")]
413            Db::Pgsql(db) => {
414                db.fetch_sql();
415            }
416            _ => {}
417        };
418        self
419    }
420    /// 排序
421    ///
422    /// * field 排序字段
423    /// * by 排序方法 true 降序 false 升序
424    pub fn order(&mut self, field: &str, by: bool) -> &mut Self {
425        match self {
426            #[cfg(feature = "db-mysql")]
427            Db::Mysql(db) => {
428                db.order(field, by);
429            }
430            #[cfg(feature = "db-sqlite")]
431            Db::Sqlite(db) => {
432                db.order(field, by);
433            }
434            #[cfg(feature = "db-mssql")]
435            Db::Mssql(db) => {
436                db.order(field, by);
437            }
438            #[cfg(feature = "db-pgsql")]
439            Db::Pgsql(db) => {
440                db.order(field, by);
441            }
442            _ => {}
443        }
444        self
445    }
446
447    pub fn group(&mut self, field: &str) -> &mut Self {
448        match self {
449            #[cfg(feature = "db-mysql")]
450            Db::Mysql(db) => {
451                db.group(field);
452            }
453            #[cfg(feature = "db-sqlite")]
454            Db::Sqlite(db) => {
455                db.group(field);
456            }
457            #[cfg(feature = "db-mssql")]
458            Db::Mssql(db) => {
459                db.group(field);
460            }
461            #[cfg(feature = "db-pgsql")]
462            Db::Pgsql(db) => {
463                db.group(field);
464            }
465            _ => {}
466        }
467        self
468    }
469
470    pub fn distinct(&mut self) -> &mut Self {
471        match self {
472            #[cfg(feature = "db-mysql")]
473            Db::Mysql(db) => {
474                db.distinct();
475            }
476            #[cfg(feature = "db-sqlite")]
477            Db::Sqlite(db) => {
478                db.distinct();
479            }
480            #[cfg(feature = "db-mssql")]
481            Db::Mssql(db) => {
482                db.distinct();
483            }
484            #[cfg(feature = "db-pgsql")]
485            Db::Pgsql(db) => {
486                db.distinct();
487            }
488            _ => {}
489        }
490        self
491    }
492
493    pub fn json(&mut self, field: &str) -> &mut Self {
494        match self {
495            #[cfg(feature = "db-mysql")]
496            Db::Mysql(db) => {
497                db.json(field);
498            }
499            #[cfg(feature = "db-sqlite")]
500            Db::Sqlite(db) => {
501                db.json(field);
502            }
503            #[cfg(feature = "db-mssql")]
504            Db::Mssql(db) => {
505                db.json(field);
506            }
507            #[cfg(feature = "db-pgsql")]
508            Db::Pgsql(db) => {
509                db.json(field);
510            }
511            _ => {}
512        }
513        self
514    }
515    /// 坐标系
516    pub fn location(&mut self, field: &str) -> &mut Self {
517        match self {
518            #[cfg(feature = "db-mysql")]
519            Db::Mysql(db) => {
520                db.location(field);
521            }
522            #[cfg(feature = "db-sqlite")]
523            Db::Sqlite(db) => {
524                db.location(field);
525            }
526            #[cfg(feature = "db-mssql")]
527            Db::Mssql(db) => {
528                db.location(field);
529            }
530            #[cfg(feature = "db-pgsql")]
531            Db::Pgsql(db) => {
532                db.location(field);
533            }
534            _ => {}
535        }
536        self
537    }
538
539    pub fn column(&mut self, field: &str) -> JsonValue {
540        match self {
541            #[cfg(feature = "db-mysql")]
542            Db::Mysql(db) => db.column(field),
543            #[cfg(feature = "db-sqlite")]
544            Db::Sqlite(db) => db.column(field),
545            #[cfg(feature = "db-mssql")]
546            Db::Mssql(db) => db.column(field),
547            #[cfg(feature = "db-pgsql")]
548            Db::Pgsql(db) => db.column(field),
549            _ => object! {},
550        }
551    }
552
553    pub fn where_and(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
554        if field.contains("|") {
555            let fields: Vec<&str> = field.split("|").collect();
556            for field in fields.iter() {
557                self.where_or(field.to_string().as_str(), compare, value.clone());
558            }
559            return self;
560        }
561        let compare = compare.to_lowercase();
562        let compare = compare.replace(" ", "");
563        let compare = compare.as_str();
564
565        let value = match &value {
566            JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
567            JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
568            JsonValue::Array(arr) => {
569                JsonValue::Array(
570                    arr.iter().map(|v| match v {
571                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
572                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
573                        _ => v.clone(),
574                    }).collect()
575                )
576            }
577            JsonValue::Object(obj) => {
578                let mut new_obj = object::Object::new();
579                for (k, v) in obj.iter() {
580                    let vv = match v {
581                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
582                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
583                        _ => v.clone(),
584                    };
585                    new_obj.insert(k, vv);
586                }
587                JsonValue::Object(new_obj)
588            }
589            _ => value.clone(),
590        };
591        match self {
592            #[cfg(feature = "db-mysql")]
593            Db::Mysql(db) => {
594                db.where_and(field, compare, value);
595            }
596            #[cfg(feature = "db-sqlite")]
597            Db::Sqlite(db) => {
598                db.where_and(field, compare, value);
599            }
600            #[cfg(feature = "db-mssql")]
601            Db::Mssql(db) => {
602                db.where_and(field, compare, value);
603            }
604            #[cfg(feature = "db-pgsql")]
605            Db::Pgsql(db) => {
606                db.where_and(field, compare, value);
607            }
608            _ => {}
609        };
610        self
611    }
612
613    pub fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
614        if field.contains("|") {
615            let fields: Vec<&str> = field.split("|").collect();
616            for field in fields.iter() {
617                self.where_or(field.to_string().as_str(), compare, value.clone());
618            }
619            return self;
620        }
621        let compare = compare.to_lowercase();
622        let compare = compare.replace(" ", "");
623        let compare = compare.as_str();
624
625        let value = match &value {
626            JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
627            JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
628            JsonValue::Array(arr) => {
629                JsonValue::Array(
630                    arr.iter().map(|v| match v {
631                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
632                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
633                        _ => v.clone(),
634                    }).collect()
635                )
636            }
637            JsonValue::Object(obj) => {
638                let mut new_obj = object::Object::new();
639                for (k, v) in obj.iter() {
640                    let vv = match v {
641                        JsonValue::Short(s) => JsonValue::String(s.as_str().replace("'", "''")),
642                        JsonValue::String(s) => JsonValue::String(s.replace("'", "''")),
643                        _ => v.clone(),
644                    };
645                    new_obj.insert(k, vv);
646                }
647                JsonValue::Object(new_obj)
648            }
649            _ => value.clone(),
650        };
651        match self {
652            #[cfg(feature = "db-mysql")]
653            Db::Mysql(db) => {
654                db.where_or(field, compare, value);
655            }
656            #[cfg(feature = "db-sqlite")]
657            Db::Sqlite(db) => {
658                db.where_or(field, compare, value);
659            }
660            #[cfg(feature = "db-mssql")]
661            Db::Mssql(db) => {
662                db.where_or(field, compare, value);
663            }
664            #[cfg(feature = "db-pgsql")]
665            Db::Pgsql(db) => {
666                db.where_or(field, compare, value);
667            }
668            _ => {}
669        };
670        self
671    }
672    pub fn where_column(&mut self, field_a: &str, compare: &str, field_b: &str) -> &mut Self {
673        match self {
674            #[cfg(feature = "db-mysql")]
675            Db::Mysql(db) => {
676                db.where_column(field_a, compare, field_b);
677            }
678            #[cfg(feature = "db-sqlite")]
679            Db::Sqlite(db) => {
680                db.where_column(field_a, compare, field_b);
681            }
682            #[cfg(feature = "db-mssql")]
683            Db::Mssql(db) => {
684                db.where_column(field_a, compare, field_b);
685            }
686            #[cfg(feature = "db-pgsql")]
687            Db::Pgsql(db) => {
688                db.where_column(field_a, compare, field_b);
689            }
690            _ => {}
691        };
692        self
693    }
694    pub fn where_in_sub(&mut self, field: &str, sub_sql: &str) -> &mut Self {
695        match self {
696            #[cfg(feature = "db-mysql")]
697            Db::Mysql(db) => {
698                db.where_in_sub(field, sub_sql);
699            }
700            #[cfg(feature = "db-sqlite")]
701            Db::Sqlite(db) => {
702                db.where_in_sub(field, sub_sql);
703            }
704            #[cfg(feature = "db-mssql")]
705            Db::Mssql(db) => {
706                db.where_in_sub(field, sub_sql);
707            }
708            #[cfg(feature = "db-pgsql")]
709            Db::Pgsql(db) => {
710                db.where_in_sub(field, sub_sql);
711            }
712            _ => {}
713        };
714        self
715    }
716    pub fn where_not_in_sub(&mut self, field: &str, sub_sql: &str) -> &mut Self {
717        match self {
718            #[cfg(feature = "db-mysql")]
719            Db::Mysql(db) => {
720                db.where_not_in_sub(field, sub_sql);
721            }
722            #[cfg(feature = "db-sqlite")]
723            Db::Sqlite(db) => {
724                db.where_not_in_sub(field, sub_sql);
725            }
726            #[cfg(feature = "db-mssql")]
727            Db::Mssql(db) => {
728                db.where_not_in_sub(field, sub_sql);
729            }
730            #[cfg(feature = "db-pgsql")]
731            Db::Pgsql(db) => {
732                db.where_not_in_sub(field, sub_sql);
733            }
734            _ => {}
735        };
736        self
737    }
738    pub fn where_exists(&mut self, sub_sql: &str) -> &mut Self {
739        match self {
740            #[cfg(feature = "db-mysql")]
741            Db::Mysql(db) => {
742                db.where_exists(sub_sql);
743            }
744            #[cfg(feature = "db-sqlite")]
745            Db::Sqlite(db) => {
746                db.where_exists(sub_sql);
747            }
748            #[cfg(feature = "db-mssql")]
749            Db::Mssql(db) => {
750                db.where_exists(sub_sql);
751            }
752            #[cfg(feature = "db-pgsql")]
753            Db::Pgsql(db) => {
754                db.where_exists(sub_sql);
755            }
756            _ => {}
757        };
758        self
759    }
760    pub fn where_not_exists(&mut self, sub_sql: &str) -> &mut Self {
761        match self {
762            #[cfg(feature = "db-mysql")]
763            Db::Mysql(db) => {
764                db.where_not_exists(sub_sql);
765            }
766            #[cfg(feature = "db-sqlite")]
767            Db::Sqlite(db) => {
768                db.where_not_exists(sub_sql);
769            }
770            #[cfg(feature = "db-mssql")]
771            Db::Mssql(db) => {
772                db.where_not_exists(sub_sql);
773            }
774            #[cfg(feature = "db-pgsql")]
775            Db::Pgsql(db) => {
776                db.where_not_exists(sub_sql);
777            }
778            _ => {}
779        };
780        self
781    }
782    pub fn update_column(&mut self, field_a: &str, compare: &str) -> &mut Self {
783        match self {
784            #[cfg(feature = "db-mysql")]
785            Db::Mysql(db) => {
786                db.update_column(field_a, compare);
787            }
788            #[cfg(feature = "db-sqlite")]
789            Db::Sqlite(db) => {
790                db.update_column(field_a, compare);
791            }
792            #[cfg(feature = "db-mssql")]
793            Db::Mssql(db) => {
794                db.update_column(field_a, compare);
795            }
796            #[cfg(feature = "db-pgsql")]
797            Db::Pgsql(db) => {
798                db.update_column(field_a, compare);
799            }
800            _ => {}
801        };
802        self
803    }
804    pub fn count(&mut self) -> JsonValue {
805        match self {
806            #[cfg(feature = "db-mysql")]
807            Db::Mysql(db) => db.count(),
808            #[cfg(feature = "db-sqlite")]
809            Db::Sqlite(db) => db.count(),
810            #[cfg(feature = "db-mssql")]
811            Db::Mssql(db) => db.count(),
812            #[cfg(feature = "db-pgsql")]
813            Db::Pgsql(db) => db.count(),
814            _ => JsonValue::from(0),
815        }
816    }
817    pub fn max(&mut self, field: &str) -> JsonValue {
818        match self {
819            #[cfg(feature = "db-mysql")]
820            Db::Mysql(db) => db.max(field),
821            #[cfg(feature = "db-sqlite")]
822            Db::Sqlite(db) => db.max(field),
823            #[cfg(feature = "db-mssql")]
824            Db::Mssql(db) => db.max(field),
825            #[cfg(feature = "db-pgsql")]
826            Db::Pgsql(db) => db.max(field),
827            _ => object! {},
828        }
829    }
830
831    pub fn min(&mut self, field: &str) -> JsonValue {
832        match self {
833            #[cfg(feature = "db-mysql")]
834            Db::Mysql(db) => db.min(field),
835            #[cfg(feature = "db-sqlite")]
836            Db::Sqlite(db) => db.min(field),
837            #[cfg(feature = "db-mssql")]
838            Db::Mssql(db) => db.min(field),
839            #[cfg(feature = "db-pgsql")]
840            Db::Pgsql(db) => db.min(field),
841            _ => object! {},
842        }
843    }
844
845    pub fn sum(&mut self, field: &str) -> JsonValue {
846        match self {
847            #[cfg(feature = "db-mysql")]
848            Db::Mysql(db) => db.sum(field),
849            #[cfg(feature = "db-sqlite")]
850            Db::Sqlite(db) => db.sum(field),
851            #[cfg(feature = "db-mssql")]
852            Db::Mssql(db) => db.sum(field),
853            #[cfg(feature = "db-pgsql")]
854            Db::Pgsql(db) => db.sum(field),
855            _ => object! {},
856        }
857    }
858
859    pub fn avg(&mut self, field: &str) -> JsonValue {
860        match self {
861            #[cfg(feature = "db-mysql")]
862            Db::Mysql(db) => db.avg(field),
863            #[cfg(feature = "db-sqlite")]
864            Db::Sqlite(db) => db.avg(field),
865            #[cfg(feature = "db-mssql")]
866            Db::Mssql(db) => db.avg(field),
867            #[cfg(feature = "db-pgsql")]
868            Db::Pgsql(db) => db.avg(field),
869            _ => object! {},
870        }
871    }
872
873    pub fn select(&mut self) -> JsonValue {
874        match self {
875            #[cfg(feature = "db-mysql")]
876            Db::Mysql(db) => db.select(),
877            #[cfg(feature = "db-sqlite")]
878            Db::Sqlite(db) => db.select(),
879            #[cfg(feature = "db-mssql")]
880            Db::Mssql(db) => db.select(),
881            #[cfg(feature = "db-pgsql")]
882            Db::Pgsql(db) => db.select(),
883            _ => object! {},
884        }
885    }
886
887    pub fn find(&mut self) -> JsonValue {
888        match self {
889            #[cfg(feature = "db-mysql")]
890            Db::Mysql(db) => db.find(),
891            #[cfg(feature = "db-sqlite")]
892            Db::Sqlite(db) => db.find(),
893            #[cfg(feature = "db-mssql")]
894            Db::Mssql(db) => db.find(),
895            #[cfg(feature = "db-pgsql")]
896            Db::Pgsql(db) => db.find(),
897            _ => object! {},
898        }
899    }
900
901    pub fn value(&mut self, field: &str) -> JsonValue {
902        match self {
903            #[cfg(feature = "db-mysql")]
904            Db::Mysql(db) => db.value(field),
905            #[cfg(feature = "db-sqlite")]
906            Db::Sqlite(db) => db.value(field),
907            #[cfg(feature = "db-mssql")]
908            Db::Mssql(db) => db.value(field),
909            #[cfg(feature = "db-pgsql")]
910            Db::Pgsql(db) => db.value(field),
911            _ => Null,
912        }
913    }
914
915    pub fn insert(&mut self, mut data: JsonValue) -> JsonValue {
916        let ts = match self {
917            #[cfg(feature = "db-mysql")]
918            Db::Mysql(db) => db.params.timestamps,
919            #[cfg(feature = "db-sqlite")]
920            Db::Sqlite(db) => db.params.timestamps,
921            #[cfg(feature = "db-mssql")]
922            Db::Mssql(db) => db.params.timestamps,
923            #[cfg(feature = "db-pgsql")]
924            Db::Pgsql(db) => db.params.timestamps,
925            _ => false,
926        };
927        if ts {
928            let now = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
929            if data["created_at"].is_empty() {
930                data["created_at"] = now.clone().into();
931            }
932            if data["updated_at"].is_empty() {
933                data["updated_at"] = now.into();
934            }
935        }
936        match self {
937            #[cfg(feature = "db-mysql")]
938            Db::Mysql(db) => db.insert(data),
939            #[cfg(feature = "db-sqlite")]
940            Db::Sqlite(db) => db.insert(data),
941            #[cfg(feature = "db-mssql")]
942            Db::Mssql(db) => db.insert(data),
943            #[cfg(feature = "db-pgsql")]
944            Db::Pgsql(db) => db.insert(data),
945            _ => JsonValue::from(""),
946        }
947    }
948
949    pub fn insert_all(&mut self, data: JsonValue) -> JsonValue {
950        let data = if data.is_object() {
951            JsonValue::from(vec![data])
952        } else {
953            data
954        };
955        match self {
956            #[cfg(feature = "db-mysql")]
957            Db::Mysql(db) => db.insert_all(data.clone()),
958            #[cfg(feature = "db-sqlite")]
959            Db::Sqlite(db) => db.insert_all(data.clone()),
960            #[cfg(feature = "db-mssql")]
961            Db::Mssql(db) => db.insert_all(data.clone()),
962            #[cfg(feature = "db-pgsql")]
963            Db::Pgsql(db) => db.insert_all(data.clone()),
964            _ => object! {},
965        }
966    }
967
968    pub fn upsert(&mut self, data: JsonValue, conflict_fields: Vec<&str>) -> JsonValue {
969        match self {
970            #[cfg(feature = "db-mysql")]
971            Db::Mysql(db) => db.upsert(data.clone(), conflict_fields),
972            #[cfg(feature = "db-sqlite")]
973            Db::Sqlite(db) => db.upsert(data.clone(), conflict_fields),
974            #[cfg(feature = "db-mssql")]
975            Db::Mssql(db) => db.upsert(data.clone(), conflict_fields),
976            #[cfg(feature = "db-pgsql")]
977            Db::Pgsql(db) => db.upsert(data.clone(), conflict_fields),
978            _ => JsonValue::from(""),
979        }
980    }
981
982    pub fn page(&mut self, mut page: i32, limit: i32) -> &mut Self {
983        if page <= 0 {
984            page = 1;
985        }
986        match self {
987            #[cfg(feature = "db-mysql")]
988            Db::Mysql(db) => {
989                db.page(page, limit);
990            }
991            #[cfg(feature = "db-sqlite")]
992            Db::Sqlite(db) => {
993                db.page(page, limit);
994            }
995            #[cfg(feature = "db-mssql")]
996            Db::Mssql(db) => {
997                db.page(page, limit);
998            }
999            #[cfg(feature = "db-pgsql")]
1000            Db::Pgsql(db) => {
1001                db.page(page, limit);
1002            }
1003            _ => {}
1004        };
1005        self
1006    }
1007
1008    pub fn limit(&mut self, count: i32) -> &mut Self {
1009        match self {
1010            #[cfg(feature = "db-mysql")]
1011            Db::Mysql(db) => {
1012                db.limit(count);
1013            }
1014            #[cfg(feature = "db-sqlite")]
1015            Db::Sqlite(db) => {
1016                db.limit(count);
1017            }
1018            #[cfg(feature = "db-mssql")]
1019            Db::Mssql(db) => {
1020                db.limit(count);
1021            }
1022            #[cfg(feature = "db-pgsql")]
1023            Db::Pgsql(db) => {
1024                db.limit(count);
1025            }
1026            _ => {}
1027        };
1028        self
1029    }
1030
1031    pub fn update(&mut self, mut data: JsonValue) -> JsonValue {
1032        let ts = match self {
1033            #[cfg(feature = "db-mysql")]
1034            Db::Mysql(db) => db.params.timestamps,
1035            #[cfg(feature = "db-sqlite")]
1036            Db::Sqlite(db) => db.params.timestamps,
1037            #[cfg(feature = "db-mssql")]
1038            Db::Mssql(db) => db.params.timestamps,
1039            #[cfg(feature = "db-pgsql")]
1040            Db::Pgsql(db) => db.params.timestamps,
1041            _ => false,
1042        };
1043        if ts {
1044            let now = Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
1045            if data["updated_at"].is_empty() {
1046                data["updated_at"] = now.into();
1047            }
1048        }
1049        match self {
1050            #[cfg(feature = "db-mysql")]
1051            Db::Mysql(db) => db.update(data),
1052            #[cfg(feature = "db-sqlite")]
1053            Db::Sqlite(db) => db.update(data),
1054            #[cfg(feature = "db-mssql")]
1055            Db::Mssql(db) => db.update(data),
1056            #[cfg(feature = "db-pgsql")]
1057            Db::Pgsql(db) => db.update(data),
1058            _ => JsonValue::from(0),
1059        }
1060    }
1061
1062    pub fn update_all(&mut self, data: JsonValue) -> JsonValue {
1063        match self {
1064            #[cfg(feature = "db-mysql")]
1065            Db::Mysql(db) => db.update_all(data.clone()),
1066            #[cfg(feature = "db-sqlite")]
1067            Db::Sqlite(db) => db.update_all(data.clone()),
1068            #[cfg(feature = "db-mssql")]
1069            Db::Mssql(db) => db.update_all(data.clone()),
1070            #[cfg(feature = "db-pgsql")]
1071            Db::Pgsql(db) => db.update_all(data.clone()),
1072            _ => JsonValue::from(0),
1073        }
1074    }
1075
1076    pub fn get_connection(&mut self) -> Connection {
1077        match self {
1078            #[cfg(feature = "db-mysql")]
1079            Db::Mysql(db) => db.connection.clone(),
1080            #[cfg(feature = "db-sqlite")]
1081            Db::Sqlite(db) => db.connection.clone(),
1082            #[cfg(feature = "db-mssql")]
1083            Db::Mssql(db) => db.connection.clone(),
1084            #[cfg(feature = "db-pgsql")]
1085            Db::Pgsql(db) => db.connection.clone(),
1086            _ => Connection::new(""),
1087        }
1088    }
1089    pub fn database_tables(&mut self) -> JsonValue {
1090        match self {
1091            #[cfg(feature = "db-mysql")]
1092            Db::Mysql(db) => db.database_tables(),
1093            #[cfg(feature = "db-sqlite")]
1094            Db::Sqlite(db) => db.database_tables(),
1095            #[cfg(feature = "db-mssql")]
1096            Db::Mssql(db) => db.database_tables(),
1097            #[cfg(feature = "db-pgsql")]
1098            Db::Pgsql(db) => db.database_tables(),
1099            _ => JsonValue::Array(vec![]),
1100        }
1101    }
1102    pub fn database_create(&mut self, name: &str) -> bool {
1103        match self {
1104            #[cfg(feature = "db-mysql")]
1105            Db::Mysql(db) => db.database_create(name),
1106            #[cfg(feature = "db-sqlite")]
1107            Db::Sqlite(db) => db.database_create(name),
1108            #[cfg(feature = "db-mssql")]
1109            Db::Mssql(db) => db.database_create(name),
1110            #[cfg(feature = "db-pgsql")]
1111            Db::Pgsql(db) => db.database_create(name),
1112            _ => false,
1113        }
1114    }
1115    pub fn truncate(&mut self, table: &str) -> bool {
1116        match self {
1117            #[cfg(feature = "db-mysql")]
1118            Db::Mysql(db) => db.truncate(table),
1119            #[cfg(feature = "db-sqlite")]
1120            Db::Sqlite(db) => db.truncate(table),
1121            #[cfg(feature = "db-mssql")]
1122            Db::Mssql(db) => db.truncate(table),
1123            #[cfg(feature = "db-pgsql")]
1124            Db::Pgsql(db) => db.truncate(table),
1125            _ => false,
1126        }
1127    }
1128    pub fn backups(&mut self, filename: &str) -> bool {
1129        match self {
1130            #[cfg(feature = "db-mysql")]
1131            Db::Mysql(db) => {
1132                // 定义要执行的命令
1133                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() {
1134                    Ok(output) => {
1135                        if output.status.success() {
1136                            // 将备份写入文件
1137                            info!("数据库备份完成！");
1138                            return true;
1139                        }
1140                        true
1141                    }
1142                    Err(e) => {
1143                        // 打印错误信息
1144                        error!("mysqldump 命令执行失败：{e}");
1145                        false
1146                    }
1147                }
1148            }
1149            #[cfg(feature = "db-sqlite")]
1150            Db::Sqlite(_db) => false,
1151            #[cfg(feature = "db-mssql")]
1152            Db::Mssql(_db) => false,
1153            #[cfg(feature = "db-pgsql")]
1154            Db::Pgsql(_db) => false,
1155            _ => false,
1156        }
1157    }
1158
1159    pub fn delete(&mut self) -> JsonValue {
1160        match self {
1161            #[cfg(feature = "db-mysql")]
1162            Db::Mysql(db) => db.delete(),
1163            #[cfg(feature = "db-sqlite")]
1164            Db::Sqlite(db) => db.delete(),
1165            #[cfg(feature = "db-mssql")]
1166            Db::Mssql(db) => db.delete(),
1167            #[cfg(feature = "db-pgsql")]
1168            Db::Pgsql(db) => db.delete(),
1169            _ => JsonValue::from(0),
1170        }
1171    }
1172    pub fn field(&mut self, name: &str) -> &mut Self {
1173        match self {
1174            #[cfg(feature = "db-mysql")]
1175            Db::Mysql(db) => {
1176                db.field(name);
1177            }
1178            #[cfg(feature = "db-sqlite")]
1179            Db::Sqlite(db) => {
1180                db.field(name);
1181            }
1182            #[cfg(feature = "db-mssql")]
1183            Db::Mssql(db) => {
1184                db.field(name);
1185            }
1186            #[cfg(feature = "db-pgsql")]
1187            Db::Pgsql(db) => {
1188                db.field(name);
1189            }
1190            _ => {}
1191        };
1192        self
1193    }
1194    pub fn hidden(&mut self, name: &str) -> &mut Self {
1195        match self {
1196            #[cfg(feature = "db-mysql")]
1197            Db::Mysql(db) => {
1198                db.hidden(name);
1199            }
1200            #[cfg(feature = "db-sqlite")]
1201            Db::Sqlite(db) => {
1202                db.hidden(name);
1203            }
1204            #[cfg(feature = "db-mssql")]
1205            Db::Mssql(db) => {
1206                db.hidden(name);
1207            }
1208            #[cfg(feature = "db-pgsql")]
1209            Db::Pgsql(db) => {
1210                db.hidden(name);
1211            }
1212            _ => {}
1213        };
1214        self
1215    }
1216
1217    pub fn transaction(&mut self) -> bool {
1218        match self {
1219            #[cfg(feature = "db-mysql")]
1220            Db::Mysql(db) => db.transaction(),
1221            #[cfg(feature = "db-sqlite")]
1222            Db::Sqlite(db) => db.transaction(),
1223            #[cfg(feature = "db-mssql")]
1224            Db::Mssql(db) => db.transaction(),
1225            #[cfg(feature = "db-pgsql")]
1226            Db::Pgsql(db) => db.transaction(),
1227            _ => false,
1228        }
1229    }
1230
1231    pub fn commit(&mut self) -> bool {
1232        match self {
1233            #[cfg(feature = "db-mysql")]
1234            Db::Mysql(db) => db.commit(),
1235            #[cfg(feature = "db-sqlite")]
1236            Db::Sqlite(db) => db.commit(),
1237            #[cfg(feature = "db-mssql")]
1238            Db::Mssql(db) => db.commit(),
1239            #[cfg(feature = "db-pgsql")]
1240            Db::Pgsql(db) => db.commit(),
1241            _ => false,
1242        }
1243    }
1244
1245    pub fn rollback(&mut self) -> bool {
1246        match self {
1247            #[cfg(feature = "db-mysql")]
1248            Db::Mysql(db) => db.rollback(),
1249            #[cfg(feature = "db-sqlite")]
1250            Db::Sqlite(db) => db.rollback(),
1251            #[cfg(feature = "db-mssql")]
1252            Db::Mssql(db) => db.rollback(),
1253            #[cfg(feature = "db-pgsql")]
1254            Db::Pgsql(db) => db.rollback(),
1255            _ => false,
1256        }
1257    }
1258
1259    pub fn transaction_fn<F, R>(&mut self, f: F) -> Result<R, String>
1260    where
1261        F: FnOnce(&mut Self) -> Result<R, String>,
1262    {
1263        if !self.transaction() {
1264            return Err("事务开启失败".to_string());
1265        }
1266        match f(self) {
1267            Ok(result) => {
1268                if self.commit() {
1269                    Ok(result)
1270                } else {
1271                    self.rollback();
1272                    Err("事务提交失败".to_string())
1273                }
1274            }
1275            Err(e) => {
1276                self.rollback();
1277                Err(e)
1278            }
1279        }
1280    }
1281
1282    pub fn sql(&mut self, sql: &str) -> Result<JsonValue, String> {
1283        match self {
1284            #[cfg(feature = "db-mysql")]
1285            Db::Mysql(db) => db.sql(sql),
1286            #[cfg(feature = "db-sqlite")]
1287            Db::Sqlite(db) => db.sql(sql),
1288            #[cfg(feature = "db-mssql")]
1289            Db::Mssql(db) => db.sql(sql),
1290            #[cfg(feature = "db-pgsql")]
1291            Db::Pgsql(db) => db.sql(sql),
1292            _ => Err("".to_string()),
1293        }
1294    }
1295
1296    pub fn sql_execute(&mut self, sql: &str) -> Result<JsonValue, String> {
1297        match self {
1298            #[cfg(feature = "db-mysql")]
1299            Db::Mysql(db) => db.sql_execute(sql),
1300            #[cfg(feature = "db-sqlite")]
1301            Db::Sqlite(db) => db.sql_execute(sql),
1302            #[cfg(feature = "db-mssql")]
1303            Db::Mssql(db) => db.sql_execute(sql),
1304            #[cfg(feature = "db-pgsql")]
1305            Db::Pgsql(db) => db.sql_execute(sql),
1306            _ => Err("".to_string()),
1307        }
1308    }
1309
1310    /// 自增
1311    pub fn inc(&mut self, field: &str, num: f64) -> &mut Self {
1312        match self {
1313            #[cfg(feature = "db-mysql")]
1314            Db::Mysql(db) => {
1315                db.inc(field, num);
1316            }
1317            #[cfg(feature = "db-sqlite")]
1318            Db::Sqlite(db) => {
1319                db.inc(field, num);
1320            }
1321            #[cfg(feature = "db-mssql")]
1322            Db::Mssql(db) => {
1323                db.inc(field, num);
1324            }
1325            #[cfg(feature = "db-pgsql")]
1326            Db::Pgsql(db) => {
1327                db.inc(field, num);
1328            }
1329            _ => {}
1330        }
1331        self
1332    }
1333    /// 自减
1334    pub fn dec(&mut self, field: &str, num: f64) -> &mut Self {
1335        match self {
1336            #[cfg(feature = "db-mysql")]
1337            Db::Mysql(db) => {
1338                db.dec(field, num);
1339            }
1340            #[cfg(feature = "db-sqlite")]
1341            Db::Sqlite(db) => {
1342                db.dec(field, num);
1343            }
1344            #[cfg(feature = "db-mssql")]
1345            Db::Mssql(db) => {
1346                db.dec(field, num);
1347            }
1348            #[cfg(feature = "db-pgsql")]
1349            Db::Pgsql(db) => {
1350                db.dec(field, num);
1351            }
1352            _ => {}
1353        }
1354        self
1355    }
1356
1357    pub fn buildsql(&mut self) -> String {
1358        match self {
1359            #[cfg(feature = "db-mysql")]
1360            Db::Mysql(db) => db.buildsql(),
1361            #[cfg(feature = "db-sqlite")]
1362            Db::Sqlite(db) => db.buildsql(),
1363            #[cfg(feature = "db-mssql")]
1364            Db::Mssql(db) => db.buildsql(),
1365            #[cfg(feature = "db-pgsql")]
1366            Db::Pgsql(db) => db.buildsql(),
1367            _ => "".to_string(),
1368        }
1369    }
1370    pub fn join_fields(&mut self, fields: Vec<&str>) -> &mut Self {
1371        match self {
1372            #[cfg(feature = "db-mysql")]
1373            Db::Mysql(db) => {
1374                db.join_fields(fields);
1375            }
1376            #[cfg(feature = "db-sqlite")]
1377            Db::Sqlite(db) => {
1378                db.join_fields(fields);
1379            }
1380            #[cfg(feature = "db-mssql")]
1381            Db::Mssql(db) => {
1382                db.join_fields(fields);
1383            }
1384            #[cfg(feature = "db-pgsql")]
1385            Db::Pgsql(db) => {
1386                db.join_fields(fields);
1387            }
1388            _ => {}
1389        }
1390        self
1391    }
1392    /// 连接
1393    ///
1394    /// * main_table 主表表名
1395    /// * main_fields 主表字段名
1396    /// * right_table 关联主表名
1397    /// * right_fields 关联字段名
1398    pub fn join(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self {
1399        match self {
1400            #[cfg(feature = "db-mysql")]
1401            Db::Mysql(db) => {
1402                db.join(main_table, main_fields, right_table, right_fields);
1403            }
1404            #[cfg(feature = "db-sqlite")]
1405            Db::Sqlite(db) => {
1406                db.join(main_table, main_fields, right_table, right_fields);
1407            }
1408            #[cfg(feature = "db-mssql")]
1409            Db::Mssql(db) => {
1410                db.join(main_table, main_fields, right_table, right_fields);
1411            }
1412            #[cfg(feature = "db-pgsql")]
1413            Db::Pgsql(db) => {
1414                db.join(main_table, main_fields, right_table, right_fields);
1415            }
1416            _ => {}
1417        }
1418        self
1419    }
1420
1421    /// 内连接--用来取交集
1422    ///
1423    /// * table 链表表名
1424    /// * main_fields 主表字段
1425    /// * second_fields 附表关联字段
1426    pub fn join_inner(&mut self, table: &str, main_fields: &str, second_fields: &str) -> &mut Self {
1427        match self {
1428            #[cfg(feature = "db-mysql")]
1429            Db::Mysql(db) => {
1430                db.join_inner(table, main_fields, second_fields);
1431            }
1432            #[cfg(feature = "db-sqlite")]
1433            Db::Sqlite(db) => {
1434                db.join_inner(table, main_fields, second_fields);
1435            }
1436            #[cfg(feature = "db-mssql")]
1437            Db::Mssql(db) => {
1438                db.join_inner(table, main_fields, second_fields);
1439            }
1440            #[cfg(feature = "db-pgsql")]
1441            Db::Pgsql(db) => {
1442                db.join_inner(table, main_fields, second_fields);
1443            }
1444            _ => {}
1445        }
1446        self
1447    }
1448
1449    pub fn join_right(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self {
1450        match self {
1451            #[cfg(feature = "db-mysql")]
1452            Db::Mysql(db) => {
1453                db.join_right(main_table, main_fields, right_table, right_fields);
1454            }
1455            #[cfg(feature = "db-sqlite")]
1456            Db::Sqlite(db) => {
1457                db.join_right(main_table, main_fields, right_table, right_fields);
1458            }
1459            #[cfg(feature = "db-mssql")]
1460            Db::Mssql(db) => {
1461                db.join_right(main_table, main_fields, right_table, right_fields);
1462            }
1463            #[cfg(feature = "db-pgsql")]
1464            Db::Pgsql(db) => {
1465                db.join_right(main_table, main_fields, right_table, right_fields);
1466            }
1467            _ => {}
1468        }
1469        self
1470    }
1471
1472    pub fn join_full(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self {
1473        match self {
1474            #[cfg(feature = "db-mysql")]
1475            Db::Mysql(db) => {
1476                db.join_full(main_table, main_fields, right_table, right_fields);
1477            }
1478            #[cfg(feature = "db-sqlite")]
1479            Db::Sqlite(db) => {
1480                db.join_full(main_table, main_fields, right_table, right_fields);
1481            }
1482            #[cfg(feature = "db-mssql")]
1483            Db::Mssql(db) => {
1484                db.join_full(main_table, main_fields, right_table, right_fields);
1485            }
1486            #[cfg(feature = "db-pgsql")]
1487            Db::Pgsql(db) => {
1488                db.join_full(main_table, main_fields, right_table, right_fields);
1489            }
1490            _ => {}
1491        }
1492        self
1493    }
1494
1495    pub fn union(&mut self, sub_sql: &str) -> &mut Self {
1496        match self {
1497            #[cfg(feature = "db-mysql")]
1498            Db::Mysql(db) => {
1499                db.union(sub_sql);
1500            }
1501            #[cfg(feature = "db-sqlite")]
1502            Db::Sqlite(db) => {
1503                db.union(sub_sql);
1504            }
1505            #[cfg(feature = "db-mssql")]
1506            Db::Mssql(db) => {
1507                db.union(sub_sql);
1508            }
1509            #[cfg(feature = "db-pgsql")]
1510            Db::Pgsql(db) => {
1511                db.union(sub_sql);
1512            }
1513            _ => {}
1514        };
1515        self
1516    }
1517
1518    pub fn union_all(&mut self, sub_sql: &str) -> &mut Self {
1519        match self {
1520            #[cfg(feature = "db-mysql")]
1521            Db::Mysql(db) => {
1522                db.union_all(sub_sql);
1523            }
1524            #[cfg(feature = "db-sqlite")]
1525            Db::Sqlite(db) => {
1526                db.union_all(sub_sql);
1527            }
1528            #[cfg(feature = "db-mssql")]
1529            Db::Mssql(db) => {
1530                db.union_all(sub_sql);
1531            }
1532            #[cfg(feature = "db-pgsql")]
1533            Db::Pgsql(db) => {
1534                db.union_all(sub_sql);
1535            }
1536            _ => {}
1537        };
1538        self
1539    }
1540
1541    pub fn lock_for_update(&mut self) -> &mut Self {
1542        match self {
1543            #[cfg(feature = "db-mysql")]
1544            Db::Mysql(db) => {
1545                db.lock_for_update();
1546            }
1547            #[cfg(feature = "db-sqlite")]
1548            Db::Sqlite(db) => {
1549                db.lock_for_update();
1550            }
1551            #[cfg(feature = "db-mssql")]
1552            Db::Mssql(db) => {
1553                db.lock_for_update();
1554            }
1555            #[cfg(feature = "db-pgsql")]
1556            Db::Pgsql(db) => {
1557                db.lock_for_update();
1558            }
1559            _ => {}
1560        };
1561        self
1562    }
1563
1564    pub fn lock_for_share(&mut self) -> &mut Self {
1565        match self {
1566            #[cfg(feature = "db-mysql")]
1567            Db::Mysql(db) => {
1568                db.lock_for_share();
1569            }
1570            #[cfg(feature = "db-sqlite")]
1571            Db::Sqlite(db) => {
1572                db.lock_for_share();
1573            }
1574            #[cfg(feature = "db-mssql")]
1575            Db::Mssql(db) => {
1576                db.lock_for_share();
1577            }
1578            #[cfg(feature = "db-pgsql")]
1579            Db::Pgsql(db) => {
1580                db.lock_for_share();
1581            }
1582            _ => {}
1583        };
1584        self
1585    }
1586}
1587
1588/// 模型数据库字段模型
1589#[derive(Clone, Debug)]
1590pub struct Table {
1591    pub version: String,
1592    pub table: String,
1593    pub title: String,
1594    pub primary_key: String,
1595    pub unique: Vec<String>,
1596    pub index: Vec<Vec<String>>,
1597    pub fields: JsonValue,
1598    pub partition: bool,
1599    pub partition_columns: JsonValue,
1600}
1601
1602impl Table {
1603    pub fn to_str(self) -> String {
1604        let data = object! {
1605            version:self.version,
1606            table:self.table,
1607            title:self.title,
1608            primary_key:self.primary_key,
1609            unique:self.unique,
1610            index:self.index,
1611            fields:self.fields,
1612            partition:self.partition,
1613            partition_columns:self.partition_columns,
1614        };
1615        data.to_string()
1616    }
1617    pub fn parse(mut data: JsonValue) -> Table {
1618        let mut unique = vec![];
1619        for item in 0..data["unique"].len() {
1620            let str = data["unique"][item].clone().to_string();
1621            unique.push(str);
1622        }
1623        let mut index = vec![];
1624        for item in data["index"].members_mut() {
1625            let mut row = vec![];
1626            for col in item.members_mut() {
1627                row.push(col.to_string());
1628            }
1629            if !row.is_empty() {
1630                index.push(row);
1631            }
1632        }
1633        Self {
1634            version: data["version"].to_string(),
1635            table: data["table"].to_string(),
1636            title: data["title"].to_string(),
1637            primary_key: data["primary_key"].to_string(),
1638            unique,
1639            index,
1640            fields: data["fields"].clone(),
1641            partition: data["partition"].as_bool().unwrap_or(false),
1642            partition_columns: data["partition_columns"].clone(),
1643        }
1644    }
1645}
1646
1647#[cfg(test)]
1648mod tests {
1649    use super::Table;
1650    use json::{array, object};
1651
1652    fn sample_table() -> Table {
1653        Table {
1654            version: "1.0.0".to_string(),
1655            table: "users".to_string(),
1656            title: "Users".to_string(),
1657            primary_key: "id".to_string(),
1658            unique: vec!["email".to_string(), "phone".to_string()],
1659            index: vec![
1660                vec!["name".to_string()],
1661                vec!["created_at".to_string(), "status".to_string()],
1662            ],
1663            fields: object! {
1664                id: "bigint",
1665                name: "string",
1666                active: true,
1667            },
1668            partition: true,
1669            partition_columns: array!["created_at", "region"],
1670        }
1671    }
1672
1673    fn assert_tables_equal(actual: &Table, expected: &Table) {
1674        assert_eq!(actual.version, expected.version);
1675        assert_eq!(actual.table, expected.table);
1676        assert_eq!(actual.title, expected.title);
1677        assert_eq!(actual.primary_key, expected.primary_key);
1678        assert_eq!(actual.unique, expected.unique);
1679        assert_eq!(actual.index, expected.index);
1680        assert_eq!(actual.fields, expected.fields);
1681        assert_eq!(actual.partition, expected.partition);
1682        assert_eq!(actual.partition_columns, expected.partition_columns);
1683    }
1684
1685    #[test]
1686    fn table_to_str_contains_expected_keys_and_values() {
1687        let json_str = sample_table().to_str();
1688
1689        assert!(json_str.contains("\"version\":\"1.0.0\""));
1690        assert!(json_str.contains("\"table\":\"users\""));
1691        assert!(json_str.contains("\"primary_key\":\"id\""));
1692        assert!(json_str.contains("\"partition\":true"));
1693        assert!(json_str.contains("\"unique\":[\"email\",\"phone\"]"));
1694        assert!(json_str.contains("\"partition_columns\":[\"created_at\",\"region\"]"));
1695    }
1696
1697    #[test]
1698    fn table_parse_reads_all_fields() {
1699        let data = object! {
1700            version: "2.1.3",
1701            table: "orders",
1702            title: "Orders",
1703            primary_key: "order_id",
1704            unique: array!["order_no", "out_trade_no"],
1705            index: array![
1706                array!["user_id"],
1707                array!["created_at", "status"],
1708            ],
1709            fields: object! {
1710                order_id: "bigint",
1711                amount: "decimal",
1712            },
1713            partition: true,
1714            partition_columns: array!["created_at"],
1715        };
1716
1717        let table = Table::parse(data);
1718
1719        assert_eq!(table.version, "2.1.3");
1720        assert_eq!(table.table, "orders");
1721        assert_eq!(table.title, "Orders");
1722        assert_eq!(table.primary_key, "order_id");
1723        assert_eq!(table.unique, vec!["order_no", "out_trade_no"]);
1724        assert_eq!(table.index, vec![vec!["user_id"], vec!["created_at", "status"]]);
1725        assert_eq!(table.fields, object! { order_id: "bigint", amount: "decimal" });
1726        assert!(table.partition);
1727        assert_eq!(table.partition_columns, array!["created_at"]);
1728    }
1729
1730    #[test]
1731    fn table_roundtrip_to_str_and_parse() {
1732        let original = sample_table();
1733        let json_str = original.clone().to_str();
1734        let parsed_json = json::parse(&json_str).expect("valid table json");
1735        let parsed_table = Table::parse(parsed_json);
1736
1737        assert_tables_equal(&parsed_table, &original);
1738    }
1739
1740    #[test]
1741    fn table_parse_with_missing_fields_uses_defaults() {
1742        let data = object! {};
1743
1744        let table = Table::parse(data);
1745
1746        assert_eq!(table.version, "null");
1747        assert_eq!(table.table, "null");
1748        assert_eq!(table.title, "null");
1749        assert_eq!(table.primary_key, "null");
1750        assert!(table.unique.is_empty());
1751        assert!(table.index.is_empty());
1752        assert_eq!(table.fields, json::JsonValue::Null);
1753        assert!(!table.partition);
1754        assert_eq!(table.partition_columns, json::JsonValue::Null);
1755    }
1756
1757    #[test]
1758    fn table_parse_nested_index_arrays() {
1759        let data = object! {
1760            index: array![
1761                array!["col_a", "col_b"],
1762                array!["col_c"],
1763            ]
1764        };
1765
1766        let table = Table::parse(data);
1767
1768        assert_eq!(table.index, vec![vec!["col_a", "col_b"], vec!["col_c"]]);
1769    }
1770
1771    #[test]
1772    fn table_parse_unique_array() {
1773        let data = object! {
1774            unique: array!["email", "username"]
1775        };
1776
1777        let table = Table::parse(data);
1778
1779        assert_eq!(table.unique, vec!["email", "username"]);
1780    }
1781
1782    #[test]
1783    fn table_parse_partition_and_partition_columns() {
1784        let data = object! {
1785            partition: true,
1786            partition_columns: array!["created_at", "tenant_id"]
1787        };
1788
1789        let table = Table::parse(data);
1790
1791        assert!(table.partition);
1792        assert_eq!(table.partition_columns, array!["created_at", "tenant_id"]);
1793    }
1794}
br_db/lib.rs

br_db/
lib.rs
