jsql-neo 6.5.4 → 6.5.5

package/README.md

@@ -3,7 +3,7 @@
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
 > MySQL, PostgreSQL, MongoDB, Redis, SQL, TypeScript, **and the browser**.
 
-> **v6.5.4** — stable release · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo) · [jsql.vexify.top](https://jsql.vexify.top)
+> **v6.5.5** — 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.4 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.5.5 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/wasm_client.js

@@ -725,24 +725,59 @@ class JSQL {
   /**
    * 校验 UPDATE 后的主键 / UNIQUE 值不与其它行冲突。
    * 逐行比对（未建索引也正确）；值未变化时跳过。
+   *
+   * 6.5.5 性能修复（对齐 native_client.js 的 6.4.8 修复，那次漏了 wasm 侧）：
+   *   旧写法无条件 `this.find(table, {}, {limit: 1e9})` 把整张表导出成 JSON，
+   *   再逐字段 find/some。updateById 于是在 10 万行的表上要 ~590ms/次 ——
+   *   比读整张表还贵，而它本来只需要定位一行。
+   *     UPDATE t SET age = 30 WHERE id = 1   ← age 不是键，不可能冲突，却付了全表钱
+   *
+   * 新逻辑（性能从 O(表行数) 降回 O(1)）：
+   *   1. 只筛出 pk + unique 列，且**确实出现在 updateData 里**的（touched）；
+   *      一个都没碰 → 直接 return，整张表一个字都不读；
+   *   2. 先用主键把**自己那一行**取回来（一条走 pk 的 find，limit 1，O(1)）。
+   *      所有 touched 列的新值都和现值相同 → 值没变，同样直接 return
+   *      （幂等更新不误报，也不再触发全表扫描）；
+   *   3. 真的动了键，才退化成整表扫描逐字段比对（正确性优先）。
    */
   async _assertNoKeyConflict(table, id, data, selfSeq) {
     const schema = this._schemas[table];
     if (!schema) return;
     const fields = Object.keys(schema).filter(f => schema[f] && (schema[f].primaryKey || schema[f].unique));
     if (!fields.length) return;
+    // 只在**确实要改主键 / UNIQUE 列**时才做冲突检查。
+    const touched = fields.filter(f => Object.prototype.hasOwnProperty.call(data, f));
+    if (!touched.length) return;
+
+    // 自己那一行：走主键的 find(limit 1)，不整表导出。
+    let self = null;
+    try {
+      const pk = this._pkOf(table);
+      if (pk) {
+        const one = await this.find(table, { [pk]: this._coercePkId(table, id) }, { limit: 1, offset: 0 });
+        self = Array.isArray(one) ? (one[0] || null) : null;
+      }
+    } catch (_) {
+      self = null;   // 取不到就走下面的全量比对
+    }
+    // 所有 touched 列的值都没变 → 幂等更新，不可能产生新冲突，无需扫表。
+    if (self && touched.every(f => self[f] === data[f])) return;
+
     let rows;
     try {
       rows = await this.find(table, {}, { limit: 1e9, offset: 0 });
     } catch (_) {
       return;   // 读不到就不拦，交给底层报错
     }
+    if (!Array.isArray(rows)) return;
+    // 把自己那一行找出来并从比对中排除。注意：self 来自上一次 find，
+    // 与 rows 里的对象不是同一个引用，所以必须按 id 重新定位，不能直接 r !== self。
+    const selfRow = self || rows.find(r => r && String(r.id) === String(id)) || null;
     for (const f of fields) {
       if (!Object.prototype.hasOwnProperty.call(data, f)) continue;
       const nv = data[f];
-      const self = rows.find(r => r && String(r.id) === String(id));
-      if (self && self[f] === nv) continue;             // 值没变
-      if (rows.some(r => r && r !== self && r[f] === nv)) {
+      if (selfRow && selfRow[f] === nv) continue;       // 值没变
+      if (rows.some(r => r && r !== selfRow && r[f] === nv)) {
         const e = new Error(`Duplicate entry '${nv}' for key '${f}'`);
         e.code = 'ER_DUP_ENTRY';
         e.errno = 1062;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jsql-neo",
-  "version": "6.5.4",
-  "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
+  "version": "6.5.5",
+  "description": "JSQL-NEO \u2014 Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
   "exports": {
@@ -97,4 +97,4 @@
   "devDependencies": {
     "c8": "^10.1.2"
   }
-}
+}