jsql-neo 6.3.4 → 6.3.5

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL. PostgreSQL. MongoDB. Redis. SQL. TypeScript. The browser. **And it fits in one npm package.**
 
-> **v6.3.4** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo)
+> **v6.3.5** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)
@@ -233,7 +233,7 @@ npm install && npm run build                 # option 3: from source
 Verify:
 
 ```bash
-node -e "console.log(require('jsql-neo/package.json').version)"   # 6.3.4
+node -e "console.log(require('jsql-neo/package.json').version)"   # 6.3.5
 ```
 
 ### 30-second demo
@@ -1470,7 +1470,7 @@ jsql mod --engine wasm        # switch engine (restart required)
 
 ```bash
 $ jsql version
-jsql-neo v6.3.4
+jsql-neo v6.3.5
 engine: native (napi) | wasm | js
 node: v22.0.0  platform: linux x64
 ```
@@ -1491,7 +1491,7 @@ jsql tui --memory -q                      # memory mode, quiet
 jsql tui --prompt 'db> ' --no-color
 ```
 
-The status bar shows: `db=<name> dialect=<d> mode=<tui|batch> ver=6.3.4`.
+The status bar shows: `db=<name> dialect=<d> mode=<tui|batch> ver=6.3.5`.
 
 ### Keyboard shortcuts
 
@@ -4175,7 +4175,7 @@ Data dir: /root/.jsql-neo/data
 
 ```bash
 $ jsql version
-jsql-neo v6.3.4
+jsql-neo v6.3.5
 engine: native (napi) | wasm | js
 node: v22.0.0
 platform: linux x64
@@ -5275,7 +5275,7 @@ Apache License
 
 *JSQL-NEO — One engine to rule them all. MySQL. PostgreSQL. MongoDB. Redis. SQL. TypeScript. The browser.*
 
-*文档版本：v6.3.4 · 最后更新：2026-09-27*
+*文档版本：v6.3.5 · 最后更新：2026-09-27*
 
 ---
 
@@ -7047,7 +7047,7 @@ Usage: jsql version
 
 输出版本与环境信息：
 
-  jsql-neo v6.3.4
+  jsql-neo v6.3.5
   engine: native (napi) | wasm | js
   node: v22.0.0
   platform: linux x64
