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: name.clone(), attrs },
811            children: Vec::new(),
812        };
813        self.parse_children(&mut node)?;
814        // 跳过结束标签 </name>
815        // P4-1 修复：未闭合标签必须报错（之前 EOF 时静默返回 Ok）
816        if self.starts_with("</") {
817            self.pos += 2;
818            let end_name = self.read_name();
819            self.skip_whitespace();
820            if self.pos < self.input.len() && self.input.as_bytes()[self.pos] == b'>' {
821                self.pos += 1;
822            }
823            // 验证标签名匹配
824            if let XmlNodeType::Element { name: n, .. } = &node.node_type {
825                if n != &end_name {
826                    return Err(DynamicSqlError::ParseError(format!(
827                        "标签不匹配: <{}> vs </{}>",
828                        n, end_name
829                    )));
830                }
831            }
832        } else {
833            // 非 self-closing 标签必须有 </name> 结束标签
834            // 否则视为未闭合标签错误
835            return Err(DynamicSqlError::ParseError(format!(
836                "未闭合的标签: <{}>（缺少 </{}>）",
837                name, name
838            )));
839        }
840        Ok(node)
841    }
842
843    fn parse_text(&mut self) -> String {
844        let start = self.pos;
845        while self.pos < self.input.len() {
846            let b = self.input.as_bytes()[self.pos];
847            if b == b'<' {
848                break;
849            }
850            self.pos += 1;
851        }
852        // 反转义 XML 实体
853        self.input[start..self.pos]
854            .replace("&gt;", ">")
855            .replace("&lt;", "<")
856            .replace("&amp;", "&")
857            .replace("&quot;", "\"")
858            .replace("&apos;", "'")
859    }
860
861    fn read_name(&mut self) -> String {
862        let start = self.pos;
863        while self.pos < self.input.len() {
864            let b = self.input.as_bytes()[self.pos];
865            if b.is_ascii_alphanumeric() || b == b'_' || b == b'-' || b == b':' {
866                self.pos += 1;
867            } else {
868                break;
869            }
870        }
871        self.input[start..self.pos].to_string()
872    }
873
874    fn read_attr_value(&mut self) -> Result<String, DynamicSqlError> {
875        if self.pos >= self.input.len() {
876            return Err(DynamicSqlError::ParseError("属性值缺失".into()));
877        }
878        let quote = self.input.as_bytes()[self.pos];
879        if quote != b'"' && quote != b'\'' {
880            return Err(DynamicSqlError::ParseError(format!(
881                "属性值应以引号开头, 实际: {}",
882                quote as char
883            )));
884        }
885        self.pos += 1;
886        let start = self.pos;
887        while self.pos < self.input.len() {
888            if self.input.as_bytes()[self.pos] == quote {
889                let raw = &self.input[start..self.pos];
890                // 反转义 XML 实体（属性值中允许出现 &gt; &lt; &amp; &quot; &apos;）
891                let value = raw
892                    .replace("&gt;", ">")
893                    .replace("&lt;", "<")
894                    .replace("&amp;", "&")
895                    .replace("&quot;", "\"")
896                    .replace("&apos;", "'");
897                self.pos += 1;
898                return Ok(value);
899            }
900            self.pos += 1;
901        }
902        Err(DynamicSqlError::ParseError("属性值未闭合".into()))
903    }
904
905    fn skip_whitespace(&mut self) {
906        while self.pos < self.input.len() {
907            if !self.input.as_bytes()[self.pos].is_ascii_whitespace() {
908                break;
909            }
910            self.pos += 1;
911        }
912    }
913
914    fn skip_comment(&mut self) -> Result<(), DynamicSqlError> {
915        // 跳过 <!--
916        self.pos += 4;
917        while self.pos + 2 < self.input.len() {
918            if &self.input[self.pos..self.pos + 3] == "-->" {
919                self.pos += 3;
920                return Ok(());
921            }
922            self.pos += 1;
923        }
924        Err(DynamicSqlError::ParseError("注释未闭合".into()))
925    }
926
927    fn starts_with(&self, s: &str) -> bool {
928        self.input[self.pos..].starts_with(s)
929    }
930}
931
932#[cfg(test)]
933mod tests {
934    use super::*;
935
936    // ---- SqlParams 测试 ----
937
938    #[test]
939    fn test_sql_params_set_get() {
940        let mut p = SqlParams::new();
941        p.set("name", "Alice");
942        p.set_int("age", 30);
943        p.set_bool("active", true);
944        p.set_null("deleted");
945
946        assert!(matches!(p.get("name"), Some(ParamValue::String(_))));
947        assert!(matches!(p.get("age"), Some(ParamValue::Int(30))));
948        assert!(matches!(p.get("active"), Some(ParamValue::Bool(true))));
949        assert!(matches!(p.get("deleted"), Some(ParamValue::Null)));
950        assert!(p.get("missing").is_none());
951    }
952
953    #[test]
954    fn test_sql_params_is_null() {
955        let mut p = SqlParams::new();
956        assert!(p.is_null("missing"));
957        p.set_null("x");
958        assert!(p.is_null("x"));
959        p.set("y", "val");
960        assert!(!p.is_null("y"));
961        assert!(p.is_not_null("y"));
962    }
963
964    #[test]
965    fn test_sql_params_contains() {
966        let mut p = SqlParams::new();
967        p.set("a", "1");
968        assert!(p.contains("a"));
969        assert!(!p.contains("b"));
970    }
971
972    // ---- 简单 SELECT 测试 ----
973
974    #[test]
975    fn test_simple_select_no_params() {
976        let xml = r#"<select id="all">SELECT * FROM users</select>"#;
977        let parser = DynamicSqlParser::from_xml(xml).unwrap();
978        let params = SqlParams::new();
979        let sql = parser.build("all", &params).unwrap();
980        assert_eq!(sql, "SELECT * FROM users");
981    }
982
983    #[test]
984    fn test_select_with_param_binding() {
985        let xml = r#"<select id="by_id">SELECT * FROM users WHERE id = #{id}</select>"#;
986        let parser = DynamicSqlParser::from_xml(xml).unwrap();
987        let mut params = SqlParams::new();
988        params.set_int("id", 42);
989        let sql = parser.build("by_id", &params).unwrap();
990        assert_eq!(sql, "SELECT * FROM users WHERE id = ?");
991    }
992
993    #[test]
994    fn test_select_with_string_interpolation() {
995        let xml = r#"<select id="by_table">SELECT * FROM ${table}</select>"#;
996        let parser = DynamicSqlParser::from_xml(xml).unwrap();
997        let mut params = SqlParams::new();
998        params.set("table", "users");
999        let sql = parser.build("by_table", &params).unwrap();
1000        assert_eq!(sql, "SELECT * FROM users");
1001    }
1002
1003    // ---- <if> 测试 ----
1004
1005    #[test]
1006    fn test_if_true() {
1007        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <if test="name != null">AND name = #{name}</if></select>"#;
1008        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1009        let mut params = SqlParams::new();
1010        params.set("name", "Alice");
1011        let sql = parser.build("q", &params).unwrap();
1012        assert!(sql.contains("AND name = ?"));
1013    }
1014
1015    #[test]
1016    fn test_if_false() {
1017        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <if test="name != null">AND name = #{name}</if></select>"#;
1018        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1019        let params = SqlParams::new();
1020        let sql = parser.build("q", &params).unwrap();
1021        assert!(!sql.contains("AND name"));
1022    }
1023
1024    #[test]
1025    fn test_if_null_check() {
1026        let xml = r#"<select id="q">SELECT * FROM users <if test="name == null">WHERE name IS NULL</if></select>"#;
1027        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1028
1029        let params = SqlParams::new();
1030        let sql = parser.build("q", &params).unwrap();
1031        assert!(sql.contains("WHERE name IS NULL"));
1032
1033        let mut params = SqlParams::new();
1034        params.set("name", "Alice");
1035        let sql = parser.build("q", &params).unwrap();
1036        assert!(!sql.contains("WHERE name IS NULL"));
1037    }
1038
1039    #[test]
1040    fn test_if_string_equals() {
1041        let xml = r#"<select id="q">SELECT * FROM users <if test="role == 'admin'">WHERE is_admin = 1</if></select>"#;
1042        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1043
1044        let mut params = SqlParams::new();
1045        params.set("role", "admin");
1046        let sql = parser.build("q", &params).unwrap();
1047        assert!(sql.contains("WHERE is_admin = 1"));
1048
1049        let mut params = SqlParams::new();
1050        params.set("role", "user");
1051        let sql = parser.build("q", &params).unwrap();
1052        assert!(!sql.contains("WHERE is_admin"));
1053    }
1054
1055    #[test]
1056    fn test_if_numeric_comparison() {
1057        let xml = r#"<select id="q">SELECT * FROM users <if test="age &gt; 18">WHERE age &gt; 18</if></select>"#;
1058        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1059
1060        let mut params = SqlParams::new();
1061        params.set_int("age", 25);
1062        let sql = parser.build("q", &params).unwrap();
1063        assert!(sql.contains("WHERE age > 18"));
1064
1065        let mut params = SqlParams::new();
1066        params.set_int("age", 15);
1067        let sql = parser.build("q", &params).unwrap();
1068        assert!(!sql.contains("WHERE age"));
1069    }
1070
1071    #[test]
1072    fn test_if_and_or() {
1073        let xml = r#"<select id="q">SELECT * FROM users <if test="name != null and age != null">WHERE name = #{name} AND age = #{age}</if></select>"#;
1074        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1075
1076        let mut params = SqlParams::new();
1077        params.set("name", "Alice");
1078        params.set_int("age", 30);
1079        let sql = parser.build("q", &params).unwrap();
1080        assert!(sql.contains("WHERE name = ? AND age = ?"));
1081
1082        let mut params = SqlParams::new();
1083        params.set("name", "Alice");
1084        let sql = parser.build("q", &params).unwrap();
1085        assert!(!sql.contains("WHERE"));
1086    }
1087
1088    // ---- <where> 测试 ----
1089
1090    #[test]
1091    fn test_where_strips_leading_and() {
1092        let xml = r#"<select id="q">SELECT * FROM users <where><if test="name != null">AND name = #{name}</if></where></select>"#;
1093        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1094        let mut params = SqlParams::new();
1095        params.set("name", "Alice");
1096        let sql = parser.build("q", &params).unwrap();
1097        assert!(sql.contains("WHERE name = ?"));
1098        assert!(!sql.contains("WHERE AND"));
1099    }
1100
1101    #[test]
1102    fn test_where_empty_no_clause() {
1103        let xml = r#"<select id="q">SELECT * FROM users <where><if test="name != null">AND name = #{name}</if></where></select>"#;
1104        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1105        let params = SqlParams::new();
1106        let sql = parser.build("q", &params).unwrap();
1107        assert_eq!(sql, "SELECT * FROM users");
1108    }
1109
1110    #[test]
1111    fn test_where_multiple_conditions() {
1112        let xml = r#"<select id="q">SELECT * FROM users <where>
1113            <if test="name != null">AND name = #{name}</if>
1114            <if test="age != null">AND age = #{age}</if>
1115        </where></select>"#;
1116        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1117        let mut params = SqlParams::new();
1118        params.set("name", "Alice");
1119        params.set_int("age", 30);
1120        let sql = parser.build("q", &params).unwrap();
1121        assert!(sql.contains("WHERE name = ? AND age = ?"));
1122    }
1123
1124    // ---- <set> 测试 ----
1125
1126    #[test]
1127    fn test_set_strips_trailing_comma() {
1128        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>"#;
1129        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1130        let mut params = SqlParams::new();
1131        params.set("name", "Alice");
1132        params.set_int("age", 30);
1133        params.set_int("id", 1);
1134        let sql = parser.build("u", &params).unwrap();
1135        // <set> 语义：trim 末尾逗号；逗号后规范化为单个空格
1136        assert!(sql.contains("SET name = ?, age = ? WHERE id = ?"));
1137    }
1138
1139    #[test]
1140    fn test_set_single_field() {
1141        let xml = r#"<update id="u">UPDATE users <set><if test="name != null">name = #{name},</if></set> WHERE id = #{id}</update>"#;
1142        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1143        let mut params = SqlParams::new();
1144        params.set("name", "Alice");
1145        params.set_int("id", 1);
1146        let sql = parser.build("u", &params).unwrap();
1147        assert!(sql.contains("SET name = ? WHERE id = ?"));
1148    }
1149
1150    // ---- <foreach> 测试 ----
1151
1152    #[test]
1153    fn test_foreach_basic() {
1154        let xml = r#"<select id="q">SELECT * FROM users WHERE id IN (<foreach collection="ids" item="id" separator=",">#{id}</foreach>)</select>"#;
1155        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1156        let mut params = SqlParams::new();
1157        params.set_array(
1158            "ids",
1159            vec![ParamValue::Int(1), ParamValue::Int(2), ParamValue::Int(3)],
1160        );
1161        let sql = parser.build("q", &params).unwrap();
1162        // separator="," 不带空格，foreach 前会自动加一个空格
1163        assert!(sql.contains("WHERE id IN ( ?,?,?)"));
1164    }
1165
1166    #[test]
1167    fn test_foreach_empty() {
1168        let xml = r#"<select id="q">SELECT * FROM users WHERE id IN (<foreach collection="ids" item="id" separator=",">#{id}</foreach>)</select>"#;
1169        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1170        let params = SqlParams::new();
1171        let sql = parser.build("q", &params).unwrap();
1172        assert!(sql.contains("WHERE id IN ( )") || sql.contains("WHERE id IN ()"));
1173    }
1174
1175    #[test]
1176    fn test_foreach_with_strings() {
1177        let xml = r#"<select id="q">SELECT * FROM users WHERE name IN (<foreach collection="names" item="n" separator=",">#{n}</foreach>)</select>"#;
1178        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1179        let mut params = SqlParams::new();
1180        params.set_array(
1181            "names",
1182            vec![
1183                ParamValue::String("Alice".into()),
1184                ParamValue::String("Bob".into()),
1185            ],
1186        );
1187        let (sql, binds) = parser.build_with_binds("q", &params).unwrap();
1188        assert_eq!(binds.len(), 2);
1189        assert!(sql.contains("?"));
1190    }
1191
1192    // ---- <choose> 测试 ----
1193
1194    #[test]
1195    fn test_choose_when_matches() {
1196        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <choose>
1197            <when test="role == 'admin'">AND is_admin = 1</when>
1198            <otherwise>AND is_admin = 0</otherwise>
1199        </choose></select>"#;
1200        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1201        let mut params = SqlParams::new();
1202        params.set("role", "admin");
1203        let sql = parser.build("q", &params).unwrap();
1204        assert!(sql.contains("AND is_admin = 1"));
1205        assert!(!sql.contains("AND is_admin = 0"));
1206    }
1207
1208    #[test]
1209    fn test_choose_otherwise() {
1210        let xml = r#"<select id="q">SELECT * FROM users WHERE 1=1 <choose>
1211            <when test="role == 'admin'">AND is_admin = 1</when>
1212            <otherwise>AND is_admin = 0</otherwise>
1213        </choose></select>"#;
1214        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1215        let mut params = SqlParams::new();
1216        params.set("role", "user");
1217        let sql = parser.build("q", &params).unwrap();
1218        assert!(sql.contains("AND is_admin = 0"));
1219    }
1220
1221    // ---- <trim> 测试 ----
1222
1223    #[test]
1224    fn test_trim_prefix_suffix() {
1225        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>"#;
1226        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1227        let mut params = SqlParams::new();
1228        params.set("name", "Alice");
1229        let sql = parser.build("q", &params).unwrap();
1230        assert!(sql.contains("WHERE name = ?"));
1231    }
1232
1233    #[test]
1234    fn test_trim_empty() {
1235        let xml = r#"<select id="q">SELECT * FROM users <trim prefix="WHERE" prefixOverrides="AND"><if test="name != null">AND name = #{name}</if></trim></select>"#;
1236        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1237        let params = SqlParams::new();
1238        let sql = parser.build("q", &params).unwrap();
1239        assert_eq!(sql, "SELECT * FROM users");
1240    }
1241
1242    // ---- 错误处理测试 ----
1243
1244    #[test]
1245    fn test_statement_not_found() {
1246        let xml = r#"<select id="a">SELECT 1</select>"#;
1247        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1248        let params = SqlParams::new();
1249        let result = parser.build("missing", &params);
1250        assert!(matches!(result, Err(DynamicSqlError::StatementNotFound(_))));
1251    }
1252
1253    #[test]
1254    fn test_missing_param() {
1255        let xml = r#"<select id="q">SELECT * FROM users WHERE id = #{id}</select>"#;
1256        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1257        let params = SqlParams::new();
1258        let result = parser.build("q", &params);
1259        assert!(matches!(result, Err(DynamicSqlError::MissingParam(_))));
1260    }
1261
1262    #[test]
1263    fn test_parse_error_unclosed_tag() {
1264        // P4-1 修复：未闭合标签必须返回 ParseError，而非"接受任何结果"
1265        let xml = r#"<select id="q">SELECT 1"#;
1266        let result = DynamicSqlParser::from_xml(xml);
1267        assert!(
1268            matches!(result, Err(DynamicSqlError::ParseError(_))),
1269            "未闭合标签应返回 ParseError，实际: {:?}",
1270            result
1271        );
1272        if let Err(DynamicSqlError::ParseError(msg)) = result {
1273            assert!(
1274                msg.contains("未闭合") || msg.contains("标签") || msg.contains("EOF"),
1275                "错误信息应提及未闭合/标签/EOF: {}",
1276                msg
1277            );
1278        }
1279    }
1280
1281    // ---- 多语句管理测试 ----
1282
1283    #[test]
1284    fn test_multiple_statements() {
1285        let xml = r#"
1286        <select id="find_all">SELECT * FROM users</select>
1287        <select id="find_by_id">SELECT * FROM users WHERE id = #{id}</select>
1288        <insert id="insert">INSERT INTO users (name) VALUES (#{name})</insert>
1289        <update id="update">UPDATE users SET name = #{name} WHERE id = #{id}</update>
1290        <delete id="delete">DELETE FROM users WHERE id = #{id}</delete>
1291        "#;
1292        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1293        let mut ids = parser.statement_ids();
1294        ids.sort();
1295        assert_eq!(
1296            ids,
1297            vec!["delete", "find_all", "find_by_id", "insert", "update"]
1298        );
1299    }
1300
1301    // ---- XML 实体测试 ----
1302
1303    #[test]
1304    fn test_xml_entities() {
1305        let xml =
1306            r#"<select id="q">SELECT * FROM users WHERE age &gt; 18 AND age &lt; 65</select>"#;
1307        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1308        let params = SqlParams::new();
1309        let sql = parser.build("q", &params).unwrap();
1310        assert!(sql.contains("age > 18 AND age < 65"));
1311    }
1312
1313    // ---- 完整流程测试 ----
1314
1315    #[test]
1316    fn test_full_dynamic_query() {
1317        let xml = r#"<select id="search">
1318            SELECT u.id, u.name, o.total
1319            FROM users u
1320            LEFT JOIN orders o ON u.id = o.user_id
1321            <where>
1322                <if test="name != null">AND u.name LIKE #{name}</if>
1323                <if test="min_age != null">AND u.age &gt; #{min_age}</if>
1324                <if test="status != null">AND u.status = #{status}</if>
1325            </where>
1326            ORDER BY u.id
1327        </select>"#;
1328        let parser = DynamicSqlParser::from_xml(xml).unwrap();
1329        let mut params = SqlParams::new();
1330        params.set("name", "%Alice%");
1331        params.set_int("min_age", 18);
1332        // status 不设置
1333
1334        let (sql, binds) = parser.build_with_binds("search", &params).unwrap();
1335        assert!(sql.contains("SELECT u.id, u.name, o.total"));
1336        assert!(sql.contains("FROM users u"));
1337        assert!(sql.contains("LEFT JOIN orders o ON u.id = o.user_id"));
1338        assert!(sql.contains("WHERE u.name LIKE ? AND u.age > ?"));
1339        assert!(!sql.contains("u.status"));
1340        assert!(sql.contains("ORDER BY u.id"));
1341        assert_eq!(binds.len(), 2);
1342    }
1343}
sz_orm_core/dynamic_sql.rs

sz_orm_core/
dynamic_sql.rs
