jsql-neo 6.5.28 → 6.5.29

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, **and the browser**.
 
-> **v6.5.28** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.5.29** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
 
 ![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)

package/index.js

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

package/lib/ast.js

@@ -128,40 +128,47 @@ function transform(ast, fn) {
   return visit(ast);
 }
 
-/** 原地改写：fn(node) 返回值非 undefined 时替换原节点。 */
+/**
+ * 原地改写：fn(node) 返回值非 undefined 时替换原节点。
+ *
+ * 根节点同样可替换（#58）：此前 visit 只在 `parent && key` 时才调用 fn 并回写，
+ * 根节点 parent===null 一律被跳过，于是 rewrite 无法替换整棵树，而 transform 可以。
+ * 现在数组容器本身作为父级传入（数组元素按 index 回写），根节点替换通过
+ * 返回值交回调用方。
+ */
 function rewrite(ast, fn) {
   const seen = new Set();
+  let root = ast;
+
+  const assign = (parent, key, value) => {
+    if (parent === null || parent === undefined) { root = value; return; }
+    parent[key] = value;
+  };
 
-  const visit = (value, parent, key, index) => {
+  const visit = (value, parent, key) => {
     if (value === null || typeof value !== 'object') {
-      if (parent && key) {
-        const r = fn(value);
-        if (r !== undefined) {
-          if (index === undefined) parent[key] = r; else parent[key][index] = r;
-        }
-      }
+      const r = fn(value);
+      if (r !== undefined) assign(parent, key, r);
       return;
     }
     if (seen.has(value)) return;
     seen.add(value);
 
     if (Array.isArray(value)) {
-      for (let i = 0; i < value.length; i++) visit(value[i], parent, key, i);
+      for (let i = 0; i < value.length; i++) visit(value[i], value, i);
       return;
     }
 
     for (const k of childKeys(value)) visit(value[k], value, k);
 
-    if (isNode(value) && parent && key) {
+    if (isNode(value)) {
       const r = fn(value);
-      if (r !== undefined) {
-        if (index === undefined) parent[key] = r; else parent[key][index] = r;
-      }
+      if (r !== undefined) assign(parent, key, r);
     }
   };
 
   visit(ast, null, null);
-  return ast;
+  return root;
 }
 
 /** 语句引用的所有表名（含 JOIN / 子查询）。 */

package/lib/btree.js

@@ -296,31 +296,37 @@ class BTree {
     remove(key, rowIndex) {
         if (!this._root) return false;
         const removed = this._removeFromNode(this._root, key, rowIndex);
-        // 删掉整个键（而非仅删某个 rowIndex）后，叶子的键域可能缩小，
-        // 沿途的分隔键副本可能已指向不存在的键 —— 自顶向下重建一次。
-        if (removed) {
+        // 返回值区分三种情况：
+        //   0        → 什么都没删（key 或 rowIndex 不存在）
+        //   1 / 'key'→ 整个键被删掉（该 key 的最后一个 rowIndex）
+        //   2 / 'row'→ 只删掉该 key 下的某一行，键仍在（#53）
+        // size 统计的是 distinct keys，所以只有「键消失」时才递减。
+        if (removed === 2) {
+            // 键仍存在，size 不变；分隔键也无需重建
+        } else if (removed) {
             this._size--;
             if (!this._root.leaf) this._fixSeparators(this._root);
         }
         if (this._root.keys.length === 0 && !this._root.leaf && this._root.children.length > 0) {
             this._root = this._root.children[0];
         }
-        return removed;
+        // 对外契约是布尔值：删掉了行就是 true（此前重复 key 场景错误地返回 false）
+        return !!removed;
     }
 
     _removeFromNode(node, key, rowIndex) {
         if (node.leaf) {
             const i = this._lowerBound(node.keys, key);
-            if (i >= node.keys.length || node.keys[i] !== key) return false;
-            if (!node.values[i].includes(rowIndex)) return false;
+            if (i >= node.keys.length || node.keys[i] !== key) return 0;
+            if (!node.values[i].includes(rowIndex)) return 0;
             const vals = node.values[i].filter(v => v !== rowIndex);
             if (vals.length === 0) {
                 node.keys.splice(i, 1);
                 node.values.splice(i, 1);
-                return true;
+                return 1;
             }
             node.values[i] = vals;
-            return false;
+            return 2;
         }
 
         let i = this._route(node, key);

package/lib/date-types.js

@@ -35,6 +35,25 @@ function validateDateType(value, type, fieldName) {
 
 function pad2(n) { return String(n).padStart(2, '0'); }
 
+/**
+ * 解析 ISO-8601 字符串尾部残余部分里的时区标记，返回「相对 UTC 的分钟偏移」。
+ * 输入形如 'Z'、'z'、'+08:00'、'-0500'、'.500Z'、' +02:00'。
+ * 没有时区标记（或无法识别）返回 null —— 调用方按本地时间字面值处理。
+ */
+function parseIsoTimezone(rest) {
+    let s = String(rest == null ? '' : rest).trim();
+    // 去掉小数秒
+    if (s.startsWith('.')) s = s.replace(/^\.\d+/, '');
+    if (s === 'Z' || s === 'z') return 0;
+    const m = s.match(/^([+-])(\d{2}):?(\d{2})$/);
+    if (!m) return null;
+    const hh = parseInt(m[2], 10);
+    const mm = parseInt(m[3], 10);
+    if (hh > 23 || mm > 59) return null;   // 非法偏移：交给后续校验报错
+    const sign = m[1] === '-' ? -1 : 1;
+    return sign * (hh * 60 + mm);
+}
+
 /**
  * 本地时区的 'YYYY-MM-DD'。
  * 不能用 toISOString().slice(0,10) —— 那是 UTC：东八区 2023-01-01 00:00 本地
@@ -115,7 +134,7 @@ function validateDateTime(value, fieldName) {
         return toLocalDateTimeString(new Date(value * 1000));
     }
     if (typeof value === 'string') {
-        // ISO format: 2024-01-15T10:30:00.000Z（带时区标记，按字面取日期+时间）
+        // ISO format: 2024-01-15T10:30:00.000Z / +08:00（可能带时区标记）
         const isoMatch = value.match(/^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})/);
         if (isoMatch) {
             // P2-35: 验证日期和时间有效性
@@ -129,6 +148,15 @@ function validateDateTime(value, fieldName) {
                 const dt = new Date(y, mo - 1, d);
                 if (dt.getFullYear() === y && dt.getMonth() === mo - 1 && dt.getDate() === d &&
                     h >= 0 && h < 24 && mi >= 0 && mi < 60 && s >= 0 && s < 60) {
+                    // #50：带 Z / ±HH:MM 时区标记时必须换算到本地时区。
+                    // 此前无条件按字面值存储，'2024-01-15T10:30:00Z'（UTC）在 UTC+8
+                    // 会被存成本地 10:30，整体偏 8 小时。
+                    const tz = parseIsoTimezone(value.slice(isoMatch[0].length));
+                    if (tz !== null) {
+                        const ms = Date.UTC(y, mo - 1, d, h, mi, s) - tz * 60000;
+                        return toLocalDateTimeString(new Date(ms));
+                    }
+                    // 无时区标记：按本地时间字面值（MySQL 语义）
                     return datePart + ' ' + timePart;
                 }
             }

package/lib/query.js

@@ -6,6 +6,36 @@
 
 const { createError } = require('./errors');
 
+/**
+ * 稳定序列化（#55）：把查询参数变成可比较的缓存键。
+ * 普通对象的键排序，函数/RegExp/BigInt/Date 保留可辨识信息，循环引用截断。
+ */
+function stableKey(value, seen) {
+    seen = seen || new Set();
+    if (value === null) return 'null';
+    const t = typeof value;
+    if (t === 'bigint') return value.toString() + 'n';
+    if (t === 'number') return Object.is(value, -0) ? '-0' : String(value);
+    if (t === 'string') return JSON.stringify(value);
+    if (t === 'boolean') return String(value);
+    if (t === 'undefined') return 'undefined';
+    if (t === 'function') return 'fn:' + String(value);
+    if (t === 'symbol') return 'sym:' + String(value);
+    if (value instanceof RegExp) return 're:' + value.source + '/' + value.flags;
+    if (value instanceof Date) return 'date:' + value.getTime();
+    if (seen.has(value)) return '[circular]';
+    seen.add(value);
+    let out;
+    if (Array.isArray(value)) {
+        out = '[' + value.map(v => stableKey(v, seen)).join(',') + ']';
+    } else {
+        out = '{' + Object.keys(value).sort()
+            .map(k => JSON.stringify(k) + ':' + stableKey(value[k], seen)).join(',') + '}';
+    }
+    seen.delete(value);
+    return out;
+}
+
 class Query {
     constructor(table, conditions = {}) {
         this._table = table;
@@ -210,12 +240,46 @@ class Query {
     // 缓存
     // ============================================================
 
+    /**
+     * 缓存键（#55）：必须覆盖所有影响结果的参数。
+     * 旧实现只按 TTL 判断，同一 Query 实例换 where/orderBy/limit/offset 后
+     * 仍命中旧缓存，返回过期结果。
+     */
+    _cacheKey(depth = 0) {
+        if (depth > 5) return '[deep]';
+        const joins = this._joins.map(j => ({
+            type: j.type,
+            table: j.table && (j.table._name || j.table.name) || j.table,
+            localField: j.localField,
+            foreignField: j.foreignField,
+            as: j.as,
+        }));
+        return stableKey({
+            table: this._table && this._table._name,
+            conditions: this._conditions,
+            orderBy: this._orderBy,
+            limit: this._limitCount,
+            offset: this._offsetCount,
+            select: this._selectFields,
+            groupBy: this._groupBy,
+            having: this._having,
+            distinct: this._distinct,
+            distinctField: this._distinctField,
+            joins,
+            union: this._union ? this._union._cacheKey(depth + 1) : null,
+            caseExpr: this._caseExpr,
+            caseAs: this._caseAs,
+            window: this._window,
+            forUpdate: this._forUpdate,
+        });
+    }
+
     /**
      * 缓存查询结果
      * @param {number} ttlMs - 缓存有效期（毫秒），默认 60000
      */
     cache(ttlMs = 60000) {
-        this._cache = { ttl: ttlMs, result: null, timestamp: 0 };
+        this._cache = { ttl: ttlMs, result: null, timestamp: 0, key: null };
         return this;
     }
 
@@ -227,8 +291,11 @@ class Query {
         const startTime = Date.now();
         if (this._explain) return this._getExplain();
 
+        // 缓存键要包含 where/orderBy/limit/offset 等全部参数（#55）
+        const cacheKey = this._cache ? this._cacheKey() : null;
         // 缓存命中: 返回每行的浅拷贝，与未命中路径一致，避免调用方修改污染缓存
-        if (this._cache && this._cache.result && (Date.now() - this._cache.timestamp < this._cache.ttl)) {
+        if (this._cache && this._cache.result && this._cache.key === cacheKey &&
+            (Date.now() - this._cache.timestamp < this._cache.ttl)) {
             // #37：命中返回副本，而不是内部数组引用——调用方对返回值做变更
             // （push/splice/改字段）会污染缓存；未命中路径返回的是新数组，行为应一致。
             return this._cache.result.map(row => (row && typeof row === 'object' ? { ...row } : row));
@@ -334,6 +401,7 @@ class Query {
         if (this._cache) {
             this._cache.result = rows.map(row => (row && typeof row === 'object' ? { ...row } : row));
             this._cache.timestamp = Date.now();
+            this._cache.key = cacheKey;
         }
 
         this._table._db._logSlowQuery(`get ${this._table._name}`, Date.now() - startTime, rows.length);
@@ -428,6 +496,7 @@ class Query {
         if (this._cache) {
             this._cache.result = null;
             this._cache.timestamp = 0;
+            this._cache.key = null;
         }
         return this;
     }

package/lib/sql.js

@@ -1533,7 +1533,25 @@ class Parser {
       this.expectKeyword('GROUP'); this.expectKeyword('BY');
       groupBy = [];
       while (true) {
-        groupBy.push(this.parseColumnRef());
+        // 支持表达式分组：GROUP BY a%2、GROUP BY UPPER(name)（#51）。
+        // 裸列名仍保留字符串形态，避免破坏既有别名解析与下游处理。
+        let g;
+        const save = this.pos;
+        const GROUP_END = ['HAVING', 'ORDER', 'LIMIT', 'OFFSET', 'UNION', 'INTERSECT',
+          'EXCEPT', 'RETURNING', 'WITH'];
+        const endsGroupItem = (tk) => {
+          if (tk.type === 'eof') return true;
+          if (tk.type === 'op' && (tk.value === ',' || tk.value === ';' || tk.value === ')')) return true;
+          return GROUP_END.some(w => this.isWord(w));
+        };
+        try {
+          g = this.parseColumnRef();
+          if (!endsGroupItem(this.peek())) { this.pos = save; g = this.parseScalar(); }
+        } catch (e) {
+          this.pos = save;
+          g = this.parseScalar();
+        }
+        groupBy.push(g);
         if (this.peek().type === 'op' && this.peek().value === ',') { this.next(); continue; }
         break;
       }
@@ -1631,6 +1649,17 @@ class Parser {
       else if (this.isKeyword('DISTINCT')) this.next();
       except = { all, select: this.parseSelect() };
     }
+    // 标准 SQL：组合查询尾部的 ORDER BY / LIMIT / OFFSET 作用于整个结果。
+    // 语法上它们会被解析进最右侧的 SELECT（#57），这里逐层提升到外层，
+    // 否则执行层在 concat 后直接返回，尾部子句被静默丢弃。
+    {
+      const rhsSel = (union || intersect || except || {}).select;
+      if (rhsSel) {
+        if (rhsSel.orderBy) { orderBy = rhsSel.orderBy; rhsSel.orderBy = null; }
+        if (rhsSel.limit !== null && rhsSel.limit !== undefined) { limit = rhsSel.limit; rhsSel.limit = null; }
+        if (rhsSel.offset) { offset = rhsSel.offset; rhsSel.offset = 0; }
+      }
+    }
     // FETCH FIRST n ROWS ONLY（SQL 标准的 LIMIT 写法）
     if (this.isWord('FETCH')) {
       this.next();
@@ -4964,6 +4993,24 @@ function evaluateCaseVal(caseExpr, row, ctx) {
   return caseExpr.elseVal ? resolveOperand(caseExpr.elseVal, row, ctx) : null;
 }
 
+/**
+ * 聚合参数的可读列名（#54）：c.column 通常是 AST 节点（{type:'column',name:'b'}），
+ * 直接字符串拼理会得到 "SUM([object Object])"。
+ */
+function columnLabel(col) {
+  if (col === undefined || col === null) return '*';
+  if (typeof col === 'string') return col;
+  if (typeof col === 'number' || typeof col === 'bigint') return String(col);
+  if (typeof col === 'object') {
+    if (col.type === 'column' && col.name !== undefined) return String(col.name);
+    if (col.type === 'star' || col.type === '*') return '*';
+    if (col.type === 'value' || col.type === 'literal') return String(col.value);
+    if (col.type === 'tuple' && Array.isArray(col.items)) return col.items.map(columnLabel).join(', ');
+    try { return scalarName(col); } catch (e) { return 'expr'; }
+  }
+  return String(col);
+}
+
 function scalarName(node) {
   if (!node) return 'expr';
   switch (node.type) {
@@ -4976,7 +5023,7 @@ function scalarName(node) {
     case 'literal': return String(node.value);
     case 'arith': return scalarName(node.left) + ' ' + node.op + ' ' + scalarName(node.right);
     case 'case': return 'CASE';
-    case 'aggregate': return node.fn + '(' + (node.column || '*') + ')';
+    case 'aggregate': return node.fn + '(' + columnLabel(node.column) + ')';
     default: return 'expr';
   }
 }
@@ -4989,7 +5036,7 @@ function scalarColumnName(c) {
   }
   if (c.alias) return c.alias;
   if (c.scalar) return scalarName(c.scalar);
-  if (c.aggregate) return c.alias || (c.aggregate === 'COUNT' ? 'COUNT(*)' : c.aggregate + '(' + c.column + ')');
+  if (c.aggregate) return c.alias || c.aggregate + '(' + columnLabel(c.column) + ')';
   if (c.literal !== undefined) return String(c.literal);
   if (c.caseExpr) return 'CASE';
   if (c.expr === '*') return '*';
@@ -5050,7 +5097,16 @@ function scalarColumnValue(c, r, ctx) {
   }
   
   if (c.literal !== undefined) return c.literal;
-  if (c.caseExpr) return projectScalar(evaluateCaseVal(c.caseExpr, r, ctx));
+  if (c.caseExpr) {
+    // CASE WHEN 内嵌聚合（#52）：先把聚合按当前分组替换成字面值，
+    // 否则 resolveOperand 不认识 aggregate 节点，条件恒为假 → 恒走 ELSE。
+    if (ctx && ctx._replaceAggregates && containsAggregateNode(c.caseExpr)) {
+      const copy = JSON.parse(JSON.stringify(c.caseExpr));
+      ctx._replaceAggregates(copy, ctx.group || [r]);
+      return projectScalar(evaluateCaseVal(copy, r, ctx));
+    }
+    return projectScalar(evaluateCaseVal(c.caseExpr, r, ctx));
+  }
   if (c.expr === '*') return r[Object.keys(r).find(k => !k.startsWith('_'))];
   return projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, ctx));
 }
@@ -6524,13 +6580,42 @@ class SQLExecutor {
         return typeof agg.result === 'function' ? agg.result(state) : state;
       }
     }
+    // 整数精确累加（#56）：SUM/AVG 若全为整数，用 BigInt 累加，
+    // 避免 >2^53 时 Number 浮点加法把 9007199254740993 + 9007199254740992
+    // 舍入成 18014398509481984。结果在安全范围内仍返回 number。
+    const exactIntSum = () => {
+      let total = 0n;
+      for (const v of values) {
+        if (typeof v === 'bigint') { total += v; continue; }
+        if (typeof v === 'number' && Number.isInteger(v)) { total += BigInt(v); continue; }
+        if (typeof v === 'string' && /^[-+]?\d+$/.test(v.trim())) {
+          try { total += BigInt(v.trim()); continue; } catch (e) { return undefined; }
+        }
+        return undefined;
+      }
+      return total;
+    };
+    const SAFE_MAX = BigInt(Number.MAX_SAFE_INTEGER);
+    const SAFE_MIN = BigInt(Number.MIN_SAFE_INTEGER);
     if (fn === 'SUM') {
       // MySQL 语义：空集（或无任何非 NULL 值）的 SUM 为 NULL，而非 0。
       // AVG/MIN/MAX 已按此处理，此前只有 SUM 漏了。
       if (!values.length) return null;
+      const exact = exactIntSum();
+      if (exact !== undefined) {
+        return (exact >= SAFE_MIN && exact <= SAFE_MAX) ? Number(exact) : exact;
+      }
       return values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0);
     }
-    if (fn === 'AVG') return values.length ? values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0) / values.length : null;
+    if (fn === 'AVG') {
+      if (!values.length) return null;
+      const exact = exactIntSum();
+      if (exact !== undefined) {
+        // 先精确求和，再除以行数；Number(total) 只在最后一步转换
+        return Number(exact) / values.length;
+      }
+      return values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0) / values.length;
+    }
     if (fn === 'MIN' || fn === 'MAX') {
       const vs = values.filter(v => v !== null && v !== undefined);
       if (!vs.length) return null;
@@ -7327,36 +7412,108 @@ class SQLExecutor {
     return statement;
   }
 
+  /**
+   * 组合查询（UNION/INTERSECT/EXCEPT）尾部的 ORDER BY / LIMIT / OFFSET（#57）。
+   * 此时 rows 已是投影后的数组，排序键按左分支列名或 1-based 列序号解析。
+   */
+  _finalizeSetOp(rows, columns, statement) {
+    let out = rows;
+    const orderBy = statement.orderBy;
+    if (Array.isArray(orderBy) && orderBy.length) {
+      const idxOf = (name) => {
+        const n = String(name).toLowerCase();
+        for (let i = 0; i < columns.length; i++) {
+          if (String(columns[i]).toLowerCase() === n) return i;
+        }
+        return -1;
+      };
+      const objOf = (r) => {
+        if (r && !Array.isArray(r) && typeof r === 'object') return r;
+        const o = {};
+        for (let i = 0; i < columns.length; i++) o[columns[i]] = r ? r[i] : undefined;
+        return o;
+      };
+      const keyed = out.map((r, i) => ({ r, i, o: objOf(r) }));
+      const keyOf = (entry, o) => {
+        const c = o.column;
+        if (typeof c === 'number') {
+          if (c >= 1 && c <= columns.length) return entry.r[c - 1];
+          throw new Error(`ORDER BY position ${c} is out of range`);
+        }
+        if (typeof c === 'string' || (c && (c.type === 'column' || (c.type === 'value' && typeof c.value === 'number')))) {
+          if (c && c.type === 'value') {
+            const n = Number(c.value);
+            if (n >= 1 && n <= columns.length) return entry.r[n - 1];
+            throw new Error(`ORDER BY position ${n} is out of range`);
+          }
+          const name = typeof c === 'string' ? c : c.name;
+          const idx = idxOf(name);
+          if (idx === -1) throw new Error(`no such column: ${name}`);
+          return entry.r[idx];
+        }
+        // 表达式排序：按列名构造对象后求值
+        return resolveOperand(c, entry.o, this.ctx);
+      };
+      keyed.sort((a, b) => {
+        for (const o of orderBy) {
+          const av = keyOf(a, o);
+          const bv = keyOf(b, o);
+          if (av === bv) continue;
+          const aNull = av === null || av === undefined;
+          const bNull = bv === null || bv === undefined;
+          if (aNull || bNull) {
+            const r = aNull && bNull ? 0 : (aNull ? -1 : 1);
+            return o.dir === 'desc' ? -r : r;
+          }
+          const d = typeof av === 'number' && typeof bv === 'number'
+            ? av - bv : String(av).localeCompare(String(bv));
+          if (d !== 0) return o.dir === 'desc' ? -d : d;
+        }
+        return a.i - b.i;
+      });
+      out = keyed.map(x => x.r);
+    }
+    if (statement.offset) out = out.slice(statement.offset);
+    if (statement.limit !== null && statement.limit !== undefined) out = out.slice(0, statement.limit);
+    return out;
+  }
+
   async executeSelect(statement) {
     // 视图：FROM 里的视图名展开成子查询
     if (this.engine && this.engine._views) this._expandViews(statement);
 
+    // 集合运算：左分支不应用尾部 ORDER BY/LIMIT/OFFSET（它们属于整个组合结果）
+    const setOpBase = { orderBy: null, limit: null, offset: 0, fetch: undefined };
+
     // UNION 处理
     if (statement.union) {
-      const left = await this.executeSelect({ ...statement, union: null });
+      const left = await this.executeSelect({ ...statement, ...setOpBase, union: null });
       const right = await this.executeSelect(statement.union.select);
       let rows = left.rows.concat(right.rows);
       if (!statement.union.all) rows = dedupeRows(rows);
+      rows = this._finalizeSetOp(rows, left.columns, statement);
       return { ok: true, type: 'select', columns: left.columns, rows, raw: rows };
     }
 
     // INTERSECT：保留同时出现在右侧结果中的行（默认 DISTINCT，与 UNION 的处理保持一致）
     if (statement.intersect) {
-      const left = await this.executeSelect({ ...statement, intersect: null, except: null });
+      const left = await this.executeSelect({ ...statement, ...setOpBase, intersect: null, except: null });
       const right = await this.executeSelect(statement.intersect.select);
       const seen = new Set(right.rows.map(r => JSON.stringify(r)));
       let out = left.rows.filter(r => seen.has(JSON.stringify(r)));
       if (!statement.intersect.all) out = dedupeRows(out);
+      out = this._finalizeSetOp(out, left.columns, statement);
       return { ok: true, type: 'select', columns: left.columns, rows: out, raw: out };
     }
 
     // EXCEPT：去掉出现在右侧结果中的行（默认 DISTINCT）
     if (statement.except) {
-      const left = await this.executeSelect({ ...statement, intersect: null, except: null });
+      const left = await this.executeSelect({ ...statement, ...setOpBase, intersect: null, except: null });
       const right = await this.executeSelect(statement.except.select);
       const seen = new Set(right.rows.map(r => JSON.stringify(r)));
       let out = left.rows.filter(r => !seen.has(JSON.stringify(r)));
       if (!statement.except.all) out = dedupeRows(out);
+      out = this._finalizeSetOp(out, left.columns, statement);
       return { ok: true, type: 'select', columns: left.columns, rows: out, raw: out };
     }
 
@@ -7555,7 +7712,8 @@ class SQLExecutor {
       // 此前全用 resolveOperand({type:'column', name:g}) 按列名取，导致 GROUP BY b
       // 取 row['b']，而原始行里没有 b 列（b 是别名），全返回 undefined 并成一组。
       const aliases = {};        // alias名字 → true（存在性检查用）
-      const aliasToCol = {};     // alias名字 → 对应的表达式（用于从原始行取值）
+      const aliasToCol = {};     // alias名字 → 对应的列名（用于从原始行取值）
+      const aliasExpr = {};      // alias名字 → 对应的表达式 AST（GROUP BY 表达式别名，#51）
       if (statement.columns) {
         for (const c of statement.columns) {
           if (c.alias) {
@@ -7565,18 +7723,28 @@ class SQLExecutor {
             // expr 可能是字符串 'a'（列名）或对象 {type:'column', name:'a'}
             if (typeof src === 'string') aliasToCol[c.alias.toLowerCase()] = src;
             else if (src && src.type === 'column') aliasToCol[c.alias.toLowerCase()] = src.name;
+            else if (src && typeof src === 'object') aliasExpr[c.alias.toLowerCase()] = src;
           }
         }
       }
       const groups = new Map();
       for (const row of rows) {
         const key = JSON.stringify(statement.groupBy.map(g => {
+          // 表达式分组（#51）：直接对原始行求值表达式
+          if (g && typeof g === 'object') {
+            const v = resolveOperand(g, row, this.ctx);
+            return typeof v === 'bigint' ? v.toString() + 'n' : v;
+          }
           const key = String(g).toLowerCase();
           if (aliases[key]) {
             // 优先用行中已有的 alias 值（投影后才有），没有则尝试从原始列取值
             if (row[key] !== undefined) return row[key];
             // alias → 原始列名 的映射（如 b → a），从原始行取该列的值
             if (aliasToCol[key]) return resolveOperand({ type: 'column', name: aliasToCol[key] }, row, this.ctx);
+            if (aliasExpr[key]) {
+              const v = resolveOperand(aliasExpr[key], row, this.ctx);
+              return typeof v === 'bigint' ? v.toString() + 'n' : v;
+            }
             return row[key];   // row[key] 为 undefined，但保持一致
           }
           return resolveOperand({ type: 'column', name: g }, row, this.ctx);
@@ -7647,7 +7815,14 @@ class SQLExecutor {
             return allKeys.map(k => r[k]);
           }
           if (c.scalar) return resolveOperand(c.scalar, r, this.ctx);
-          if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);
+          if (c.caseExpr) {
+            if (containsAggregateNode(c.caseExpr)) {
+              const cc = JSON.parse(JSON.stringify(c.caseExpr));
+              this._replaceAggregates(cc, r._group || [r]);
+              return evaluateCaseVal(cc, r, this.ctx);
+            }
+            return evaluateCaseVal(c.caseExpr, r, this.ctx);
+          }
           if (c.aggregate) return this._aggValue(r._group || [r], c.aggregate || 'COUNT', c.column, c.distinct, c.separator, c.orderBy);
           return resolveOperand({ type: 'column', name: c.expr }, r, this.ctx);
         }));
@@ -7663,7 +7838,8 @@ class SQLExecutor {
     // 无 GROUP BY 的整表聚合：顶层是聚合（AVG(x)）、自定义聚合（total(x)），
     // 以及嵌套聚合（ROUND(AVG(x),1) —— 聚合藏在 scalar 的参数里，顶层 c.aggregate 为空）
     const hasNestedAgg = !statement.groupBy &&
-      statement.columns.some(c => c.scalar && containsAggregateNode(c.scalar));
+      statement.columns.some(c => (c.scalar && containsAggregateNode(c.scalar)) ||
+        (c.caseExpr && containsAggregateNode(c.caseExpr)));
     if (!statement.groupBy && (statement.columns.some(c => c.aggregate && !c.window) || hasCustomAgg || hasNestedAgg)) {
       const cols = statement.columns.map(c => scalarColumnName(c));
       const tableName2 = statement.from ? (statement.from.tables[0].table || null) : null;
@@ -7688,7 +7864,15 @@ class SQLExecutor {
           }
           return projectScalar(resolveOperand(c.scalar, rows[0] || {}, this.ctx));
         }
-        if (c.caseExpr) return projectScalar(resolveOperand(c.caseExpr, rows[0] || {}, this.ctx));
+        if (c.caseExpr) {
+          // CASE 内嵌聚合按整表求值替换（#52）
+          if (containsAggregateNode(c.caseExpr)) {
+            const nestedCase = JSON.parse(JSON.stringify(c.caseExpr));
+            this._replaceAggregates(nestedCase, rows);
+            return projectScalar(evaluateCaseVal(nestedCase, rows[0] || {}, this.ctx));
+          }
+          return projectScalar(evaluateCaseVal(c.caseExpr, rows[0] || {}, this.ctx));
+        }
         if (c.expr !== null && c.expr !== '*') return rows[0] ? projectScalar(resolveOperand({ type: 'column', name: c.expr }, rows[0])) : null;
         return null;
       };

package/native/.installed.json

@@ -0,0 +1,8 @@
+{
+  "tag": "v6.5.29",
+  "sha256": "e39295e4bd4f2b705a8b686454c5f2bbe519261bc839810185775146acbadcde",
+  "packageVersion": "6.5.29",
+  "installedAt": "2026-11-09T04:35:25.960Z",
+  "platform": "linux",
+  "arch": "x64"
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jsql-neo",
-  "version": "6.5.28",
-  "description": "JSQL-NEO \u2014 Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
+  "version": "6.5.29",
+  "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
   "exports": {
@@ -50,12 +50,12 @@
   "scripts": {
     "postinstall": "node postinstall.js",
     "build:native": "node scripts/build-native.js",
-    "test": "node test/smoke.js && node test/result-raw.test.js && node test/native-install.test.js && node test/native-cli.test.js && node test/finalize-bigint.test.js && node test/native.test.js && node test/json-functions.test.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js && node test/star-nag.test.js && node test/plugin-xql.test.js && node test/bug-regression-2.test.js && node test/issue-34-35-36.test.js && node test/issue-g4.test.js && node test/issue-38.test.js && node test/issue-39.test.js && node test/issue-40.test.js && node test/issue-44.test.js && node test/issue-45.test.js && node test/issue-46.test.js && node test/issue-47.test.js && node test/issue-48.test.js",
+    "test": "node test/smoke.js && node test/result-raw.test.js && node test/native-install.test.js && node test/native-cli.test.js && node test/finalize-bigint.test.js && node test/native.test.js && node test/json-functions.test.js && node test/sql-parser.test.js && node test/readme-audit.test.js && node test/query-opt.test.js && node test/wal-recovery.test.js && node test/mysql-compat-hijack.test.js && node test/dml-constraints.test.js && node test/star-nag.test.js && node test/plugin-xql.test.js && node test/bug-regression-2.test.js && node test/issue-34-35-36.test.js && node test/issue-g4.test.js && node test/issue-38.test.js && node test/issue-39.test.js && node test/issue-40.test.js && node test/issue-44.test.js && node test/issue-45.test.js && node test/issue-46.test.js && node test/issue-47.test.js && node test/issue-48.test.js && node test/issue-50.test.js && node test/issue-51.test.js && node test/issue-52.test.js && node test/issue-53.test.js && node test/issue-54.test.js && node test/issue-55.test.js && node test/issue-56.test.js && node test/issue-57.test.js && node test/issue-58.test.js",
     "test:parser": "node test/sql-parser.test.js",
     "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/result-raw.test.js && node test/native-install.test.js && node test/native-cli.test.js && node test/finalize-bigint.test.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 && node test/savepoint.test.js && node test/alter-table.test.js && node test/null-semantics.test.js && node test/identifier-keywords.test.js && node test/issue-34-35-36.test.js && node test/sql-semantics.test.js && node test/extra-coverage.test.js && node test/filter-compile.test.js && node test/recursive-cte.test.js && node test/index-ddl.test.js && node test/mongo-group.test.js && node test/multiprotocol.test.js && node test/issue-g4.test.js && node test/issue-38.test.js && node test/issue-39.test.js && node test/issue-40.test.js && node test/issue-44.test.js && node test/issue-45.test.js && node test/issue-46.test.js && node test/issue-47.test.js && node test/issue-48.test.js",
+    "test:all": "node test/smoke.js && node test/result-raw.test.js && node test/native-install.test.js && node test/native-cli.test.js && node test/finalize-bigint.test.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 && node test/savepoint.test.js && node test/alter-table.test.js && node test/null-semantics.test.js && node test/identifier-keywords.test.js && node test/issue-34-35-36.test.js && node test/sql-semantics.test.js && node test/extra-coverage.test.js && node test/filter-compile.test.js && node test/recursive-cte.test.js && node test/index-ddl.test.js && node test/mongo-group.test.js && node test/multiprotocol.test.js && node test/issue-g4.test.js && node test/issue-38.test.js && node test/issue-39.test.js && node test/issue-40.test.js && node test/issue-44.test.js && node test/issue-45.test.js && node test/issue-46.test.js && node test/issue-47.test.js && node test/issue-48.test.js && node test/issue-50.test.js && node test/issue-51.test.js && node test/issue-52.test.js && node test/issue-53.test.js && node test/issue-54.test.js && node test/issue-55.test.js && node test/issue-56.test.js && node test/issue-57.test.js && node test/issue-58.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:dml": "node test/dml-constraints.test.js",
@@ -103,4 +103,4 @@
   "devDependencies": {
     "c8": "^10.1.2"
   }
-}
+}

package/test/issue-50.test.js

@@ -0,0 +1,83 @@
+/*
+ * Issue #50 — DATETIME 列把 ISO-8601 的 Z / 时区偏移当成本地时间原样存储。
+ *
+ * '2024-01-15T10:30:00Z' 表示 UTC 10:30，在 UTC+8 环境落库应为 '2024-01-15 18:30:00'，
+ * 而不是丢掉 Z 变成 10:30:00。不带时区标记的写法仍按本地时间字面值处理（MySQL 语义）。
+ *
+ * 注意：断言按运行环境时区动态计算期望值，CI 在 UTC 下同样成立。
+ */
+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'));
+
+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).slice(0, 300) : ''); }
+}
+
+const pad2 = (n) => String(n).padStart(2, '0');
+function localStr(utcMs) {
+  const d = new Date(utcMs);
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ` +
+    `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`;
+}
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, { safety: false });
+  await q('CREATE TABLE t (id INTEGER PRIMARY KEY, dt DATETIME)');
+
+  // 1) 带 Z：UTC → 本地
+  await q("INSERT INTO t (id, dt) VALUES (1, '2024-01-15T10:30:00Z')");
+  let r = await q('SELECT dt FROM t WHERE id = 1');
+  const expectZ = localStr(Date.parse('2024-01-15T10:30:00Z'));
+  ok('#50 ISO Z 按 UTC 转本地时区', r.rows[0][0] === expectZ, { got: r.rows[0][0], want: expectZ });
+  if (new Date().getTimezoneOffset() === -480) {
+    ok('#50 UTC+8 下 Z 时间 +8 小时', r.rows[0][0] === '2024-01-15 18:30:00', r.rows[0][0]);
+  }
+
+  // 2) 带正偏移 +02:00
+  await q("INSERT INTO t (id, dt) VALUES (2, '2024-01-15T10:30:00+02:00')");
+  r = await q('SELECT dt FROM t WHERE id = 2');
+  const expectPlus2 = localStr(Date.parse('2024-01-15T10:30:00+02:00'));
+  ok('#50 ISO +02:00 偏移正确换算', r.rows[0][0] === expectPlus2, { got: r.rows[0][0], want: expectPlus2 });
+
+  // 3) 带负偏移 -05:00
+  await q("INSERT INTO t (id, dt) VALUES (3, '2024-01-15T10:30:00-05:00')");
+  r = await q('SELECT dt FROM t WHERE id = 3');
+  const expectMinus5 = localStr(Date.parse('2024-01-15T10:30:00-05:00'));
+  ok('#50 ISO -05:00 偏移正确换算', r.rows[0][0] === expectMinus5, { got: r.rows[0][0], want: expectMinus5 });
+
+  // 4) 带毫秒 + Z
+  await q("INSERT INTO t (id, dt) VALUES (4, '2024-01-15T10:30:00.500Z')");
+  r = await q('SELECT dt FROM t WHERE id = 4');
+  ok('#50 带毫秒的 Z 同样换算（毫秒截断）', r.rows[0][0] === expectZ, r.rows[0][0]);
+
+  // 5) 不带时区标记：仍是字面值（本地时间），不能被当成 UTC
+  await q("INSERT INTO t (id, dt) VALUES (5, '2024-01-15T10:30:00')");
+  await q("INSERT INTO t (id, dt) VALUES (6, '2024-01-15 10:30:00')");
+  r = await q('SELECT dt FROM t WHERE id IN (5,6)');
+  ok('#50 无时区的 ISO 串按字面值保存', r.rows[0][0] === '2024-01-15 10:30:00', r.rows[0][0]);
+  ok('#50 MySQL 格式原样保留', r.rows[1][0] === '2024-01-15 10:30:00', r.rows[1][0]);
+
+  // 6) 纯日期列不受影响
+  await q('CREATE TABLE d (id INTEGER PRIMARY KEY, dd DATE)');
+  await q("INSERT INTO d (id, dd) VALUES (1, '2024-01-15')");
+  r = await q('SELECT dd FROM d');
+  ok('#50 DATE 列行为不变', r.rows[0][0] === '2024-01-15', r.rows[0][0]);
+
+  // 7) 直接调用 date-types 的规范化函数
+  const { validateDateType } = require(path.join(ROOT, 'lib', 'date-types.js'));
+  ok('#50 validateDateType datetime Z',
+    validateDateType('2024-01-15T10:30:00Z', 'datetime', 'dt') === expectZ,
+    validateDateType('2024-01-15T10:30:00Z', 'datetime', 'dt'));
+  ok('#50 validateDateType 非法日期仍报错',
+    (() => { try { validateDateType('2024-13-45T10:30:00Z', 'datetime', 'dt'); return false; } catch (e) { return true; } })());
+})();
+
+setTimeout(() => {
+  console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+  if (fail > 0) process.exit(1);
+}, 10);

package/test/issue-51.test.js

@@ -0,0 +1,56 @@
+/*
+ * Issue #51 — GROUP BY <expression> 崩溃。
+ *
+ * GROUP BY 解析此前只接受裸列引用（parseColumnRef），遇到 a%2、b+1 这类表达式
+ * 会在 GROUP BY 之后报 "Unexpected token ... after statement"。
+ * 修复后应支持任意标量表达式分组，且结果正确。
+ */
+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'));
+
+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).slice(0, 400) : ''); }
+}
+const norm = (rows) => rows.map(r => r.map(v => (typeof v === 'bigint' ? Number(v) : v))).sort((a, b) => String(a[0]).localeCompare(String(b[0])));
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, { safety: false });
+  await q('CREATE TABLE g (id INTEGER PRIMARY KEY, a INTEGER, b INTEGER)');
+  await q('INSERT INTO g VALUES (1,1,10),(2,2,20),(3,3,30),(4,4,40)');
+
+  let r = await q('SELECT a%2 AS p, COUNT(*) FROM g GROUP BY a%2');
+  ok('#51 GROUP BY a%2 不抛错且结果正确',
+    JSON.stringify(norm(r.rows)) === JSON.stringify([[0, 2], [1, 2]]), r.rows);
+
+  r = await q('SELECT a%2 AS p, COUNT(*) FROM g GROUP BY p');
+  ok('#51 GROUP BY 别名仍然可用',
+    JSON.stringify(norm(r.rows)) === JSON.stringify([[0, 2], [1, 2]]), r.rows);
+
+  r = await q('SELECT b+1 AS bp, COUNT(*) FROM g GROUP BY b+1');
+  ok('#51 GROUP BY 算术表达式 b+1',
+    JSON.stringify(norm(r.rows)) === JSON.stringify([[11, 1], [21, 1], [31, 1], [41, 1]]), r.rows);
+
+  r = await q("SELECT UPPER('x') AS u, COUNT(*) FROM g GROUP BY UPPER('x')");
+  ok('#51 GROUP BY 函数表达式', r.rows.length === 1 && Number(r.rows[0][1]) === 4, r.rows);
+
+  r = await q('SELECT a%2 AS p, SUM(b) AS s FROM g GROUP BY a%2 ORDER BY p');
+  ok('#51 表达式分组 + 聚合 + ORDER BY',
+    JSON.stringify(norm(r.rows)) === JSON.stringify([[0, 60], [1, 40]]), r.rows);
+
+  r = await q('SELECT a%2 AS p, COUNT(*) FROM g GROUP BY a%2 HAVING COUNT(*) > 2');
+  ok('#51 表达式分组 + HAVING', r.rows.length === 0, r.rows);
+
+  r = await q('SELECT a, COUNT(*) FROM g GROUP BY a');
+  ok('#51 朴素列分组未被破坏', r.rows.length === 4, r.rows);
+
+  r = await q('SELECT a, b, COUNT(*) FROM g GROUP BY a, b');
+  ok('#51 多列分组未被破坏', r.rows.length === 4, r.rows);
+
+  console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+  if (fail > 0) process.exit(1);
+})();

package/test/issue-52.test.js

@@ -0,0 +1,62 @@
+/*
+ * Issue #52 — CASE WHEN 内嵌聚合恒为 0。
+ *
+ * `SELECT CASE WHEN COUNT(*) > 2 THEN 1 ELSE 0 END FROM t` 中，
+ * 聚合节点没有按分组求值替换（resolveOperand 看不到 aggregate → null → 条件为假），
+ * 且无 GROUP BY 时整表聚合识别只检查 c.scalar，漏了 c.caseExpr，
+ * 于是输出逐行 0 而不是一行 1。
+ */
+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'));
+
+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).slice(0, 400) : ''); }
+}
+const j = (rows) => JSON.stringify(rows, (k, v) => (typeof v === 'bigint' ? v.toString() + 'n' : v));
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, { safety: false });
+  await q('CREATE TABLE t (id INTEGER PRIMARY KEY, v INTEGER, g TEXT)');
+  await q("INSERT INTO t VALUES (1,1,'a'),(2,2,'a'),(3,3,'b'),(4,4,'b')");
+
+  let r = await q('SELECT CASE WHEN COUNT(*)>2 THEN 1 ELSE 0 END FROM t');
+  ok('#52 整表聚合 CASE WHEN COUNT(*)>2 => [[1]]', j(r.rows) === j([[1]]), r.rows);
+
+  r = await q('SELECT CASE WHEN COUNT(*)>10 THEN 1 ELSE 0 END FROM t');
+  ok('#52 条件为假走 ELSE => [[0]]', j(r.rows) === j([[0]]), r.rows);
+
+  r = await q('SELECT CASE WHEN SUM(v)>6 THEN 1 ELSE 0 END AS f FROM t');
+  ok('#52 SUM 内嵌 CASE', j(r.rows) === j([[1]]), r.rows);
+
+  r = await q('SELECT CASE WHEN SUM(v)>100 THEN 1 ELSE 0 END AS f FROM t');
+  ok('#52 SUM 条件为假', j(r.rows) === j([[0]]), r.rows);
+
+  r = await q('SELECT CASE WHEN COUNT(*)>2 THEN COUNT(*) ELSE 0 END FROM t');
+  ok('#52 THEN 分支也是聚合 => [[4]]', j(r.rows) === j([[4]]), r.rows);
+
+  r = await q('SELECT CASE WHEN COUNT(*)>2 THEN 1 ELSE 0 END AS f FROM t GROUP BY g');
+  ok('#52 GROUP BY 路径每组计数=2，条件假', j(r.rows) === j([[0], [0]]), r.rows);
+
+  r = await q('SELECT CASE WHEN COUNT(*)>=2 THEN 1 ELSE 0 END AS f FROM t GROUP BY g');
+  ok('#52 GROUP BY 路径每组计数=2，条件真 => [[1],[1]]', j(r.rows) === j([[1], [1]]), r.rows);
+
+  r = await q('SELECT g, CASE WHEN SUM(v)>3 THEN 1 ELSE 0 END AS f FROM t GROUP BY g');
+  ok('#52 GROUP BY 每组 SUM', j(r.rows) === j([['a', 0], ['b', 1]]), r.rows);
+
+  r = await q('SELECT CASE WHEN MAX(v)>=4 THEN 1 ELSE 0 END FROM t');
+  ok('#52 MAX 内嵌 CASE', j(r.rows) === j([[1]]), r.rows);
+
+  r = await q('SELECT COUNT(*) AS c, CASE WHEN COUNT(*)>2 THEN 1 ELSE 0 END AS f FROM t');
+  ok('#52 普通聚合列与 CASE 聚合列共存', j(r.rows) === j([[4, 1]]), r.rows);
+
+  r = await q('SELECT CASE WHEN COUNT(*)>2 THEN 1 ELSE 0 END AS f FROM t HAVING CASE WHEN COUNT(*)>2 THEN 1 ELSE 0 END = 1');
+  ok('#52 HAVING 里的 CASE 聚合', j(r.rows) === j([[1]]), r.rows);
+
+  console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+  if (fail > 0) process.exit(1);
+})();

package/test/issue-53.test.js

@@ -0,0 +1,50 @@
+/*
+ * Issue #53 — BTree.remove(key, rowIndex) 在「同一 key 挂着多行」时返回 false，
+ * 即使那一行确实被删掉了。返回契约错误，调用方（索引维护）会以为删除失败。
+ */
+const path = require('path');
+const BTree = require(path.join(__dirname, '..', 'lib', 'btree.js'));
+
+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).slice(0, 300) : ''); }
+}
+
+try {
+  // 最小复现
+  const t = new BTree(4);
+  t.insert(46, 17);
+  t.insert(46, 18);
+
+  const r = t.remove(46, 17);
+  ok('#53 删除重复 key 中的一行返回 true', r === true, r);
+  ok('#53 剩余行仍可查到', JSON.stringify(t.search(46)) === JSON.stringify([18]), t.search(46));
+  ok('#53 size 正确递减', t.size === 1, t.size);
+
+  // 再删剩下的那一行：key 整个消失
+  const r2 = t.remove(46, 18);
+  ok('#53 删掉最后一行返回 true', r2 === true, r2);
+  ok('#53 key 已不存在', JSON.stringify(t.search(46)) === JSON.stringify([]), t.search(46));
+  ok('#53 size 归零', t.size === 0, t.size);
+
+  // 删不存在的行仍返回 false
+  t.insert(7, 1);
+  ok('#53 行号不存在返回 false', t.remove(7, 99) === false);
+  ok('#53 不存在的 key 返回 false', t.remove(12345, 1) === false);
+  ok('#53 误删后数据完好', JSON.stringify(t.search(7)) === JSON.stringify([1]), t.search(7));
+
+  // 大量重复 key + 删除，条目不应丢失
+  const big = new BTree(4);
+  for (let i = 0; i < 40; i++) big.insert(5, i);
+  for (let i = 0; i < 20; i++) ok(`#53 重复 key 批量删除第${i}行返回 true`, big.remove(5, i) === true);
+  const left = big.search(5);
+  ok('#53 批量删除后剩余行完整', JSON.stringify(left) === JSON.stringify(Array.from({ length: 20 }, (_, i) => i + 20)), left);
+  ok('#53 批量删除后 size 按 distinct keys 计（1）', big.size === 1, big.size);
+} catch (e) {
+  fail++;
+  console.log('[FAIL] unexpected exception:', (e && e.stack) || e);
+}
+
+console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+if (fail > 0) process.exit(1);

package/test/issue-54.test.js

@@ -0,0 +1,53 @@
+/*
+ * Issue #54 — 未起别名的聚合列列名是 "SUM([object Object])"。
+ *
+ * scalarColumnName 对 c.aggregate 直接做字符串拼接，而 c.column 是 AST 节点对象，
+ * 于是被 String() 成 "[object Object]"。应输出 "SUM(b)"。
+ */
+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'));
+
+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).slice(0, 300) : ''); }
+}
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, { safety: false });
+  await q('CREATE TABLE s (id INTEGER PRIMARY KEY, b INTEGER, c INTEGER, name TEXT)');
+  await q("INSERT INTO s VALUES (1,10,1,'a'),(2,20,2,'b'),(3,30,3,'c')");
+
+  let r = await q('SELECT SUM(b) FROM s');
+  ok('#54 SUM 列名为 SUM(b)', r.columns[0] === 'SUM(b)', r.columns);
+  ok('#54 SUM 值正确', r.rows[0][0] === 60, r.rows);
+
+  r = await q('SELECT AVG(b), MIN(b), MAX(b), COUNT(b), COUNT(*) FROM s');
+  ok('#54 AVG/MIN/MAX/COUNT 列名可读',
+    JSON.stringify(r.columns) === JSON.stringify(['AVG(b)', 'MIN(b)', 'MAX(b)', 'COUNT(b)', 'COUNT(*)']), r.columns);
+
+  r = await q('SELECT SUM(b+c) FROM s');
+  ok('#54 聚合参数是表达式时列名不含 [object Object]', !/\[object Object\]/.test(r.columns[0]), r.columns);
+  ok('#54 表达式聚合值正确（1+10+2+20+3+30=66）', r.rows[0][0] === 66, r.rows);
+
+  r = await q('SELECT SUM(b) AS total FROM s');
+  ok('#54 有别名时别名优先', r.columns[0] === 'total', r.columns);
+
+  r = await q('SELECT MAX(LENGTH(name)) FROM s');
+  ok('#54 函数参数聚合列名不含 [object Object]', !/\[object Object\]/.test(r.columns[0]), r.columns);
+
+  r = await q('SELECT SUM(b), COUNT(*) FROM s');
+  ok('#54 多列各自命名', JSON.stringify(r.columns) === JSON.stringify(['SUM(b)', 'COUNT(*)']), r.columns);
+
+  r = await q('SELECT c, SUM(b) FROM s GROUP BY c');
+  ok('#54 GROUP BY 路径同样正确', JSON.stringify(r.columns) === JSON.stringify(['c', 'SUM(b)']), r.columns);
+
+  // raw 对象的键名也要可读
+  ok('#54 raw 键名为 SUM(b)', Object.keys(r.raw[0]).includes('SUM(b)'), Object.keys(r.raw[0]));
+
+  console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+  if (fail > 0) process.exit(1);
+})();

package/test/issue-55.test.js

@@ -0,0 +1,86 @@
+/*
+ * Issue #55 — Query.cache() 复用不同过滤条件时返回过期结果。
+ *
+ * 缓存只按 TTL 判断，key 里不含 where/orderBy/limit/offset 等可变参数，
+ * 于是同一个 Query 实例改了条件后仍命中旧缓存。
+ * 修复后缓存键必须覆盖查询参数：参数变化 → 失配 → 重新执行。
+ */
+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'));
+
+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).slice(0, 400) : ''); }
+}
+const ids = (rows) => rows.map(r => Number(r.id));
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, { safety: false });
+  await q('CREATE TABLE c (id INTEGER PRIMARY KEY AUTOINCREMENT, g TEXT, n INTEGER)');
+  await q("INSERT INTO c (g, n) VALUES ('a',1),('b',2),('a',3),('b',4)");
+  const t = db.c;
+
+  // 核心复现
+  const qb = t.where({ g: 'a' }).cache(60000);
+  const a1 = qb.get();
+  ok('#55 首次 g=a => [1,3]', JSON.stringify(ids(a1)) === JSON.stringify([1, 3]), a1);
+  const b1 = qb.where({ g: 'b' }).get();
+  ok('#55 改成 g=b 后不得返回旧缓存 => [2,4]', JSON.stringify(ids(b1)) === JSON.stringify([2, 4]), b1);
+  const a2 = qb.where({ g: 'a' }).get();
+  ok('#55 切回 g=a => [1,3]', JSON.stringify(ids(a2)) === JSON.stringify([1, 3]), a2);
+
+  // 参数变化都必须失配
+  const qo = t.where({}).cache(60000);
+  const asc = qo.orderBy('g', 'asc').get();
+  ok('#55 orderBy g asc => [1,3,2,4]', JSON.stringify(ids(asc)) === JSON.stringify([1, 3, 2, 4]), asc);
+  // 追加 id DESC 后组内顺序应反转 => [3,1,4,2]，若命中旧缓存则仍是 [1,3,2,4]
+  const desc = qo.orderBy('id', 'desc').get();
+  ok('#55 orderBy 变化不复用旧排序 => [3,1,4,2]',
+    JSON.stringify(ids(desc)) === JSON.stringify([3, 1, 4, 2]), desc);
+
+  const ql = t.where({}).cache(60000);
+  const lim1 = ql.limit(1).get();
+  ok('#55 limit=1 => 1 行', lim1.length === 1, lim1);
+  const lim2 = ql.limit(3).get();
+  ok('#55 limit 变化 => 3 行', lim2.length === 3, lim2);
+  const off = ql.offset(1).get();
+  ok('#55 offset 变化 => 3 行', off.length === 3, off);
+
+  // 真正相同参数仍要走缓存（否则等于禁用缓存）
+  const qs = t.where({ g: 'b' }).cache(60000);
+  const s1 = qs.get();
+  await q("UPDATE c SET n = 99 WHERE g = 'b'");
+  const s2 = qs.get();
+  ok('#55 相同参数再次 get 命中缓存（未看到 UPDATE）', JSON.stringify(ids(s2)) === JSON.stringify(ids(s1)) && s2[0].n !== 99, s2);
+  await q("UPDATE c SET n = 2 WHERE id = 2");
+  await q("UPDATE c SET n = 4 WHERE id = 4");
+
+  // invalidateCache 仍然有效
+  const qi = t.where({ g: 'a' }).cache(60000);
+  qi.get();
+  await q("UPDATE c SET n = 77 WHERE id = 1");
+  qi.invalidateCache();
+  const iv = qi.get();
+  ok('#55 invalidateCache 后重新执行', iv.find(r => Number(r.id) === 1).n === 77, iv);
+  await q("UPDATE c SET n = 1 WHERE id = 1");
+
+  // 值类型不同的条件不能共用缓存
+  const qv = t.where({ n: 2 }).cache(60000);
+  const v1 = qv.get();
+  ok('#55 where n=2', JSON.stringify(ids(v1)) === JSON.stringify([2]), v1);
+  const v2 = qv.where({ n: '2' }).get();
+  ok('#55 where n="2" 语义等值，结果一致', JSON.stringify(ids(v2)) === JSON.stringify([2]), v2);
+
+  // select 变化
+  const qsel = t.where({}).cache(60000);
+  qsel.select(['id']).get();
+  const sel2 = qsel.select(['id', 'g']).get();
+  ok('#55 select 变化 => 新字段可见', Object.keys(sel2[0]).sort().join(',') === 'g,id', Object.keys(sel2[0]));
+
+  console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+  if (fail > 0) process.exit(1);
+})();

