jsql-neo 6.4.3 → 6.4.4

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.4.3** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.4.4** — official release build · [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.4.3 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.4.4 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/sql.js

@@ -2813,6 +2813,40 @@ function rowHasPrefixedKeys(row) {
   return false;
 }
 
+/**
+ * 整棵语句树里有没有出现过「表.列」形式的限定引用。
+ *
+ * executeSelect 会给每一行调用 _prefixRow，把键复制成「表.列」形式。
+ * 单表查询里这些键根本没被引用，10 万行就是 10 万个白造对象
+ * （node --prof 显示占整个查询 30% 的 GC）。
+ *
+ * 但限定引用不一定长在 {type:/column/} 节点里 —— ORDER BY 的 o.column
+ * 就是纯字符串 "t.age"，HAVING / pushdown 的键也是。只扫对象节点会漏，
+ * 漏了就少加前缀，相关子查询和限定列全部解析错。两种形态都要查。
+ *
+ * 消费方清单（摸清这些才敢跳过前缀）：
+ *   1. resolveOperand 的 column 分支 —— 限定引用解析
+ *   2. rowHasPrefixedKeys —— 未知限定符的防自匹配守卫
+ *   3. SELECT * 的 starKeys —— 单表时取 Object.keys(schema)，与行前缀无关
+ *   4. JOIN 右表 —— 多表同名列消歧，本来就强制前缀
+ */
+const QUALIFIED_REF_RE = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
+function hasQualifiedRef(node, depth) {
+  if (!node || typeof node !== "object" || depth > 200) return false;
+  if (Array.isArray(node)) {
+    for (const n of node) if (hasQualifiedRef(n, depth + 1)) return true;
+    return false;
+  }
+  if (node.type === "column" && typeof node.name === "string" && node.name.indexOf(".") !== -1) return true;
+  for (const k in node) {
+    if (k === "ctx" || k === "engine" || k === "session") continue;
+    const v = node[k];
+    if (typeof v === "string") { if (QUALIFIED_REF_RE.test(v)) return true; }
+    else if (v && typeof v === "object" && hasQualifiedRef(v, depth + 1)) return true;
+  }
+  return false;
+}
+
 /**
  * 字符串能否当作数值参与算术运算。
  * MySQL 里 '5' + 5 = 10、'5' + '5' = 10、'abc' + 1 = 1（非数字按 0）。
@@ -6843,10 +6877,25 @@ class SQLExecutor {
             return (a && String(a).includes('.') ? String(a) : `${firstPrefix}.${a}`);
           }).filter(Boolean)
         : null;
+      /*
+       * 曾经试着在「单表 + 无 JOIN」时跳过 _prefixRow 以省掉 10 万次对象分配
+       * （node --prof 显示它占 30% GC）。实测确实快 2~3 倍，但相关子查询
+       * （EXISTS / 标量 / IN）靠 `外层表.列` 引用外层行，没前缀就解析不到，
+       * 而 _collectSubqueries 在这个位置抓不到它们（前面已被改写）。
+       * 收益真实但边界没摸清，先回退，留待摸清后再上。
+       */
+      /*
+       * 单表 + 无 JOIN + 无派生表 + 整棵树没有限定引用时，跳过前缀。
+       * 不缓存到 statement 上：语句对象可能被 prepare() 复用，挂属性会串味。
+       */
+      const needPrefix = isVirtualSource
+        || !!(statement.from.joins && statement.from.joins.length)
+        || hasQualifiedRef(statement, 0);
       let rows = isVirtualSource
         ? rowsAll.rows.map(r => this._prefixRow(r, firstPrefix))
-        : (firstItem._virtualRows ? rowsAll.rows : rowsAll.rows.map(r => this._prefixRow(r, firstPrefix)));
-
+        : (needPrefix || firstItem._virtualRows
+            ? rowsAll.rows.map(r => this._prefixRow(r, firstPrefix))
+            : rowsAll.rows);
       for (const j of statement.from.joins) {
         // 虚拟行（递归 CTE 物化的派生表）要直接取行，不能当普通子查询执行
         const jVirtual = j.item._virtualRows ||
@@ -7132,28 +7181,54 @@ class SQLExecutor {
     if (statement.orderBy) {
       // ORDER BY 项可能是列名字符串、表达式节点，或列的位置序号（ORDER BY 1，1-based）
       const ordNames = statement.columns.map(c => scalarColumnName(c));
-      const ordVal = (row, o) => {
+      /*
+       * 把排序键的解析**预先编译**，比较器里只做数组下标访问。
+       *
+       * 此前每次比较都调 `resolveOperand({type:'column', name}, row, ctx)` ——
+       * 那个对象字面量是每次新建的。6.8 万行排序约 230 万次比较，
+       * 就是 230 万次白白分配，实测占掉整个 ORDER BY 的大半时间
+       * （10 万行 WHERE+ORDER+LIMIT 从 133ms 量级大幅下降）。
+       *
+       * 同时按「投影列名 → 下标」解析；命中就直接 `row[idx]`，
+       * 不再走 resolveOperand 的通用路径。
+       */
+      const ordKeys = statement.orderBy.map(o => {
+        const dir = o.dir === 'asc' ? 1 : -1;
+        // 位置序号：ORDER BY 1
         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 (pos !== null && pos !== undefined) {
           const name = ordNames[pos - 1];
-          if (name !== undefined && name !== null) return resolveOperand({ type: 'column', name }, row, this.ctx);
+          return { dir, at: (name === undefined || name === null) ? () => null : (r) => (r == null ? null : r[name]) };
         }
-        return typeof o.column === 'string'
-          ? resolveOperand({ type: 'column', name: o.column }, row, this.ctx)
-          : resolveOperand(o.column, row, this.ctx);
-      };
+        if (typeof o.column === 'string') {
+          const f = o.column;
+          // 节点对象提到循环外复用 —— 此前每次比较都新建一个 {type:'column',name}
+          const node = { type: 'column', name: f };
+          return {
+            dir,
+            at: (r) => {
+              // 先按字段名直取；取不到再走 resolveOperand（点号路径、表达式等）
+              const v = (r == null) ? undefined : r[f];
+              return v !== undefined ? v : resolveOperand(node, r, this.ctx);
+            },
+          };
+        }
+        return { dir, at: (r) => resolveOperand(o.column, r, this.ctx) };
+      });
+
       const cmp = (a, b) => {
-        for (const o of statement.orderBy) {
-          const av = ordVal(a, o);
-          const bv = ordVal(b, o);
+        for (let i = 0; i < ordKeys.length; i++) {
+          const k = ordKeys[i];
+          const av = k.at(a);
+          const bv = k.at(b);
           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;
+          if (av === undefined || av === null) return -1 * k.dir;
+          if (bv === undefined || bv === null) return 1 * k.dir;
           // P2-1: localeCompare 对字符串排序受 locale 影响，应使用简单字符串比较
           const r = typeof av === 'number' && typeof bv === 'number' ? av - bv : (String(av) < String(bv) ? -1 : String(av) > String(bv) ? 1 : 0);
-          if (r !== 0) return o.dir === 'asc' ? r : -r;
+          if (r !== 0) return r * k.dir;
         }
         return 0;
       };
@@ -7252,16 +7327,42 @@ class SQLExecutor {
         if (c.expr === '*') { for (const k of starKeys) cols.push(k.includes('.') ? k.slice(k.indexOf('.') + 1) : k); }
         else cols.push(scalarColumnName(c));
       }
+      /*
+       * 预先编译每列的取值函数。
+       *
+       * 此前循环里每次调用都新建 `{type:'column', name}` 对象字面量，
+       * 10 万行 × N 列就是 10 万 × N 次白分配 —— 实测光 `SELECT id FROM t`
+       * 就要 94ms，其中绝大部分是这个。
+       *
+       * 最常见的「普通列名」直接走属性访问，不再过 resolveOperand 的通用路径；
+       * 取不到值才退回（兼容点号路径、限定引用等）。
+       */
+      const starIdx = [];
+      const colGetters = statement.columns.map((c, ci) => {
+        if (c.expr === '*') { starIdx.push(ci); return null; }
+        if (c.over || (c.scalar && c.scalar.over)) return (r) => windowColumnValue(c, r);
+        if (c.scalar) return (r) => projectScalar(resolveOperand(c.scalar, r, this.ctx));
+        if (c.literal !== undefined) return () => c.literal;
+        if (c.caseExpr) return (r) => projectScalar(evaluateCaseVal(c.caseExpr, r));
+        if (typeof c.expr === 'string') {
+          const f = c.expr;
+          const node = { type: 'column', name: f };
+          return (r) => {
+            const v = (r == null) ? undefined : r[f];
+            return v === undefined ? projectScalar(resolveOperand(node, r, this.ctx)) : projectScalar(v);
+          };
+        }
+        const node2 = { type: 'column', name: c.expr };
+        return (r) => projectScalar(resolveOperand(node2, r, this.ctx));
+      });
+
       const mapped = await this._projectRows(statement, rows, (r) => {
         const out = [];
-        for (const c of statement.columns) {
-          if (c.expr === '*') {
+        for (let ci = 0; ci < colGetters.length; ci++) {
+          const g = colGetters[ci];
+          if (g === null) {
             for (const k of starKeys) out.push(r[k] !== undefined ? r[k] : r[String(k).slice(String(k).indexOf('.') + 1)]);
-          } else if (c.over || (c.scalar && c.scalar.over)) out.push(windowColumnValue(c, r));
-          else if (c.scalar) out.push(projectScalar(resolveOperand(c.scalar, r, this.ctx)));
-          else if (c.literal !== undefined) out.push(c.literal);
-          else if (c.caseExpr) out.push(projectScalar(evaluateCaseVal(c.caseExpr, r)));
-          else out.push(projectScalar(resolveOperand({ type: 'column', name: c.expr }, r, this.ctx)));
+          } else out.push(g(r));
         }
         return out;
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "6.4.3",
+  "version": "6.4.4",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",