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

br_db/
lib.rs