package/test/issue-56.test.js

@@ -0,0 +1,70 @@
+/*
+ * Issue #56 — SUM/AVG 对 >2^53 的整数丢精度。
+ *
+ * 聚合累加用 Number(v) 的浮点加法，9007199254740993 + 9007199254740992
+ * 会被舍入成 18014398509481984。修复：整数输入用 BigInt 精确累加，
+ * 结果超出安全范围时以 BigInt 返回（executeSQL 收尾转字符串），
+ * 安全范围内仍返回 number，浮点输入保持原行为。
+ */
+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'));
+
+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, (k, v) => (typeof v === 'bigint' ? v.toString() + 'n' : v)).slice(0, 400) : ''); }
+}
+// 聚合结果可能是 number / bigint / 超出 2^53 后被 finalize 成字符串
+const s = (v) => String(v);
+
+(async () => {
+  const db = new Database(':memory:', { autoSave: false });
+  const q = (sql) => executeSQL(db, sql, { safety: false });
+  await q('CREATE TABLE b (id INTEGER PRIMARY KEY AUTOINCREMENT, x BIGINT)');
+  await q('INSERT INTO b (x) VALUES (9007199254740993),(9007199254740992)');
+
+  let r = await q('SELECT SUM(x) FROM b');
+  ok('#56 SUM >2^53 精确 => 18014398509481985', s(r.rows[0][0]) === '18014398509481985', r.rows);
+
+  r = await q('SELECT AVG(x) FROM b');
+  ok('#56 AVG => 9007199254740992.5（double 下等于 9007199254740992）',
+    Number(r.rows[0][0]) === 9007199254740992.5, r.rows);
+
+  r = await q('SELECT SUM(x), AVG(x) FROM b');
+  ok('#56 SUM+AVG 同列', s(r.rows[0][0]) === '18014398509481985' && Number(r.rows[0][1]) === 9007199254740992.5, r.rows);
+
+  r = await q('SELECT id, SUM(x) AS t FROM b GROUP BY id ORDER BY id');
+  ok('#56 GROUP BY 单行 SUM 不丢精度',
+    s(r.rows[0][1]) === '9007199254740993' && s(r.rows[1][1]) === '9007199254740992', r.rows);
+
+  // 安全范围 / 普通浮点不能回归
+  await q('CREATE TABLE small (n INTEGER, f DOUBLE)');
+  await q('INSERT INTO small (n, f) VALUES (1,1.5),(2,2.5),(3,3.5)');
+  r = await q('SELECT SUM(n), AVG(n) FROM small');
+  ok('#56 小整数 SUM 仍是 number 6', r.rows[0][0] === 6 && typeof r.rows[0][0] === 'number', r.rows);
+  ok('#56 小整数 AVG 仍是 number 2', r.rows[0][1] === 2 && typeof r.rows[0][1] === 'number', r.rows);
+  r = await q('SELECT SUM(f), AVG(f) FROM small');
+  ok('#56 浮点 SUM 保持 7.5', r.rows[0][0] === 7.5 && typeof r.rows[0][0] === 'number', r.rows);
+  ok('#56 浮点 AVG 保持 2.5', r.rows[0][1] === 2.5, r.rows);
+
+  // 空集语义不能被改坏
+  r = await q('SELECT SUM(n) FROM small WHERE n > 100');
+  ok('#56 空集 SUM 仍为 NULL', r.rows[0][0] === null, r.rows);
+  r = await q('SELECT AVG(n) FROM small WHERE n > 100');
+  ok('#56 空集 AVG 仍为 NULL', r.rows[0][0] === null, r.rows);
+
+  // 负值 / 混合字符串数字
+  await q("CREATE TABLE mix (k TEXT)");
+  await q("INSERT INTO mix (k) VALUES ('9007199254740993'),('1')");
+  r = await q('SELECT SUM(k) FROM mix');
+  ok('#56 十进制字符串参与精确求和', s(r.rows[0][0]) === '9007199254740994', r.rows);
+
+  // DISTINCT 仍然有效
+  r = await q('SELECT SUM(DISTINCT x) FROM b');
+  ok('#56 SUM(DISTINCT) 正常', s(r.rows[0][0]) === '18014398509481985', r.rows);
+
+  console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+  if (fail > 0) process.exit(1);
+})();

