serializable-bptree 8.1.7 → 8.3.0

package/README.md

@@ -158,7 +158,7 @@ const others = candidates.filter((c) => driver.tree !== c.tree)
 // 2. Execute query using the selected driver
 let keys = driver.tree.keys(driver.condition)
 for (const { tree, condition } of others) {
-  keys = tree.keys(condition, keys)
+  keys = tree.keys(condition, { filterValues: keys })
 }
 
 console.log('Found: ', keys)

package/dist/cjs/index.cjs

@@ -2154,17 +2154,24 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  *whereStream(condition, limit, order = "asc") {
+  *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -2187,8 +2194,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -2208,16 +2219,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  keys(condition, filterValues, order = "asc") {
+  keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  where(condition, order = "asc") {
+  where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -2245,6 +2256,33 @@ 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]));
+    for (const [key, value] of sorted) {
+      let before = this.insertableNode(value);
+      before = this._insertAtLeaf(before, key, value);
+      if (before.values.length === this.order) {
+        let after = this._createNode(
+          true,
+          [],
+          [],
+          before.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);
+        this._updateNode(after);
+        this._insertInParent(before, after.values[0], after);
+      }
+    }
+  }
   _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -2600,6 +2638,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
@@ -3229,17 +3275,24 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  async *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  async *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for await (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  async *whereStream(condition, limit, order = "asc") {
+  async *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -3262,8 +3315,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -3283,16 +3340,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  async keys(condition, filterValues, order = "asc") {
+  async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for await (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for await (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  async where(condition, order = "asc") {
+  async where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for await (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for await (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -3322,6 +3379,35 @@ 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]));
+      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) {
+          let after = await this._createNode(
+            true,
+            [],
+            [],
+            before.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);
+          await this._updateNode(after);
+          await this._insertInParent(before, after.values[0], after);
+        }
+      }
+    });
+  }
   async _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -3683,6 +3769,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

@@ -2118,17 +2118,24 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  *whereStream(condition, limit, order = "asc") {
+  *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -2151,8 +2158,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -2172,16 +2183,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  keys(condition, filterValues, order = "asc") {
+  keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  where(condition, order = "asc") {
+  where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -2209,6 +2220,33 @@ 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]));
+    for (const [key, value] of sorted) {
+      let before = this.insertableNode(value);
+      before = this._insertAtLeaf(before, key, value);
+      if (before.values.length === this.order) {
+        let after = this._createNode(
+          true,
+          [],
+          [],
+          before.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);
+        this._updateNode(after);
+        this._insertInParent(before, after.values[0], after);
+      }
+    }
+  }
   _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -2564,6 +2602,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
@@ -3193,17 +3239,24 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return void 0;
   }
-  async *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
+  async *keysStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
+    const stream = this.whereStream(condition, options);
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    let count = 0;
     for await (const [key] of stream) {
       if (intersection && !intersection.has(key)) {
         continue;
       }
       yield key;
+      count++;
+      if (limit !== void 0 && count >= limit) {
+        break;
+      }
     }
   }
-  async *whereStream(condition, limit, order = "asc") {
+  async *whereStream(condition, options) {
+    const { filterValues, limit, order = "asc" } = options ?? {};
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
@@ -3226,8 +3279,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       earlyTerminate
     );
     let count = 0;
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
       const [k, v] = pair;
+      if (intersection && !intersection.has(k)) {
+        continue;
+      }
       let isMatch = true;
       for (const key in condition) {
         if (key === driverKey) continue;
@@ -3247,16 +3304,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     }
   }
-  async keys(condition, filterValues, order = "asc") {
+  async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
-    for await (const key of this.keysStream(condition, filterValues, void 0, order)) {
+    for await (const key of this.keysStream(condition, options)) {
       set.add(key);
     }
     return set;
   }
-  async where(condition, order = "asc") {
+  async where(condition, options) {
     const map = /* @__PURE__ */ new Map();
-    for await (const [key, value] of this.whereStream(condition, void 0, order)) {
+    for await (const [key, value] of this.whereStream(condition, options)) {
       map.set(key, value);
     }
     return map;
@@ -3286,6 +3343,35 @@ 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]));
+      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) {
+          let after = await this._createNode(
+            true,
+            [],
+            [],
+            before.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);
+          await this._updateNode(after);
+          await this._insertInParent(before, after.values[0], after);
+        }
+      }
+    });
+  }
   async _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -3647,6 +3733,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

