jsql-neo 6.3.3 → 6.3.5

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/nativesrc/jsql-neo-core/src/engine/hybrid.rs

@@ -60,7 +60,14 @@ impl HybridEngine {
     }
 
     /// 打开磁盘存储目录（mode: 'hybrid' | 'disk' | 'memory'；memory 或空目录忽略）
-    /// 每次 open 重置引擎状态，避免多个库目录/实例间残留表数据
+    ///
+    /// 注意（6.3.4）：这里仍然会重置引擎状态，但语义已改变 ——
+    /// 以前全进程只有一个引擎，`open(dirB)` 会把 `open(dirA)` 的表全部清空，
+    /// 导致同进程无法持有两个独立数据库。现在每个 JS `Database` 实例有独立的
+    /// 引擎句柄，`open()` 只重置自己那一份。
+    ///
+    /// 但对**同一个句柄**重复 open 不同目录仍会丢弃上一个目录的内存表，
+    /// 因此调用方（native_client.js）应为每个 Database 分配独立句柄。
     pub fn open(&mut self, dir: &str, mode: &str) -> Result<(), String> {
         self.mem.borrow_mut().clear();
         self.meta.borrow_mut().clear();