package/test/issue-57.test.js

@@ -0,0 +1,70 @@
+/*
+ * Issue #57 — UNION / INTERSECT / EXCEPT 静默丢弃 ORDER BY / LIMIT / OFFSET。
+ *
+ * 语法层把组合查询尾部的 ORDER BY/LIMIT/OFFSET 挂在最右侧 SELECT 上，
+ * 执行层却在 concat 后直接返回，导致这些子句完全失效。
+ * 修复后：尾部子句提升为整个组合结果的语义（标准 SQL），按左列名/列序号排序分页。
+ */
+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'));
+
+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).slice(0, 400) : ''); }
+}
+const j = (rows) => JSON.stringify(rows);
+
+(async () => {
+  const db = new Database(':memory:');
+  const q = (sql) => executeSQL(db, sql, { safety: false });
+
+  let r = await q('SELECT 1 AS x UNION SELECT 2 UNION SELECT 3 LIMIT 1');
+  ok('#57 UNION ... LIMIT 1 => [[1]]', j(r.rows) === j([[1]]), r.rows);
+
+  r = await q('SELECT 1 AS x UNION SELECT 2 UNION SELECT 3 ORDER BY x DESC LIMIT 1');
+  ok('#57 UNION ... ORDER BY x DESC LIMIT 1 => [[3]]', j(r.rows) === j([[3]]), r.rows);
+
+  r = await q('SELECT 1 AS x UNION SELECT 2 UNION SELECT 3 ORDER BY 1 DESC LIMIT 1');
+  ok('#57 ORDER BY 列序号 => [[3]]', j(r.rows) === j([[3]]), r.rows);
+
+  r = await q('SELECT 1 AS x UNION SELECT 2 UNION SELECT 3 ORDER BY x DESC LIMIT 2 OFFSET 1');
+  ok('#57 LIMIT 2 OFFSET 1 => [[2],[1]]', j(r.rows) === j([[2], [1]]), r.rows);
+
+  r = await q('SELECT 1 AS x UNION ALL SELECT 1 UNION ALL SELECT 1 LIMIT 2');
+  ok('#57 UNION ALL LIMIT 2 => 2 行', r.rows.length === 2, r.rows);
+
+  r = await q('SELECT 1 AS x UNION SELECT 2 UNION SELECT 3 LIMIT 1 OFFSET 1');
+  ok('#57 LIMIT 1 OFFSET 1 => [[2]]', j(r.rows) === j([[2]]), r.rows);
+
+  r = await q('SELECT 1 AS x EXCEPT SELECT 2 LIMIT 1');
+  ok('#57 EXCEPT + LIMIT => [[1]]', j(r.rows) === j([[1]]), r.rows);
+
+  r = await q('SELECT 1 AS x INTERSECT SELECT 1 INTERSECT SELECT 1 LIMIT 1');
+  ok('#57 INTERSECT + LIMIT => [[1]]', j(r.rows) === j([[1]]), r.rows);
+
+  // 表数据上的组合查询
+  await q('CREATE TABLE u1 (id INTEGER PRIMARY KEY AUTOINCREMENT, v INTEGER)');
+  await q('CREATE TABLE u2 (id INTEGER PRIMARY KEY AUTOINCREMENT, v INTEGER)');
+  await q('INSERT INTO u1 (v) VALUES (1),(3)');
+  await q('INSERT INTO u2 (v) VALUES (2),(4)');
+  r = await q('SELECT v FROM u1 UNION SELECT v FROM u2 ORDER BY v DESC LIMIT 2');
+  ok('#57 两表 UNION + ORDER BY v DESC LIMIT 2 => [[4],[3]]', j(r.rows) === j([[4], [3]]), r.rows);
+
+  r = await q('SELECT v FROM u1 UNION SELECT v FROM u2 ORDER BY v LIMIT 3 OFFSET 1');
+  ok('#57 两表 UNION + LIMIT/OFFSET => [[2],[3],[4]]', j(r.rows) === j([[2], [3], [4]]), r.rows);
+
+  r = await q('SELECT v FROM u1 UNION ALL SELECT v FROM u2 ORDER BY 1 LIMIT 1');
+  ok('#57 表数据 ORDER BY 1', j(r.rows) === j([[1]]), r.rows);
+
+  // 不改变无尾部子句的行为
+  r = await q('SELECT 1 AS x UNION SELECT 2');
+  ok('#57 无 LIMIT 行为不变', j(r.rows) === j([[1], [2]]), r.rows);
+
+  // 子句顺序正常（ORDER BY 在 LIMIT 前）已验证；LIMIT 在 ORDER BY 之前非法，不测
+
+  console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+  if (fail > 0) process.exit(1);
+})();