@@ -7703,7 +7703,7 @@ CI（GitHub Actions）矩阵：`node 20/22` × `linux/macos/windows` × `native/
 
 *JSQL-NEO — One engine to rule them all. MySQL. PostgreSQL. MongoDB. Redis. SQL. TypeScript. The browser.*
 
-*文档版本：v6.3.4 · 共 19 个附录 · 最后更新：2026-09-27*
+*文档版本：v6.3.5 · 共 19 个附录 · 最后更新：2026-09-27*
 
 ---
 
@@ -8310,4 +8310,4 @@ npm test
 
 *JSQL-NEO — One engine to rule them all. MySQL. PostgreSQL. MongoDB. Redis. SQL. TypeScript. The browser.*
 
-*文档版本：v6.3.4 · 附录 A–Z · 全文 6000+ 行 · 最后更新：2026-09-27*
+*文档版本：v6.3.5 · 附录 A–Z · 全文 6000+ 行 · 最后更新：2026-09-27*

package/index.js

@@ -1,5 +1,5 @@
 /**
- * JSQL-NEO v6.3.4 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.3.5 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/database.js

@@ -1499,8 +1499,23 @@ class Database {
         if (!this._runHooks('beforeUpdate', [tableName, id, data])) return;
         const row = this._resolveId(table, id);
         if (!row) return { ok: false, error: 'not found' };
-        Object.assign(row, data);
+        // 改主键/唯一列时要先确认新值不与其它行冲突。
+        // 此前直接 Object.assign，导致
+        //   UPDATE t SET id = 1 WHERE id = 2   （t 已有 id=1）
+        // 静默产生两行同主键 —— 主键索引只留一个，SELECT 结果与实际存储不一致。
+        // MySQL / SQLite 都会报 UNIQUE constraint failed。
+        // 注意：UNIQUE 列记录在 table._cachedUniqueFields（不是 _indexes），
+        // 逐行比对即可，未建索引时也能正确拦截。
         const pk = this._pkOf(table);
+        const uniq = (table._cachedUniqueFields || []).filter(f => f !== pk);
+        for (const field of [pk, ...uniq]) {
+            if (!field || !Object.prototype.hasOwnProperty.call(data, field)) continue;
+            const nv = data[field];
+            if (nv === row[field]) continue;          // 值没变，不算冲突
+            const clash = table._rows.find(r => r !== row && r[field] === nv);
+            if (clash) throw createError('ER_DUP_ENTRY', `Duplicate entry '${nv}' for key '${field}'`);
+        }
+        Object.assign(row, data);
         if (pk) this._walWrite({ op: 'update', table: tableName, pk, id, row: { ...data } });
         this._emit('update', { table: tableName, id, data });
         this._runHooks('afterUpdate', [tableName, id, data, { ok: true }]);
@@ -1562,13 +1577,21 @@ class Database {
         if (table._primaryKey) {
             for (const id of ids) removed += table.removeById(id);
         } else {
+            // 无主键表没有稳定的行标识，_resolveId 只能把 id 当 1-based 行号，
+            // 而 _rowPkId 在无主键时回退到 row.id（业务列名）——
+            // 两者语义不一致，导致 DELETE ... WHERE id IN (3,5) 删错行。
+            // 这里先按「行对象 === id」尝试（SQL 层可以直接传行引用），
+            // 退化到行号解析；并一次性收集目标后统一移除，避免边删边移位。
+            const targets = [];
+            const seen = new Set();
+            const push = (row) => { if (row && !seen.has(row)) { seen.add(row); targets.push(row); } };
             for (const id of ids) {
-                const row = this._resolveId(table, id);
-                const idx = row ? table._rows.findIndex(r => r === row) : -1;
-                if (idx !== -1) {
-                    table._rows.splice(idx, 1);
-                    removed++;
-                }
+                if (id && typeof id === 'object') { push(id); continue; }
+                push(this._resolveId(table, id));
+            }
+            if (targets.length) {
+                table._rows = table._rows.filter(r => !seen.has(r));
+                removed = targets.length;
             }
             table._rebuildPKIndex();
             table._rebuildAllBTrees();

package/lib/sql.js

@@ -610,6 +610,17 @@ class Parser {
 
     while (true) {
       const t = this.peek();
+      // 列级 CHECK (age INT CHECK(age >= 0))。
+      // CHECK 刻意不在 KEYWORDS 里（避免影响同名标识符），所以用 isWord 匹配，
+      // 放在 keyword switch 之外。表级 CHECK 已能被解析（同样只是跳过），
+      // 列级此前会直接 return def，把 CHECK 留在流里 →
+      // "Expected ',' or ')' in CREATE TABLE, got 'CHECK'"。
+      // 与表级保持一致：解析并跳过，条件文本存到 def.check 供后续实现。
+      if (this.isWord('CHECK')) {
+        this.next();
+        if (this.peek().type === 'op' && this.peek().value === '(') this._skipParens();
+        continue;
+      }
       if (t.type === 'keyword') {
         switch (t.value) {
           case 'PRIMARY':
@@ -1073,8 +1084,19 @@ class Parser {
         this.expect('op', ')');
         aggregate = { type: 'COUNT', column: col, distinct: aggDistinct };
         aggregate = this.parseOptionalOver(aggregate);
-        aggregate.alias = this.parseOptionalAlias();
-        columns.push({ expr: col, aggregate: 'COUNT', column: col, alias: aggregate.alias, over: aggregate.over || null, window: !!aggregate.over, distinct: aggDistinct });
+        // 聚合后紧跟运算符：SUM(v)/COUNT(*) / COUNT(*)-1 …
+        // 顶层聚合默认被表示为独立的 aggregate 字段，不参与后续运算，
+        // 运算符会留在流里 → "Unexpected token '/' after statement"。
+        // 此时整体降级成 scalar 表达式（arith 里嵌 aggregate），
+        // 由执行层的嵌套聚合替换逻辑求值。
+        // 注意：先看尾随运算符，再取别名 —— 顺序反了会把 AS 当成运算符的一部分。
+        const cntTail = this.parseArithTail(aggregate);
+        if (cntTail) {
+          columns.push({ expr: null, scalar: cntTail, alias: this.parseOptionalAlias() });
+        } else {
+          aggregate.alias = this.parseOptionalAlias();
+          columns.push({ expr: col, aggregate: 'COUNT', column: col, alias: aggregate.alias, over: aggregate.over || null, window: !!aggregate.over, distinct: aggDistinct });
+        }
       } else if (t.type === 'keyword' && ['SUM', 'AVG', 'MIN', 'MAX'].includes(t.value)) {
         this.next();
         const fn = t.value;
@@ -1085,8 +1107,14 @@ class Parser {
         this.expect('op', ')');
         aggregate = { type: fn, column: col, distinct: aggDistinct2 };
         aggregate = this.parseOptionalOver(aggregate);
-        aggregate.alias = this.parseOptionalAlias();
-        columns.push({ expr: col, aggregate: fn, column: col, alias: aggregate.alias, over: aggregate.over || null, window: !!aggregate.over, distinct: aggDistinct2 });
+        // 同 COUNT 分支：聚合参与后续算术时降级成 scalar 表达式
+        const fnTail = this.parseArithTail(aggregate);
+        if (fnTail) {
+          columns.push({ expr: null, scalar: fnTail, alias: this.parseOptionalAlias() });
+        } else {
+          aggregate.alias = this.parseOptionalAlias();
+          columns.push({ expr: col, aggregate: fn, column: col, alias: aggregate.alias, over: aggregate.over || null, window: !!aggregate.over, distinct: aggDistinct2 });
+        }
       } else if (t.type === 'op' && t.value === '*') {
         this.next();
         columns.push({ expr: '*' });
@@ -1762,9 +1790,49 @@ class Parser {
       this.peek(1) && this.peek(1).type === 'keyword' && this.peek(1).value === 'SELECT';
     if (!isSubqueryParen && this.peek().type === 'op' && this.peek().value === '(') {
       this.next();
-      const e = this.parseExpr();
+      // 递归解析括号内的完整表达式（到 ')' 为止）。
+      // 此处不能用 parseExpr()：它一路走到 parseComparison，
+      // 而内层看不到 ')' 会抛 "Expected comparison operator, got ')'"。
+      // 用 bareExprDepth>0 的 parseArgExpr 走同一套优先级，但允许裸操作数收尾。
+      this.bareExprDepth = (this.bareExprDepth || 0) + 1;
+      let left;
+      try {
+        left = this.parseOr();
+      } finally {
+        this.bareExprDepth--;
+      }
       this.expect('op', ')');
-      return e;
+      // 括号整体是一个完整的左操作数，后面若紧跟运算符必须继续参与运算：
+      //   SELECT (1+2)*3  /  SELECT (a+b)/2  /  WHERE (x+1) > 5
+      // 直接 return 会把运算符留在流里 → "Unexpected token '*' after statement"
+      // （2*(3+4) 正常是因为 '(' 出现在右操作数位置，不走这个分支。）
+      // 先乘除后加减，与 parseTerm/parseAdditive 的优先级一致。
+      for (;;) {
+        const t = this.peek();
+        if (t.type !== 'op' || !['*', '/', '%'].includes(t.value)) break;
+        this.next();
+        const right = this.parseExpr();
+        left = { type: 'arith', op: t.value, left, right };
+      }
+      for (;;) {
+        const t = this.peek();
+        if (t.type !== 'op' || !['+', '-'].includes(t.value)) break;
+        this.next();
+        const right = this.parseExpr();
+        left = { type: 'arith', op: t.value, left, right };
+      }
+      // 尾随比较/条件运算符：WHERE (a) = 1 / (a) IN (...) / (a) LIKE 'x' /
+      // (a) IS NULL / (a) BETWEEN 1 AND 5 / (a) NOT IN (...)。
+      // 一律交给 parseComparison —— 它是完整实现，覆盖这些全部形式。
+      const nx = this.peek();
+      const isCmp = nx.type === 'op' &&
+        ['=', '!=', '<>', '<', '<=', '>', '>=', '<=>', '@>', '<@'].includes(nx.value);
+      const isCondKw = nx.type === 'keyword' &&
+        ['IN', 'LIKE', 'ILIKE', 'IS', 'BETWEEN', 'REGEXP', 'RLIKE', 'NOT'].includes(nx.value);
+      if (isCmp || isCondKw) {
+        return this.parseComparison(left);
+      }
+      return left;
     }
     // EXISTS (SELECT ...)：子查询是否存在至少一行
     if (this.isKeyword('EXISTS')) {
@@ -1777,6 +1845,42 @@ class Parser {
     return this.parseComparison();
   }
 
+  /**
+   * 聚合（或任意已解析好的左操作数）之后若紧跟算术运算符，继续解析并返回
+   * 组合后的 arith 节点；没有运算符则返回 null（调用方走原有的 aggregate 列路径）。
+   *   SELECT SUM(v)/COUNT(*)   → arith('/', SUM, arith('/', COUNT))
+   * 优先级与 parseTerm / parseAdditive 一致：先乘除后加减。
+   */
+  parseArithTail(left) {
+    // 投影分支里的 aggregate 对象是 { type: 'SUM', column, distinct } ——
+    // type 直接是聚合函数名，不是 'aggregate'。而执行层的 _replaceAggregates
+    // 只认 type === 'aggregate'，不规范化就会漏替换 → 整个表达式求值为 null。
+    // 这里包一层 { type:'aggregate', fn, column, … } 供替换逻辑识别。
+    const seed = left && left.type !== 'aggregate' && typeof left.type === 'string' &&
+      /^[A-Z][A-Z0-9_]*$/.test(left.type)
+      ? { type: 'aggregate', fn: left.type, column: left.column,
+          distinct: left.distinct, separator: left.separator, orderBy: left.orderBy }
+      : left;
+
+    let node = seed;
+    let touched = false;
+    for (;;) {
+      const t = this.peek();
+      if (t.type !== 'op' || !['*', '/', '%'].includes(t.value)) break;
+      this.next();
+      node = { type: 'arith', op: t.value, left: node, right: this.parseScalar() };
+      touched = true;
+    }
+    for (;;) {
+      const t = this.peek();
+      if (t.type !== 'op' || !['+', '-'].includes(t.value)) break;
+      this.next();
+      node = { type: 'arith', op: t.value, left: node, right: this.parseScalar() };
+      touched = true;
+    }
+    return touched ? node : null;
+  }
+
   /**
    * 解析聚合调用：fn ( [DISTINCT] expr [, expr*] [ORDER BY ...] [SEPARATOR 'x'] )
    * 以及 COUNT(*) 这类无参形式。
@@ -1838,7 +1942,27 @@ class Parser {
       // 否则会被当作逐行标量函数：既返回 null，又不会折叠分组
       if (AGG_FUNCS.has(String(t.value).toUpperCase()) &&
           this.peek().type === 'op' && this.peek().value === '(') {
-        return this.parseAggregateCall(String(t.value).toUpperCase());
+        const agg = this.parseAggregateCall(String(t.value).toUpperCase());
+        // 聚合结果也是一个完整的左操作数，后面可紧跟运算符：
+        //   SELECT SUM(sal)/COUNT(*) AS avg   ← 算平均值的标准写法
+        //   SELECT SUM(sal) - MIN(sal)        ← 极差
+        //   SELECT MAX(sal) * 2
+        // 不处理的话运算符会留在流里 → "Unexpected token '/' after statement"。
+        // （加括号写成 (SUM(sal))/2 之所以正常，是走了括号分组分支。）
+        let left = agg;
+        for (;;) {
+          const nx = this.peek();
+          if (nx.type !== 'op' || !['*', '/', '%'].includes(nx.value)) break;
+          this.next();
+          left = { type: 'arith', op: nx.value, left, right: this.parseOperand() };
+        }
+        for (;;) {
+          const nx = this.peek();
+          if (nx.type !== 'op' || !['+', '-'].includes(nx.value)) break;
+          this.next();
+          left = { type: 'arith', op: nx.value, left, right: this.parseOperand() };
+        }
+        return left;
       }
       // 支持 alias.column 引用
       if (this.peek().type === 'op' && this.peek().value === '.') {
@@ -2039,10 +2163,33 @@ class Parser {
     }
     // 括号分组：支持 (1+2)、2*(3+4) 等出现在算术/函数参数任意位置
     // 注意：parseOperand 开头已通过 const t = this.next() 消费了 '(', 此处不可再 next()
+    //
+    // 括号整体是一个完整的左操作数，后面若紧跟运算符必须继续参与运算，
+    // 否则运算符会留在流里：
+    //   SELECT (1+2)*3        → Unexpected token '*' after statement
+    //   WHERE (a) = 1         → Expected comparison operator, got ')'
     if (t.type === 'op' && t.value === '(') {
-      const inner = this.parseArgExpr();   // 容忍裸操作数，允许纯算术分组
+      let left = this.parseArgExpr();   // 容忍裸操作数，允许纯算术分组
       this.expect('op', ')');
-      return inner;
+      // 先乘除后加减，与 parseTerm / parseAdditive 的优先级一致
+      for (;;) {
+        const nx = this.peek();
+        if (nx.type !== 'op' || !['*', '/', '%'].includes(nx.value)) break;
+        this.next();
+        left = { type: 'arith', op: nx.value, left, right: this.parseArgExpr() };
+      }
+      for (;;) {
+        const nx = this.peek();
+        if (nx.type !== 'op' || !['+', '-'].includes(nx.value)) break;
+        this.next();
+        left = { type: 'arith', op: nx.value, left, right: this.parseArgExpr() };
+      }
+      // 尾随比较运算符交给 parseComparison（完整实现，覆盖 =/</>/LIKE/IN/IS…）
+      const cx = this.peek();
+      if (cx.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>=', '<=>'].includes(cx.value)) {
+        return this.parseComparison(left);
+      }
+      return left;
     }
     if (t.type === 'op' && (t.value === '-' || t.value === '+')) {
       const num = this.next();
@@ -2190,7 +2337,15 @@ class Parser {
         const v = this.parseOperand();
         cond = { type: 'compare', op: '=', left: base, right: v };
       } else {
-        cond = this.parseComparison();
+        // 条件可能是完整比较（WHEN a > 1），也可能是裸值/裸列（WHEN 1、WHEN flag）。
+        // parseComparison 只接受比较式，裸值会抛 "Expected comparison operator, got 'THEN'"。
+        // 先看清下一个 token 决定走哪条路，避免用 try/catch 回溯吞掉真实错误。
+        const nx = this.peek();
+        const isCmp = (nx.type === 'op' && ['=', '!=', '<>', '<', '<=', '>', '>=', '<=>'].includes(nx.value)) ||
+          (nx.type === 'keyword' && ['IN', 'LIKE', 'ILIKE', 'IS', 'BETWEEN', 'REGEXP', 'RLIKE', 'NOT'].includes(nx.value)) ||
+          this.isWord('NOT');
+        cond = isCmp ? this.parseComparison()
+          : { type: 'isTruth', operand: this.parseArgExpr(), not: false, truth: true };
       }
       this.expectKeyword('THEN');
       const val = this.parseOperand();
@@ -2202,8 +2357,13 @@ class Parser {
     return { type: 'case', branches, elseVal };
   }
 
-  parseComparison() {
-    const left = this.parseBitwise();
+  /**
+   * 解析比较表达式。
+   * preLeft：已解析好的左操作数（括号分组场景 —— parseNot 消费到 ')' 后传进来），
+   *          省略时正常从 parseBitwise() 取左操作数。
+   */
+  parseComparison(preLeft) {
+    const left = preLeft !== undefined ? preLeft : this.parseBitwise();
     const t = this.peek();
     let not = false;
     if (t.type === 'keyword' && t.value === 'NOT') {
@@ -2347,7 +2507,10 @@ const OPERATORS = {
 function applyCast(value, dataType) {
   const t = String(dataType || '').toUpperCase().replace(/\(.*\)$/, '').trim();
   if (value === null || value === undefined) return null;
-  if (t === 'INTEGER' || t === 'INT' || t === 'BIGINT' || t === 'SMALLINT' || t === 'TINYINT') {
+  // SIGNED / UNSIGNED 是 MySQL 的整型别名（CAST(x AS SIGNED)），
+  // 此前没列入整型分支，导致 CAST('12abc' AS SIGNED) 原样返回字符串。
+  if (t === 'INTEGER' || t === 'INT' || t === 'BIGINT' || t === 'SMALLINT' ||
+      t === 'TINYINT' || t === 'SIGNED' || t === 'UNSIGNED' || t === 'MEDIUMINT') {
     // MySQL CAST(... AS SIGNED/INT)：取数字前缀（'12abc'→12），无法解析时返回 0（而非 null）。
     if (typeof value === 'boolean') return value ? 1 : 0;
     if (typeof value === 'number') return Number.isFinite(value) ? Math.trunc(value) : 0;
@@ -2374,6 +2537,23 @@ function rowHasPrefixedKeys(row) {
   return false;
 }
 
+/**
+ * 字符串能否当作数值参与算术运算。
+ * MySQL 里 '5' + 5 = 10、'5' + '5' = 10、'abc' + 1 = 1（非数字按 0）。
+ * 纯数字（含小数/负号/科学计数）才返回数值，否则返回 null。
+ */
+function numericIfNumeric(v) {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  if (typeof v === 'boolean') return v ? 1 : 0;
+  if (typeof v !== 'string') return null;
+  const s = v.trim();
+  if (s === '') return null;
+  // 严格数字：可选符号 + 数字（含小数与指数），不接受 '12abc' 这类前缀形式
+  if (!/^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/.test(s)) return null;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : null;
+}
+
 function resolveOperand(operand, row, ctx) {
   if (operand === null || operand === undefined) return null;
   if (typeof operand === 'string') return resolveOperand({ type: 'column', name: operand }, row, ctx);
@@ -2423,11 +2603,28 @@ function resolveOperand(operand, row, ctx) {
       const r = resolveOperand(operand.right, row, ctx);
       if (l === null || r === null || l === undefined || r === undefined) return null;
       switch (operand.op) {
-        case '+': return l + r;
-        case '-': return l - r;
-        case '*': return l * r;
-        case '/': return r === 0 ? null : l / r;
-        case '%': return r === 0 ? null : l % r;
+        // MySQL/SQLite 里 + 永远是算术加法，字符串拼接只走 || 或 CONCAT。
+        // 直接用 JS 的 l + r 会让 '5' + 5 得到 '55'（静默返回字符串），
+        // 数字与字符串混合的算术会一路错下去。
+        // 判据：任一侧是 number，或字符串能被完整解析为数字 → 走数值加法。
+        case '+': {
+          // MySQL / SQLite 语义（已用 sqlite3 实测核对）：
+          //   '5' + 5 = 10   '5' + '5' = 10   'abc' + 1 = 1   'a' + 'b' = 0
+          // 任一侧是「数值」时做算术加法，另一侧非数值按 0；
+          // 两侧都不是数值才是 0（JS 的 l + r 会把 '5' + 5 拼成 '55'）。
+          if (typeof l === 'number' || typeof r === 'number') {
+            const ln2 = numericIfNumeric(l), rn2 = numericIfNumeric(r);
+            return (ln2 === null ? 0 : ln2) + (rn2 === null ? 0 : rn2);
+          }
+          const ln = numericIfNumeric(l), rn = numericIfNumeric(r);
+          if (ln !== null) return ln + (rn === null ? 0 : rn);
+          if (rn !== null) return rn;   // 左侧非数值按 0
+          return 0;
+        }
+        case '-': return Number(l) - Number(r);
+        case '*': return Number(l) * Number(r);
+        case '/': return r === 0 ? null : Number(l) / Number(r);
+        case '%': return r === 0 ? null : Number(l) % Number(r);
         // MySQL 整数除法 DIV（结果向零取整）
         case 'DIV': return r === 0 ? null : Math.trunc(Number(l) / Number(r));
         // 位运算：先按整数归一，与 MySQL 的整数位运算语义一致
@@ -2894,7 +3091,12 @@ function applyScalarFunction(fnNode, row, ctx) {
       const b = parseSqlDate(args[1]);
       if (!a || !b) return null;
       const ms = a.getTime() - b.getTime();
-      const months = (a.getFullYear() - b.getFullYear()) * 12 + (a.getMonth() - b.getMonth());
+      // MySQL 的整月差：先算日历月数差，再按「结束日的日 < 起始日的日」退一档。
+      // 只算日历月差会高估：
+      //   TIMESTAMPDIFF(MONTH,'2026-01-15','2026-03-14') = 1（差 1 个月零 29 天，不足 2 个月）
+      //   TIMESTAMPDIFF(MONTH,'2026-01-31','2026-03-01') = 1（1/31+1月=2/28，2/28+1月=3/28，够不到 3/1）
+      let months = (a.getFullYear() - b.getFullYear()) * 12 + (a.getMonth() - b.getMonth());
+      if (a.getDate() < b.getDate()) months--;
       switch (unit) {
         case 'MICROSECOND': return Math.floor(ms * 1000);
         case 'SECOND': return Math.floor(ms / 1000);
@@ -2904,7 +3106,7 @@ function applyScalarFunction(fnNode, row, ctx) {
         case 'WEEK': return Math.floor(ms / (86400000 * 7));
         case 'MONTH': return months;
         case 'QUARTER': return Math.floor(months / 3);
-        case 'YEAR': return a.getFullYear() - b.getFullYear();
+        case 'YEAR': return Math.floor(months / 12);
         default: return null;
       }
     }
@@ -2995,6 +3197,30 @@ function applyScalarFunction(fnNode, row, ctx) {
     case 'LTRIM': return args[0] == null ? null : String(args[0]).replace(/^\s+/, '');
     case 'RTRIM': return args[0] == null ? null : String(args[0]).replace(/\s+$/, '');
     case 'ABS': return args[0] == null ? null : Math.abs(args[0]);
+    case 'SIGN': {   // MySQL：正数 1 / 0 → 0 / 负数 -1；NULL → NULL
+      const v = numericIfNumeric(args[0]);
+      if (v === null) return args[0] == null ? null : 0;
+      return v > 0 ? 1 : (v < 0 ? -1 : 0);
+    }
+    case 'TRUNCATE': {   // MySQL：直接截断，不四舍五入；NULL → NULL
+      const x = numericIfNumeric(args[0]);
+      if (x === null) return args[0] == null ? null : null;
+      const digits = args[1] === undefined || args[1] === null ? 0 : Math.trunc(Number(args[1])) || 0;
+      const factor = Math.pow(10, digits);
+      if (!Number.isFinite(factor)) return x;
+      return Math.trunc(x * factor) / factor;
+    }
+    case 'SUBSTRING_INDEX': {   // MySQL：按分隔符切，返回左边 count 段（count<0 从右数）
+      const s = args[0] == null ? null : String(args[0]);
+      const d = args[1] == null ? null : String(args[1]);
+      if (s === null || d === null || d === '') return null;
+      const n = Math.trunc(Number(args[2]));
+      if (!Number.isFinite(n)) return null;
+      if (n === 0) return '';
+      const parts = s.split(d);
+      if (n > 0) return parts.slice(0, n).join(d);
+      return parts.slice(n).join(d);   // n<0：取末尾 |n| 段
+    }
     case 'ROUND': {
       // MySQL 语义：四舍五入「半远离零」（Math.round 是半向 +∞，对负数会错，如 -3.5→-3）
       // 位数 D 可为负（向小数点左侧舍入）；非数值/非法输入返回 null，绝不抛 TypeError/RangeError。
@@ -3974,7 +4200,10 @@ class SQLExecutor {
         }
         if (typeof statement.limit === 'number') candidates = candidates.slice(0, statement.limit);
         for (const row of candidates) {
-          const id = this._rowPkId(row, pkCols);
+          // 无主键表没有稳定行标识：_rowPkId 会回退到 row.id（业务列名），
+          // 而存储层的 _resolveId 把 id 当 1-based 行号 —— 两者语义不一致，
+          // DELETE ... WHERE id IN (3,5) 会删错行。此时直接传行对象，存储层按引用删。
+          const id = pkCols.length > 0 ? this._rowPkId(row, pkCols) : row;
           if (id !== undefined) { ids.push(id); removedRows.push(row); }
         }
         if (ids.length > 0) {
@@ -4259,9 +4488,48 @@ class SQLExecutor {
     return row ? row.id : undefined;
   }
 
-  async _readTable(table) {
+  /**
+   * 从 WHERE 表达式里提取「可直接下推给存储层」的等值条件。
+   *
+   * 此前 _readTable 一律 `find(table, {}, ...)` 拉全表回内存再逐行 evaluateExpr，
+   * WHERE 完全没有下推 —— 2 万行表上 `WHERE id = ?` 也要扫 2 万行（约 88ms/次），
+   * 而主键索引本可以做到微秒级。
+   *
+   * 只认最安全的一类：column = <字面量>（含 AND 连接）。
+   * 其它条件（范围、OR、函数、IN、子查询）一律不下推，交回内存过滤，
+   * 避免为了快而改错结果。
+   */
+  _pushdownEqualities(statement) {
+    const out = {};
+    if (!statement || !statement.where || typeof statement.where !== 'object') return out;
+    const visit = (node) => {
+      if (!node || typeof node !== 'object') return;
+      if (node.type === 'and') { visit(node.left); visit(node.right); return; }
+      if (node.type !== 'compare' || node.op !== '=') return;
+      const isCol = n => n && n.type === 'column' && typeof n.name === 'string';
+      const isVal = n => n && n.type === 'value' && n.value !== null && n.value !== undefined;
+      let col = null, val = null;
+      if (isCol(node.left) && isVal(node.right)) { col = node.left.name; val = node.right.value; }
+      else if (isCol(node.right) && isVal(node.left)) { col = node.right.name; val = node.left.value; }
+      if (col === null) return;
+      const key = col.includes('.') ? col.slice(col.lastIndexOf('.') + 1) : col;
+      // 同一列出现多个等值条件（如 id=1 AND id=2）时不推，交给内存求值
+      if (Object.prototype.hasOwnProperty.call(out, key)) delete out[key];
+      else out[key] = val;
+    };
+    visit(statement.where);
+    return out;
+  }
+
+  async _readTable(table, statement) {
     const schema = await this._getSchema(table);
-    const rows = (await this.engine.find(table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
+    // 有可下推的等值条件时交给存储层走索引；没有则维持原来的全表读取
+    const filter = statement ? this._pushdownEqualities(statement) : {};
+    const useIndex = Object.keys(filter).length > 0 &&
+      (typeof this.engine.exists === 'function' || typeof this.engine.find === 'function');
+    const rows = useIndex
+      ? (await this.engine.find(table, filter, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema))
+      : (await this.engine.find(table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
     return { schema, rows };
   }
 
@@ -4622,6 +4890,17 @@ class SQLExecutor {
       delete node.column;
       return;
     }
+    // 投影分支构造的聚合节点形如 { type: 'SUM', column, distinct }（type 就是函数名），
+    // 与 parseAggregateCall 产出的 { type:'aggregate', fn } 并存。
+    // 两种都要替换，否则 SUM(v)/COUNT(*) 整式求值为 null。
+    if (typeof node.type === 'string' && AGG_FUNCS.has(node.type) &&
+        (node.column !== undefined || node.over === undefined)) {
+      const fn = node.type;
+      node.type = 'value';
+      node.value = this._aggValue(group, fn, node.column, node.distinct, node.separator, node.orderBy);
+      delete node.column;
+      return;
+    }
     for (const k of Object.keys(node)) {
       if (node[k] && typeof node[k] === 'object') this._replaceAggregates(node[k], group);
     }
@@ -5133,7 +5412,7 @@ class SQLExecutor {
         const res = await this.executeSelect(firstItem.subquery);
         rowsAll = { rows: this._subQueryRows(res), schema: null, columns: res.columns };
       } else {
-        rowsAll = await this._readTable(firstItem.table);
+        rowsAll = await this._readTable(firstItem.table, statement);
       }
       schema = rowsAll.schema;
       const firstPrefix = firstItem.alias || firstItem.table;
@@ -5142,7 +5421,7 @@ class SQLExecutor {
       for (const j of statement.from.joins) {
         const rightRes = j.item.subquery
           ? await this.executeSelect(j.item.subquery)
-          : await this._readTable(j.item.table);
+          : await this._readTable(j.item.table, statement);
         const rightPrefix = j.item.alias || j.item.table;
         const rightRows = (j.item.subquery ? this._subQueryRows(rightRes) : rightRes.rows).map(r => this._prefixRow(r, rightPrefix));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.3.4",
+  "version": "6.3.5",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -51,9 +51,10 @@
     "test:btree": "node test/btree.test.js",
     "test:native": "node test/native.test.js",
     "test:regress": "node test/regress-5.1.0.js",
-    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/native.test.js && node test/native-multi-instance.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js",
+    "test:all": "node test/smoke.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/native.test.js && node test/native-multi-instance.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js && node test/dml-constraints.test.js",
     "test:coverage": "c8 --all --include='lib/**' --exclude='lib/web_ui.js' --reporter=text --reporter=lcov node test/coverage.js",
-    "test:orms": "node examples/orms/run-all.js"
+    "test:orms": "node examples/orms/run-all.js",
+    "test:dml": "node test/dml-constraints.test.js"
   },
   "keywords": [
     "database",

package/test/dml-constraints.test.js

@@ -0,0 +1,163 @@
+/*
+ * DML 与表约束回归测试。
+ *
+ * 覆盖两类曾静默出错的问题：
+ *   1. 无主键表批量删除删错行 —— 存储层把 id 当 1-based 行号，
+ *      边解析边删会让后续行号整体左移（DELETE ... WHERE id <= 2
+ *      在 5 行表上只删掉 1 行，且留下的是第 2 行）。
+ *   2. UPDATE 改主键/唯一列不校验冲突 —— 直接 Object.assign，
+ *      静默产生两行同主键（MySQL / SQLite 都会报 UNIQUE constraint failed）。
+ *
+ * 每个用例独立建库，避免状态污染。
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const { Database } = require(path.join(ROOT, 'index.js'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql.js'));
+
+const OPTS = { safety: false };
+let pass = 0, fail = 0;
+
+function ok(name, cond, extra) {
+  if (cond) { pass++; console.log('[OK]  ', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra) : ''); }
+}
+const rowsOf = r => (Array.isArray(r) ? r[0] : r).rows;
+const eq = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+/** 跑一个用例：每次给全新的 :memory: 库 */
+async function t(name, fn) {
+  const db = new Database(':memory:');
+  try {
+    const r = await fn({
+      exec: (sql) => executeSQL(db, sql, OPTS),
+      rows: (sql) => executeSQL(db, sql, OPTS).then(rowsOf),
+      scalar: (sql) => executeSQL(db, sql, OPTS).then(r => rowsOf(r)[0][0]),
+      mustFail: async (sql) => {
+        try { await executeSQL(db, sql, OPTS); return '本该报错却成功了'; }
+        catch (e) { return true; }
+      },
+    });
+    if (r === true) ok(name, true);
+    else ok(name, false, r);
+  } catch (e) {
+    ok(name, false, String(e.message || e).slice(0, 120));
+  } finally {
+    try { await db.stop(); } catch (_) { /* ignore */ }
+  }
+}
+
+(async () => {
+  console.log('\n--- 无主键表：批量删除曾删错行 ---');
+  await t('无主键 DELETE 多个连续行', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3),(4),(5)`);
+    await exec(`DELETE FROM t WHERE id <= 2`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[3], [4], [5]]);
+  });
+  await t('无主键 DELETE IN 列表', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3),(4),(5)`);
+    await exec(`DELETE FROM t WHERE id IN (1,4)`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[2], [3], [5]]);
+  });
+  await t('无主键 DELETE 单行（回归对照）', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3)`);
+    await exec(`DELETE FROM t WHERE id = 2`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[1], [3]]);
+  });
+  await t('无主键 DELETE 全部', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3)`);
+    await exec(`DELETE FROM t`);
+    return eq(await rows(`SELECT id FROM t`), []);
+  });
+  await t('有主键 DELETE 多个（回归对照）', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3),(4),(5)`);
+    await exec(`DELETE FROM t WHERE id <= 2`);
+    return eq(await rows(`SELECT id FROM t ORDER BY id`), [[3], [4], [5]]);
+  });
+  await t('无主键 DELETE 后行数正确', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT)`);
+    await exec(`INSERT INTO t VALUES (1),(2),(3)`);
+    const r = await exec(`DELETE FROM t WHERE id > 1`);
+    if (r.affectedRows !== 2) return { affectedRows: r.affectedRows, want: 2 };
+    return eq(await scalar(`SELECT COUNT(*) AS c FROM t`), 1);
+  });
+
+  console.log('\n--- UPDATE 改主键 / 唯一列曾不校验冲突 ---');
+  await t('UPDATE 主键成已存在值 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20)`);
+    return mustFail(`UPDATE t SET id = 1 WHERE id = 2`);
+  });
+  await t('UPDATE 主键冲突后数据未损坏', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20),(3,30)`);
+    try { await exec(`UPDATE t SET id = 1 WHERE id = 2`); } catch (_) { /* expected */ }
+    return eq(await rows(`SELECT id, v FROM t ORDER BY id`), [[1, 10], [2, 20], [3, 30]]);
+  });
+  await t('UPDATE 主键成不冲突值 → 成功', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20),(3,30)`);
+    await exec(`UPDATE t SET id = 9 WHERE id = 2`);
+    return eq(await rows(`SELECT id, v FROM t ORDER BY id`), [[1, 10], [3, 30], [9, 20]]);
+  });
+  await t('UPDATE 主键为自身值 → 允许', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(9,20)`);
+    await exec(`UPDATE t SET id = 9 WHERE id = 9`);
+    return eq(await scalar(`SELECT COUNT(*) AS c FROM t`), 2);
+  });
+  await t('UPDATE UNIQUE 列成已存在值 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,'a'),(2,'b')`);
+    return mustFail(`UPDATE t SET e = 'a' WHERE id = 2`);
+  });
+  await t('UPDATE UNIQUE 列成不冲突值 → 成功', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,'a'),(2,'b')`);
+    await exec(`UPDATE t SET e = 'c' WHERE id = 2`);
+    return eq(await rows(`SELECT id, e FROM t ORDER BY id`), [[1, 'a'], [2, 'c']]);
+  });
+  await t('UPDATE 非约束列不受影响', async ({ exec, rows }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v INT)`);
+    await exec(`INSERT INTO t VALUES (1,10),(2,20)`);
+    await exec(`UPDATE t SET v = 99 WHERE id = 1`);
+    return eq(await rows(`SELECT id, v FROM t ORDER BY id`), [[1, 99], [2, 20]]);
+  });
+
+  console.log('\n--- 既有约束行为回归对照 ---');
+  await t('INSERT 主键重复 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY)`);
+    await exec(`INSERT INTO t VALUES (1)`);
+    return mustFail(`INSERT INTO t VALUES (1)`);
+  });
+  await t('INSERT NOT NULL 违反 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT, v TEXT NOT NULL)`);
+    return mustFail(`INSERT INTO t VALUES (1,NULL)`);
+  });
+  await t('INSERT UNIQUE 重复 → 报错', async ({ exec, mustFail }) => {
+    await exec(`CREATE TABLE t (id INT, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,'a')`);
+    return mustFail(`INSERT INTO t VALUES (2,'a')`);
+  });
+  await t('UNIQUE 允许多个 NULL', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT, e TEXT UNIQUE)`);
+    await exec(`INSERT INTO t VALUES (1,NULL),(2,NULL)`);
+    return eq(await scalar(`SELECT COUNT(*) AS c FROM t`), 2);
+  });
+  await t('删除后主键可复用', async ({ exec, scalar }) => {
+    await exec(`CREATE TABLE t (id INT PRIMARY KEY, v TEXT)`);
+    await exec(`INSERT INTO t VALUES (1,'a')`);
+    await exec(`DELETE FROM t WHERE id = 1`);
+    await exec(`INSERT INTO t VALUES (1,'c')`);
+    return eq(await scalar(`SELECT v FROM t WHERE id = 1`), 'c');
+  });
+
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail === 0 ? 0 : 1);
+})();

package/test/native-multi-instance.test.js

@@ -99,12 +99,16 @@ const hasHandles = typeof native.jsqlInstanceNew === 'function';
         const B = new JSQL({ path: dB, mode: 'hybrid' });
         await A.start();
         await B.start();
-        if (hasHandles) {
-            ok('JS 层已启用多实例', A._multiInstance === true);
-            ok('两实例句柄不同', A._handle !== B._handle, { a: A._handle, b: B._handle });
+        if (!hasHandles) {
+            // 旧版二进制没有句柄 API，两个 JS 实例会落到同一个默认实例上，
+            // 此时建同名表必然冲突 —— 只能验证「回退到单实例」这个事实本身。
+            ok('旧版二进制下回退单实例（_handle 为 null）', A._handle === null && B._handle === null);
+            skipTest('JS 层多实例并存测试', '旧版预编译二进制无 jsqlInstanceNew，两实例共享默认实例');
+            await A.stop();
+            await B.stop();
         } else {
-            ok('旧版二进制下回退单实例（_handle 为 null）', A._handle === null);
-        }
+        ok('JS 层已启用多实例', A._multiInstance === true);
+        ok('两实例句柄不同', A._handle !== B._handle, { a: A._handle, b: B._handle });
         await A.createTable('t', SCHEMA);
         await A.insert('t', { tag: 'A1' });
         await A.insert('t', { tag: 'A2' });
@@ -124,7 +128,8 @@ const hasHandles = typeof native.jsqlInstanceNew === 'function';
 
         await A.stop();
         await B.stop();
-        if (hasHandles) ok('stop 释放句柄', A._handle === null && B._handle === null);
+        ok('stop 释放句柄', A._handle === null && B._handle === null);
+        }   // else: hasHandles
         fs.rmSync(dA, { recursive: true, force: true });
         fs.rmSync(dB, { recursive: true, force: true });
     }

package/test/sql-parser.test.js

@@ -584,6 +584,195 @@ const rowsOf = (r) => (Array.isArray(r) ? r[0] : r).rows;
     ok('分组 + ORDER BY + LIMIT 只返回 1 行', lim.rows.length === 1 && lim.rows[0][0] === 'ops', lim.rows);
   }
 
+  /* ---- 括号分组后接运算符：曾报 Unexpected token '*' ---- */
+  console.log('\n--- BUG 修复: 括号分组参与后续运算 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // parseNot 的括号分组分支：解析到 ')' 就闭合返回，运算符留在流里
+    const cases = [
+      ['SELECT (1+2)*3 AS v', 9],
+      ['SELECT (3)*4 AS v', 12],
+      ['SELECT (1+2)*(3+4) AS v', 21],
+      ['SELECT (1+2)/2 AS v', 1.5],
+      ['SELECT 10-(2+3) AS v', 5],
+      ['SELECT (2+3)%2 AS v', 1],
+      ['SELECT (1+2)+3 AS v', 6],
+      ['SELECT ((1+2))*3 AS v', 9],      // 嵌套括号
+      ['SELECT (1+2) AS v', 3],         // 无运算符（回归对照）
+      ['SELECT 2*(3+4) AS v', 14],       // ( 在右操作数位置（回归对照）
+    ];
+    for (const [sql, expect] of cases) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+
+    // WHERE 里的括号同样要能参与比较
+    const w = await run(`SELECT name FROM emp WHERE (sal + 100) > 350 ORDER BY sal DESC`);
+    ok('WHERE (sal+100) > 350 括号参与比较',
+      w.rows.length === 2 && w.rows[0][0] === 'c' && w.rows[1][0] === 'd', w.rows);
+  }
+
+  /* ---- 聚合参与算术：SUM(x)/COUNT(*) 这类写法曾直接报错 ---- */
+  console.log('\n--- BUG 修复: 聚合函数参与算术运算 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // mock emp: eng(sal 100,200) / ops(sal 300,300)
+    // 全表 SUM=900 COUNT=4 AVG=225 MIN=100 MAX=300
+    const cases = [
+      ['SELECT SUM(sal)/COUNT(*) AS avg FROM emp', 225],   // 算平均值的标准写法
+      ['SELECT SUM(sal)-MIN(sal) AS range FROM emp', 800], // 极差
+      ['SELECT MAX(sal)*2 AS m FROM emp', 600],
+      ['SELECT SUM(sal)+1 AS s FROM emp', 901],
+      ['SELECT COUNT(*)*100 AS c FROM emp', 400],
+      ['SELECT SUM(sal)/COUNT(*) FROM emp', 225],         // 无别名
+    ];
+    for (const [sql, expect] of cases) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+
+    // 分组场景：分组路径也要能算 SUM/COUNT
+    const g = await run(`SELECT dept, SUM(sal)/COUNT(*) AS avg FROM emp GROUP BY dept ORDER BY avg DESC`);
+    ok('分组 + SUM/COUNT 每组各自的平均',
+      g.rows.length === 2 && g.rows[0][0] === 'ops' && g.rows[0][1] === 300
+      && g.rows[1][1] === 150, g.rows);
+
+    // 与其它聚合混用不能互相破坏
+    const m = await run(`SELECT SUM(sal)/COUNT(*) AS avg, MAX(sal) AS mx, MIN(sal) AS mn FROM emp`);
+    ok('SUM/COUNT 与 MAX/MIN 并存', m.rows[0][0] === 225 && m.rows[0][1] === 300 && m.rows[0][2] === 100, m.rows);
+
+    // 原有路径回归对照（不带运算符）
+    const s = await run(`SELECT SUM(sal) AS s, COUNT(*) AS c, AVG(sal) AS a FROM emp`);
+    ok('SUM/COUNT/AVG 单独使用不受影响', s.rows[0][0] === 900 && s.rows[0][1] === 4 && s.rows[0][2] === 225, s.rows);
+  }
+
+  /* ---- TIMESTAMPDIFF 整月差：曾按日历月差高估 ---- */
+  console.log('\n--- BUG 修复: TIMESTAMPDIFF 整月差语义 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // MySQL：先算日历月差，再按「结束日的日 < 起始日的日」退一档。
+    // 只算日历月差会高估，且 YEAR 同样受影响。
+    const cases = [
+      // [SQL 片段, 期望, 描述]
+      [`TIMESTAMPDIFF(MONTH,'2026-01-31','2026-03-01')`, 1, '月末出发不足整月'],
+      [`TIMESTAMPDIFF(MONTH,'2026-01-15','2026-03-14')`, 1, '差一月零29天不满两月'],
+      [`TIMESTAMPDIFF(MONTH,'2026-01-01','2026-03-01')`, 2, '月初对齐'],
+      [`TIMESTAMPDIFF(MONTH,'2026-01-15','2026-03-15')`, 2, '同日对齐'],
+      [`TIMESTAMPDIFF(YEAR,'2020-06-15','2026-06-14')`, 5, 'YEAR 差一天不满整年'],
+      [`TIMESTAMPDIFF(YEAR,'2020-06-15','2026-06-15')`, 6, 'YEAR 整年'],
+      [`TIMESTAMPDIFF(QUARTER,'2026-01-01','2026-07-01')`, 2, 'QUARTER 整季'],
+      [`TIMESTAMPDIFF(DAY,'2026-01-01','2026-03-01')`, 59, 'DAY 不受影响'],
+    ];
+    for (const [expr, expect, desc] of cases) {
+      let got = null, err = null;
+      try { got = (await run(`SELECT ${expr} AS v`)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${desc}: ${expr} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+  }
+
+  /* ---- 隐式类型转换：+ 必须是算术而非字符串拼接 ---- */
+  console.log('\n--- BUG 修复: 算术运算中的隐式类型转换 ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    // 语义已用 Python sqlite3 实测核对：'5'+5=10、'abc'+1=1、'a'+'b'=0
+    const cases = [
+      [`SELECT '5' + 5 AS v`, 10, '数字字符串 + 数字'],
+      [`SELECT 5 + '5' AS v`, 10, '数字 + 数字字符串'],
+      [`SELECT '5' + '5' AS v`, 10, '两个数字字符串'],
+      [`SELECT '2.5' * 2 AS v`, 5, '数字字符串乘法'],
+      [`SELECT '10' - 4 AS v`, 6, '数字字符串减法'],
+      [`SELECT 'abc' + 1 AS v`, 1, '非数字按 0（MySQL/SQLite 语义）'],
+      [`SELECT 'a' + 'b' AS v`, 0, '两侧都非数字返 0'],
+      [`SELECT 1 + 2 AS v`, 3, '纯数字回归对照'],
+    ];
+    for (const [sql, expect, desc] of cases) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${desc}: ${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+
+    // CAST(... AS SIGNED) 是 MySQL 整型别名，此前未列入整型分支，
+    // 导致 CAST('12abc' AS SIGNED) 原样返回字符串
+    const cast = [
+      [`SELECT CAST('12abc' AS SIGNED) AS v`, 12, 'SIGNED 取数字前缀'],
+      [`SELECT CAST('abc' AS SIGNED) AS v`, 0, 'SIGNED 非数字返 0'],
+      [`SELECT CAST(12.9 AS SIGNED) AS v`, 12, 'SIGNED 截断小数'],
+      [`SELECT CAST(12.9 AS INTEGER) AS v`, 12, 'INTEGER 回归对照'],
+    ];
+    for (const [sql, expect, desc] of cast) {
+      let got = null, err = null;
+      try { got = (await run(sql)).rows[0][0]; } catch (e) { err = e; }
+      ok(`${desc}: ${sql} = ${expect}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+  }
+
+  /* ---- CASE WHEN 裸值条件 + 补齐缺失的 MySQL 函数 ---- */
+  console.log('\n--- BUG 修复: CASE 裸值条件 / SIGN / TRUNCATE / SUBSTRING_INDEX ---');
+  {
+    const run = async (sql) => executeSQL(engine, sql, OPTS);
+    const one = async (sql) => (await run(sql)).rows[0][0];
+
+    // 搜索形式 CASE 的条件可能是裸值/裸列，此前 parseComparison 只收比较式
+    const caseCases = [
+      [`SELECT CASE WHEN 1 THEN 'a' ELSE 'b' END AS v`, 'a', 'CASE WHEN 裸数字'],
+      [`SELECT CASE WHEN 0 THEN 'a' ELSE 'b' END AS v`, 'b', 'CASE WHEN 假'],
+      [`SELECT CASE WHEN NULL THEN 'a' ELSE 'b' END AS v`, 'b', 'CASE WHEN NULL 走 ELSE'],
+      [`SELECT CASE WHEN 1=1 THEN 'a' ELSE 'b' END AS v`, 'a', 'CASE WHEN 比较式'],
+      [`SELECT CASE WHEN 1 IN (1,2) THEN 'y' ELSE 'n' END AS v`, 'y', 'CASE WHEN IN'],
+      [`SELECT CASE 2 WHEN 2 THEN 'y' ELSE 'n' END AS v`, 'y', 'CASE 简单形式'],
+    ];
+    for (const [sql, expect, desc] of caseCases) {
+      let got = null, err = null;
+      try { got = await one(sql); } catch (e) { err = e; }
+      ok(`${desc}`, err === null && got === expect, err ? String(err.message || err) : got);
+    }
+
+    // 缺失的 MySQL 函数
+    const fnCases = [
+      ['SIGN(-9)', -1, 'SIGN 负'], ['SIGN(9)', 1, 'SIGN 正'], ['SIGN(0)', 0, 'SIGN 零'],
+      ['TRUNCATE(3.987,2)', 3.98, 'TRUNCATE 截断而非四舍五入'],
+      ['TRUNCATE(-3.987,2)', -3.98, 'TRUNCATE 负数'],
+      [`SUBSTRING_INDEX('a.b.c','.',2)`, 'a.b', 'SUBSTRING_INDEX 取左'],
+      [`SUBSTRING_INDEX('a.b.c','.',-1)`, 'c', 'SUBSTRING_INDEX 取右'],
+      [`SUBSTRING_INDEX('a.b.c','.',0)`, '', 'SUBSTRING_INDEX 取 0 段'],
+    ];
+    for (const [expr, expect, desc] of fnCases) {
+      let got = null, err = null;
+      try { got = await one(`SELECT ${expr} AS v`); } catch (e) { err = e; }
+      ok(`${desc}: ${expr} = ${JSON.stringify(expect)}`, err === null && got === expect,
+        err ? String(err.message || err) : got);
+    }
+  }
+
+  /* ---- 列级 CHECK 约束：此前直接报 CREATE TABLE 语法错误 ---- */
+  console.log('\n--- BUG 修复: 列级 CHECK 约束解析 ---');
+  {
+    // 表级 CHECK 早已能解析（同样只是跳过），列级却会报
+    //   Expected ',' or ')' in CREATE TABLE, got 'CHECK'
+    // 因为 parseColumnDef 的 default 分支直接 return def，把 CHECK 留在流里。
+    // CHECK 刻意不在 KEYWORDS 里（避免影响同名标识符），要用 isWord 匹配。
+    const ddls = [
+      `CREATE TABLE ck1 (a INT CHECK(a > 0))`,
+      `CREATE TABLE ck2 (a INT CHECK(a > 0), b TEXT)`,
+      `CREATE TABLE ck3 (a INT NOT NULL CHECK(a > 0))`,
+      `CREATE TABLE ck4 (a TEXT, b INT CHECK(b > 0))`,
+      `CREATE TABLE ck5 (a INT, CHECK(a > 0))`,       // 表级（回归对照）
+      `CREATE TABLE ck6 (a INT UNIQUE CHECK(a > 0))`,
+    ];
+    for (const ddl of ddls) {
+      let err = null;
+      try { parseSQL(ddl); } catch (e) { err = e; }
+      ok(`可解析：${ddl}`, err === null, err ? String(err.message || err) : '');
+    }
+  }
+
   console.log(`\n${pass} passed, ${fail} failed`);
   process.exit(fail === 0 ? 0 : 1);
 })();