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

br_db/
lib.rs
