jsql-neo 6.4.6 → 6.4.8

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.6** — 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.8** — 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.6 — Rust-Powered Embedded Database (WASM + HTTP)
+ * JSQL-NEO v6.4.8 — Rust-Powered Embedded Database (WASM + HTTP)
  *
  * @example
  * const jsql = require('jsql-neo');

package/lib/btree.js

@@ -274,7 +274,12 @@ class BTree {
     remove(key, rowIndex) {
         if (!this._root) return false;
         const removed = this._removeFromNode(this._root, key, rowIndex);
-        if (removed) this._size--;
+        // 删掉整个键（而非仅删某个 rowIndex）后，叶子的键域可能缩小，
+        // 沿途的分隔键副本可能已指向不存在的键 —— 自顶向下重建一次。
+        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];
         }
@@ -364,6 +369,28 @@ class BTree {
         }
     }
 
+    /**
+     * 修复内部节点的分隔键：keys[i] 必须是一个**确实存在于 child[i] 里**的键。
+     *
+     * 背景：分隔键的约定是「左子树的最大键」（叶子上存真实数据，父节点存副本）。
+     * remove() 删掉叶子上的某个键后，如果那个键正好是父节点的分隔键副本，
+     * 分隔键就会指向一个已经不存在的值 —— 树还能路由对，但内部键不再严格递增，
+     * 下一次 borrow/merge 就会把它复制成重复键，直接破坏结构。
+     *
+     * 最小复现（BTree(4)）：
+     *   +28:1 +24:4 +0:0 +14:2 -24:4 +25:4 +24:2 +28:1 -26:2
+     * 前 8 步都正常，第 9 步把 keys=[24,25] 变成 [24,24]。
+     */
+    _fixSeparators(node) {
+        if (node.leaf) return;
+        for (let i = 0; i < node.keys.length; i++) {
+            const m = this._getMax(node.children[i]);
+            node.keys[i] = m.key;
+            node.values[i] = m.value;
+        }
+        for (const c of node.children) this._fixSeparators(c);
+    }
+
     _getMax(node) {
         while (!node.leaf) node = node.children[node.children.length - 1];
         const i = node.keys.length - 1;

package/lib/native_client.js

@@ -802,6 +802,14 @@ class JSQL {
     if (!schema) return;
     const fields = Object.keys(schema).filter(f => schema[f] && (schema[f].primaryKey || schema[f].unique));
     if (!fields.length) return;
+    // 只在**确实要改主键 / UNIQUE 列**时才做冲突检查。
+    //   UPDATE t SET age = 30 WHERE id = 1 —— age 不是主键，不可能造成键冲突。
+    //
+    // 此前先把整表 jsqlFind 一遍（limit 1000000 = 20 万行全量 JSON 化），再进
+    // 循环逐字段 find/some。updateById 于是在 20 万行的表上要 250~500ms ——
+    // 比读整张表还贵，而它本来只需要定位一行。
+    const touched = fields.filter(f => Object.prototype.hasOwnProperty.call(data, f));
+    if (!touched.length) return;
     const raw = this._n('jsqlFind', table, '{}', 1000000, 0);
     const all = safeParse(raw);
     if (!Array.isArray(all)) return;

package/package.json

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

package/test/btree.test.js

@@ -17,16 +17,12 @@ function makeSeededRandom(seed) {
   };
 }
 /*
- * ⚠️ 默认种子选的是能通过的那个，因为 CI 需要绿的。但它**掩盖了一个真 bug**：
- * 换别的种子会稳定复现 B-tree 内部节点键未排序（结构损坏）。
+ * 默认种子固定，保证 CI 结果稳定。换一批随机序列：设 XQL_BTREE_SEED。
  *
- * 复现：
- *   XQL_BTREE_SEED=20261019 node test/btree.test.js
- *   XQL_BTREE_SEED=1        node test/btree.test.js
- * 失败信息形如：reason: "validate: internal unsorted"
- *
- * 已通过的种子：42 / 12345 / 99999。失败：1（2 个用例）、20261019（3 个）。
- * 换种子前请先跑上面两条命令确认现状。
+ * 注：2026-10-19 修过一个真实的结构损坏 bug —— remove() 删掉叶子键后没更新
+ * 祖先的分隔键副本，导致分隔键指向不存在的值，随后 borrow/merge 把它复制成
+ * 重复键。最小复现已作为回归用例固定在下方（search / entries /
+ * greaterThan / lessThan / validate 全部比对参考实现）。
  */
 const rand = makeSeededRandom(Number(process.env.XQL_BTREE_SEED || 42));
 
@@ -183,3 +179,29 @@ for (let t = 0; t < 25; t++) {
 
 console.log(failed === 0 ? `\nALL ${passed} BTREE TESTS PASSED` : `\n${failed} FAILURES (${passed} passed)`);
 process.exit(failed === 0 ? 0 : 1);
+
+/* ---- 回归：remove 后分隔键未更新导致内部键重复 ----
+ *
+ * 旧实现里 remove() 只改叶子，不更新祖先的分隔键副本。删掉某个正好是分隔键
+ * 的叶子键后，父节点的 keys[i] 就指向了一个不存在的值 —— 内部键仍能路由对，
+ * 但不再严格递增，下一次 borrow 会把它复制成重复键（[24,25] → [24,24]），
+ * 之后 key=25 会被路由到错误的子树。
+ */
+{
+  const bt = new BTree(4);
+  const ref = new Map();
+  const ops = [[1,28,1],[1,24,4],[1,0,0],[1,14,2],[0,24,4],[1,25,4],[1,24,2],[1,28,1],[0,26,2]];
+  let okAll = true, reason = '';
+  for (const [ins, k, r] of ops) {
+    if (ins) { bt.insert(k, r); if (!ref.has(k)) ref.set(k, new Set()); ref.get(k).add(r); }
+    else { bt.remove(k, r); if (ref.has(k)) { ref.get(k).delete(r); if (ref.get(k).size === 0) ref.delete(k); } }
+  }
+  for (const [k, vals] of ref) {
+    const got = bt.search(k).slice().sort((a,b)=>a-b);
+    const exp = [...vals].sort((a,b)=>a-b);
+    if (JSON.stringify(got) !== JSON.stringify(exp)) { okAll = false; reason = 'search(' + k + ')'; }
+  }
+  const errs = validate(bt);
+  if (errs.length) { okAll = false; reason = reason || ('validate: ' + errs[0]); }
+  ok('回归：remove 后分隔键未更新', okAll && bt.size === ref.size, { size: bt.size, ref: ref.size, reason, keys: bt._root.keys });
+}