serializable-bptree 6.1.0 → 6.2.0

package/dist/esm/index.mjs

@@ -432,7 +432,7 @@ var CacheEntanglementAsync = class extends CacheEntanglement {
 };
 
 // src/base/BPTree.ts
-var BPTree = class {
+var BPTree = class _BPTree {
   _cachedRegexp;
   strategy;
   comparator;
@@ -449,9 +449,15 @@ var BPTree = class {
     lt: (nv, v) => this.comparator.isLower(nv, v),
     lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
     equal: (nv, v) => this.comparator.isSame(nv, v),
-    primaryEqual: (nv, v) => this.comparator.isPrimarySame(nv, v),
     notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
     or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
+    primaryGt: (nv, v) => this.comparator.isPrimaryHigher(nv, v),
+    primaryGte: (nv, v) => this.comparator.isPrimaryHigher(nv, v) || this.comparator.isPrimarySame(nv, v),
+    primaryLt: (nv, v) => this.comparator.isPrimaryLower(nv, v),
+    primaryLte: (nv, v) => this.comparator.isPrimaryLower(nv, v) || this.comparator.isPrimarySame(nv, v),
+    primaryEqual: (nv, v) => this.comparator.isPrimarySame(nv, v),
+    primaryNotEqual: (nv, v) => this.comparator.isPrimarySame(nv, v) === false,
+    primaryOr: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isPrimarySame(nv, v2)),
     like: (nv, v) => {
       const nodeValue = this.comparator.match(nv);
       const value = this.comparator.match(v);
@@ -466,9 +472,15 @@ var BPTree = class {
     lt: (v) => this.insertableNode(v),
     lte: (v) => this.insertableNode(v),
     equal: (v) => this.insertableNode(v),
-    primaryEqual: (v) => this.insertableNodeByPrimary(v),
     notEqual: (v) => this.leftestNode(),
     or: (v) => this.insertableNode(this.lowestValue(this.ensureValues(v))),
+    primaryGt: (v) => this.insertableNodeByPrimary(v),
+    primaryGte: (v) => this.insertableNodeByPrimary(v),
+    primaryLt: (v) => this.insertableNodeByPrimary(v),
+    primaryLte: (v) => this.insertableRightestNodeByPrimary(v),
+    primaryEqual: (v) => this.insertableNodeByPrimary(v),
+    primaryNotEqual: (v) => this.leftestNode(),
+    primaryOr: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(this.ensureValues(v))),
     like: (v) => this.leftestNode()
   };
   verifierEndNode = {
@@ -477,12 +489,20 @@ var BPTree = class {
     lt: (v) => null,
     lte: (v) => null,
     equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
-    primaryEqual: (v) => null,
     notEqual: (v) => null,
     or: (v) => this.insertableEndNode(
       this.highestValue(this.ensureValues(v)),
       this.verifierDirection.or
     ),
+    primaryGt: (v) => null,
+    primaryGte: (v) => null,
+    primaryLt: (v) => null,
+    primaryLte: (v) => null,
+    primaryEqual: (v) => null,
+    primaryNotEqual: (v) => null,
+    primaryOr: (v) => this.insertableRightestEndNodeByPrimary(
+      this.highestPrimaryValue(this.ensureValues(v))
+    ),
     like: (v) => null
   };
   verifierDirection = {
@@ -491,9 +511,15 @@ var BPTree = class {
     lt: -1,
     lte: -1,
     equal: 1,
-    primaryEqual: 1,
     notEqual: 1,
     or: 1,
+    primaryGt: 1,
+    primaryGte: 1,
+    primaryLt: -1,
+    primaryLte: -1,
+    primaryEqual: 1,
+    primaryNotEqual: 1,
+    primaryOr: 1,
     like: 1
   };
   /**
@@ -507,11 +533,93 @@ var BPTree = class {
     lt: false,
     lte: false,
     equal: true,
-    primaryEqual: true,
     notEqual: false,
     or: false,
+    primaryGt: false,
+    primaryGte: false,
+    primaryLt: false,
+    primaryLte: false,
+    primaryEqual: true,
+    primaryNotEqual: false,
+    primaryOr: false,
     like: false
   };
+  /**
+   * Priority map for condition types.
+   * Higher value = higher selectivity (fewer expected results).
+   * Used by `chooseDriver` to select the most selective index.
+   */
+  static conditionPriority = {
+    equal: 100,
+    primaryEqual: 100,
+    or: 80,
+    primaryOr: 80,
+    gt: 50,
+    gte: 50,
+    lt: 50,
+    lte: 50,
+    primaryGt: 50,
+    primaryGte: 50,
+    primaryLt: 50,
+    primaryLte: 50,
+    like: 30,
+    notEqual: 10,
+    primaryNotEqual: 10
+  };
+  /**
+   * 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(candidates) {
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) return candidates[0];
+    let best = candidates[0];
+    let bestScore = 0;
+    for (const candidate of candidates) {
+      let score = 0;
+      for (const key in candidate.condition) {
+        const condKey = key;
+        const priority = _BPTree.conditionPriority[condKey] ?? 0;
+        if (priority > score) {
+          score = priority;
+        }
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        best = candidate;
+      }
+    }
+    return best;
+  }
+  /**
+   * 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, condition) {
+    for (const key in condition) {
+      const verify = this.verifierMap[key];
+      const condValue = condition[key];
+      if (!verify(nodeValue, condValue)) {
+        return false;
+      }
+    }
+    return true;
+  }
   constructor(strategy, comparator, option) {
     this.strategy = strategy;
     this.comparator = comparator;
@@ -545,6 +653,14 @@ var BPTree = class {
     const i = v.length - 1;
     return [...v].sort((a, b) => this.comparator.asc(a, b))[i];
   }
+  lowestPrimaryValue(v) {
+    const i = 0;
+    return [...v].sort((a, b) => this.comparator.primaryAsc(a, b))[i];
+  }
+  highestPrimaryValue(v) {
+    const i = v.length - 1;
+    return [...v].sort((a, b) => this.comparator.primaryAsc(a, b))[i];
+  }
   _insertAtLeaf(node, key, value) {
     if (node.values.length) {
       for (let i = 0, len = node.values.length; i < len; i++) {
@@ -624,8 +740,7 @@ var BPTreeSync = class extends BPTree {
       capacity: this.option.capacity ?? 1e3
     });
   }
-  getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate) {
-    const pairs = [];
+  *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
     let node = startNode;
     let done = false;
     let hasMatched = false;
@@ -634,71 +749,52 @@ var BPTreeSync = class extends BPTree {
         done = true;
         break;
       }
-      let i = node.values.length;
-      while (i--) {
-        const nValue = node.values[i];
-        const keys = node.keys[i];
-        if (comparator(nValue, value)) {
-          hasMatched = true;
-          let j = keys.length;
-          while (j--) {
-            pairs.push([keys[j], nValue]);
+      const len = node.values.length;
+      if (direction === 1) {
+        for (let i = 0; i < len; i++) {
+          const nValue = node.values[i];
+          const keys = node.keys[i];
+          if (comparator(nValue, value)) {
+            hasMatched = true;
+            for (let j = 0; j < keys.length; j++) {
+              yield [keys[j], nValue];
+            }
+          } else if (earlyTerminate && hasMatched) {
+            done = true;
+            break;
+          }
+        }
+      } else {
+        let i = len;
+        while (i--) {
+          const nValue = node.values[i];
+          const keys = node.keys[i];
+          if (comparator(nValue, value)) {
+            hasMatched = true;
+            let j = keys.length;
+            while (j--) {
+              yield [keys[j], nValue];
+            }
+          } else if (earlyTerminate && hasMatched) {
+            done = true;
+            break;
           }
-        } else if (earlyTerminate && hasMatched) {
-          done = true;
-          break;
         }
       }
       if (done) break;
-      if (!node.prev) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.prev);
-    }
-    return new Map(pairs.reverse());
-  }
-  getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate) {
-    const pairs = [];
-    let node = startNode;
-    let done = false;
-    let hasMatched = false;
-    while (!done) {
-      if (endNode && node.id === endNode.id) {
-        done = true;
-        break;
-      }
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const keys = node.keys[i];
-        if (comparator(nValue, value)) {
-          hasMatched = true;
-          for (let j = 0, len2 = keys.length; j < len2; j++) {
-            const key = keys[j];
-            pairs.push([key, nValue]);
-          }
-        } else if (earlyTerminate && hasMatched) {
+      if (direction === 1) {
+        if (!node.next) {
           done = true;
           break;
         }
+        node = this.getNode(node.next);
+      } else {
+        if (!node.prev) {
+          done = true;
+          break;
+        }
+        node = this.getNode(node.prev);
       }
-      if (done) break;
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return new Map(pairs);
-  }
-  getPairs(value, startNode, endNode, comparator, direction, earlyTerminate) {
-    switch (direction) {
-      case -1:
-        return this.getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate);
-      case 1:
-        return this.getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate);
-      default:
-        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
   _createNodeId(isLeaf) {
@@ -1069,6 +1165,31 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
+  insertableRightestNodeByPrimary(value) {
+    let node = this.getNode(this.root.id);
+    while (!node.leaf) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const k = node.keys;
+        if (this.comparator.isPrimaryLower(value, nValue)) {
+          node = this.getNode(k[i]);
+          break;
+        }
+        if (i + 1 === node.values.length) {
+          node = this.getNode(k[i + 1]);
+          break;
+        }
+      }
+    }
+    return node;
+  }
+  insertableRightestEndNodeByPrimary(value) {
+    const node = this.insertableRightestNodeByPrimary(value);
+    if (!node.next) {
+      return null;
+    }
+    return this.getNode(node.next);
+  }
   insertableEndNode(value, direction) {
     const insertableNode = this.insertableNode(value);
     let key;
@@ -1129,55 +1250,109 @@ var BPTreeSync = class extends BPTree {
     }
     this._nodeDeleteBuffer.clear();
   }
-  keys(condition, filterValues) {
-    for (const k in condition) {
-      const key = k;
-      const value = condition[key];
-      const startNode = this.verifierStartNode[key](value);
-      const endNode = this.verifierEndNode[key](value);
-      const direction = this.verifierDirection[key];
-      const comparator = this.verifierMap[key];
-      const earlyTerminate = this.verifierEarlyTerminate[key];
-      const pairs = this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
-      if (!filterValues) {
-        filterValues = new Set(pairs.keys());
-      } else {
-        const intersections = /* @__PURE__ */ new Set();
-        for (const key2 of filterValues) {
-          const has = pairs.has(key2);
-          if (has) {
-            intersections.add(key2);
+  /**
+   * 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) {
+    let node = this.leftestNode();
+    while (true) {
+      if (node.values) {
+        const len = node.values.length;
+        for (let i = 0; i < len; i++) {
+          const keys = node.keys[i];
+          for (let j = 0; j < keys.length; j++) {
+            if (keys[j] === key) {
+              return node.values[i];
+            }
           }
         }
-        filterValues = intersections;
       }
+      if (!node.next) break;
+      node = this.getNode(node.next);
     }
-    return filterValues ?? /* @__PURE__ */ new Set([]);
+    return void 0;
   }
-  where(condition) {
-    let result = null;
-    for (const k in condition) {
-      const key = k;
-      const value = condition[key];
-      const startNode = this.verifierStartNode[key](value);
-      const endNode = this.verifierEndNode[key](value);
-      const direction = this.verifierDirection[key];
-      const comparator = this.verifierMap[key];
-      const earlyTerminate = this.verifierEarlyTerminate[key];
-      const pairs = this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
-      if (result === null) {
-        result = pairs;
-      } else {
-        const intersection = /* @__PURE__ */ new Map();
-        for (const [k2, v] of pairs) {
-          if (result.has(k2)) {
-            intersection.set(k2, v);
-          }
+  *keysStream(condition, filterValues, limit) {
+    const stream = this.whereStream(condition, limit);
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    for (const [key] of stream) {
+      if (intersection && !intersection.has(key)) {
+        continue;
+      }
+      yield key;
+    }
+  }
+  *whereStream(condition, limit) {
+    let driverKey = null;
+    if ("primaryEqual" in condition) driverKey = "primaryEqual";
+    else if ("equal" in condition) driverKey = "equal";
+    else if ("gt" in condition) driverKey = "gt";
+    else if ("gte" in condition) driverKey = "gte";
+    else if ("lt" in condition) driverKey = "lt";
+    else if ("lte" in condition) driverKey = "lte";
+    else if ("primaryGt" in condition) driverKey = "primaryGt";
+    else if ("primaryGte" in condition) driverKey = "primaryGte";
+    else if ("primaryLt" in condition) driverKey = "primaryLt";
+    else if ("primaryLte" in condition) driverKey = "primaryLte";
+    else if ("like" in condition) driverKey = "like";
+    else if ("notEqual" in condition) driverKey = "notEqual";
+    else if ("primaryNotEqual" in condition) driverKey = "primaryNotEqual";
+    else if ("or" in condition) driverKey = "or";
+    else if ("primaryOr" in condition) driverKey = "primaryOr";
+    if (!driverKey) return;
+    const value = condition[driverKey];
+    const startNode = this.verifierStartNode[driverKey](value);
+    const endNode = this.verifierEndNode[driverKey](value);
+    const direction = this.verifierDirection[driverKey];
+    const comparator = this.verifierMap[driverKey];
+    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
+    const generator = this.getPairsGenerator(
+      value,
+      startNode,
+      endNode,
+      comparator,
+      direction,
+      earlyTerminate
+    );
+    let count = 0;
+    for (const pair of generator) {
+      const [k, v] = pair;
+      let isMatch = true;
+      for (const key in condition) {
+        if (key === driverKey) continue;
+        const verify = this.verifierMap[key];
+        const condValue = condition[key];
+        if (!verify(v, condValue)) {
+          isMatch = false;
+          break;
         }
-        result = intersection;
       }
+      if (isMatch) {
+        yield pair;
+        count++;
+        if (limit !== void 0 && count >= limit) {
+          break;
+        }
+      }
+    }
+  }
+  keys(condition, filterValues) {
+    const set = /* @__PURE__ */ new Set();
+    for (const key of this.keysStream(condition, filterValues)) {
+      set.add(key);
+    }
+    return set;
+  }
+  where(condition) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [key, value] of this.whereStream(condition)) {
+      map.set(key, value);
     }
-    return result ?? /* @__PURE__ */ new Map();
+    return map;
   }
   insert(key, value) {
     const before = this.insertableNode(value);
@@ -1552,8 +1727,7 @@ var BPTreeAsync = class extends BPTree {
       this.lock.writeUnlock(lockId);
     });
   }
-  async getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate) {
-    const pairs = [];
+  async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
     let node = startNode;
     let done = false;
     let hasMatched = false;
@@ -1562,71 +1736,52 @@ var BPTreeAsync = class extends BPTree {
         done = true;
         break;
       }
-      let i = node.values.length;
-      while (i--) {
-        const nValue = node.values[i];
-        const keys = node.keys[i];
-        if (comparator(nValue, value)) {
-          hasMatched = true;
-          let j = keys.length;
-          while (j--) {
-            pairs.push([keys[j], nValue]);
+      const len = node.values.length;
+      if (direction === 1) {
+        for (let i = 0; i < len; i++) {
+          const nValue = node.values[i];
+          const keys = node.keys[i];
+          if (comparator(nValue, value)) {
+            hasMatched = true;
+            for (let j = 0; j < keys.length; j++) {
+              yield [keys[j], nValue];
+            }
+          } else if (earlyTerminate && hasMatched) {
+            done = true;
+            break;
+          }
+        }
+      } else {
+        let i = len;
+        while (i--) {
+          const nValue = node.values[i];
+          const keys = node.keys[i];
+          if (comparator(nValue, value)) {
+            hasMatched = true;
+            let j = keys.length;
+            while (j--) {
+              yield [keys[j], nValue];
+            }
+          } else if (earlyTerminate && hasMatched) {
+            done = true;
+            break;
           }
-        } else if (earlyTerminate && hasMatched) {
-          done = true;
-          break;
         }
       }
       if (done) break;
-      if (!node.prev) {
-        done = true;
-        break;
-      }
-      node = await this.getNode(node.prev);
-    }
-    return new Map(pairs.reverse());
-  }
-  async getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate) {
-    const pairs = [];
-    let node = startNode;
-    let done = false;
-    let hasMatched = false;
-    while (!done) {
-      if (endNode && node.id === endNode.id) {
-        done = true;
-        break;
-      }
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const keys = node.keys[i];
-        if (comparator(nValue, value)) {
-          hasMatched = true;
-          for (let j = 0, len2 = keys.length; j < len2; j++) {
-            const key = keys[j];
-            pairs.push([key, nValue]);
-          }
-        } else if (earlyTerminate && hasMatched) {
+      if (direction === 1) {
+        if (!node.next) {
           done = true;
           break;
         }
+        node = await this.getNode(node.next);
+      } else {
+        if (!node.prev) {
+          done = true;
+          break;
+        }
+        node = await this.getNode(node.prev);
       }
-      if (done) break;
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = await this.getNode(node.next);
-    }
-    return new Map(pairs);
-  }
-  async getPairs(value, startNode, endNode, comparator, direction, earlyTerminate) {
-    switch (direction) {
-      case -1:
-        return await this.getPairsRightToLeft(value, startNode, endNode, comparator, earlyTerminate);
-      case 1:
-        return await this.getPairsLeftToRight(value, startNode, endNode, comparator, earlyTerminate);
-      default:
-        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
   async _createNodeId(isLeaf) {
@@ -1997,6 +2152,31 @@ var BPTreeAsync = class extends BPTree {
     }
     return node;
   }
+  async insertableRightestNodeByPrimary(value) {
+    let node = await this.getNode(this.root.id);
+    while (!node.leaf) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const k = node.keys;
+        if (this.comparator.isPrimaryLower(value, nValue)) {
+          node = await this.getNode(k[i]);
+          break;
+        }
+        if (i + 1 === node.values.length) {
+          node = await this.getNode(k[i + 1]);
+          break;
+        }
+      }
+    }
+    return node;
+  }
+  async insertableRightestEndNodeByPrimary(value) {
+    const node = await this.insertableRightestNodeByPrimary(value);
+    if (!node.next) {
+      return null;
+    }
+    return await this.getNode(node.next);
+  }
   async insertableEndNode(value, direction) {
     const insertableNode = await this.insertableNode(value);
     let key;
@@ -2057,58 +2237,114 @@ var BPTreeAsync = class extends BPTree {
     }
     this._nodeDeleteBuffer.clear();
   }
-  async keys(condition, filterValues) {
+  /**
+   * 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.
+   */
+  async get(key) {
     return this.readLock(async () => {
-      for (const k in condition) {
-        const key = k;
-        const value = condition[key];
-        const startNode = await this.verifierStartNode[key](value);
-        const endNode = await this.verifierEndNode[key](value);
-        const direction = this.verifierDirection[key];
-        const comparator = this.verifierMap[key];
-        const earlyTerminate = this.verifierEarlyTerminate[key];
-        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
-        if (!filterValues) {
-          filterValues = new Set(pairs.keys());
-        } else {
-          const intersections = /* @__PURE__ */ new Set();
-          for (const key2 of filterValues) {
-            const has = pairs.has(key2);
-            if (has) {
-              intersections.add(key2);
+      let node = await this.leftestNode();
+      while (true) {
+        if (node.values) {
+          const len = node.values.length;
+          for (let i = 0; i < len; i++) {
+            const keys = node.keys[i];
+            for (let j = 0; j < keys.length; j++) {
+              if (keys[j] === key) {
+                return node.values[i];
+              }
             }
           }
-          filterValues = intersections;
         }
+        if (!node.next) break;
+        node = await this.getNode(node.next);
       }
-      return filterValues ?? /* @__PURE__ */ new Set([]);
+      return void 0;
+    });
+  }
+  async *keysStream(condition, filterValues, limit) {
+    const stream = this.whereStream(condition, limit);
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    for await (const [key] of stream) {
+      if (intersection && !intersection.has(key)) {
+        continue;
+      }
+      yield key;
+    }
+  }
+  async *whereStream(condition, limit) {
+    let driverKey = null;
+    if ("primaryEqual" in condition) driverKey = "primaryEqual";
+    else if ("equal" in condition) driverKey = "equal";
+    else if ("gt" in condition) driverKey = "gt";
+    else if ("gte" in condition) driverKey = "gte";
+    else if ("lt" in condition) driverKey = "lt";
+    else if ("lte" in condition) driverKey = "lte";
+    else if ("primaryGt" in condition) driverKey = "primaryGt";
+    else if ("primaryGte" in condition) driverKey = "primaryGte";
+    else if ("primaryLt" in condition) driverKey = "primaryLt";
+    else if ("primaryLte" in condition) driverKey = "primaryLte";
+    else if ("like" in condition) driverKey = "like";
+    else if ("notEqual" in condition) driverKey = "notEqual";
+    else if ("primaryNotEqual" in condition) driverKey = "primaryNotEqual";
+    else if ("or" in condition) driverKey = "or";
+    else if ("primaryOr" in condition) driverKey = "primaryOr";
+    if (!driverKey) return;
+    const value = condition[driverKey];
+    const startNode = await this.verifierStartNode[driverKey](value);
+    const endNode = await this.verifierEndNode[driverKey](value);
+    const direction = this.verifierDirection[driverKey];
+    const comparator = this.verifierMap[driverKey];
+    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
+    const generator = this.getPairsGenerator(
+      value,
+      startNode,
+      endNode,
+      comparator,
+      direction,
+      earlyTerminate
+    );
+    let count = 0;
+    for await (const pair of generator) {
+      const [k, v] = pair;
+      let isMatch = true;
+      for (const key in condition) {
+        if (key === driverKey) continue;
+        const verify = this.verifierMap[key];
+        const condValue = condition[key];
+        if (!verify(v, condValue)) {
+          isMatch = false;
+          break;
+        }
+      }
+      if (isMatch) {
+        yield pair;
+        count++;
+        if (limit !== void 0 && count >= limit) {
+          break;
+        }
+      }
+    }
+  }
+  async keys(condition, filterValues) {
+    return this.readLock(async () => {
+      const set = /* @__PURE__ */ new Set();
+      for await (const key of this.keysStream(condition, filterValues)) {
+        set.add(key);
+      }
+      return set;
     });
   }
   async where(condition) {
     return this.readLock(async () => {
-      let result = null;
-      for (const k in condition) {
-        const key = k;
-        const value = condition[key];
-        const startNode = await this.verifierStartNode[key](value);
-        const endNode = await this.verifierEndNode[key](value);
-        const direction = this.verifierDirection[key];
-        const comparator = this.verifierMap[key];
-        const earlyTerminate = this.verifierEarlyTerminate[key];
-        const pairs = await this.getPairs(value, startNode, endNode, comparator, direction, earlyTerminate);
-        if (result === null) {
-          result = pairs;
-        } else {
-          const intersection = /* @__PURE__ */ new Map();
-          for (const [k2, v] of pairs) {
-            if (result.has(k2)) {
-              intersection.set(k2, v);
-            }
-          }
-          result = intersection;
-        }
+      const map = /* @__PURE__ */ new Map();
+      for await (const [key, value] of this.whereStream(condition)) {
+        map.set(key, value);
       }
-      return result ?? /* @__PURE__ */ new Map();
+      return map;
     });
   }
   async insert(key, value) {