jsql-neo 6.3.2 → 6.3.4

package/lib/sql.js

@@ -1096,8 +1096,11 @@ class Parser {
         alias = this.parseOptionalAlias();
         columns.push({ expr: null, caseExpr, alias });
       } else {
-        // 列 / 常量 / 函数 / 算术表达式
-        const expr = this.parseScalar();
+        // 列 / 常量 / 函数 / 算术表达式 / 括号分组 / 标量布尔（NOT、比较、LIKE…）。
+        // 此前用 parseScalar()，导致 SELECT (1+2) / SELECT NOT 0 / SELECT 'a' LIKE 'b'
+        // 这类合法标量在投影列表里解析报错。parseArgExpr() 允许裸操作数，
+        // 又能在存在运算符时走完整表达式解析，列/常量/函数行为不变。
+        const expr = this.parseArgExpr();
         let alias = null;
         alias = this.parseOptionalAlias();
         if (expr.type === 'star') {
@@ -1165,7 +1168,19 @@ class Parser {
           }
         } catch (e) {
           this.pos = save;
-          col = this.parseScalar();
+          // ORDER BY 可以引用输出列别名，而别名可能与聚合函数同名：
+          //   SELECT AVG(v) AS avg FROM t GROUP BY g ORDER BY avg DESC
+          // 这种 token 已被词法器标成 keyword（AVG/SUM/COUNT/MAX/MIN 都在关键字表里），
+          // parseColumnRef 只认 ident 会失败，parseScalar 又会把它当函数调用 → "got 'AVG'"。
+          // 此处把裸 keyword 当作列名，与 SQLite / MySQL 的行为一致。
+          const tk = this.peek();
+          if (tk.type === 'keyword' && !this.isWord('ASC') && !this.isWord('DESC')
+              && !ORDER_END.some(w => this.isWord(w))) {
+            this.next();
+            col = tk.value;
+          } else {
+            col = this.parseScalar();
+          }
         }
         let dir = 'asc';
         if (this.isKeyword('ASC')) { this.next(); }
@@ -2005,6 +2020,14 @@ class Parser {
         this.peek().type === 'op' && this.peek().value === '(') {
       return this.parseAggregateCall(String(t.value).toUpperCase());
     }
+    // 裸关键字、且后面不跟 '(' → 当作列名/别名。
+    // 典型场景：SELECT AVG(v) AS avg FROM t GROUP BY g ORDER BY avg DESC
+    // 'avg' 已被词法器标成 keyword（AVG 在关键字表里），既进不了 parseColumnRef（只认 ident），
+    // 也不满足上面的聚合调用分支（后面是 DESC 不是 '('），最终会抛 "got 'AVG'"。
+    // ORDER BY 引用输出别名是标准 SQL 行为，SQLite / MySQL 都允许。
+    if (t.type === 'keyword' && !(this.peek().type === 'op' && this.peek().value === '(')) {
+      return { type: 'column', name: t.value };
+    }
     // 一元按位取反 ~x
     if (t.type === 'op' && t.value === '~') {
       return { type: 'bitnot', expr: this.parseOperand() };
@@ -2014,6 +2037,13 @@ class Parser {
       this.expect('op', ')');
       return { type: 'subquery', select: sub };
     }
+    // 括号分组：支持 (1+2)、2*(3+4) 等出现在算术/函数参数任意位置
+    // 注意：parseOperand 开头已通过 const t = this.next() 消费了 '(', 此处不可再 next()
+    if (t.type === 'op' && t.value === '(') {
+      const inner = this.parseArgExpr();   // 容忍裸操作数，允许纯算术分组
+      this.expect('op', ')');
+      return inner;
+    }
     if (t.type === 'op' && (t.value === '-' || t.value === '+')) {
       const num = this.next();
       if (num.type !== 'number') throw new Error('Expected number after sign');
@@ -2318,8 +2348,11 @@ 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') {
-    const n = Number(value);
-    return Number.isFinite(n) ? Math.trunc(n) : null;
+    // 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;
+    const m = String(value).trim().match(/^[+-]?\d+(\.\d+)?/);
+    return m ? Math.trunc(Number(m[0])) : 0;
   }
   if (t === 'FLOAT' || t === 'DOUBLE' || t === 'REAL' || t === 'NUMERIC' || t === 'DECIMAL') {
     const n = Number(value);
@@ -2659,6 +2692,23 @@ function pgDatePart(part, d) {
   }
 }
 
+/**
+ * 按自然月推进并在月末做「钳制」，对齐 MySQL 的日期加减语义。
+ * JS 的 setMonth()/setFullYear() 会溢出（2023-01-31 +1 月 → 2023-03-03），
+ * 而 MySQL 会把超出目标月天数的日期夹到当月最后一天（→ 2023-02-28）。
+ * 先 setDate(1) 再切月，避免切换过程中先溢出再被钳制。
+ */
+function addMonthsClamped(d, n) {
+  const day = d.getDate();
+  const t = new Date(d.getTime());
+  t.setDate(1);
+  t.setMonth(t.getMonth() + n);
+  const lastDay = new Date(t.getFullYear(), t.getMonth() + 1, 0).getDate();
+  t.setDate(Math.min(day, lastDay));
+  d.setTime(t.getTime());
+  return d;
+}
+
 /** PG AGE(from, to) 的间隔文本：'6 years 7 mons 11 days' */
 function pgAge(from, to) {
   let years = to.getFullYear() - from.getFullYear();
@@ -2760,9 +2810,9 @@ function applyScalarFunction(fnNode, row, ctx) {
       switch (String(iv.unit || '').toUpperCase()) {
         case 'DAY': case 'DAYS': d.setDate(d.getDate() + n); break;
         case 'WEEK': case 'WEEKS': d.setDate(d.getDate() + n * 7); break;
-        case 'MONTH': case 'MONTHS': d.setMonth(d.getMonth() + n); break;
-        case 'QUARTER': d.setMonth(d.getMonth() + n * 3); break;
-        case 'YEAR': case 'YEARS': d.setFullYear(d.getFullYear() + n); break;
+        case 'MONTH': case 'MONTHS': addMonthsClamped(d, n); break;
+        case 'QUARTER': addMonthsClamped(d, n * 3); break;
+        case 'YEAR': case 'YEARS': addMonthsClamped(d, n * 12); break;
         case 'HOUR': case 'HOURS': d.setHours(d.getHours() + n); break;
         case 'MINUTE': case 'MINUTES': d.setMinutes(d.getMinutes() + n); break;
         case 'SECOND': case 'SECONDS': d.setSeconds(d.getSeconds() + n); break;
@@ -2956,7 +3006,14 @@ function applyScalarFunction(fnNode, row, ctx) {
       if (!Number.isFinite(factor)) return x;      // 位数过大：值不变
       if (factor === 0) return 0;                   // 位数过小：舍入到 0
       const sign = x < 0 ? -1 : 1;
-      return sign * Math.round(Math.abs(x) * factor) / factor;
+      const scaled = Math.abs(x) * factor;
+      const floor = Math.floor(scaled);
+      const frac = scaled - floor;
+      // 二进制浮点误差会把恰好落在中点的值存成略小（1.005*100 = 100.49999999999999），
+      // 在中点附近按相对误差判定为「半」，以「半远离零」进位，避免静默少 1。
+      const eps = Math.abs(scaled) * Number.EPSILON * 4 + Number.EPSILON;
+      const rounded = Math.abs(frac - 0.5) < eps ? floor + 1 : Math.round(scaled);
+      return sign * rounded / factor;
     }
     case 'FLOOR': return args[0] == null ? null : Math.floor(args[0]);
     case 'CEIL': case 'CEILING': return args[0] == null ? null : Math.ceil(args[0]);
@@ -2968,6 +3025,13 @@ function applyScalarFunction(fnNode, row, ctx) {
     case 'NULLIF': return args[0] === args[1] ? null : args[0];
     case 'IF': return args[0] ? args[1] : args[2];
     case 'REPLACE': return args[0] == null ? null : String(args[0]).split(args[1]).join(args[2]);
+    case 'REPEAT': {
+      // 此前完全缺失，静默返回 null
+      if (args[0] == null || args[1] == null) return null;
+      const n = Math.trunc(Number(args[1]));
+      if (!Number.isFinite(n) || n <= 0) return '';
+      return String(args[0]).repeat(n);
+    }
     case 'SUBSTRING': case 'SUBSTR': {
       if (args[0] == null) return null;
       const s = String(args[0]);
@@ -2985,11 +3049,18 @@ function applyScalarFunction(fnNode, row, ctx) {
     }
     case 'LEFT': return args[0] == null ? null : String(args[0]).slice(0, Number(args[1]));
     case 'RIGHT': return args[0] == null ? null : String(args[0]).slice(-Number(args[1]));
-    case 'LOCATE': case 'INSTR': {
+    case 'LOCATE': {
       if (args[0] == null || args[1] == null) return null;
       const idx = String(args[1]).indexOf(String(args[0]));
       return idx + 1;
     }
+    case 'INSTR': {
+      // INSTR(str, substr)：参数顺序与 LOCATE(substr, str) 相反。
+      // 此前两者共用一段代码，导致 INSTR 静默返回 0。
+      if (args[0] == null || args[1] == null) return null;
+      const idx = String(args[0]).indexOf(String(args[1]));
+      return idx + 1;
+    }
     case 'REVERSE': return args[0] == null ? null : String(args[0]).split('').reverse().join('');
     case 'LPAD': {
       if (args[0] == null) return null;
@@ -3163,8 +3234,10 @@ function evaluateExpr(expr, row, ctx) {
     case 'xor': return Boolean(evaluateExpr(expr.left, row, ctx)) !== Boolean(evaluateExpr(expr.right, row, ctx));
     case 'not': {
       // 三值逻辑：NOT UNKNOWN = UNKNOWN（返回 null，在 WHERE/ON/HAVING 中视为不选中）
-      const v = evaluateExpr(expr.expr, row, ctx);
-      return v === null ? null : !v;
+      // 必须用 resolveOperand 取值：evaluateExpr 只认布尔类节点，
+      // 对 value/column/arith 会落到 default 返回 false，导致 NOT 恒为真。
+      const v = resolveOperand(expr.expr, row, ctx);
+      return v === null || v === undefined ? null : !v;
     }
     case 'compare': {
       const l = resolveOperand(expr.left, row, ctx);
@@ -3311,6 +3384,25 @@ function windowColumnValue(c, r) {
   return v === undefined ? null : v;
 }
 
+// 表达式树里是否含 aggregate 节点（用于识别 ROUND(AVG(x),1) 这类嵌套聚合）
+function containsAggregateNode(node) {
+  if (!node || typeof node !== 'object') return false;
+  if (Array.isArray(node)) return node.some(containsAggregateNode);
+  if (node.type === 'aggregate') return true;
+  for (const k of Object.keys(node)) {
+    const v = node[k];
+    if (v && typeof v === 'object' && containsAggregateNode(v)) return true;
+  }
+  return false;
+}
+
+// 结果集中的 SQL 布尔值按 MySQL 语义呈现为 1/0（如 SELECT 'a' LIKE 'b' → 0）
+function projectScalar(v) {
+  if (v === true) return 1;
+  if (v === false) return 0;
+  return v;
+}
+
 function scalarColumnValue(c, r, ctx) {
   if (c.over || (c.scalar && c.scalar.over)) return windowColumnValue(c, r);
   // 聚合列优先：GROUP_CONCAT / STDDEV 等同时带 scalar 与 aggregate
@@ -3326,13 +3418,21 @@ function scalarColumnValue(c, r, ctx) {
       const col = s.args && s.args[0];
       return ctx._aggValue(ctx.group, fn, col, c.aggregate ? c.distinct : (c.scalar && c.scalar.distinct));
     }
-    return resolveOperand(c.scalar, r, ctx);
+    // 嵌套聚合：ROUND(AVG(x),1)、UPPER(MIN(s)) 等 —— 顶层不是聚合函数，
+    // 但参数里可能夹着 aggregate 节点。resolveOperand 不认识这种节点会返回 null，
+    // 所以先把整棵 scalar 树里的聚合按当前分组求值替换成字面值（每行都要替换，故用深拷贝）。
+    if (ctx && ctx._aggValue && s && containsAggregateNode(s)) {
+      const copy = JSON.parse(JSON.stringify(s));
+      ctx._replaceAggregates(copy, ctx.group || [r]);
+      return projectScalar(resolveOperand(copy, r, ctx));
+    }
+    return projectScalar(resolveOperand(c.scalar, r, ctx));
   }
   
   if (c.literal !== undefined) return c.literal;
-  if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r, ctx);
+  if (c.caseExpr) return projectScalar(evaluateCaseVal(c.caseExpr, r, ctx));
   if (c.expr === '*') return r[Object.keys(r).find(k => !k.startsWith('_'))];
-  return resolveOperand({ type: 'column', name: c.expr }, r, ctx);
+  return projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, ctx));
 }
 
 function sqlTypeName(type) {
@@ -3387,21 +3487,21 @@ class SQLExecutor {
   async execute(statement) {
     switch (statement.type) {
       case 'createTable': {
-        if (statement.ifNotExists && this.engine.hasTable && this.engine.hasTable(statement.name)) {
+        if (statement.ifNotExists && this.engine.hasTable && await this.engine.hasTable(statement.name)) {
           return { ok: true, type: 'createTable', table: statement.name, affectedRows: 0, skipped: true };
         }
         const r = await this.engine.createTable(statement.name, statement.schema);
         return { ok: true, type: 'createTable', table: statement.name, affectedRows: 0, result: r };
       }
       case 'dropTable': {
-        if (statement.ifExists && !this.engine.hasTable(statement.table)) {
+        if (statement.ifExists && !(await this.engine.hasTable(statement.table))) {
           return { ok: true, type: 'dropTable', table: statement.table, affectedRows: 0 };
         }
         await this.engine.dropTable(statement.table);
         return { ok: true, type: 'dropTable', table: statement.table, affectedRows: 0 };
       }
       case 'truncate': {
-        if (this.engine.hasTable(statement.name)) await this.engine.truncate(statement.name);
+        if (await this.engine.hasTable(statement.name)) await this.engine.truncate(statement.name);
         return { ok: true, type: 'truncate', table: statement.name, affectedRows: 0 };
       }
       case 'alterTable': {
@@ -3754,7 +3854,7 @@ class SQLExecutor {
       }
       case 'createIndex': {
         const tName = statement.table;
-        if (typeof this.engine.hasTable === 'function' && !this.engine.hasTable(tName)) {
+        if (typeof this.engine.hasTable === 'function' && !(await this.engine.hasTable(tName))) {
           throw new Error(`Table '${tName}' does not exist`);
         }
         let handled = false;
@@ -4136,7 +4236,7 @@ class SQLExecutor {
   }
 
   async _getSchema(name) {
-    if (this.engine.hasTable && !this.engine.hasTable(name)) {
+    if (this.engine.hasTable && !(await this.engine.hasTable(name))) {
       throw new Error(`Table '${name}' does not exist`);
     }
     const schema = this.engine.getTableSchema
@@ -4436,7 +4536,12 @@ class SQLExecutor {
         return typeof agg.result === 'function' ? agg.result(state) : state;
       }
     }
-    if (fn === 'SUM') return values.reduce((s, v) => s + (typeof v === 'number' ? v : Number(v) || 0), 0);
+    if (fn === 'SUM') {
+      // MySQL 语义：空集（或无任何非 NULL 值）的 SUM 为 NULL，而非 0。
+      // AVG/MIN/MAX 已按此处理，此前只有 SUM 漏了。
+      if (!values.length) return null;
+      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 === 'MIN' || fn === 'MAX') {
       const vs = values.filter(v => v !== null && v !== undefined);
@@ -5165,7 +5270,11 @@ class SQLExecutor {
     // 聚合输出（无 GROUP BY 时）
     const hasCustomAgg = this.ctx && this.ctx.aggregates && statement.columns.some(c => c.scalar && c.scalar.type === 'func' && Object.prototype.hasOwnProperty.call(this.ctx.aggregates, String(c.scalar.name).toUpperCase()));
     // 注意：带 OVER 的聚合是窗口函数，不是“整表塌缩成一行”的聚合，必须排除
-    if (!statement.groupBy && (statement.columns.some(c => c.aggregate && !c.window) || hasCustomAgg)) {
+    // 无 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));
+    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;
       // HAVING 判定不通过时 rows 已为空，此时整表聚合也应为空，不能无条件补一行
@@ -5180,9 +5289,17 @@ class SQLExecutor {
             return this._aggValue(rows, fn, c.scalar.args && c.scalar.args[0]);
           }
         }
-        if (c.scalar) return resolveOperand(c.scalar, rows[0] || {}, this.ctx);
-        if (c.caseExpr) return resolveOperand(c.caseExpr, rows[0] || {}, this.ctx);
-        if (c.expr !== null && c.expr !== '*') return rows[0] ? resolveOperand({ type: 'column', name: c.expr }, rows[0]) : null;
+        if (c.scalar) {
+          // 先把参数里的聚合按整表求值替换掉，否则 ROUND(AVG(x),1) 会得到 null
+          if (containsAggregateNode(c.scalar)) {
+            const nested = JSON.parse(JSON.stringify(c.scalar));
+            this._replaceAggregates(nested, rows);
+            return projectScalar(resolveOperand(nested, rows[0] || {}, this.ctx));
+          }
+          return projectScalar(resolveOperand(c.scalar, rows[0] || {}, this.ctx));
+        }
+        if (c.caseExpr) return projectScalar(resolveOperand(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;
       };
       return { ok: true, type: 'select', table: tableName2, columns: cols, rows: [[...statement.columns.map(valueOf)]], aggregate: statement.aggregate };
@@ -5197,9 +5314,54 @@ class SQLExecutor {
         : rows;
       const mapped = await this._projectRows(statement, rowsForGroups, (r) => {
         const group = r._group || [r];
-        return statement.columns.map(c => scalarColumnValue(c, r, { _aggValue: this._aggValue.bind(this), group, ctxAggregates: this.ctx ? this.ctx.aggregates : null }));
+        return statement.columns.map(c => scalarColumnValue(c, r, {
+          _aggValue: this._aggValue.bind(this),
+          _replaceAggregates: this._replaceAggregates.bind(this),
+          group,
+          ctxAggregates: this.ctx ? this.ctx.aggregates : null,
+        }));
       });
-      return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: mapped, raw: rowsForGroups };
+      // GROUP BY 路径此前直接 return，ORDER BY 完全没有生效
+      //（SELECT dept, SUM(sal) AS total FROM emp GROUP BY dept ORDER BY total DESC
+      //   返回的仍是分组出现顺序）。这里补上排序，规则与非分组路径一致。
+      let outRows = mapped;
+      if (statement.orderBy && mapped.length > 1) {
+        const ordVal = (row, o) => {
+          // row 是投影后的 [v1, v2, ...]，按列名下标取
+          const name = typeof o.column === 'string' ? o.column
+            : (o.column && o.column.type === 'column' ? o.column.name : null);
+          const pos = (o.column && typeof o.column === 'object' && o.column.type === 'value'
+            && typeof o.column.value === 'number') ? o.column.value
+            : (typeof o.column === 'number' ? o.column : null);
+          if (name === null && pos !== null && pos >= 1 && pos <= cols.length) {
+            return row[pos - 1];
+          }
+          if (name === null) return null;
+          const idx = cols.indexOf(name);
+          return idx === -1 ? null : row[idx];
+        };
+        const cmp = (a, b) => {
+          for (const o of statement.orderBy) {
+            const av = ordVal(a.row, o);
+            const bv = ordVal(b.row, o);
+            if (av === bv || (av === undefined && bv === undefined)) continue;
+            if (av === undefined || av === null) return o.dir === 'asc' ? -1 : 1;
+            if (bv === undefined || bv === null) return o.dir === 'asc' ? 1 : -1;
+            const r = typeof av === 'number' && typeof bv === 'number' ? av - bv : String(av).localeCompare(String(bv));
+            if (r !== 0) return o.dir === 'asc' ? r : -r;
+          }
+          return 0;
+        };
+        outRows = mapped
+          .map((row, i) => ({ row, src: rowsForGroups[i] }))
+          .sort(cmp)
+          .map(x => x.row);
+      }
+      if (statement.limit !== null) {
+        const start = statement.offset || 0;
+        outRows = outRows.slice(start, start + statement.limit);
+      }
+      return { ok: true, type: 'select', table: statement.from ? (statement.from.tables[0].table || null) : null, columns: cols, rows: outRows, raw: rowsForGroups };
     }
 
     if (statement.orderBy) {
@@ -5257,11 +5419,11 @@ class SQLExecutor {
     const cols = statement.columns.map(c => scalarColumnName(c));
     const mapped = await this._projectRows(statement, rows, (r) => statement.columns.map(c => {
       if (c.over || (c.scalar && c.scalar.over)) return windowColumnValue(c, r);
-      if (c.scalar) return resolveOperand(c.scalar, r, this.ctx);
+      if (c.scalar) return projectScalar(resolveOperand(c.scalar, r, this.ctx));
       if (c.expr === '*') return null;
       if (c.literal !== undefined) return c.literal;
-      if (c.caseExpr) return evaluateCaseVal(c.caseExpr, r);
-      return resolveOperand({ type: 'column', name: c.expr }, r, this.ctx);
+      if (c.caseExpr) return projectScalar(evaluateCaseVal(c.caseExpr, r));
+      return projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, this.ctx));
     }));
     return { ok: true, type: 'select', table: tableName, columns: cols, rows: mapped, raw: rows };
   }

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();