sz_orm_core/
dynamic_sql.rs

1//! XML/py_sql 动态 SQL 构造器（rbatis 风格）
2//!
3//! rbatis 的核心特性是 XML 风格的动态 SQL 模板：
4//! - `<select>` / `<insert>` / `<update>` / `<delete>` 顶层语句
5//! - `<if test="...">` 条件块
6//! - `<where>` 自动处理首个 AND/OR
7//! - `<set>` UPDATE 语句的 SET 子句
8//! - `<foreach>` 循环展开（用于 IN 子句）
9//! - `<choose><when><otherwise>` 多分支选择
10//! - `<trim>` 通用前后缀修剪
11//! - `#{name}` 命名参数绑定
12//!
13//! # 用法
14//!
15//! ```ignore
16//! use sz_orm_core::dynamic_sql::{DynamicSqlParser, SqlParams};
17//! use std::collections::HashMap;
18//!
19//! let xml = r#"
20//! <select id="find_users">
21//!     SELECT * FROM users
22//!     <where>
23//!         <if test="name != null">AND name = #{name}</if>
24//!         <if test="age != null">AND age &gt; #{age}</if>
25//!     </where>
26//! </select>
27//! "#;
28//!
29//! let parser = DynamicSqlParser::from_xml(xml);
30//! let mut params = SqlParams::new();
31//! params.set("name", "Alice");
32//! // params.set("age", 18);  // 不设置则 if 不生效
33//!
34//! let sql = parser.build("find_users", &params).unwrap();
35//! // SELECT * FROM users WHERE name = ?
36//! ```
37//!
38//! # 支持的标签
39//!
40//! | 标签 | 作用 |
41//! |------|------|
42//! | `<select id>` | SELECT 语句容器 |
43//! | `<insert id>` | INSERT 语句容器 |
44//! | `<update id>` | UPDATE 语句容器 |
45//! | `<delete id>` | DELETE 语句容器 |
46//! | `<if test="expr">` | 条件包含 |
47//! | `<where>` | WHERE 子句（自动处理首个 AND/OR） |
48//! | `<set>` | SET 子句（自动处理末尾逗号） |
49//! | `<foreach collection="x" item="i" separator=",">` | 循环展开 |
50//! | `<choose>` / `<when>` / `<otherwise>` | 多分支选择 |
51//! | `<trim prefix="..." suffix="..." prefixOverrides="AND">` | 通用修剪 |
52//! | `#{name}` | 命名参数绑定 |
53//! | `${name}` | 字符串插值（注意 SQL 注入风险） |
54//!
55//! # 安全警告
56//!
57//! `${name}` 字符串插值存在 SQL 注入风险，即使已添加基础转义。
58//! **强烈推荐使用 `#{name}` 命名参数绑定**，仅在 SQL 结构动态（如表名/列名）时
59//! 才使用 `${name}`，且必须确保输入来源可信。
60
61use std::collections::HashMap;
62
63/// 动态 SQL 错误
64#[derive(Debug, Clone, PartialEq)]
65pub enum DynamicSqlError {
66    /// XML 解析错误
67    ParseError(String),
68    /// 找不到指定的语句 ID
69    StatementNotFound(String),
70    /// 表达式求值错误
71    EvalError(String),
72    /// 参数缺失
73    MissingParam(String),
74}
75
76impl std::fmt::Display for DynamicSqlError {
77    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78        match self {
79            DynamicSqlError::ParseError(msg) => write!(f, "XML 解析错误: {}", msg),
80            DynamicSqlError::StatementNotFound(id) => {
81                write!(f, "找不到语句 ID: {}", id)
82            }
83            DynamicSqlError::EvalError(msg) => write!(f, "表达式求值错误: {}", msg),
84            DynamicSqlError::MissingParam(name) => write!(f, "缺少参数: {}", name),
85        }
86    }
87}
88
89impl std::error::Error for DynamicSqlError {}
90
91/// SQL 参数容器
92///
93/// 支持命名参数，按 `#{name}` 引用。
94#[derive(Debug, Clone, Default)]
95pub struct SqlParams {
96    params: HashMap<String, ParamValue>,
97}
98
99/// 参数值
100#[derive(Debug, Clone)]
101pub enum ParamValue {
102    /// Null
103    Null,
104    /// 字符串
105    String(String),
106    /// 整数
107    Int(i64),
108    /// 浮点
109    Float(f64),
110    /// 布尔
111    Bool(bool),
112    /// 数组（用于 foreach）
113    Array(Vec<ParamValue>),
114}
115
116impl SqlParams {
117    /// 创建空参数集
118    pub fn new() -> Self {
119        Self::default()
120    }
121
122    /// 设置字符串参数
123    pub fn set(&mut self, name: &str, value: &str) {
124        self.params
125            .insert(name.to_string(), ParamValue::String(value.to_string()));
126    }
127
128    /// 设置整数参数
129    pub fn set_int(&mut self, name: &str, value: i64) {
130        self.params.insert(name.to_string(), ParamValue::Int(value));
131    }
132
133    /// 设置浮点参数
134    pub fn set_float(&mut self, name: &str, value: f64) {
135        self.params
136            .insert(name.to_string(), ParamValue::Float(value));
137    }
138
139    /// 设置布尔参数
140    pub fn set_bool(&mut self, name: &str, value: bool) {
141        self.params
142            .insert(name.to_string(), ParamValue::Bool(value));
143    }
144
145    /// 设置 null
146    pub fn set_null(&mut self, name: &str) {
147        self.params.insert(name.to_string(), ParamValue::Null);
148    }
149
150    /// 设置数组参数
151    pub fn set_array(&mut self, name: &str, values: Vec<ParamValue>) {
152        self.params
153            .insert(name.to_string(), ParamValue::Array(values));
154    }
155
156    /// 获取参数值
157    pub fn get(&self, name: &str) -> Option<&ParamValue> {
158        self.params.get(name)
159    }
160
161    /// 是否存在参数
162    pub fn contains(&self, name: &str) -> bool {
163        self.params.contains_key(name)
164    }
165
166    /// 判断参数是否为 null（或不存在）
167    pub fn is_null(&self, name: &str) -> bool {
168        matches!(self.params.get(name), None | Some(ParamValue::Null))
169    }
170
171    /// 判断参数是否不为 null
172    pub fn is_not_null(&self, name: &str) -> bool {
173        !self.is_null(name)
174    }
175
176    /// 获取所有参数名
177    pub fn names(&self) -> Vec<String> {
178        self.params.keys().cloned().collect()
179    }
180}
181
182/// 动态 SQL 解析器
183#[derive(Debug, Clone)]
184pub struct DynamicSqlParser {
185    /// 已解析的语句：id → 语句节点
186    statements: HashMap<String, XmlNode>,
187}
188
189impl DynamicSqlParser {
190    /// 创建空解析器
191    pub fn new() -> Self {
192        Self {
193            statements: HashMap::new(),
194        }
195    }
196
197    /// 从 XML 字符串解析
198    pub fn from_xml(xml: &str) -> Result<Self, DynamicSqlError> {
199        let mut parser = Self::new();
200        parser.parse_xml(xml)?;
201        Ok(parser)
202    }
203
204    /// 解析 XML 字符串
205    fn parse_xml(&mut self, xml: &str) -> Result<(), DynamicSqlError> {
206        let root = XmlParser::parse(xml)?;
207        for child in &root.children {
208            if let XmlNodeType::Element { name, attrs } = &child.node_type {
209                let id = attrs
210                    .get("id")
211                    .ok_or_else(|| DynamicSqlError::ParseError(format!("<{}> 缺少 id 属性", name)))?
212                    .clone();
213                self.statements.insert(id, child.clone());
214            }
215        }
216        Ok(())
217    }
218
219    /// 构建指定 ID 的 SQL 语句
220    pub fn build(&self, id: &str, params: &SqlParams) -> Result<String, DynamicSqlError> {
221        let node = self
222            .statements
223            .get(id)
224            .ok_or_else(|| DynamicSqlError::StatementNotFound(id.to_string()))?;
225        let mut ctx = BuildContext::new(params);
226        self.build_node(node, &mut ctx)?;
227        Ok(self.cleanup_sql(&ctx.buffer))
228    }
229
230    /// 构建并返回 SQL + 绑定参数（按出现顺序）
231    pub fn build_with_binds(
232        &self,
233        id: &str,
234        params: &SqlParams,
235    ) -> Result<(String, Vec<ParamValue>), DynamicSqlError> {
236        let node = self
237            .statements
238            .get(id)
239            .ok_or_else(|| DynamicSqlError::StatementNotFound(id.to_string()))?;
240        let mut ctx = BuildContext::new(params);
241        self.build_node(node, &mut ctx)?;
242        Ok((self.cleanup_sql(&ctx.buffer), ctx.binds))
243    }
244
245    /// 列出所有已注册的语句 ID
246    pub fn statement_ids(&self) -> Vec<String> {
247        let mut ids: Vec<String> = self.statements.keys().cloned().collect();
248        ids.sort();
249        ids
250    }
251
252    // ---- 内部：节点构建 ----
253
254    fn build_node(&self, node: &XmlNode, ctx: &mut BuildContext) -> Result<(), DynamicSqlError> {
255        match &node.node_type {
256            XmlNodeType::Text(text) => {
257                self.append_text(text, ctx)?;
258            }
259            XmlNodeType::Element { name, attrs } => {
260                match name.as_str() {
261                    "select" | "insert" | "update" | "delete" => {
262                        for child in &node.children {
263                            self.build_node(child, ctx)?;
264                        }
265                    }
266                    "if" => {
267                        let test = attrs.get("test").ok_or_else(|| {
268                            DynamicSqlError::ParseError("<if> 缺少 test 属性".into())
269                        })?;
270                        if eval_test(test, ctx.params)? {
271                            for child in &node.children {
272                                self.build_node(child, ctx)?;
273                            }
274                        }
275                    }
276                    "where" => {
277                        let mut sub_ctx = BuildContext::new(ctx.params);
278                        for child in &node.children {
279                            self.build_node(child, &mut sub_ctx)?;
280                        }
281                        let content = sub_ctx.buffer.trim();
282                        if !content.is_empty() {
283                            // 去除开头的 AND/OR
284                            let cleaned = strip_leading_and_or(content);
285                            ctx.buffer.push_str(" WHERE ");
286                            ctx.buffer.push_str(cleaned.trim());
287                            // 把子上下文收集的绑定参数传回父上下文
288                            ctx.binds.extend(sub_ctx.binds);
289                        }
290                    }
291                    "set" => {
292                        let mut sub_ctx = BuildContext::new(ctx.params);
293                        for child in &node.children {
294                            self.build_node(child, &mut sub_ctx)?;
295                        }
296                        let content = sub_ctx.buffer.trim();
297                        if !content.is_empty() {
298                            // 去除末尾的逗号
299                            let cleaned = content.trim_end_matches(',').trim();
300                            // 规范化逗号：每个逗号后保留一个空格
301                            let normalized = normalize_set_commas(cleaned);
302                            ctx.buffer.push_str(" SET ");
303                            ctx.buffer.push_str(&normalized);
304                            ctx.binds.extend(sub_ctx.binds);
305                        }
306                    }
307                    "foreach" => {
308                        self.build_foreach(node, attrs, ctx)?;
309                    }
310                    "choose" => {
311                        self.build_choose(node, ctx)?;
312                    }
313                    "trim" => {
314                        self.build_trim(node, attrs, ctx)?;
315                    }
316                    _ => {
317                        // 未知标签，递归处理子节点
318                        for child in &node.children {
319                            self.build_node(child, ctx)?;
320                        }
321                    }
322                }
323            }
324        }
325        Ok(())
326    }
327
328    fn build_foreach(
329        &self,
330        node: &XmlNode,
331        attrs: &HashMap<String, String>,
332        ctx: &mut BuildContext,
333    ) -> Result<(), DynamicSqlError> {
334        let collection = attrs
335            .get("collection")
336            .ok_or_else(|| DynamicSqlError::ParseError("<foreach> 缺少 collection 属性".into()))?;
337        let item = attrs.get("item").map(|s| s.as_str()).unwrap_or("item");
338        let separator = attrs.get("separator").map(|s| s.as_str()).unwrap_or(",");
339        let open = attrs.get("open").cloned().unwrap_or_default();
340        let close = attrs.get("close").cloned().unwrap_or_default();
341
342        let arr = match ctx.params.get(collection) {
343            Some(ParamValue::Array(arr)) => arr.clone(),
344            _ => return Ok(()),
345        };
346
347        // 仅克隆一次参数集，循环内复用（避免每次迭代克隆整个 SqlParams）
348        let mut sub_params = ctx.params.clone();
349        let mut parts: Vec<String> = Vec::new();
350        for v in &arr {
351            // 临时设置 item 变量（覆盖上一次迭代的值，无需还原，因为 sub_params 不会被外部观察）
352            match v {
353                ParamValue::String(s) => sub_params.set(item, s),
354                ParamValue::Int(i) => sub_params.set_int(item, *i),
355                ParamValue::Float(f) => sub_params.set_float(item, *f),
356                ParamValue::Bool(b) => sub_params.set_bool(item, *b),
357                ParamValue::Null => sub_params.set_null(item),
358                ParamValue::Array(_) => {} // 嵌套数组不支持
359            }
360            let mut sub_ctx = BuildContext::new(&sub_params);
361            for child in &node.children {
362                self.build_node(child, &mut sub_ctx)?;
363            }
364            parts.push(sub_ctx.buffer.trim().to_string());
365            // 把子上下文收集的绑定参数传回父上下文（按出现顺序）
366            ctx.binds.extend(sub_ctx.binds);
367        }
368        if !parts.is_empty() {
369            let joined = parts.join(separator);
370            ctx.buffer.push(' ');
371            if !open.is_empty() {
372                ctx.buffer.push_str(&open);
373            }
374            ctx.buffer.push_str(&joined);
375            if !close.is_empty() {
376                ctx.buffer.push_str(&close);
377            }
378        }
379        Ok(())
380    }
381
382    fn build_choose(&self, node: &XmlNode, ctx: &mut BuildContext) -> Result<(), DynamicSqlError> {
383        for child in &node.children {
384            if let XmlNodeType::Element { name, attrs } = &child.node_type {
385                match name.as_str() {
386                    "when" => {
387                        let test = attrs.get("test").ok_or_else(|| {
388                            DynamicSqlError::ParseError("<when> 缺少 test 属性".into())
389                        })?;
390                        if eval_test(test, ctx.params)? {
391                            for c in &child.children {
392                                self.build_node(c, ctx)?;
393                            }
394                            return Ok(());
395                        }
396                    }
397                    "otherwise" => {
398                        for c in &child.children {
399                            self.build_node(c, ctx)?;
400                        }
401                        return Ok(());
402                    }
403                    _ => {}
404                }
405            }
406        }
407        Ok(())
408    }
409
410    fn build_trim(
411        &self,
412        node: &XmlNode,
413        attrs: &HashMap<String, String>,
414        ctx: &mut BuildContext,
415    ) -> Result<(), DynamicSqlError> {
416        let prefix = attrs.get("prefix").cloned().unwrap_or_default();
417        let suffix = attrs.get("suffix").cloned().unwrap_or_default();
418        let prefix_overrides = attrs.get("prefixOverrides").cloned().unwrap_or_default();
419        let suffix_overrides = attrs.get("suffixOverrides").cloned().unwrap_or_default();
420
421        let mut sub_ctx = BuildContext::new(ctx.params);
422        for child in &node.children {
423            self.build_node(child, &mut sub_ctx)?;
424        }
425        let mut content = sub_ctx.buffer.trim().to_string();
426
427        // 处理 prefixOverrides
428        if !prefix_overrides.is_empty() {
429            for ov in prefix_overrides.split('|') {
430                if content.starts_with(ov) {
431                    content = content[ov.len()..].trim_start().to_string();
432                    break;
433                }
434            }
435        }
436        // 处理 suffixOverrides
437        if !suffix_overrides.is_empty() {
438            for ov in suffix_overrides.split('|') {
439                if content.ends_with(ov) {
440                    content = content[..content.len() - ov.len()].trim_end().to_string();
441                    break;
442                }
443            }
444        }
445
446        if !content.is_empty() {
447            ctx.buffer.push(' ');
448            if !prefix.is_empty() {
449                ctx.buffer.push_str(&prefix);
450                ctx.buffer.push(' ');
451            }
452            ctx.buffer.push_str(&content);
453            if !suffix.is_empty() {
454                ctx.buffer.push(' ');
455                ctx.buffer.push_str(&suffix);
456            }
457            // 把子上下文收集的绑定参数传回父上下文
458            ctx.binds.extend(sub_ctx.binds);
459        }
460        Ok(())
461    }
462
463    fn append_text(&self, text: &str, ctx: &mut BuildContext) -> Result<(), DynamicSqlError> {
464        let mut i = 0;
465        let bytes = text.as_bytes();
466        while i < bytes.len() {
467            if i + 1 < bytes.len() && bytes[i] == b'#' && bytes[i + 1] == b'{' {
468                // #{name} 参数绑定
469                let end = text[i + 2..].find('}').ok_or_else(|| {
470                    DynamicSqlError::ParseError(format!("未闭合的 #{{}}: {}", &text[i..]))
471                })?;
472                let name = &text[i + 2..i + 2 + end];
473                let value = ctx
474                    .params
475                    .get(name)
476                    .ok_or_else(|| DynamicSqlError::MissingParam(name.to_string()))?
477                    .clone();
478                ctx.buffer.push('?');
479                ctx.binds.push(value);
480                i += 2 + end + 1; // 跳过 #{name}
481            } else if i + 1 < bytes.len() && bytes[i] == b'$' && bytes[i + 1] == b'{' {
482                // ${name} 字符串插值
483                let end = text[i + 2..].find('}').ok_or_else(|| {
484                    DynamicSqlError::ParseError(format!("未闭合的 ${{}}: {}", &text[i..]))
485                })?;
486                let name = &text[i + 2..i + 2 + end];
487                let value = ctx
488                    .params
489                    .get(name)
490                    .ok_or_else(|| DynamicSqlError::MissingParam(name.to_string()))?;
491                let s = param_to_string(value);
492                ctx.buffer.push_str(&s);
493                i += 2 + end + 1;
494            } else {
495                ctx.buffer.push(bytes[i] as char);
496                i += 1;
497            }
498        }
499        Ok(())
500    }
501
502    /// 清理 SQL 中的多余空白
503    fn cleanup_sql(&self, sql: &str) -> String {
504        let mut result = String::with_capacity(sql.len());
505        let mut prev_space = false;
506        for c in sql.chars() {
507            if c.is_whitespace() {
508                if !prev_space {
509                    result.push(' ');
510                    prev_space = true;
511                }
512            } else {
513                result.push(c);
514                prev_space = false;
515            }
516        }
517        result.trim().to_string()
518    }
519}
520
521impl Default for DynamicSqlParser {
522    fn default() -> Self {
523        Self::new()
524    }
525}
526
527/// 构建上下文
528struct BuildContext<'a> {
529    buffer: String,
530    binds: Vec<ParamValue>,
531    params: &'a SqlParams,
532}
533
534impl<'a> BuildContext<'a> {
535    fn new(params: &'a SqlParams) -> Self {
536        Self {
537            buffer: String::new(),
538            binds: Vec::new(),
539            params,
540        }
541    }
542}
543
544/// 评估 `<if test="...">` 表达式
545///
546/// 支持的表达式语法：
547/// - `name != null` — 参数存在且非 Null
548/// - `name == null` — 参数不存在或为 Null
549/// - `name != null and age != null` — AND（不区分大小写）
550/// - `name != null or age != null` — OR
551/// - `name == 'Alice'` — 字符串相等
552/// - `name == "Alice"` — 字符串相等（双引号）
553/// - `age > 18` — 数值比较（仅 >=, >, <, <=）
554fn eval_test(expr: &str, params: &SqlParams) -> Result<bool, DynamicSqlError> {
555    let expr = expr.trim();
556
557    // 处理 OR
558    if let Some(idx) = find_keyword(expr, " or ") {
559        let left = &expr[..idx];
560        let right = &expr[idx + 4..];
561        return Ok(eval_test(left, params)? || eval_test(right, params)?);
562    }
563
564    // 处理 AND
565    if let Some(idx) = find_keyword(expr, " and ") {
566        let left = &expr[..idx];
567        let right = &expr[idx + 5..];
568        return Ok(eval_test(left, params)? && eval_test(right, params)?);
569    }
570
571    // 处理 != null / == null
572    if let Some(stripped) = expr.strip_suffix("!= null") {
573        let name = stripped.trim();
574        return Ok(params.is_not_null(name));
575    }
576    if let Some(stripped) = expr.strip_suffix("== null") {
577        let name = stripped.trim();
578        return Ok(params.is_null(name));
579    }
580
581    // 处理 == '字符串' / == "字符串"
582    if let Some(idx) = expr.find("==") {
583        let left = expr[..idx].trim();
584        let right = expr[idx + 2..].trim();
585        let actual = params.get(left);
586        let expected = right.trim_matches('\'').trim_matches('"');
587        return Ok(match actual {
588            Some(ParamValue::String(s)) => s == expected,
589            _ => false,
590        });
591    }
592    if let Some(idx) = expr.find("!=") {
593        let left = expr[..idx].trim();
594        let right = expr[idx + 2..].trim();
595        let actual = params.get(left);
596        let expected = right.trim_matches('\'').trim_matches('"');
597        return Ok(match actual {
598            Some(ParamValue::String(s)) => s != expected,
599            _ => true,
600        });
601    }
602
603    // 处理 >, <, >=, <=
604    type CmpFn = fn(i64, i64) -> bool;
605    let cmps: [(&str, CmpFn); 4] = [
606        (">=", |a, b| a >= b),
607        ("<=", |a, b| a <= b),
608        (">", |a, b| a > b),
609        ("<", |a, b| a < b),
610    ];
611    for (op, cmp) in cmps {
612        if let Some(idx) = expr.find(op) {
613            let left = expr[..idx].trim();
614            let right_str = expr[idx + op.len()..].trim();
615            if let (Some(ParamValue::Int(a)), Ok(b)) = (params.get(left), right_str.parse::<i64>())
616            {
617                return Ok(cmp(*a, b));
618            }
619            return Ok(false);
620        }
621    }
622
623    Err(DynamicSqlError::EvalError(format!(
624        "无法解析表达式: {}",
625        expr
626    )))
627}
628
629/// 在表达式中查找关键字（不区分大小写，但需要前后是空格）
630fn find_keyword(expr: &str, keyword: &str) -> Option<usize> {
631    let lower = expr.to_lowercase();
632    lower.find(keyword)
633}
634
635/// 去除开头的 AND 或 OR
636fn strip_leading_and_or(s: &str) -> &str {
637    let trimmed = s.trim_start();
638    let lower = trimmed.to_lowercase();
639    if lower.starts_with("and ") {
640        trimmed[4..].trim_start()
641    } else if lower.starts_with("or ") {
642        trimmed[3..].trim_start()
643    } else {
644        trimmed
645    }
646}
647
648/// 参数值转字符串（用于 ${name} 插值）
649fn param_to_string(v: &ParamValue) -> String {
650    match v {
651        ParamValue::Null => "NULL".to_string(),
652        ParamValue::String(s) => escape_sql_string(s),
653        ParamValue::Int(i) => i.to_string(),
654        ParamValue::Float(f) => f.to_string(),
655        ParamValue::Bool(b) => {
656            if *b {
657                "TRUE".to_string()
658            } else {
659                "FALSE".to_string()
660            }
661        }
662        ParamValue::Array(_) => "[]".to_string(),
663    }
664}
665
666/// 转义 SQL 字符串字面量中的特殊字符
667/// 用于 ${name} 插值场景（不推荐使用 ${}，应优先使用 #{}）
668fn escape_sql_string(s: &str) -> String {
669    let mut out = String::with_capacity(s.len() + 2);
670    for ch in s.chars() {
671        match ch {
672            '\'' => out.push_str("''"),
673            '\\' => out.push_str("\\\\"),
674            '\n' => out.push_str("\\n"),
675            '\r' => out.push_str("\\r"),
676            '\0' => out.push_str("\\0"),
677            _ => out.push(ch),
678        }
679    }
680    out
681}
682
683/// 规范化 SET 子句中的逗号：确保每个逗号后跟一个空格
684/// 用于 `<set>` 标签的输出清理
685fn normalize_set_commas(s: &str) -> String {
686    let mut out = String::with_capacity(s.len());
687    let mut chars = s.chars().peekable();
688    while let Some(ch) = chars.next() {
689        if ch == ',' {
690            out.push(',');
691            // 跳过逗号后已有的空白
692            while matches!(chars.peek(), Some(c) if c.is_whitespace()) {
693                chars.next();
694            }
695            out.push(' ');
696        } else {
697            out.push(ch);
698        }
699    }
700    out
701}
702
703// =====================================================
704// 简易 XML 解析器
705// =====================================================
706
707#[derive(Debug, Clone)]
708pub struct XmlNode {
709    pub node_type: XmlNodeType,
710    pub children: Vec<XmlNode>,
711}
712
713#[derive(Debug, Clone)]
714pub enum XmlNodeType {
715    Text(String),
716    Element {
717        name: String,
718        attrs: HashMap<String, String>,
719    },
720}
721
722struct XmlParser<'a> {
723    input: &'a str,
724    pos: usize,
725}
726
727impl<'a> XmlParser<'a> {
728    fn parse(input: &'a str) -> Result<XmlNode, DynamicSqlError> {
729        let mut parser = Self { input, pos: 0 };
730        let mut root = XmlNode {
731            node_type: XmlNodeType::Element {
732                name: "root".to_string(),
733                attrs: HashMap::new(),
734            },
735            children: Vec::new(),
736        };
737        parser.parse_children(&mut root)?;
738        Ok(root)
739    }
740
741    fn parse_children(&mut self, parent: &mut XmlNode) -> Result<(), DynamicSqlError> {
742        loop {
743            if self.pos >= self.input.len() {
744                break;
745            }
746            // 检查是否是结束标签
747            if self.starts_with("</") {
748                break;
749            }
750            // 检查是否是注释
751            if self.starts_with("<!--") {
752                self.skip_comment()?;
753                continue;
754            }
755            // 检查是否是开始标签
756            if self.starts_with("<") {
757                let element = self.parse_element()?;
758                parent.children.push(element);
759            } else {
760                // 文本内容（保留空白，由后续 cleanup_sql 统一规范化）
761                let text = self.parse_text();
762                parent.children.push(XmlNode {
763                    node_type: XmlNodeType::Text(text),
764                    children: Vec::new(),
765                });
766            }
767        }
768        Ok(())
769    }
770
771    fn parse_element(&mut self) -> Result<XmlNode, DynamicSqlError> {
772        // 跳过 '<'
773        self.pos += 1;
774        // 读取标签名
775        let name = self.read_name();
776        // 读取属性
777        let mut attrs = HashMap::new();
778        loop {
779            self.skip_whitespace();
780            if self.pos >= self.input.len() {
781                return Err(DynamicSqlError::ParseError("未闭合的标签".into()));
782            }
783            let c = self.input.as_bytes()[self.pos] as char;
784            if c == '>' {
785                self.pos += 1;
786                break;
787            }
788            if c == '/' {
789                // 自闭合标签
790                if self.pos + 1 < self.input.len() && self.input.as_bytes()[self.pos + 1] == b'>' {
791                    self.pos += 2;
792                    return Ok(XmlNode {
793                        node_type: XmlNodeType::Element { name, attrs },
794                        children: Vec::new(),
795                    });
796                }
797            }
798            // 读取属性名
799            let attr_name = self.read_name();
800            self.skip_whitespace();
801            if self.pos < self.input.len() && self.input.as_bytes()[self.pos] == b'=' {
802                self.pos += 1;
803                self.skip_whitespace();
804                let attr_value = self.read_attr_value()?;
805                attrs.insert(attr_name, attr_value);
806            }
807        }
808        // 解析子节点
809        let mut node = XmlNode {
810            node_type: XmlNodeType::Element { name, attrs },
811            children: Vec::new(),
812        };
813        self.parse_children(&mut node)?;
814        // 跳过结束标签 </name>
815        if self.starts_with("</") {
816            self.pos += 2;
817            let end_name = self.read_name();
818            self.skip_whitespace();
819            if self.pos < self.input.len() && self.input.as_bytes()[self.pos] == b'>' {
820                self.pos += 1;
821            }
822            // 验证标签名匹配
823            if let XmlNodeType::Element { name, .. } = &node.node_type {
824                if name != &end_name {
825                    return Err(DynamicSqlError::ParseError(format!(
826                        "标签不匹配: <{}> vs </{}>",
827                        name, end_name
828                    )));
829                }
830            }
831        }
832        Ok(node)
833    }
834
835    fn parse_text(&mut self) -> String {
836        let start = self.pos;
837        while self.pos < self.input.len() {
838            let b = self.input.as_bytes()[self.pos];
839            if b == b'<' {
840                break;
841            }
842            self.pos += 1;
843        }
844        // 反转义 XML 实体
845        self.input[start..self.pos]
846            .replace("&gt;", ">")
847            .replace("&lt;", "<")
848            .replace("&amp;", "&")
849            .replace("&quot;", "\"")
850            .replace("&apos;", "'")
851    }
852
853    fn read_name(&mut self) -> String {
854        let start = self.pos;
855        while self.pos < self.input.len() {
856            let b = self.input.as_bytes()[self.pos];
857            if b.is_ascii_alphanumeric() || b == b'_' || b == b'-' || b == b':' {
858                self.pos += 1;
859            } else {
860                break;
861            }
862        }
863        self.input[start..self.pos].to_string()
864    }
865
866    fn read_attr_value(&mut self) -> Result<String, DynamicSqlError> {
867        if self.pos >= self.input.len() {
868            return Err(DynamicSqlError::ParseError("属性值缺失".into()));
869        }
870        let quote = self.input.as_bytes()[self.pos];
871        if quote != b'"' && quote != b'\'' {
872            return Err(DynamicSqlError::ParseError(format!(
873                "属性值应以引号开头, 实际: {}",
874                quote as char
875            )));
876        }
877        self.pos += 1;
878        let start = self.pos;
879        while self.pos < self.input.len() {
880            if self.input.as_bytes()[self.pos] == quote {
881                let raw = &self.input[start..self.pos];
882                // 反转义 XML 实体（属性值中允许出现 &gt; &lt; &amp; &quot; &apos;）
883                let value = raw
884                    .replace("&gt;", ">")
885                    .replace("&lt;", "<")
886                    .replace("&amp;", "&")
887                    .replace("&quot;", "\"")
888                    .replace("&apos;", "'");
889                self.pos += 1;
890                return Ok(value);
891            }
892            self.pos += 1;
893        }
894        Err(DynamicSqlError::ParseError("属性值未闭合".into()))
895    }
896
897    fn skip_whitespace(&mut self) {
898        while self.pos < self.input.len() {
899            if !self.input.as_bytes()[self.pos].is_ascii_whitespace() {
900                break;
901            }
902            self.pos += 1;
903        }
904    }
905
906    fn skip_comment(&mut self) -> Result<(), DynamicSqlError> {
907        // 跳过 <!--
908        self.pos += 4;
909        while self.pos + 2 < self.input.len() {
910            if &self.input[self.pos..self.pos + 3] == "-->" {
911                self.pos += 3;
912                return Ok(());
913            }
914            self.pos += 1;
915        }
916        Err(DynamicSqlError::ParseError("注释未闭合".into()))
917    }
918
919    fn starts_with(&self, s: &str) -> bool {
920        self.input[self.pos..].starts_with(s)
921    }
922}
923
924#[cfg(test)]
925mod tests {
926    use super::*;
927
928    // ---- SqlParams 测试 ----
929
930    #[test]
931    fn test_sql_params_set_get() {
932        let mut p = SqlParams::new();
933        p.set("name", "Alice");
934        p.set_int("age", 30);
935        p.set_bool("active", true);
936        p.set_null("deleted");
937
938        assert!(matches!(p.get("name"), Some(ParamValue::String(_))));
939        assert!(matches!(p.get("age"), Some(ParamValue::Int(30))));
940        assert!(matches!(p.get("active"), Some(ParamValue::Bool(true))));
941        assert!(matches!(p.get("deleted"), Some(ParamValue::Null)));
942        assert!(p.get("missing").is_none());
943    }
944
945    #[test]
946    fn test_sql_params_is_null() {
947        let mut p = SqlParams::new();
948        assert!(p.is_null("missing"));
949        p.set_null("x");
950        assert!(p.is_null("x"));
951        p.set("y", "val");
952        assert!(!p.is_null("y"));
953        assert!(p.is_not_null("y"));
954    }
955
956    #[test]
957    fn test_sql_params_contains() {
958        let mut p = SqlParams::new();
959        p.set("a", "1");
960        assert!(p.contains("a"));
961        assert!(!p.contains("b"));
962    }
963
964    // ---- 简单 SELECT 测试 ----
965
966    #[test]
967    fn test_simple_select_no_params() {
968        let xml = r#"<select id="all">SELECT * FROM users</select>"#;
969        let parser = DynamicSqlParser::from_xml(xml).unwrap();
970        let params = SqlParams::new();
971        let sql = parser.build("all", &params).unwrap();
972        assert_eq!(sql, "SELECT * FROM users");
973    }
974
975    #[test]
976    fn test_select_with_param_binding() {
977        let xml = r#"<select id="by_id">SELECT * FROM users WHERE id = #{id}</select>"#;
978        let parser = DynamicSqlParser::from_xml(xml).unwrap();
979        let mut params = SqlParams::new();
980        params.set_int("id", 42);
981        let sql = parser.build("by_id", &params).unwrap();
982        assert_eq!(sql, "SELECT * FROM users WHERE id = ?");
983    }
984
985    #[test]
986    fn test_select_with_string_interpolation() {
987        let xml = r#"<select id="by_table">SELECT * FROM ${table}</select>"#;
988        let parser = DynamicSqlParser::from_xml(xml).unwrap();
989        let mut params = SqlParams::new();
990        params.set("table", "users");
991        let sql = parser.build("by_table", &params).unwrap();
992        assert_eq!(sql, "SELECT * FROM users");
993    }
994
995    // ---- <if> 测试 ----
996
997    #[test]
998    fn test_if_true() {
999        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <if test="name != null">AND name = #{name}</if></select>"#;
1000        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1001        let mut params = SqlParams::new();
1002        params.set("name", "Alice");
1003        let sql = parser.build("q", &params).unwrap();
1004        assert!(sql.contains("AND name = ?"));
1005    }
1006
1007    #[test]
1008    fn test_if_false() {
1009        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <if test="name != null">AND name = #{name}</if></select>"#;
1010        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1011        let params = SqlParams::new();
1012        let sql = parser.build("q", &params).unwrap();
1013        assert!(!sql.contains("AND name"));
1014    }
1015
1016    #[test]
1017    fn test_if_null_check() {
1018        let xml = r#"<select id="q">SELECT * FROM users <if test="name == null">WHERE name IS NULL</if></select>"#;
1019        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1020
1021        let params = SqlParams::new();
1022        let sql = parser.build("q", &params).unwrap();
1023        assert!(sql.contains("WHERE name IS NULL"));
1024
1025        let mut params = SqlParams::new();
1026        params.set("name", "Alice");
1027        let sql = parser.build("q", &params).unwrap();
1028        assert!(!sql.contains("WHERE name IS NULL"));
1029    }
1030
1031    #[test]
1032    fn test_if_string_equals() {
1033        let xml = r#"<select id="q">SELECT * FROM users <if test="role == 'admin'">WHERE is_admin = 1</if></select>"#;
1034        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1035
1036        let mut params = SqlParams::new();
1037        params.set("role", "admin");
1038        let sql = parser.build("q", &params).unwrap();
1039        assert!(sql.contains("WHERE is_admin = 1"));
1040
1041        let mut params = SqlParams::new();
1042        params.set("role", "user");
1043        let sql = parser.build("q", &params).unwrap();
1044        assert!(!sql.contains("WHERE is_admin"));
1045    }
1046
1047    #[test]
1048    fn test_if_numeric_comparison() {
1049        let xml = r#"<select id="q">SELECT * FROM users <if test="age &gt; 18">WHERE age &gt; 18</if></select>"#;
1050        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1051
1052        let mut params = SqlParams::new();
1053        params.set_int("age", 25);
1054        let sql = parser.build("q", &params).unwrap();
1055        assert!(sql.contains("WHERE age > 18"));
1056
1057        let mut params = SqlParams::new();
1058        params.set_int("age", 15);
1059        let sql = parser.build("q", &params).unwrap();
1060        assert!(!sql.contains("WHERE age"));
1061    }
1062
1063    #[test]
1064    fn test_if_and_or() {
1065        let xml = r#"<select id="q">SELECT * FROM users <if test="name != null and age != null">WHERE name = #{name} AND age = #{age}</if></select>"#;
1066        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1067
1068        let mut params = SqlParams::new();
1069        params.set("name", "Alice");
1070        params.set_int("age", 30);
1071        let sql = parser.build("q", &params).unwrap();
1072        assert!(sql.contains("WHERE name = ? AND age = ?"));
1073
1074        let mut params = SqlParams::new();
1075        params.set("name", "Alice");
1076        let sql = parser.build("q", &params).unwrap();
1077        assert!(!sql.contains("WHERE"));
1078    }
1079
1080    // ---- <where> 测试 ----
1081
1082    #[test]
1083    fn test_where_strips_leading_and() {
1084        let xml = r#"<select id="q">SELECT * FROM users <where><if test="name != null">AND name = #{name}</if></where></select>"#;
1085        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1086        let mut params = SqlParams::new();
1087        params.set("name", "Alice");
1088        let sql = parser.build("q", &params).unwrap();
1089        assert!(sql.contains("WHERE name = ?"));
1090        assert!(!sql.contains("WHERE AND"));
1091    }
1092
1093    #[test]
1094    fn test_where_empty_no_clause() {
1095        let xml = r#"<select id="q">SELECT * FROM users <where><if test="name != null">AND name = #{name}</if></where></select>"#;
1096        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1097        let params = SqlParams::new();
1098        let sql = parser.build("q", &params).unwrap();
1099        assert_eq!(sql, "SELECT * FROM users");
1100    }
1101
1102    #[test]
1103    fn test_where_multiple_conditions() {
1104        let xml = r#"<select id="q">SELECT * FROM users <where>
1105            <if test="name != null">AND name = #{name}</if>
1106            <if test="age != null">AND age = #{age}</if>
1107        </where></select>"#;
1108        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1109        let mut params = SqlParams::new();
1110        params.set("name", "Alice");
1111        params.set_int("age", 30);
1112        let sql = parser.build("q", &params).unwrap();
1113        assert!(sql.contains("WHERE name = ? AND age = ?"));
1114    }
1115
1116    // ---- <set> 测试 ----
1117
1118    #[test]
1119    fn test_set_strips_trailing_comma() {
1120        let xml = r#"<update id="u">UPDATE users <set><if test="name != null">name = #{name},</if><if test="age != null">age = #{age},</if></set> WHERE id = #{id}</update>"#;
1121        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1122        let mut params = SqlParams::new();
1123        params.set("name", "Alice");
1124        params.set_int("age", 30);
1125        params.set_int("id", 1);
1126        let sql = parser.build("u", &params).unwrap();
1127        // <set> 语义：trim 末尾逗号；逗号后规范化为单个空格
1128        assert!(sql.contains("SET name = ?, age = ? WHERE id = ?"));
1129    }
1130
1131    #[test]
1132    fn test_set_single_field() {
1133        let xml = r#"<update id="u">UPDATE users <set><if test="name != null">name = #{name},</if></set> WHERE id = #{id}</update>"#;
1134        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1135        let mut params = SqlParams::new();
1136        params.set("name", "Alice");
1137        params.set_int("id", 1);
1138        let sql = parser.build("u", &params).unwrap();
1139        assert!(sql.contains("SET name = ? WHERE id = ?"));
1140    }
1141
1142    // ---- <foreach> 测试 ----
1143
1144    #[test]
1145    fn test_foreach_basic() {
1146        let xml = r#"<select id="q">SELECT * FROM users WHERE id IN (<foreach collection="ids" item="id" separator=",">#{id}</foreach>)</select>"#;
1147        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1148        let mut params = SqlParams::new();
1149        params.set_array(
1150            "ids",
1151            vec![ParamValue::Int(1), ParamValue::Int(2), ParamValue::Int(3)],
1152        );
1153        let sql = parser.build("q", &params).unwrap();
1154        // separator="," 不带空格，foreach 前会自动加一个空格
1155        assert!(sql.contains("WHERE id IN ( ?,?,?)"));
1156    }
1157
1158    #[test]
1159    fn test_foreach_empty() {
1160        let xml = r#"<select id="q">SELECT * FROM users WHERE id IN (<foreach collection="ids" item="id" separator=",">#{id}</foreach>)</select>"#;
1161        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1162        let params = SqlParams::new();
1163        let sql = parser.build("q", &params).unwrap();
1164        assert!(sql.contains("WHERE id IN ( )") || sql.contains("WHERE id IN ()"));
1165    }
1166
1167    #[test]
1168    fn test_foreach_with_strings() {
1169        let xml = r#"<select id="q">SELECT * FROM users WHERE name IN (<foreach collection="names" item="n" separator=",">#{n}</foreach>)</select>"#;
1170        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1171        let mut params = SqlParams::new();
1172        params.set_array(
1173            "names",
1174            vec![
1175                ParamValue::String("Alice".into()),
1176                ParamValue::String("Bob".into()),
1177            ],
1178        );
1179        let (sql, binds) = parser.build_with_binds("q", &params).unwrap();
1180        assert_eq!(binds.len(), 2);
1181        assert!(sql.contains("?"));
1182    }
1183
1184    // ---- <choose> 测试 ----
1185
1186    #[test]
1187    fn test_choose_when_matches() {
1188        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <choose>
1189            <when test="role == 'admin'">AND is_admin = 1</when>
1190            <otherwise>AND is_admin = 0</otherwise>
1191        </choose></select>"#;
1192        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1193        let mut params = SqlParams::new();
1194        params.set("role", "admin");
1195        let sql = parser.build("q", &params).unwrap();
1196        assert!(sql.contains("AND is_admin = 1"));
1197        assert!(!sql.contains("AND is_admin = 0"));
1198    }
1199
1200    #[test]
1201    fn test_choose_otherwise() {
1202        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <choose>
1203            <when test="role == 'admin'">AND is_admin = 1</when>
1204            <otherwise>AND is_admin = 0</otherwise>
1205        </choose></select>"#;
1206        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1207        let mut params = SqlParams::new();
1208        params.set("role", "user");
1209        let sql = parser.build("q", &params).unwrap();
1210        assert!(sql.contains("AND is_admin = 0"));
1211    }
1212
1213    // ---- <trim> 测试 ----
1214
1215    #[test]
1216    fn test_trim_prefix_suffix() {
1217        let xml = r#"<select id="q">SELECT * FROM users <trim prefix="WHERE" prefixOverrides="AND |OR "><if test="name != null">AND name = #{name}</if></trim></select>"#;
1218        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1219        let mut params = SqlParams::new();
1220        params.set("name", "Alice");
1221        let sql = parser.build("q", &params).unwrap();
1222        assert!(sql.contains("WHERE name = ?"));
1223    }
1224
1225    #[test]
1226    fn test_trim_empty() {
1227        let xml = r#"<select id="q">SELECT * FROM users <trim prefix="WHERE" prefixOverrides="AND"><if test="name != null">AND name = #{name}</if></trim></select>"#;
1228        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1229        let params = SqlParams::new();
1230        let sql = parser.build("q", &params).unwrap();
1231        assert_eq!(sql, "SELECT * FROM users");
1232    }
1233
1234    // ---- 错误处理测试 ----
1235
1236    #[test]
1237    fn test_statement_not_found() {
1238        let xml = r#"<select id="a">SELECT 1</select>"#;
1239        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1240        let params = SqlParams::new();
1241        let result = parser.build("missing", &params);
1242        assert!(matches!(result, Err(DynamicSqlError::StatementNotFound(_))));
1243    }
1244
1245    #[test]
1246    fn test_missing_param() {
1247        let xml = r#"<select id="q">SELECT * FROM users WHERE id = #{id}</select>"#;
1248        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1249        let params = SqlParams::new();
1250        let result = parser.build("q", &params);
1251        assert!(matches!(result, Err(DynamicSqlError::MissingParam(_))));
1252    }
1253
1254    #[test]
1255    fn test_parse_error_unclosed_tag() {
1256        let xml = r#"<select id="q">SELECT 1"#;
1257        let result = DynamicSqlParser::from_xml(xml);
1258        // 应该返回错误或者解析为不完整（取决于实现）
1259        // 这里我们接受任何结果，只要不 panic
1260        let _ = result;
1261    }
1262
1263    // ---- 多语句管理测试 ----
1264
1265    #[test]
1266    fn test_multiple_statements() {
1267        let xml = r#"
1268        <select id="find_all">SELECT * FROM users</select>
1269        <select id="find_by_id">SELECT * FROM users WHERE id = #{id}</select>
1270        <insert id="insert">INSERT INTO users (name) VALUES (#{name})</insert>
1271        <update id="update">UPDATE users SET name = #{name} WHERE id = #{id}</update>
1272        <delete id="delete">DELETE FROM users WHERE id = #{id}</delete>
1273        "#;
1274        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1275        let mut ids = parser.statement_ids();
1276        ids.sort();
1277        assert_eq!(
1278            ids,
1279            vec!["delete", "find_all", "find_by_id", "insert", "update"]
1280        );
1281    }
1282
1283    // ---- XML 实体测试 ----
1284
1285    #[test]
1286    fn test_xml_entities() {
1287        let xml =
1288            r#"<select id="q">SELECT * FROM users WHERE age &gt; 18 AND age &lt; 65</select>"#;
1289        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1290        let params = SqlParams::new();
1291        let sql = parser.build("q", &params).unwrap();
1292        assert!(sql.contains("age > 18 AND age < 65"));
1293    }
1294
1295    // ---- 完整流程测试 ----
1296
1297    #[test]
1298    fn test_full_dynamic_query() {
1299        let xml = r#"<select id="search">
1300            SELECT u.id, u.name, o.total
1301            FROM users u
1302            LEFT JOIN orders o ON u.id = o.user_id
1303            <where>
1304                <if test="name != null">AND u.name LIKE #{name}</if>
1305                <if test="min_age != null">AND u.age &gt; #{min_age}</if>
1306                <if test="status != null">AND u.status = #{status}</if>
1307            </where>
1308            ORDER BY u.id
1309        </select>"#;
1310        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1311        let mut params = SqlParams::new();
1312        params.set("name", "%Alice%");
1313        params.set_int("min_age", 18);
1314        // status 不设置
1315
1316        let (sql, binds) = parser.build_with_binds("search", &params).unwrap();
1317        assert!(sql.contains("SELECT u.id, u.name, o.total"));
1318        assert!(sql.contains("FROM users u"));
1319        assert!(sql.contains("LEFT JOIN orders o ON u.id = o.user_id"));
1320        assert!(sql.contains("WHERE u.name LIKE ? AND u.age > ?"));
1321        assert!(!sql.contains("u.status"));
1322        assert!(sql.contains("ORDER BY u.id"));
1323        assert_eq!(binds.len(), 2);
1324    }
1325}
sz_orm_core/dynamic_sql.rs

sz_orm_core/
dynamic_sql.rs