package/test/issue-58.test.js

@@ -0,0 +1,52 @@
+/*
+ * Issue #58 — ast.rewrite() 无法替换根节点（transform 可以）。
+ *
+ * rewrite 的 visit 只在 `parent && key` 成立时才调用 fn 并回写，
+ * 根节点 parent===null 直接被跳过；而根替换是合法需求
+ * （例如把整条 SELECT 换成改写后的版本）。
+ */
+const path = require('path');
+const ROOT = path.join(__dirname, '..');
+const AST = require(path.join(ROOT, 'lib', 'ast.js'));
+const { parseSQL } = require(path.join(ROOT, 'lib', 'sql.js'));
+
+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).slice(0, 300) : ''); }
+}
+
+try {
+  // 1) 最小复现：纯对象树
+  const tree = { type: 'select', x: 1 };
+  const out = AST.rewrite(tree, (n) => (n && n.type === 'select' ? { type: 'select', y: 2 } : undefined));
+  ok('#58 rewrite 能替换根节点', JSON.stringify(out) === JSON.stringify({ type: 'select', y: 2 }), out);
+  ok('#58 返回的就是替换后的根', out && out.y === 2 && out.x === undefined, out);
+
+  // 2) 根节点不被替换时保持原样
+  const same = { type: 'select', x: 1 };
+  AST.rewrite(same, () => undefined);
+  ok('#58 无返回值时根节点不变', JSON.stringify(same) === JSON.stringify({ type: 'select', x: 1 }), same);
+
+  // 3) 真实 SQL AST：把整条语句换成另一条
+  const ast = parseSQL('SELECT a FROM t');
+  const replaced = AST.rewrite(ast, (n) => (n && n.type === 'select' ? parseSQL('SELECT b FROM u') : undefined));
+  ok('#58 真实 AST 根替换生效', replaced && replaced.from && replaced.from.tables[0].table === 'u', replaced && replaced.from);
+
+  // 4) 嵌套节点替换仍然有效（不能为了根节点修复而回归旧行为）
+  const ast2 = parseSQL('SELECT a FROM t WHERE a > 10');
+  AST.rewrite(ast2, (n) => (n && n.type === 'value' && n.value === 10 ? { type: 'value', value: 20 } : undefined));
+  const v = AST.find(ast2, (n) => n.type === 'value' && typeof n.value === 'number');
+  ok('#58 嵌套节点替换未回归', v && v.value === 20, v);
+
+  // 5) 数组根节点
+  const arr = [{ type: 'select', x: 1 }, { type: 'select', x: 2 }];
+  AST.rewrite(arr, (n) => (n && n.type === 'select' ? { type: 'select', y: n.x + 10 } : undefined));
+  ok('#58 数组根元素替换', JSON.stringify(arr) === JSON.stringify([{ type: 'select', y: 11 }, { type: 'select', y: 12 }]), arr);
+} catch (e) {
+  fail++;
+  console.log('[FAIL] unexpected exception:', (e && e.stack) || e);
+}
+
+console.log(`\n${fail === 0 ? 'ALL PASS' : 'FAILURES'} — ${pass} passed, ${fail} failed\n`);
+if (fail > 0) process.exit(1);