dataply 0.0.23-alpha.1 → 0.0.23

package/dist/cjs/index.js

@@ -1726,6 +1726,39 @@ var BPTreeTransaction = class _BPTreeTransaction {
     }
     return true;
   }
+  /**
+   * Inserts a key-value pair into an already-cloned leaf node in-place.
+   * Unlike _insertAtLeaf, this does NOT clone or update the node via MVCC.
+   * Used by batchInsert to batch multiple insertions with a single clone/update.
+   * @returns true if the leaf was modified, false if the key already exists.
+   */
+  _insertValueIntoLeaf(leaf, key, value) {
+    if (leaf.values.length) {
+      for (let i = 0, len = leaf.values.length; i < len; i++) {
+        const nValue = leaf.values[i];
+        if (this.comparator.isSame(value, nValue)) {
+          if (leaf.keys[i].includes(key)) {
+            return false;
+          }
+          leaf.keys[i].push(key);
+          return true;
+        } else if (this.comparator.isLower(value, nValue)) {
+          leaf.values.splice(i, 0, value);
+          leaf.keys.splice(i, 0, [key]);
+          return true;
+        } else if (i + 1 === leaf.values.length) {
+          leaf.values.push(value);
+          leaf.keys.push([key]);
+          return true;
+        }
+      }
+    } else {
+      leaf.values = [value];
+      leaf.keys = [[key]];
+      return true;
+    }
+    return false;
+  }
   _cloneNode(node) {
     return JSON.parse(JSON.stringify(node));
   }
@@ -2287,29 +2320,46 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   batchInsert(entries) {
     if (entries.length === 0) return;
     const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+    let currentLeaf = null;
+    let modified = false;
     for (const [key, value] of sorted) {
-      let before = this.insertableNode(value);
-      before = this._insertAtLeaf(before, key, value);
-      if (before.values.length === this.order) {
+      const targetLeaf = this.insertableNode(value);
+      if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
+      } else {
+        if (currentLeaf !== null && modified) {
+          this._updateNode(currentLeaf);
+        }
+        currentLeaf = this._cloneNode(targetLeaf);
+        modified = false;
+      }
+      const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
+      modified = modified || changed;
+      if (currentLeaf.values.length === this.order) {
+        this._updateNode(currentLeaf);
         let after = this._createNode(
           true,
           [],
           [],
-          before.parent,
+          currentLeaf.parent,
           null,
           null
         );
         const mid = Math.ceil(this.order / 2) - 1;
         after = this._cloneNode(after);
-        after.values = before.values.slice(mid + 1);
-        after.keys = before.keys.slice(mid + 1);
-        before.values = before.values.slice(0, mid + 1);
-        before.keys = before.keys.slice(0, mid + 1);
-        this._updateNode(before);
+        after.values = currentLeaf.values.slice(mid + 1);
+        after.keys = currentLeaf.keys.slice(mid + 1);
+        currentLeaf.values = currentLeaf.values.slice(0, mid + 1);
+        currentLeaf.keys = currentLeaf.keys.slice(0, mid + 1);
+        this._updateNode(currentLeaf);
         this._updateNode(after);
-        this._insertInParent(before, after.values[0], after);
+        this._insertInParent(currentLeaf, after.values[0], after);
+        currentLeaf = null;
+        modified = false;
       }
     }
+    if (currentLeaf !== null && modified) {
+      this._updateNode(currentLeaf);
+    }
   }
   _deleteEntry(node, key) {
     if (!node.leaf) {
@@ -3403,29 +3453,46 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     if (entries.length === 0) return;
     return this.writeLock(0, async () => {
       const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+      let currentLeaf = null;
+      let modified = false;
       for (const [key, value] of sorted) {
-        let before = await this.insertableNode(value);
-        before = await this._insertAtLeaf(before, key, value);
-        if (before.values.length === this.order) {
+        const targetLeaf = await this.insertableNode(value);
+        if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
+        } else {
+          if (currentLeaf !== null && modified) {
+            await this._updateNode(currentLeaf);
+          }
+          currentLeaf = this._cloneNode(targetLeaf);
+          modified = false;
+        }
+        const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
+        modified = modified || changed;
+        if (currentLeaf.values.length === this.order) {
+          await this._updateNode(currentLeaf);
           let after = await this._createNode(
             true,
             [],
             [],
-            before.parent,
+            currentLeaf.parent,
             null,
             null
           );
           const mid = Math.ceil(this.order / 2) - 1;
           after = this._cloneNode(after);
-          after.values = before.values.slice(mid + 1);
-          after.keys = before.keys.slice(mid + 1);
-          before.values = before.values.slice(0, mid + 1);
-          before.keys = before.keys.slice(0, mid + 1);
-          await this._updateNode(before);
+          after.values = currentLeaf.values.slice(mid + 1);
+          after.keys = currentLeaf.keys.slice(mid + 1);
+          currentLeaf.values = currentLeaf.values.slice(0, mid + 1);
+          currentLeaf.keys = currentLeaf.keys.slice(0, mid + 1);
+          await this._updateNode(currentLeaf);
           await this._updateNode(after);
-          await this._insertInParent(before, after.values[0], after);
+          await this._insertInParent(currentLeaf, after.values[0], after);
+          currentLeaf = null;
+          modified = false;
         }
       }
+      if (currentLeaf !== null && modified) {
+        await this._updateNode(currentLeaf);
+      }
     });
   }
   async _deleteEntry(node, key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.23-alpha.1",
+  "version": "0.0.23",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -49,6 +49,6 @@
     "hookall": "^2.2.0",
     "mvcc-api": "^1.3.4",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^8.3.0"
+    "serializable-bptree": "^8.3.1"
   }
 }