dataply 0.0.22 → 0.0.23-alpha.1

package/dist/cjs/index.js

@@ -2182,17 +2182,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];
@@ -2215,8 +2222,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;
@@ -2236,16 +2247,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;
@@ -2273,6 +2284,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;
@@ -2624,6 +2662,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"}`);
+    }
+  }
 };
 var Ryoiki2 = class _Ryoiki2 {
   readings;
@@ -3249,17 +3295,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];
@@ -3282,8 +3335,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;
@@ -3303,16 +3360,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;
@@ -3342,6 +3399,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;
@@ -3699,6 +3785,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"}`);
+      }
+    });
+  }
 };
 var SerializeStrategy = class {
   order;
@@ -8711,6 +8807,7 @@ var RowTableEngine = class {
     if (!this.factory.isDataPage(lastInsertDataPage)) {
       throw new Error(`Last insert page is not data page`);
     }
+    const batchInsertData = [];
     for (const data of dataList) {
       const pk = ++lastPk;
       const willRowSize = this.getRequiredRowSize(data);
@@ -8755,9 +8852,10 @@ var RowTableEngine = class {
           await this.pfs.setPage(lastInsertDataPageId, lastInsertDataPage, tx);
         }
       }
-      await btx.insert(this.getRID(), pk);
+      batchInsertData.push([this.getRID(), pk]);
       pks.push(pk);
     }
+    await btx.batchInsert(batchInsertData);
     tx.__markBPTreeDirty();
     const freshMetadataPage = await this.pfs.getMetadata(tx);
     this.metadataPageManager.setLastInsertPageId(freshMetadataPage, lastInsertDataPageId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.22",
+  "version": "0.0.23-alpha.1",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -49,6 +49,6 @@
     "hookall": "^2.2.0",
     "mvcc-api": "^1.3.4",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^8.1.7"
+    "serializable-bptree": "^8.3.0"
   }
 }