@@ -1,5 +1,5 @@
 import type { TransactionEntry, TransactionResult } from 'mvcc-api';
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData, BPTreeNode, BPTreeMVCC } from '../types';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreeUnknownNode, Deferred, BPTreeLeafNode, BPTreeNodeKey, BPTreePair, SerializableData, BPTreeNode, BPTreeMVCC, BPTreeSearchOption } from '../types';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
 export declare abstract class BPTreeTransaction<K, V> {
@@ -107,28 +107,44 @@ export declare abstract class BPTreeTransaction<K, V> {
      * This method is used to initialize the stored tree and recover data.
      * If it is not called, the tree will not function.
      */
+    abstract init(): Deferred<void>;
     /**
-     * After creating a tree instance, it must be called.
-     * This method is used to initialize the stored tree and recover data.
-     * If it is not called, the tree will not function.
+     * Retrieves the value associated with the given key.
+     * @param key The key to search for.
+     * @returns A Deferred that resolves to the value if found, or undefined if not found.
      */
-    abstract init(): Deferred<void>;
+    abstract get(key: K): Deferred<V | undefined>;
+    /**
+     * Returns a generator that yields keys satisfying the given condition.
+     * This is a memory-efficient way to iterate through keys when dealing with large result sets.
+     * @param condition The search condition (e.g., gt, lt, equal, like).
+     * @param options Search options including filterValues, limit, and order.
+     * @returns An async or synchronous generator yielding keys of type K.
+     */
+    abstract keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<K> | Generator<K>;
+    /**
+     * Returns a generator that yields [key, value] pairs satisfying the given condition.
+     * This is a memory-efficient way to iterate through pairs when dealing with large result sets.
+     * @param condition The search condition (e.g., gt, lt, equal, like).
+     * @param options Search options including filterValues, limit, and order.
+     * @returns An async or synchronous generator yielding [K, V] tuples.
+     */
+    abstract whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<[K, V]> | Generator<[K, V]>;
     /**
      * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.
      * The result is key set instance, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
      * This method operates much faster than first searching with `where` and then retrieving only the key list.
      * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
-     * @param filterValues The `Set` containing values to check for intersection.
-     * Returns a `Set` containing values that are common to both the input `Set` and the intersection `Set`.
-     * If this parameter is not provided, it searches for all keys inserted into the tree.
+     * @param options Search options including filterValues, limit, and order.
      */
-    abstract keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Deferred<Set<K>>;
+    abstract keys(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Deferred<Set<K>>;
     /**
      * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.
      * The result includes the key and value attributes, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
      * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+     * @param options Search options including filterValues, limit, and order.
      */
-    abstract where(condition: BPTreeCondition<V>): Deferred<BPTreePair<K, V>>;
+    abstract where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Deferred<BPTreePair<K, V>>;
     /**
      * You enter the key and value as a pair. You can later search for the pair by value.
      * This data is stored in the tree, sorted in ascending order of value.
@@ -136,12 +152,17 @@ 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.
      * @param value The value of the pair.
-     *
      * @warning If the 'value' is not specified, a full scan will be performed to find the value associated with the key, which may lead to performance degradation.
      */
     abstract delete(key: K, value?: V): Deferred<void>;

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

@@ -1,5 +1,5 @@
 import type { TransactionResult } from 'mvcc-api';
-import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreeOrder, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead } from '../types';
+import type { AsyncBPTreeMVCC, BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, BPTreeSearchOption } from '../types';
 import { Ryoiki } from 'ryoiki';
 import { BPTreeTransaction } from '../base/BPTreeTransaction';
 import { SerializeStrategyAsync } from '../SerializeStrategyAsync';
@@ -37,11 +37,12 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     protected _initInternal(): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;
     get(key: K): Promise<V | undefined>;
-    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number, order?: BPTreeOrder): AsyncGenerator<K>;
-    whereStream(condition: BPTreeCondition<V>, limit?: number, order?: BPTreeOrder): AsyncGenerator<[K, V]>;
-    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>, order?: BPTreeOrder): Promise<Set<K>>;
-    where(condition: BPTreeCondition<V>, order?: BPTreeOrder): Promise<BPTreePair<K, V>>;
+    keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<K>;
+    whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): AsyncGenerator<[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

@@ -1,5 +1,5 @@
 import type { TransactionResult } from 'mvcc-api';
-import type { BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreeOrder, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, SyncBPTreeMVCC } from '../types';
+import type { BPTreeCondition, BPTreeConstructorOption, BPTreeLeafNode, BPTreeNode, BPTreeNodeKey, BPTreePair, BPTreeUnknownNode, SerializableData, SerializeStrategyHead, SyncBPTreeMVCC, BPTreeSearchOption } from '../types';
 import { BPTreeTransaction } from '../base/BPTreeTransaction';
 import { SerializeStrategySync } from '../SerializeStrategySync';
 import { ValueComparator } from '../base/ValueComparator';
@@ -34,11 +34,12 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     protected _initInternal(): void;
     exists(key: K, value: V): boolean;
     get(key: K): V | undefined;
-    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number, order?: BPTreeOrder): Generator<K>;
-    whereStream(condition: BPTreeCondition<V>, limit?: number, order?: BPTreeOrder): Generator<[K, V]>;
-    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>, order?: BPTreeOrder): Set<K>;
-    where(condition: BPTreeCondition<V>, order?: BPTreeOrder): BPTreePair<K, V>;
+    keysStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<K>;
+    whereStream(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): Generator<[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/dist/types/types/index.d.ts

@@ -52,6 +52,11 @@ export type BPTreeCondition<V> = Partial<{
  * - `'desc'`: Descending order - traverses from right to left
  */
 export type BPTreeOrder = 'asc' | 'desc';
+export interface BPTreeSearchOption<K> {
+    filterValues?: Set<K>;
+    limit?: number;
+    order?: BPTreeOrder;
+}
 export type BPTreePair<K, V> = Map<K, V>;
 export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
 export interface BPTreeConstructorOption {

package/package.json

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