br_db/types/
mod.rs

1use json::{JsonValue, object};
2
3static DISABLE_FIELD: &[&str] = &["default", "select", "delete", "insert", "update", "order", "group", "user", "password", "desc", "index", "from", "host", "user", "read", "partition"];
4
5/// SQL injection prevention - security critical module
6pub mod sql_safety {
7    static SQL_KEYWORDS: &[&str] = &[
8        "select", "insert", "update", "delete", "drop", "truncate", "alter",
9        "create", "exec", "execute", "union",
10    ];
11    
12    static DANGEROUS_PATTERNS: &[&str] = &[
13        "--", "/*", "*/", ";", "xp_", "sp_", "0x",
14    ];
15
16    #[inline]
17    pub fn validate_table_name(name: &str) -> bool {
18        if name.is_empty() || name.len() > 128 {
19            return false;
20        }
21        let bytes = name.as_bytes();
22        let first = bytes[0];
23        if !first.is_ascii_alphabetic() && first != b'_' {
24            return false;
25        }
26        for &b in bytes {
27            if !b.is_ascii_alphanumeric() && b != b'_' {
28                return false;
29            }
30        }
31        let lower = name.to_lowercase();
32        if SQL_KEYWORDS.iter().any(|kw| lower == *kw) {
33            return false;
34        }
35        !DANGEROUS_PATTERNS.iter().any(|p| lower.contains(p))
36    }
37
38    #[inline]
39    pub fn validate_field_name(name: &str) -> bool {
40        if name.is_empty() || name.len() > 256 {
41            return false;
42        }
43        for part in name.split('.') {
44            if part.is_empty() {
45                return false;
46            }
47            let bytes = part.as_bytes();
48            let first = bytes[0];
49            if !first.is_ascii_alphabetic() && first != b'_' {
50                return false;
51            }
52            for &b in bytes {
53                if !b.is_ascii_alphanumeric() && b != b'_' {
54                    return false;
55                }
56            }
57        }
58        let lower = name.to_lowercase();
59        if SQL_KEYWORDS.iter().any(|kw| lower == *kw) {
60            return false;
61        }
62        !DANGEROUS_PATTERNS.iter().any(|p| lower.contains(p))
63    }
64
65    #[inline]
66    pub fn escape_string(value: &str) -> String {
67        value
68            .replace('\\', "\\\\")
69            .replace('\'', "''")
70            .replace('\0', "")
71            .replace('\n', "\\n")
72            .replace('\r', "\\r")
73    }
74
75    #[inline]
76    pub fn validate_compare_orator(op: &str) -> bool {
77        matches!(
78            op.to_lowercase().as_str(),
79            "=" | "!=" | "<>" | "<" | ">" | "<=" | ">=" | "like" | "not like" |
80            "in" | "not in" | "notin" | "between" | "is" | "isnot" | "is not" |
81            "set" | "location" | "notlike"
82        )
83    }
84
85    #[cfg(test)]
86    mod tests {
87        use super::*;
88
89        #[test]
90        fn test_validate_table_name_valid() {
91            assert!(validate_table_name("users"));
92            assert!(validate_table_name("user_profiles"));
93            assert!(validate_table_name("_private_table"));
94            assert!(validate_table_name("Table123"));
95            assert!(validate_table_name("batch_insert_perf"));
96            assert!(validate_table_name("my_update_log"));
97        }
98
99        #[test]
100        fn test_validate_table_name_invalid() {
101            assert!(!validate_table_name(""));
102            assert!(!validate_table_name("123table"));
103            assert!(!validate_table_name("user-name"));
104            assert!(!validate_table_name("table.name"));
105            assert!(!validate_table_name("table name"));
106        }
107
108        #[test]
109        fn test_validate_table_name_sql_keywords() {
110            assert!(!validate_table_name("select"));
111            assert!(!validate_table_name("SELECT"));
112            assert!(!validate_table_name("insert"));
113            assert!(!validate_table_name("drop"));
114            assert!(!validate_table_name("union"));
115        }
116
117        #[test]
118        fn test_validate_table_name_dangerous_patterns() {
119            assert!(!validate_table_name("table;drop"));
120            assert!(!validate_table_name("table--comment"));
121            assert!(!validate_table_name("xp_cmdshell"));
122            assert!(!validate_table_name("sp_execute"));
123        }
124
125        #[test]
126        fn test_validate_table_name_length() {
127            let long_name = "a".repeat(128);
128            assert!(validate_table_name(&long_name));
129            let too_long = "a".repeat(129);
130            assert!(!validate_table_name(&too_long));
131        }
132
133        #[test]
134        fn test_validate_field_name_valid() {
135            assert!(validate_field_name("id"));
136            assert!(validate_field_name("user_name"));
137            assert!(validate_field_name("_hidden"));
138            assert!(validate_field_name("table1.field1"));
139        }
140
141        #[test]
142        fn test_validate_field_name_invalid() {
143            assert!(!validate_field_name(""));
144            assert!(!validate_field_name("123field"));
145            assert!(!validate_field_name("field-name"));
146            assert!(!validate_field_name(".field"));
147            assert!(!validate_field_name("field."));
148        }
149
150        #[test]
151        fn test_escape_string() {
152            assert_eq!(escape_string("hello"), "hello");
153            assert_eq!(escape_string("it's"), "it''s");
154            assert_eq!(escape_string("new\nline"), "new\\nline");
155            assert_eq!(escape_string("carriage\rreturn"), "carriage\\rreturn");
156        }
157
158        #[test]
159        fn test_escape_string_sql_injection() {
160            assert_eq!(escape_string("'; DROP TABLE users; --"), "''; DROP TABLE users; --");
161            assert_eq!(escape_string("1' OR '1'='1"), "1'' OR ''1''=''1");
162        }
163
164        #[test]
165        fn test_validate_compare_operator_valid() {
166            assert!(validate_compare_orator("="));
167            assert!(validate_compare_orator("!="));
168            assert!(validate_compare_orator("like"));
169            assert!(validate_compare_orator("LIKE"));
170            assert!(validate_compare_orator("in"));
171            assert!(validate_compare_orator("between"));
172        }
173
174        #[test]
175        fn test_validate_compare_operator_invalid() {
176            assert!(!validate_compare_orator(""));
177            assert!(!validate_compare_orator("invalid"));
178            assert!(!validate_compare_orator("=="));
179            assert!(!validate_compare_orator("&&"));
180        }
181    }
182}
183
184#[inline]
185pub fn quote_identifier(name: &str, mode: &str) -> String {
186    match mode {
187        "mysql" | "sqlite" => format!("`{}`", name),
188        "pgsql" => format!("\"{}\"", name),
189        "mssql" => format!("[{}]", name),
190        _ => name.to_string(),
191    }
192}
193
194#[cfg(feature = "db-sqlite")]
195pub mod sqlite;
196#[cfg(feature = "db-sqlite")]
197pub mod sqlite_transaction;
198#[cfg(feature = "db-mysql")]
199pub mod mysql;
200#[cfg(feature = "db-mysql")]
201pub mod mysql_transaction;
202#[cfg(feature = "db-mssql")]
203pub mod mssql;
204#[cfg(feature = "db-pgsql")]
205pub mod pgsql;
206#[cfg(feature = "db-pgsql")]
207pub mod pgsql_transaction;
208
209pub trait DbMode {
210    /// 数据库是否存在
211    fn database_tables(&mut self) -> JsonValue;
212    /// 创建数据库
213    fn database_create(&mut self, name: &str) -> bool;
214    /// 备份
215    fn backups(&mut self, _filename: &str) -> bool {
216        false
217    }
218    fn truncate(&mut self, table: &str) -> bool;
219}
220
221#[derive(Debug, Clone)]
222pub struct TableOptions {
223    table_name: String,
224    table_title: String,
225    table_key: String,
226    table_fields: JsonValue,
227    table_unique: Vec<String>,
228    table_index: Vec<Vec<String>>,
229    table_partition: bool,
230    table_partition_columns: JsonValue,
231}
232impl TableOptions {
233    pub fn set_table_name(&mut self, name: &str) {
234        self.table_name = name.to_string()
235    }
236    pub fn set_table_title(&mut self, name: &str) {
237        self.table_title = name.to_string()
238    }
239    pub fn set_table_key(&mut self, name: &str) {
240        self.table_key = name.to_string()
241    }
242    pub fn set_table_fields(&mut self, fields: JsonValue) {
243        self.table_fields = fields;
244    }
245    pub fn set_table_unique(&mut self, unique: Vec<&str>) {
246        self.table_unique = unique.iter().map(|s| s.to_string()).collect();
247    }
248    pub fn set_table_index(&mut self, index: Vec<Vec<&str>>) {
249        self.table_index = index.iter().map(|s| s.iter().map(|s| s.to_string()).collect()).collect();
250    }
251    pub fn set_table_partition(&mut self, index: bool) {
252        self.table_partition = index;
253    }
254    pub fn set_table_partition_columns(&mut self, index: JsonValue) {
255        self.table_partition_columns = index;
256    }
257}
258impl Default for TableOptions {
259    fn default() -> Self {
260        Self {
261            table_name: "".to_string(),
262            table_title: "".to_string(),
263            table_key: "".to_string(),
264            table_fields: JsonValue::Null,
265            table_unique: vec![],
266            table_index: vec![],
267            table_partition: false,
268            table_partition_columns: JsonValue::Null,
269        }
270    }
271}
272pub trait Mode: DbMode {
273    fn table_create(&mut self, options: TableOptions) -> JsonValue;
274    fn table_update(&mut self, options: TableOptions) -> JsonValue;
275    /// 获取表信息
276    fn table_info(&mut self, table: &str) -> JsonValue;
277    /// 判断表是否存在
278    fn table_is_exist(&mut self, name: &str) -> bool;
279    /// 当前表
280    fn table(&mut self, name: &str) -> &mut Self;
281    /// 别名
282    fn change_table(&mut self, name: &str) -> &mut Self;
283
284    /// 主键自增
285    fn autoinc(&mut self) -> &mut Self;
286    /// 自动时间戳
287    fn timestamps(&mut self) -> &mut Self;
288    /// 返回sql语句
289    fn fetch_sql(&mut self) -> &mut Self;
290    /// 排序
291    fn order(&mut self, field: &str, by: bool) -> &mut Self;
292    /// 分组
293    fn group(&mut self, field: &str) -> &mut Self;
294    /// 消除重复记录
295    fn distinct(&mut self) -> &mut Self;
296    /// JSON 字段
297    fn json(&mut self, field: &str) -> &mut Self;
298    /// location 字段
299    fn location(&mut self, field: &str) -> &mut Self;
300    /// 显示字段
301    fn field(&mut self, field: &str) -> &mut Self;
302    /// 原始表达式字段（不加表前缀，如 "SUM(amount) as total"、"CASE WHEN ... END as status_count"）
303    fn field_raw(&mut self, expr: &str) -> &mut Self;
304    /// 隐藏字段
305    fn hidden(&mut self, name: &str) -> &mut Self;
306    /// 查询
307    fn where_and(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self;
308    fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self;
309    /// 原始 WHERE 条件（不加表前缀，如 "YEAR(created_at) = 2026"）
310    fn where_raw(&mut self, expr: &str) -> &mut Self;
311
312    /// 子查询 WHERE field IN (sub_sql)
313    fn where_in_sub(&mut self, field: &str, sub_sql: &str) -> &mut Self;
314    /// 子查询 WHERE field NOT IN (sub_sql)
315    fn where_not_in_sub(&mut self, field: &str, sub_sql: &str) -> &mut Self;
316
317    fn where_exists(&mut self, sub_sql: &str) -> &mut Self;
318    fn where_not_exists(&mut self, sub_sql: &str) -> &mut Self;
319
320    /// 比较两个列
321    fn where_column(&mut self, field_a: &str, compare: &str, field_b: &str) -> &mut Self;
322    /// 更新指定列
323    fn update_column(&mut self, field_a: &str, compare: &str) -> &mut Self;
324    /// 分页
325    fn page(&mut self, page: i32, limit: i32) -> &mut Self;
326    /// 独立限制返回条数（不带分页偏移）
327    fn limit(&mut self, count: i32) -> &mut Self;
328    /// 查询指定列并返回数组
329    fn column(&mut self, field: &str) -> JsonValue;
330    /// 总数量
331    fn count(&mut self) -> JsonValue;
332    /// 最大值
333    fn max(&mut self, field: &str) -> JsonValue;
334    /// 最小值
335    fn min(&mut self, field: &str) -> JsonValue;
336    /// 合计
337    fn sum(&mut self, field: &str) -> JsonValue;
338    /// 平均值
339    fn avg(&mut self, field: &str) -> JsonValue;
340    /// HAVING 条件（用于 GROUP BY 后过滤，如 "COUNT(*) > 5"）
341    fn having(&mut self, expr: &str) -> &mut Self;
342    /// 获取集合
343    fn select(&mut self) -> JsonValue;
344    /// 获取单记录
345    fn find(&mut self) -> JsonValue;
346    /// 获取单一列值
347    fn value(&mut self, field: &str) -> JsonValue;
348    /// 添加
349    fn insert(&mut self, data: JsonValue) -> JsonValue;
350    /// 批量添加
351    fn insert_all(&mut self, data: JsonValue) -> JsonValue;
352
353    /// 插入或更新（冲突时更新）
354    fn upsert(&mut self, data: JsonValue, conflict_fields: Vec<&str>) -> JsonValue;
355
356    /// 更新
357    fn update(&mut self, data: JsonValue) -> JsonValue;
358    /// 批量更新
359    fn update_all(&mut self, data: JsonValue) -> JsonValue;
360    /// 删除
361    fn delete(&mut self) -> JsonValue;
362
363    /// 事务开始
364    fn transaction(&mut self) -> bool;
365    /// 事务提交
366    fn commit(&mut self) -> bool;
367    /// 事务回滚
368    fn rollback(&mut self) -> bool;
369    /// sql语句执行
370    fn sql(&mut self, sql: &str) -> Result<JsonValue, String>;
371    fn sql_execute(&mut self, sql: &str) -> Result<JsonValue, String>;
372    /// 自增
373    fn inc(&mut self, field: &str, num: f64) -> &mut Self;
374    /// 自减
375    fn dec(&mut self, field: &str, num: f64) -> &mut Self;
376
377    /// 构造子查询
378    fn buildsql(&mut self) -> String;
379
380    fn join_fields(&mut self, fields: Vec<&str>) -> &mut Self;
381    /// 连结
382    /// * main_table 主表表名
383    /// * main_fields 主表字段
384    /// * right_table 关联表名
385    /// * right_fields 关联字段名
386    fn join(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self;
387
388    /// 内连接--用来取交集
389    ///
390    /// * table 链表表名
391    /// * main_fields 主表字段
392    /// * second_fields 附表关联字段
393    fn join_inner(&mut self, table: &str, main_fields: &str, second_fields: &str) -> &mut Self;
394
395    /// 右连接
396    fn join_right(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self;
397
398    /// 全连接
399    fn join_full(&mut self, main_table: &str, main_fields: &str, right_table: &str, right_fields: &str) -> &mut Self;
400
401    fn union(&mut self, sub_sql: &str) -> &mut Self;
402    fn union_all(&mut self, sub_sql: &str) -> &mut Self;
403    fn lock_for_update(&mut self) -> &mut Self;
404    fn lock_for_share(&mut self) -> &mut Self;
405}
406
407#[derive(Clone, Debug)]
408pub struct Params {
409    pub mode: String,
410    pub autoinc: bool,
411    pub table: String,
412    pub where_and: Vec<String>,
413    pub where_or: Vec<String>,
414    pub where_column: String,
415    pub update_column: Vec<String>,
416    pub inc_dec: JsonValue,
417    pub page: i32,
418    pub limit: i32,
419    pub fields: JsonValue,
420    pub top: String,
421    pub top2: String,
422    pub order: JsonValue,
423    pub group: JsonValue,
424    pub distinct: bool,
425    pub json: JsonValue,
426    pub location: JsonValue,
427    pub sql: bool,
428    pub join: Vec<String>,
429    pub join_inner: Vec<String>,
430    pub join_table: String,
431    pub having: Vec<String>,
432    /// 独立 LIMIT（不带分页偏移）
433    pub limit_only: i32,
434    pub timestamps: bool,
435    pub unions: Vec<String>,
436    pub lock_mode: String,
437}
438
439impl Params {
440    pub fn default(mode: &str) -> Self {
441        Self {
442            mode: mode.to_string(),
443            autoinc: false,
444            table: "".to_string(),
445            where_and: vec![],
446            where_or: vec![],
447            where_column: "".to_string(),
448            update_column: vec![],
449            inc_dec: object! {},
450            page: -1,
451            limit: 10,
452            fields: object! {},
453            top: String::new(),
454            top2: String::new(),
455            order: object! {},
456            group: object! {},
457            distinct: false,
458            json: object! {},
459            location: object! {},
460            sql: false,
461            join: Vec::new(),
462            join_inner: Vec::new(),
463            join_table: "".to_string(),
464            having: vec![],
465            limit_only: -1,
466            timestamps: false,
467            unions: vec![],
468            lock_mode: "".to_string(),
469        }
470    }
471    pub fn where_sql(&mut self) -> String {
472        let mut where_and_sql = vec![];
473        let mut where_or_sql = vec![];
474        let mut sql = vec![];
475
476        for item in self.where_or.iter() {
477            where_or_sql.push(item.clone());
478        }
479        if !where_or_sql.is_empty() {
480            sql.push(format!(" ( {} ) ", where_or_sql.join(" OR ")));
481        }
482
483        for item in self.where_and.iter() {
484            where_and_sql.push(item.clone());
485        }
486        if !where_and_sql.is_empty() {
487            sql.push(where_and_sql.join(" AND "));
488        }
489
490        if !self.where_column.is_empty() {
491            sql.push(self.where_column.clone());
492        }
493
494        if !sql.is_empty() {
495            return format!("WHERE {}", sql.join(" AND "));
496        }
497        "".to_string()
498    }
499    pub fn page_limit_sql(&mut self) -> String {
500        if self.page == -1 {
501            if self.limit_only > 0 {
502                return format!("LIMIT {}", self.limit_only);
503            }
504            return "".to_string();
505        }
506        match self.mode.as_str() {
507            "mysql" => {
508                format!("LIMIT {},{}", self.page * self.limit - self.limit, self.limit)
509            }
510            "sqlite" => {
511                format!("LIMIT {} OFFSET {}", self.limit, self.page * self.limit - self.limit)
512            }
513            _ => "".to_string()
514        }
515    }
516    pub fn fields(&mut self) -> String {
517        let mut fields = vec![];
518        for (_, value) in self.fields.entries() {
519            match self.mode.as_str() {
520                "mssql" => {
521                    fields.push(format!("{value}"));
522                }
523                "mysql" => {
524                    if let Some(s) = value.as_str() {
525                        if DISABLE_FIELD.contains(&s) {
526                            fields.push(format!("`{value}`"));
527                        } else {
528                            fields.push(format!("{value}"));
529                        }
530                    } else {
531                        fields.push(format!("{value}"));
532                    }
533                }
534                _ => {
535                    fields.push(format!("{value}"));
536                }
537            }
538        }
539        let fields = {
540            if fields.is_empty() {
541                "*".into()
542            } else {
543                fields.join(",")
544            }
545        };
546        match self.mode.as_str() {
547            "mysql" => {
548                fields.to_string()
549            }
550            "sqlite" => {
551                fields.to_string()
552            }
553            "mssql" => {
554                fields.to_string()
555            }
556            _ => fields.to_string()
557        }
558    }
559    pub fn top(&mut self) -> String {
560        match self.mode.as_str() {
561            "mssql" => {
562                let wheres = self.where_sql();
563                if !self.top2.is_empty() {
564                    let order = self.order();
565                    if order.is_empty() {
566                        self.top = format!("(select ROW_NUMBER() OVER(ORDER BY rand()) as ROW,* from {} {}) as ", self.table, wheres);
567                    } else {
568                        self.top = format!("(select ROW_NUMBER() OVER({}) as ROW,* from {} {}) as ", order, self.table, wheres);
569                    }
570                    return self.top.to_string();
571                }
572                self.top.to_string()
573            }
574            _ => {
575                "".to_string()
576            }
577        }
578    }
579    pub fn top2(&mut self) -> String {
580        match self.mode.as_str() {
581            "mssql" => {
582                if self.where_and.is_empty() && self.where_or.is_empty() && !self.top2.is_empty() {
583                    return format!("where {}", self.top2);
584                }
585                if (!self.where_and.is_empty() || !self.where_or.is_empty()) && !self.top2.is_empty() {
586                    return format!("AND {}", self.top2);
587                }
588                self.top2.to_string()
589            }
590            _ => {
591                "".to_string()
592            }
593        }
594    }
595    pub fn table(&mut self) -> String {
596        match self.mode.as_str() {
597            "mssql" => {
598                if !self.top2.is_empty() {
599                    return "t".to_string();
600                }
601                self.table.to_string()
602            }
603            _ => {
604                self.table.to_string()
605            }
606        }
607    }
608    pub fn join(&mut self) -> String {
609        match self.mode.as_str() {
610            "mssql" => {
611                self.join.join(" ")
612            }
613            _ => {
614                self.join.join(" ")
615            }
616        }
617    }
618
619    // 当前只匹配了MySQL
620    pub fn join_inner(&mut self) -> String {
621        match self.mode.as_str() {
622            "mysql" => {
623                let mut join_inner = "".to_string();
624                for item in self.join_inner.iter() {
625                    join_inner = format!("{join_inner} {item}");
626                }
627                join_inner.to_string()
628            }
629            _ => {
630                "".to_string()
631            }
632        }
633    }
634
635
636    pub fn order(&mut self) -> String {
637        let mut sql = vec![];
638        for (field, item) in self.order.entries() {
639            match self.mode.as_str() {
640                "mssql" => {
641                    if DISABLE_FIELD.contains(&field) {
642                        sql.push(format!("[{field}] {item}"));
643                    } else {
644                        sql.push(format!("{field} {item}"));
645                    }
646                }
647
648                "pgsql" => {
649                    if DISABLE_FIELD.contains(&field) {
650                        sql.push(format!("\"{field}\" {item}"));
651                    } else {
652                        sql.push(format!("{field} {item}"));
653                    }
654                }
655                _ => {
656                    if DISABLE_FIELD.contains(&field) {
657                        sql.push(format!("`{field}` {item}"));
658                    } else {
659                        sql.push(format!("{field} {item}"));
660                    }
661                }
662            }
663        }
664        if !sql.is_empty() {
665            return format!("ORDER BY {}", sql.join(","));
666        }
667        "".to_string()
668    }
669    pub fn group(&mut self) -> String {
670        let mut sql = vec![];
671        for (_, field) in self.group.entries() {
672            if DISABLE_FIELD.contains(&&*field.clone().to_string()) {
673                sql.push(format!("`{field}`"));
674            } else if field.to_string().contains(".") {
675                sql.push(format!("{}", field));
676            } else {
677                sql.push(format!("{}.{}", self.table, field));
678            }
679        }
680        if !sql.is_empty() {
681            return format!("GROUP BY {}", sql.join(","));
682        }
683        "".to_string()
684    }
685    pub fn having(&mut self) -> String {
686        if self.having.is_empty() {
687            return "".to_string();
688        }
689        format!("HAVING {}", self.having.join(" AND "))
690    }
691    pub fn distinct(&self) -> String {
692        if self.distinct {
693            "DISTINCT".to_string()
694        } else {
695            "".to_string()
696        }
697    }
698    pub fn select_sql(&mut self) -> String {
699        let base = format!("SELECT {} {} FROM {} {} {} {} {} {} {} {} {} {}", self.distinct(), self.fields(), self.top(), self.table(), self.join(), self.join_inner(), self.where_sql(), self.top2(), self.group(), self.having(), self.order(), self.page_limit_sql());
700        if self.unions.is_empty() {
701            if self.lock_mode.is_empty() {
702                base
703            } else {
704                format!("{base} {}", self.lock_mode)
705            }
706        } else {
707            let unions = self.unions.join(" ");
708            if self.lock_mode.is_empty() {
709                format!("{base} {unions}")
710            } else {
711                format!("{base} {unions} {}", self.lock_mode)
712            }
713        }
714    }
715}
716
717#[cfg(test)]
718mod params_tests {
719    use super::*;
720    use json::object;
721
722    #[test]
723    fn test_quote_identifier_mysql() {
724        assert_eq!(quote_identifier("name", "mysql"), "`name`");
725        assert_eq!(quote_identifier("user", "mysql"), "`user`");
726    }
727
728    #[test]
729    fn test_quote_identifier_sqlite() {
730        assert_eq!(quote_identifier("name", "sqlite"), "`name`");
731        assert_eq!(quote_identifier("order", "sqlite"), "`order`");
732    }
733
734    #[test]
735    fn test_quote_identifier_pgsql() {
736        assert_eq!(quote_identifier("name", "pgsql"), "\"name\"");
737        assert_eq!(quote_identifier("select", "pgsql"), "\"select\"");
738    }
739
740    #[test]
741    fn test_quote_identifier_mssql() {
742        assert_eq!(quote_identifier("name", "mssql"), "[name]");
743        assert_eq!(quote_identifier("index", "mssql"), "[index]");
744    }
745
746    #[test]
747    fn test_quote_identifier_unknown() {
748        assert_eq!(quote_identifier("name", "unknown"), "name");
749        assert_eq!(quote_identifier("field", ""), "field");
750    }
751
752    #[test]
753    fn test_table_options_default() {
754        let opts = TableOptions::default();
755        assert_eq!(opts.table_name, "");
756        assert_eq!(opts.table_title, "");
757        assert_eq!(opts.table_key, "");
758        assert!(opts.table_fields.is_null());
759        assert!(opts.table_unique.is_empty());
760        assert!(opts.table_index.is_empty());
761        assert!(!opts.table_partition);
762        assert!(opts.table_partition_columns.is_null());
763    }
764
765    #[test]
766    fn test_table_options_set_table_name() {
767        let mut opts = TableOptions::default();
768        opts.set_table_name("users");
769        assert_eq!(opts.table_name, "users");
770    }
771
772    #[test]
773    fn test_table_options_set_table_title() {
774        let mut opts = TableOptions::default();
775        opts.set_table_title("User Table");
776        assert_eq!(opts.table_title, "User Table");
777    }
778
779    #[test]
780    fn test_table_options_set_table_key() {
781        let mut opts = TableOptions::default();
782        opts.set_table_key("id");
783        assert_eq!(opts.table_key, "id");
784    }
785
786    #[test]
787    fn test_table_options_set_table_fields() {
788        let mut opts = TableOptions::default();
789        let fields = object! { "name" => "varchar", "age" => "int" };
790        opts.set_table_fields(fields);
791        assert_eq!(opts.table_fields["name"], "varchar");
792        assert_eq!(opts.table_fields["age"], "int");
793    }
794
795    #[test]
796    fn test_table_options_set_table_unique() {
797        let mut opts = TableOptions::default();
798        opts.set_table_unique(vec!["email", "username"]);
799        assert_eq!(opts.table_unique, vec!["email".to_string(), "username".to_string()]);
800    }
801
802    #[test]
803    fn test_table_options_set_table_index() {
804        let mut opts = TableOptions::default();
805        opts.set_table_index(vec![vec!["name", "age"], vec!["email"]]);
806        assert_eq!(opts.table_index.len(), 2);
807        assert_eq!(opts.table_index[0], vec!["name".to_string(), "age".to_string()]);
808        assert_eq!(opts.table_index[1], vec!["email".to_string()]);
809    }
810
811    #[test]
812    fn test_table_options_set_table_partition() {
813        let mut opts = TableOptions::default();
814        assert!(!opts.table_partition);
815        opts.set_table_partition(true);
816        assert!(opts.table_partition);
817    }
818
819    #[test]
820    fn test_table_options_set_table_partition_columns() {
821        let mut opts = TableOptions::default();
822        let cols = object! { "col1" => "range", "col2" => "hash" };
823        opts.set_table_partition_columns(cols);
824        assert_eq!(opts.table_partition_columns["col1"], "range");
825        assert_eq!(opts.table_partition_columns["col2"], "hash");
826    }
827
828    #[test]
829    fn test_params_default_mysql() {
830        let p = Params::default("mysql");
831        assert_eq!(p.mode, "mysql");
832        assert!(!p.autoinc);
833        assert_eq!(p.table, "");
834        assert!(p.where_and.is_empty());
835        assert!(p.where_or.is_empty());
836        assert_eq!(p.where_column, "");
837        assert!(p.update_column.is_empty());
838        assert!(p.inc_dec.is_object());
839        assert_eq!(p.page, -1);
840        assert_eq!(p.limit, 10);
841        assert!(p.fields.is_object());
842        assert_eq!(p.top, "");
843        assert_eq!(p.top2, "");
844        assert!(p.order.is_object());
845        assert!(p.group.is_object());
846        assert!(!p.distinct);
847        assert!(p.json.is_object());
848        assert!(p.location.is_object());
849        assert!(!p.sql);
850        assert!(p.join.is_empty());
851        assert!(p.join_inner.is_empty());
852        assert_eq!(p.join_table, "");
853    }
854
855    #[test]
856    fn test_params_default_pgsql() {
857        let p = Params::default("pgsql");
858        assert_eq!(p.mode, "pgsql");
859        assert_eq!(p.page, -1);
860        assert_eq!(p.limit, 10);
861    }
862
863    #[test]
864    fn test_params_default_mssql() {
865        let p = Params::default("mssql");
866        assert_eq!(p.mode, "mssql");
867    }
868
869    #[test]
870    fn test_params_default_sqlite() {
871        let p = Params::default("sqlite");
872        assert_eq!(p.mode, "sqlite");
873    }
874
875    #[test]
876    fn test_where_sql_empty() {
877        let mut p = Params::default("mysql");
878        assert_eq!(p.where_sql(), "");
879    }
880
881    #[test]
882    fn test_where_sql_only_and() {
883        let mut p = Params::default("mysql");
884        p.where_and.push("a = 1".to_string());
885        p.where_and.push("b = 2".to_string());
886        assert_eq!(p.where_sql(), "WHERE a = 1 AND b = 2");
887    }
888
889    #[test]
890    fn test_where_sql_only_or() {
891        let mut p = Params::default("mysql");
892        p.where_or.push("a = 1".to_string());
893        p.where_or.push("b = 2".to_string());
894        assert_eq!(p.where_sql(), "WHERE  ( a = 1 OR b = 2 ) ");
895    }
896
897    #[test]
898    fn test_where_sql_and_plus_or() {
899        let mut p = Params::default("mysql");
900        p.where_and.push("c = 3".to_string());
901        p.where_or.push("a = 1".to_string());
902        p.where_or.push("b = 2".to_string());
903        let result = p.where_sql();
904        assert!(result.starts_with("WHERE"));
905        assert!(result.contains("( a = 1 OR b = 2 )"));
906        assert!(result.contains("c = 3"));
907        assert!(result.contains(" AND "));
908    }
909
910    #[test]
911    fn test_where_sql_with_where_column() {
912        let mut p = Params::default("mysql");
913        p.where_column = "x.id = y.id".to_string();
914        assert_eq!(p.where_sql(), "WHERE x.id = y.id");
915    }
916
917    #[test]
918    fn test_where_sql_all_three() {
919        let mut p = Params::default("mysql");
920        p.where_and.push("a = 1".to_string());
921        p.where_or.push("b = 2".to_string());
922        p.where_or.push("c = 3".to_string());
923        p.where_column = "x.id = y.id".to_string();
924        let result = p.where_sql();
925        assert!(result.starts_with("WHERE"));
926        assert!(result.contains("( b = 2 OR c = 3 )"));
927        assert!(result.contains("a = 1"));
928        assert!(result.contains("x.id = y.id"));
929    }
930
931    #[test]
932    fn test_page_limit_sql_default_page_neg1() {
933        let mut p = Params::default("mysql");
934        assert_eq!(p.page_limit_sql(), "");
935    }
936
937    #[test]
938    fn test_page_limit_sql_mysql() {
939        let mut p = Params::default("mysql");
940        p.page = 1;
941        p.limit = 10;
942        assert_eq!(p.page_limit_sql(), "LIMIT 0,10");
943    }
944
945    #[test]
946    fn test_page_limit_sql_mysql_page2() {
947        let mut p = Params::default("mysql");
948        p.page = 2;
949        p.limit = 20;
950        assert_eq!(p.page_limit_sql(), "LIMIT 20,20");
951    }
952
953    #[test]
954    fn test_page_limit_sql_sqlite() {
955        let mut p = Params::default("sqlite");
956        p.page = 1;
957        p.limit = 10;
958        assert_eq!(p.page_limit_sql(), "LIMIT 10 OFFSET 0");
959    }
960
961    #[test]
962    fn test_page_limit_sql_sqlite_page3() {
963        let mut p = Params::default("sqlite");
964        p.page = 3;
965        p.limit = 5;
966        assert_eq!(p.page_limit_sql(), "LIMIT 5 OFFSET 10");
967    }
968
969    #[test]
970    fn test_page_limit_sql_unknown_mode() {
971        let mut p = Params::default("unknown");
972        p.page = 1;
973        p.limit = 10;
974        assert_eq!(p.page_limit_sql(), "");
975    }
976
977    #[test]
978    fn test_fields_empty() {
979        let mut p = Params::default("mysql");
980        assert_eq!(p.fields(), "*");
981    }
982
983    #[test]
984    fn test_fields_mysql_with_disable_field() {
985        let mut p = Params::default("mysql");
986        p.fields = object! { "f1" => "order", "f2" => "name" };
987        let result = p.fields();
988        assert!(result.contains("`order`"));
989        assert!(result.contains("name"));
990        assert!(!result.contains("`name`"));
991    }
992
993    #[test]
994    fn test_fields_mysql_normal() {
995        let mut p = Params::default("mysql");
996        p.fields = object! { "f1" => "id", "f2" => "name" };
997        let result = p.fields();
998        assert!(result.contains("id"));
999        assert!(result.contains("name"));
1000    }
1001
1002    #[test]
1003    fn test_fields_mssql() {
1004        let mut p = Params::default("mssql");
1005        p.fields = object! { "f1" => "id", "f2" => "name" };
1006        let result = p.fields();
1007        assert!(result.contains("id"));
1008        assert!(result.contains("name"));
1009    }
1010
1011    #[test]
1012    fn test_fields_other_mode() {
1013        let mut p = Params::default("pgsql");
1014        p.fields = object! { "f1" => "id", "f2" => "email" };
1015        let result = p.fields();
1016        assert!(result.contains("id"));
1017        assert!(result.contains("email"));
1018    }
1019
1020    #[test]
1021    fn test_top_non_mssql() {
1022        let mut p = Params::default("mysql");
1023        assert_eq!(p.top(), "");
1024    }
1025
1026    #[test]
1027    fn test_top_mssql_without_top2() {
1028        let mut p = Params::default("mssql");
1029        p.table = "users".to_string();
1030        assert_eq!(p.top(), "");
1031    }
1032
1033    #[test]
1034    fn test_top_mssql_with_top2() {
1035        let mut p = Params::default("mssql");
1036        p.table = "users".to_string();
1037        p.top2 = "ROW BETWEEN 1 AND 10".to_string();
1038        let result = p.top();
1039        assert!(result.contains("ROW_NUMBER"));
1040        assert!(result.contains("users"));
1041        assert!(result.contains("as "));
1042    }
1043
1044    #[test]
1045    fn test_top_mssql_with_top2_and_order() {
1046        let mut p = Params::default("mssql");
1047        p.table = "users".to_string();
1048        p.top2 = "ROW BETWEEN 1 AND 10".to_string();
1049        p.order = object! { "id" => "ASC" };
1050        let result = p.top();
1051        assert!(result.contains("ROW_NUMBER"));
1052        assert!(result.contains("ORDER BY"));
1053        assert!(result.contains("id ASC"));
1054    }
1055
1056    #[test]
1057    fn test_top2_non_mssql() {
1058        let mut p = Params::default("mysql");
1059        p.top2 = "something".to_string();
1060        assert_eq!(p.top2(), "");
1061    }
1062
1063    #[test]
1064    fn test_top2_mssql_no_where_with_top2() {
1065        let mut p = Params::default("mssql");
1066        p.top2 = "ROW BETWEEN 1 AND 10".to_string();
1067        let result = p.top2();
1068        assert_eq!(result, "where ROW BETWEEN 1 AND 10");
1069    }
1070
1071    #[test]
1072    fn test_top2_mssql_with_where_and_top2() {
1073        let mut p = Params::default("mssql");
1074        p.where_and.push("a = 1".to_string());
1075        p.top2 = "ROW BETWEEN 1 AND 10".to_string();
1076        let result = p.top2();
1077        assert_eq!(result, "AND ROW BETWEEN 1 AND 10");
1078    }
1079
1080    #[test]
1081    fn test_top2_mssql_empty_top2() {
1082        let mut p = Params::default("mssql");
1083        assert_eq!(p.top2(), "");
1084    }
1085
1086    #[test]
1087    fn test_table_mssql_with_top2() {
1088        let mut p = Params::default("mssql");
1089        p.table = "users".to_string();
1090        p.top2 = "ROW BETWEEN 1 AND 10".to_string();
1091        assert_eq!(p.table(), "t");
1092    }
1093
1094    #[test]
1095    fn test_table_mssql_without_top2() {
1096        let mut p = Params::default("mssql");
1097        p.table = "users".to_string();
1098        assert_eq!(p.table(), "users");
1099    }
1100
1101    #[test]
1102    fn test_table_other_modes() {
1103        let mut p = Params::default("mysql");
1104        p.table = "orders".to_string();
1105        assert_eq!(p.table(), "orders");
1106
1107        let mut p2 = Params::default("pgsql");
1108        p2.table = "products".to_string();
1109        assert_eq!(p2.table(), "products");
1110    }
1111
1112    #[test]
1113    fn test_join_empty() {
1114        let mut p = Params::default("mysql");
1115        assert_eq!(p.join(), "");
1116    }
1117
1118    #[test]
1119    fn test_join_with_entries() {
1120        let mut p = Params::default("mysql");
1121        p.join.push("LEFT JOIN orders ON users.id = orders.user_id".to_string());
1122        p.join.push("LEFT JOIN items ON orders.id = items.order_id".to_string());
1123        let result = p.join();
1124        assert!(result.contains("LEFT JOIN orders ON users.id = orders.user_id"));
1125        assert!(result.contains("LEFT JOIN items ON orders.id = items.order_id"));
1126        assert!(result.contains(" "));
1127    }
1128
1129    #[test]
1130    fn test_join_mssql() {
1131        let mut p = Params::default("mssql");
1132        p.join.push("JOIN t2 ON t1.id = t2.fk".to_string());
1133        let result = p.join();
1134        assert_eq!(result, "JOIN t2 ON t1.id = t2.fk");
1135    }
1136
1137    #[test]
1138    fn test_join_inner_empty() {
1139        let mut p = Params::default("mysql");
1140        assert_eq!(p.join_inner(), "");
1141    }
1142
1143    #[test]
1144    fn test_join_inner_mysql() {
1145        let mut p = Params::default("mysql");
1146        p.join_inner.push("INNER JOIN orders ON users.id = orders.uid".to_string());
1147        p.join_inner.push("INNER JOIN items ON orders.id = items.oid".to_string());
1148        let result = p.join_inner();
1149        assert!(result.contains("INNER JOIN orders ON users.id = orders.uid"));
1150        assert!(result.contains("INNER JOIN items ON orders.id = items.oid"));
1151    }
1152
1153    #[test]
1154    fn test_join_inner_non_mysql() {
1155        let mut p = Params::default("pgsql");
1156        p.join_inner.push("INNER JOIN orders ON users.id = orders.uid".to_string());
1157        assert_eq!(p.join_inner(), "");
1158
1159        let mut p2 = Params::default("mssql");
1160        p2.join_inner.push("INNER JOIN orders ON users.id = orders.uid".to_string());
1161        assert_eq!(p2.join_inner(), "");
1162    }
1163
1164    #[test]
1165    fn test_order_empty() {
1166        let mut p = Params::default("mysql");
1167        assert_eq!(p.order(), "");
1168    }
1169
1170    #[test]
1171    fn test_order_with_entries() {
1172        let mut p = Params::default("mysql");
1173        p.order = object! { "id" => "ASC", "name" => "DESC" };
1174        let result = p.order();
1175        assert!(result.starts_with("ORDER BY"));
1176        assert!(result.contains("id ASC"));
1177        assert!(result.contains("name DESC"));
1178    }
1179
1180    #[test]
1181    fn test_order_mysql_disable_field() {
1182        let mut p = Params::default("mysql");
1183        p.order = object! { "order" => "ASC" };
1184        let result = p.order();
1185        assert!(result.contains("`order` ASC"));
1186    }
1187
1188    #[test]
1189    fn test_order_pgsql_disable_field() {
1190        let mut p = Params::default("pgsql");
1191        p.order = object! { "order" => "DESC" };
1192        let result = p.order();
1193        assert!(result.contains("\"order\" DESC"));
1194    }
1195
1196    #[test]
1197    fn test_order_mssql_disable_field() {
1198        let mut p = Params::default("mssql");
1199        p.order = object! { "order" => "ASC" };
1200        let result = p.order();
1201        assert!(result.contains("[order] ASC"));
1202    }
1203
1204    #[test]
1205    fn test_group_empty() {
1206        let mut p = Params::default("mysql");
1207        assert_eq!(p.group(), "");
1208    }
1209
1210    #[test]
1211    fn test_group_with_entries() {
1212        let mut p = Params::default("mysql");
1213        p.table = "users".to_string();
1214        p.group = object! { "g1" => "status" };
1215        let result = p.group();
1216        assert!(result.starts_with("GROUP BY"));
1217        assert!(result.contains("users.status"));
1218    }
1219
1220    #[test]
1221    fn test_group_disable_field() {
1222        let mut p = Params::default("mysql");
1223        p.table = "users".to_string();
1224        p.group = object! { "g1" => "order" };
1225        let result = p.group();
1226        assert!(result.contains("`order`"));
1227    }
1228
1229    #[test]
1230    fn test_group_dotted_field() {
1231        let mut p = Params::default("mysql");
1232        p.table = "users".to_string();
1233        p.group = object! { "g1" => "orders.status" };
1234        let result = p.group();
1235        assert!(result.contains("orders.status"));
1236        assert!(!result.contains("users.orders.status"));
1237    }
1238
1239    #[test]
1240    fn test_distinct_false() {
1241        let p = Params::default("mysql");
1242        assert_eq!(p.distinct(), "");
1243    }
1244
1245    #[test]
1246    fn test_distinct_true() {
1247        let mut p = Params::default("mysql");
1248        p.distinct = true;
1249        assert_eq!(p.distinct(), "DISTINCT");
1250    }
1251
1252    #[test]
1253    fn test_select_sql_basic() {
1254        let mut p = Params::default("mysql");
1255        p.table = "users".to_string();
1256        let result = p.select_sql();
1257        assert!(result.contains("SELECT"));
1258        assert!(result.contains("*"));
1259        assert!(result.contains("FROM"));
1260        assert!(result.contains("users"));
1261    }
1262
1263    #[test]
1264    fn test_select_sql_with_where_and_order() {
1265        let mut p = Params::default("mysql");
1266        p.table = "users".to_string();
1267        p.where_and.push("age > 18".to_string());
1268        p.order = object! { "name" => "ASC" };
1269        p.page = 1;
1270        p.limit = 10;
1271        let result = p.select_sql();
1272        assert!(result.contains("SELECT"));
1273        assert!(result.contains("FROM"));
1274        assert!(result.contains("users"));
1275        assert!(result.contains("WHERE age > 18"));
1276        assert!(result.contains("ORDER BY name ASC"));
1277        assert!(result.contains("LIMIT 0,10"));
1278    }
1279
1280    #[test]
1281    fn test_select_sql_with_distinct_and_group() {
1282        let mut p = Params::default("mysql");
1283        p.table = "orders".to_string();
1284        p.distinct = true;
1285        p.group = object! { "g1" => "status" };
1286        p.fields = object! { "f1" => "status", "f2" => "count" };
1287        let result = p.select_sql();
1288        assert!(result.contains("DISTINCT"));
1289        assert!(result.contains("GROUP BY"));
1290        assert!(result.contains("orders.status"));
1291    }
1292
1293    #[test]
1294    fn test_having_empty() {
1295        let mut p = Params::default("mysql");
1296        assert_eq!(p.having(), "");
1297    }
1298
1299    #[test]
1300    fn test_having_single() {
1301        let mut p = Params::default("mysql");
1302        p.having.push("COUNT(*) > 5".to_string());
1303        assert_eq!(p.having(), "HAVING COUNT(*) > 5");
1304    }
1305
1306    #[test]
1307    fn test_having_multiple() {
1308        let mut p = Params::default("mysql");
1309        p.having.push("COUNT(*) > 5".to_string());
1310        p.having.push("SUM(amount) > 100".to_string());
1311        assert_eq!(p.having(), "HAVING COUNT(*) > 5 AND SUM(amount) > 100");
1312    }
1313
1314    #[test]
1315    fn test_select_sql_with_having() {
1316        let mut p = Params::default("mysql");
1317        p.table = "orders".to_string();
1318        p.group = object! { "g1" => "status" };
1319        p.having.push("COUNT(*) > 1".to_string());
1320        let result = p.select_sql();
1321        assert!(result.contains("GROUP BY"));
1322        assert!(result.contains("HAVING COUNT(*) > 1"));
1323    }
1324
1325    #[test]
1326    fn test_field_raw_in_select_sql() {
1327        let mut p = Params::default("mysql");
1328        p.table = "orders".to_string();
1329        p.fields["raw1"] = "SUM(amount) as total".into();
1330        p.fields["raw2"] = "COUNT(*) as cnt".into();
1331        let result = p.select_sql();
1332        assert!(result.contains("SUM(amount) as total"));
1333        assert!(result.contains("COUNT(*) as cnt"));
1334        assert!(!result.contains("orders.`SUM"));
1335    }
1336
1337    #[test]
1338    fn test_where_raw_in_select_sql() {
1339        let mut p = Params::default("mysql");
1340        p.table = "orders".to_string();
1341        p.where_and.push("YEAR(created_at) = 2026".to_string());
1342        let result = p.select_sql();
1343        assert!(result.contains("WHERE YEAR(created_at) = 2026"));
1344    }
1345
1346    #[test]
1347    fn test_limit_only_default() {
1348        let mut p = Params::default("mysql");
1349        assert_eq!(p.page_limit_sql(), "");
1350    }
1351
1352    #[test]
1353    fn test_limit_only_mysql() {
1354        let mut p = Params::default("mysql");
1355        p.limit_only = 5;
1356        assert_eq!(p.page_limit_sql(), "LIMIT 5");
1357    }
1358
1359    #[test]
1360    fn test_limit_only_sqlite() {
1361        let mut p = Params::default("sqlite");
1362        p.limit_only = 10;
1363        assert_eq!(p.page_limit_sql(), "LIMIT 10");
1364    }
1365
1366    #[test]
1367    fn test_limit_only_pgsql() {
1368        let mut p = Params::default("pgsql");
1369        p.limit_only = 3;
1370        assert_eq!(p.page_limit_sql(), "LIMIT 3");
1371    }
1372
1373    #[test]
1374    fn test_page_overrides_limit_only() {
1375        let mut p = Params::default("mysql");
1376        p.limit_only = 5;
1377        p.page = 2;
1378        p.limit = 10;
1379        assert_eq!(p.page_limit_sql(), "LIMIT 10,10");
1380    }
1381
1382    #[test]
1383    fn test_limit_only_in_select_sql() {
1384        let mut p = Params::default("mysql");
1385        p.table = "users".to_string();
1386        p.limit_only = 3;
1387        let result = p.select_sql();
1388        assert!(result.contains("LIMIT 3"));
1389        assert!(!result.contains("OFFSET"));
1390    }
1391
1392    #[test]
1393    fn test_where_in_sub() {
1394        let mut p = Params::default("mysql");
1395        p.table = "users".to_string();
1396        p.where_and.push("`status` IN (SELECT status FROM active_users)".to_string());
1397        let result = p.select_sql();
1398        assert!(result.contains("WHERE `status` IN (SELECT status FROM active_users)"));
1399    }
1400
1401    #[test]
1402    fn test_where_not_in_sub() {
1403        let mut p = Params::default("pgsql");
1404        p.table = "users".to_string();
1405        p.where_and.push("\"id\" NOT IN (SELECT user_id FROM banned)".to_string());
1406        let result = p.select_sql();
1407        assert!(result.contains("WHERE \"id\" NOT IN (SELECT user_id FROM banned)"));
1408    }
1409
1410    #[test]
1411    fn test_union_single() {
1412        let mut p = Params::default("mysql");
1413        p.table = "users".to_string();
1414        p.unions.push("UNION SELECT * FROM admins".to_string());
1415        let result = p.select_sql();
1416        assert!(result.contains("UNION SELECT * FROM admins"));
1417    }
1418
1419    #[test]
1420    fn test_union_all() {
1421        let mut p = Params::default("mysql");
1422        p.table = "users".to_string();
1423        p.unions.push("UNION ALL SELECT * FROM guests".to_string());
1424        let result = p.select_sql();
1425        assert!(result.contains("UNION ALL SELECT * FROM guests"));
1426    }
1427
1428    #[test]
1429    fn test_union_multiple() {
1430        let mut p = Params::default("mysql");
1431        p.table = "users".to_string();
1432        p.unions.push("UNION SELECT * FROM admins".to_string());
1433        p.unions.push("UNION ALL SELECT * FROM guests".to_string());
1434        let result = p.select_sql();
1435        assert!(result.contains("UNION SELECT * FROM admins"));
1436        assert!(result.contains("UNION ALL SELECT * FROM guests"));
1437    }
1438
1439    #[test]
1440    fn test_no_union() {
1441        let mut p = Params::default("mysql");
1442        p.table = "users".to_string();
1443        let result = p.select_sql();
1444        assert!(!result.contains("UNION"));
1445    }
1446
1447    #[test]
1448    fn test_timestamps_default_false() {
1449        let p = Params::default("mysql");
1450        assert!(!p.timestamps);
1451    }
1452
1453    #[test]
1454    fn test_lock_for_update_in_select_sql() {
1455        let mut p = Params::default("mysql");
1456        p.table = "users".to_string();
1457        p.lock_mode = "FOR UPDATE".to_string();
1458        let result = p.select_sql();
1459        assert!(result.contains("FOR UPDATE"));
1460    }
1461
1462    #[test]
1463    fn test_lock_for_share_in_select_sql() {
1464        let mut p = Params::default("pgsql");
1465        p.table = "users".to_string();
1466        p.lock_mode = "FOR SHARE".to_string();
1467        let result = p.select_sql();
1468        assert!(result.contains("FOR SHARE"));
1469    }
1470
1471    #[test]
1472    fn test_no_lock_mode() {
1473        let mut p = Params::default("mysql");
1474        p.table = "users".to_string();
1475        let result = p.select_sql();
1476        assert!(!result.contains("FOR UPDATE"));
1477        assert!(!result.contains("FOR SHARE"));
1478    }
1479
1480    #[test]
1481    fn test_where_exists_in_select_sql() {
1482        let mut p = Params::default("mysql");
1483        p.table = "users".to_string();
1484        p.where_and.push("EXISTS (SELECT 1 FROM orders WHERE orders.user_id = users.id)".to_string());
1485        let result = p.select_sql();
1486        assert!(result.contains("EXISTS (SELECT 1 FROM orders WHERE orders.user_id = users.id)"));
1487    }
1488
1489    #[test]
1490    fn test_where_not_exists_in_select_sql() {
1491        let mut p = Params::default("mysql");
1492        p.table = "users".to_string();
1493        p.where_and.push("NOT EXISTS (SELECT 1 FROM banned WHERE banned.uid = users.id)".to_string());
1494        let result = p.select_sql();
1495        assert!(result.contains("NOT EXISTS (SELECT 1 FROM banned WHERE banned.uid = users.id)"));
1496    }
1497
1498    #[test]
1499    fn test_lock_with_union() {
1500        let mut p = Params::default("mysql");
1501        p.table = "users".to_string();
1502        p.unions.push("UNION SELECT * FROM admins".to_string());
1503        p.lock_mode = "FOR UPDATE".to_string();
1504        let result = p.select_sql();
1505        assert!(result.contains("UNION SELECT * FROM admins"));
1506        assert!(result.contains("FOR UPDATE"));
1507    }
1508
1509    #[test]
1510    fn test_lock_mode_default_empty() {
1511        let p = Params::default("mysql");
1512        assert!(p.lock_mode.is_empty());
1513    }
1514
1515    #[test]
1516    fn test_unions_default_empty() {
1517        let p = Params::default("mysql");
1518        assert!(p.unions.is_empty());
1519    }
1520}
br_db/types/mod.rs

br_db/types/
mod.rs
