serializable-bptree 8.2.0 → 8.3.1

package/dist/cjs/index.cjs

@@ -1696,6 +1696,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));
   }
@@ -2256,6 +2289,50 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._insertInParent(before, after.values[0], after);
     }
   }
+  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) {
+      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,
+          [],
+          [],
+          currentLeaf.parent,
+          null,
+          null
+        );
+        const mid = Math.ceil(this.order / 2) - 1;
+        after = this._cloneNode(after);
+        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(currentLeaf, after.values[0], after);
+        currentLeaf = null;
+        modified = false;
+      }
+    }
+    if (currentLeaf !== null && modified) {
+      this._updateNode(currentLeaf);
+    }
+  }
   _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -2611,6 +2688,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  batchInsert(entries) {
+    const tx = this.createTransaction();
+    tx.batchInsert(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
 };
 
 // node_modules/ryoiki/dist/esm/index.mjs
@@ -3344,6 +3429,52 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     });
   }
+  async batchInsert(entries) {
+    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) {
+        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,
+            [],
+            [],
+            currentLeaf.parent,
+            null,
+            null
+          );
+          const mid = Math.ceil(this.order / 2) - 1;
+          after = this._cloneNode(after);
+          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(currentLeaf, after.values[0], after);
+          currentLeaf = null;
+          modified = false;
+        }
+      }
+      if (currentLeaf !== null && modified) {
+        await this._updateNode(currentLeaf);
+      }
+    });
+  }
   async _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -3705,6 +3836,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async batchInsert(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.batchInsert(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
 };
 
 // src/base/SerializeStrategy.ts

package/dist/esm/index.mjs

@@ -1660,6 +1660,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));
   }
@@ -2220,6 +2253,50 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._insertInParent(before, after.values[0], after);
     }
   }
+  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) {
+      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,
+          [],
+          [],
+          currentLeaf.parent,
+          null,
+          null
+        );
+        const mid = Math.ceil(this.order / 2) - 1;
+        after = this._cloneNode(after);
+        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(currentLeaf, after.values[0], after);
+        currentLeaf = null;
+        modified = false;
+      }
+    }
+    if (currentLeaf !== null && modified) {
+      this._updateNode(currentLeaf);
+    }
+  }
   _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -2575,6 +2652,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  batchInsert(entries) {
+    const tx = this.createTransaction();
+    tx.batchInsert(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
 };
 
 // node_modules/ryoiki/dist/esm/index.mjs
@@ -3308,6 +3393,52 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     });
   }
+  async batchInsert(entries) {
+    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) {
+        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,
+            [],
+            [],
+            currentLeaf.parent,
+            null,
+            null
+          );
+          const mid = Math.ceil(this.order / 2) - 1;
+          after = this._cloneNode(after);
+          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(currentLeaf, after.values[0], after);
+          currentLeaf = null;
+          modified = false;
+        }
+      }
+      if (currentLeaf !== null && modified) {
+        await this._updateNode(currentLeaf);
+      }
+    });
+  }
   async _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -3669,6 +3800,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async batchInsert(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.batchInsert(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
 };
 
 // src/base/SerializeStrategy.ts

package/dist/types/BPTreeAsync.d.ts

@@ -11,4 +11,5 @@ export declare class BPTreeAsync<K, V> extends BPTreeAsyncTransaction<K, V> {
     createTransaction(): Promise<BPTreeAsyncTransaction<K, V>>;
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value?: V): Promise<void>;
+    batchInsert(entries: [K, V][]): Promise<void>;
 }

package/dist/types/BPTreeSync.d.ts

@@ -11,4 +11,5 @@ export declare class BPTreeSync<K, V> extends BPTreeSyncTransaction<K, V> {
     createTransaction(): BPTreeSyncTransaction<K, V>;
     insert(key: K, value: V): void;
     delete(key: K, value?: V): void;
+    batchInsert(entries: [K, V][]): void;
 }

package/dist/types/base/BPTreeTransaction.d.ts

@@ -80,6 +80,13 @@ export declare abstract class BPTreeTransaction<K, V> {
      * @returns Returns true if the value satisfies the condition.
      */
     verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
+    /**
+     * 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.
+     */
+    protected _insertValueIntoLeaf(leaf: BPTreeLeafNode<K, V>, key: K, value: V): boolean;
     protected _cloneNode<T extends BPTreeUnknownNode<K, V>>(node: T): T;
     /**
      * Selects the best driver key from a condition object.
@@ -152,6 +159,13 @@ export declare abstract class BPTreeTransaction<K, V> {
      * @param value The value of the pair.
      */
     abstract insert(key: K, value: V): Deferred<void>;
+    /**
+     * Inserts multiple key-value pairs into the tree in a single batch operation.
+     * Entries are sorted by value before insertion to optimize tree traversal.
+     * This is more efficient than calling insert() multiple times.
+     * @param entries Array of [key, value] pairs to insert.
+     */
+    abstract batchInsert(entries: [K, V][]): Deferred<void>;
     /**
      * Deletes the pair that matches the key and value.
      * @param key The key of the pair. This key must be unique.

package/dist/types/transaction/BPTreeAsyncTransaction.d.ts

@@ -42,6 +42,7 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Promise<Set<K>>;
     where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Promise<BPTreePair<K, V>>;
     insert(key: K, value: V): Promise<void>;
+    batchInsert(entries: [K, V][]): Promise<void>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<BPTreeUnknownNode<K, V>>;
     delete(key: K, value?: V): Promise<void>;
     getHeadData(): Promise<SerializableData>;

package/dist/types/transaction/BPTreeSyncTransaction.d.ts

@@ -39,6 +39,7 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Set<K>;
     where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): BPTreePair<K, V>;
     insert(key: K, value: V): void;
+    batchInsert(entries: [K, V][]): void;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): BPTreeUnknownNode<K, V>;
     delete(key: K, value?: V): void;
     getHeadData(): SerializableData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "8.2.0",
+  "version": "8.3.1",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",