serializable-bptree 6.1.1 → 6.2.0

package/dist/types/BPTreeSync.d.ts

@@ -7,9 +7,7 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected readonly nodes: ReturnType<typeof this._createCachedNode>;
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     private _createCachedNode;
-    protected getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, earlyTerminate: boolean): BPTreePair<K, V>;
-    protected getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, earlyTerminate: boolean): BPTreePair<K, V>;
-    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1, earlyTerminate: boolean): BPTreePair<K, V>;
+    protected getPairsGenerator(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1, earlyTerminate: boolean): Generator<[K, V]>;
     protected _createNodeId(isLeaf: boolean): string;
     protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;
@@ -31,6 +29,16 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected commitNodeCreateBuffer(): void;
     protected commitNodeUpdateBuffer(): void;
     protected commitNodeDeleteBuffer(): void;
+    /**
+     * Retrieves the value associated with the given key (PK).
+     * Note: This method performs a full scan of leaf nodes as the tree is ordered by Value, not Key.
+     *
+     * @param key The key to search for.
+     * @returns The value associated with the key, or undefined if not found.
+     */
+    get(key: K): V | undefined;
+    keysStream(condition: BPTreeCondition<V>, filterValues?: Set<K>, limit?: number): Generator<K>;
+    whereStream(condition: BPTreeCondition<V>, limit?: number): Generator<[K, V]>;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K>;
     where(condition: BPTreeCondition<V>): BPTreePair<K, V>;
     insert(key: K, value: V): void;

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

@@ -90,11 +90,45 @@ export declare abstract class BPTree<K, V> {
      * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
      */
     protected readonly verifierEarlyTerminate: Record<keyof BPTreeCondition<V>, boolean>;
+    /**
+     * Priority map for condition types.
+     * Higher value = higher selectivity (fewer expected results).
+     * Used by `chooseDriver` to select the most selective index.
+     */
+    protected static readonly conditionPriority: Record<keyof BPTreeCondition<unknown>, number>;
+    /**
+     * Selects the best driver tree from multiple tree/condition pairs.
+     * Uses rule-based optimization to choose the tree with highest estimated selectivity.
+     *
+     * @param candidates Array of { tree, condition } pairs to evaluate
+     * @returns The candidate with highest priority condition, or null if empty
+     *
+     * @example
+     * ```typescript
+     * const driver = BPTreeSync.chooseDriver([
+     *   { tree: idxId, condition: { equal: 100 } },
+     *   { tree: idxAge, condition: { gt: 20 } }
+     * ])
+     * // Returns { tree: idxId, condition: { equal: 100 } } because 'equal' has higher priority
+     * ```
+     */
+    static ChooseDriver<T>(candidates: Array<{
+        tree: T;
+        condition: BPTreeCondition<unknown>;
+    }>): {
+        tree: T;
+        condition: BPTreeCondition<unknown>;
+    } | null;
+    /**
+     * Verified if the value satisfies the condition.
+     *
+     * @param nodeValue The value to verify.
+     * @param condition The condition to verify against.
+     * @returns Returns true if the value satisfies the condition.
+     */
+    verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
     protected constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     private _createCachedRegexp;
-    protected abstract getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, earlyTerminate: boolean): Deferred<BPTreePair<K, V>>;
-    protected abstract getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, earlyTerminate: boolean): Deferred<BPTreePair<K, V>>;
-    protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, endNode: BPTreeLeafNode<K, V> | null, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1, earlyTerminate: boolean): Deferred<BPTreePair<K, V>>;
     protected abstract _createNodeId(isLeaf: boolean): Deferred<string>;
     protected abstract _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;

package/package.json

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