serializable-bptree 8.3.0 → 8.3.2

package/dist/cjs/index.cjs

@@ -1519,83 +1519,217 @@ var BPTreeTransaction = class _BPTreeTransaction {
       return regexp.test(nodeValue);
     }
   };
-  verifierStartNode = {
-    gt: (v) => this.insertableNodeByPrimary(v),
-    gte: (v) => this.insertableNodeByPrimary(v),
-    lt: (v) => this.insertableNodeByPrimary(v),
-    lte: (v) => this.insertableRightestNodeByPrimary(v),
-    equal: (v) => this.insertableNodeByPrimary(v),
-    notEqual: (v) => this.leftestNode(),
-    or: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(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 = {
-    gt: (v) => null,
-    gte: (v) => null,
-    lt: (v) => null,
-    lte: (v) => null,
-    equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
-    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) => this.insertableRightestEndNodeByPrimary(v),
-    primaryNotEqual: (v) => null,
-    primaryOr: (v) => this.insertableRightestEndNodeByPrimary(
-      this.highestPrimaryValue(this.ensureValues(v))
-    ),
-    like: (v) => null
-  };
-  verifierDirection = {
-    gt: 1,
-    gte: 1,
-    lt: -1,
-    lte: -1,
-    equal: 1,
-    notEqual: 1,
-    or: 1,
-    primaryGt: 1,
-    primaryGte: 1,
-    primaryLt: -1,
-    primaryLte: -1,
-    primaryEqual: 1,
-    primaryNotEqual: 1,
-    primaryOr: 1,
-    like: 1
-  };
-  /**
-   * Determines whether early termination is allowed for each condition.
-   * When true, the search will stop once a match is found and then a non-match is encountered.
-   * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
-   */
-  verifierEarlyTerminate = {
-    gt: false,
-    gte: false,
-    lt: false,
-    lte: false,
-    equal: true,
-    notEqual: false,
-    or: false,
-    primaryGt: false,
-    primaryGte: false,
-    primaryLt: false,
-    primaryLte: false,
-    primaryEqual: true,
-    primaryNotEqual: false,
-    primaryOr: false,
-    like: false
+  searchConfigs = {
+    gt: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    gte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    lt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    lte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    equal: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    notEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    or: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryGt: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryGte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryLt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryLte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryEqual: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryNotEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryOr: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    like: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    }
   };
   /**
    * Priority map for condition types.
@@ -1696,6 +1830,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));
   }
@@ -2175,16 +2342,20 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = this.verifierStartNode[driverKey](value);
-    let endNode = this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = config.start(this, v);
+    let endNode = config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -2196,7 +2367,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -2205,7 +2376,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }
@@ -2259,29 +2430,46 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   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) {
-      let before = this.insertableNode(value);
-      before = this._insertAtLeaf(before, key, value);
-      if (before.values.length === this.order) {
+      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,
           [],
           [],
-          before.parent,
+          currentLeaf.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);
+        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(before, after.values[0], 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) {
@@ -3296,16 +3484,20 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = await this.verifierStartNode[driverKey](value);
-    let endNode = await this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = await config.start(this, v);
+    let endNode = await config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = await this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = await this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? await this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -3317,7 +3509,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -3326,7 +3518,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }
@@ -3383,29 +3575,46 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     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) {
-        let before = await this.insertableNode(value);
-        before = await this._insertAtLeaf(before, key, value);
-        if (before.values.length === this.order) {
+        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,
             [],
             [],
-            before.parent,
+            currentLeaf.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);
+          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(before, after.values[0], 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) {

package/dist/esm/index.mjs

@@ -1483,83 +1483,217 @@ var BPTreeTransaction = class _BPTreeTransaction {
       return regexp.test(nodeValue);
     }
   };
-  verifierStartNode = {
-    gt: (v) => this.insertableNodeByPrimary(v),
-    gte: (v) => this.insertableNodeByPrimary(v),
-    lt: (v) => this.insertableNodeByPrimary(v),
-    lte: (v) => this.insertableRightestNodeByPrimary(v),
-    equal: (v) => this.insertableNodeByPrimary(v),
-    notEqual: (v) => this.leftestNode(),
-    or: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(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 = {
-    gt: (v) => null,
-    gte: (v) => null,
-    lt: (v) => null,
-    lte: (v) => null,
-    equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
-    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) => this.insertableRightestEndNodeByPrimary(v),
-    primaryNotEqual: (v) => null,
-    primaryOr: (v) => this.insertableRightestEndNodeByPrimary(
-      this.highestPrimaryValue(this.ensureValues(v))
-    ),
-    like: (v) => null
-  };
-  verifierDirection = {
-    gt: 1,
-    gte: 1,
-    lt: -1,
-    lte: -1,
-    equal: 1,
-    notEqual: 1,
-    or: 1,
-    primaryGt: 1,
-    primaryGte: 1,
-    primaryLt: -1,
-    primaryLte: -1,
-    primaryEqual: 1,
-    primaryNotEqual: 1,
-    primaryOr: 1,
-    like: 1
-  };
-  /**
-   * Determines whether early termination is allowed for each condition.
-   * When true, the search will stop once a match is found and then a non-match is encountered.
-   * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
-   */
-  verifierEarlyTerminate = {
-    gt: false,
-    gte: false,
-    lt: false,
-    lte: false,
-    equal: true,
-    notEqual: false,
-    or: false,
-    primaryGt: false,
-    primaryGte: false,
-    primaryLt: false,
-    primaryLte: false,
-    primaryEqual: true,
-    primaryNotEqual: false,
-    primaryOr: false,
-    like: false
+  searchConfigs = {
+    gt: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    gte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    lt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    lte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    equal: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    notEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    or: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryGt: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryGte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryLt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryLte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryEqual: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryNotEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryOr: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    like: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    }
   };
   /**
    * Priority map for condition types.
@@ -1660,6 +1794,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));
   }
@@ -2139,16 +2306,20 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = this.verifierStartNode[driverKey](value);
-    let endNode = this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = config.start(this, v);
+    let endNode = config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -2160,7 +2331,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -2169,7 +2340,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }
@@ -2223,29 +2394,46 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   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) {
-      let before = this.insertableNode(value);
-      before = this._insertAtLeaf(before, key, value);
-      if (before.values.length === this.order) {
+      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,
           [],
           [],
-          before.parent,
+          currentLeaf.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);
+        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(before, after.values[0], 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) {
@@ -3260,16 +3448,20 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = await this.verifierStartNode[driverKey](value);
-    let endNode = await this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = await config.start(this, v);
+    let endNode = await config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = await this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = await this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? await this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -3281,7 +3473,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -3290,7 +3482,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }
@@ -3347,29 +3539,46 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     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) {
-        let before = await this.insertableNode(value);
-        before = await this._insertAtLeaf(before, key, value);
-        if (before.values.length === this.order) {
+        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,
             [],
             [],
-            before.parent,
+            currentLeaf.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);
+          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(before, after.values[0], 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) {

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

@@ -17,15 +17,12 @@ export declare abstract class BPTreeTransaction<K, V> {
     protected isInitialized: boolean;
     protected isDestroyed: boolean;
     protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>;
-    protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
-    protected readonly verifierEndNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V> | null>>;
-    protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
-    /**
-     * Determines whether early termination is allowed for each condition.
-     * When true, the search will stop once a match is found and then a non-match is encountered.
-     * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
-     */
-    protected readonly verifierEarlyTerminate: Record<keyof BPTreeCondition<V>, boolean>;
+    protected readonly searchConfigs: Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', {
+        start: (tx: BPTreeTransaction<K, V>, v: V[]) => Deferred<BPTreeLeafNode<K, V> | null>;
+        end: (tx: BPTreeTransaction<K, V>, v: V[]) => Deferred<BPTreeLeafNode<K, V> | null>;
+        direction: 1 | -1;
+        earlyTerminate: boolean;
+    }>>;
     /**
      * Priority map for condition types.
      * Higher value = higher selectivity (fewer expected results).
@@ -80,6 +77,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.

package/package.json

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