serializable-bptree 8.1.7 → 8.2.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;
@@ -3229,17 +3240,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 +3280,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 +3305,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;

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;
@@ -3193,17 +3204,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 +3244,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 +3269,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;

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.
@@ -138,10 +154,8 @@ export declare abstract class BPTreeTransaction<K, V> {
     abstract insert(key: K, value: 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,10 +37,10 @@ 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>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<BPTreeUnknownNode<K, V>>;
     delete(key: K, value?: V): Promise<void>;

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,10 +34,10 @@ 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;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): BPTreeUnknownNode<K, V>;
     delete(key: K, value?: V): void;

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.2.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",