dataply 0.0.26-alpha.13 → 0.0.26-alpha.15

package/dist/cjs/index.js

@@ -2341,8 +2341,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = node.keys.concat(pointerP0);
-          node.values = node.values.concat(pointerK0);
+          node.keys = [...node.keys, pointerP0];
+          node.values = [...node.values, pointerK0];
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -2422,6 +2422,13 @@ function deleteOp(ops, ctx, key, comparator, value) {
     break;
   }
 }
+function batchDeleteOp(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    deleteOp(ops, ctx, key, comparator, value);
+  }
+}
 function batchInsertOp(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -3393,6 +3400,9 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   delete(key, value) {
     deleteOp(this._ops, this._ctx, key, this.comparator, value);
   }
+  batchDelete(entries) {
+    batchDeleteOp(this._ops, this._ctx, entries, this.comparator);
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
     const head = this._readHead();
@@ -3514,6 +3524,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  batchDelete(entries) {
+    const tx = this.createTransaction();
+    tx.batchDelete(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
   batchInsert(entries) {
     const tx = this.createTransaction();
     tx.batchInsert(entries);
@@ -4332,8 +4350,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = node.keys.concat(pointerP0);
-          node.values = node.values.concat(pointerK0);
+          node.keys = [...node.keys, pointerP0];
+          node.values = [...node.values, pointerK0];
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4405,6 +4423,13 @@ async function deleteOpAsync(ops, ctx, key, comparator, value) {
     break;
   }
 }
+async function batchDeleteOpAsync(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    await deleteOpAsync(ops, ctx, key, comparator, value);
+  }
+}
 async function batchInsertOpAsync(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -4827,6 +4852,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
     });
   }
+  async batchDelete(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      await batchDeleteOpAsync(this._ops, this._ctx, entries, this.comparator);
+    });
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
     const head = await this._readHead();
@@ -4952,6 +4983,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async batchDelete(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.batchDelete(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
   async batchInsert(entries) {
     return this.writeLock(1, async () => {
       const tx = await this.createTransaction();
@@ -5057,6 +5098,7 @@ var BPTreePureSync = class {
     };
     function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5193,6 +5235,12 @@ var BPTreePureSync = class {
     deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
+  batchDelete(entries) {
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    batchDeleteOp(ops, ctx, entries, this.comparator);
+    flush();
+  }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
     const ctx = this._createCtx();
@@ -5309,6 +5357,7 @@ var BPTreePureAsync = class {
     };
     async function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         await strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5477,6 +5526,14 @@ var BPTreePureAsync = class {
       await flush();
     });
   }
+  async batchDelete(entries) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await batchDeleteOpAsync(ops, ctx, entries, this.comparator);
+      await flush();
+    });
+  }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
@@ -10812,6 +10869,82 @@ var RowTableEngine = class {
       await this.pfs.freeChain(pageId, tx);
     }
   }
+  /**
+   * Deletes multiple data in batch.
+   * @param pks Array of PKs to delete
+   * @param decrementRowCount Whether to decrement the row count to metadata
+   * @param tx Transaction
+   */
+  async deleteBatch(pks, decrementRowCount, tx) {
+    this.logger.debug(`Batch deleting ${pks.length} rows`);
+    if (pks.length === 0) {
+      return;
+    }
+    await tx.__acquireWriteLock(0);
+    const collections = await this.collectItemsByPage(pks, tx);
+    if (collections.size === 0) {
+      return;
+    }
+    const metadataPage = await this.pfs.getMetadata(false, tx);
+    const lastInsertPageId = this.metadataPageManager.getLastInsertPageId(metadataPage);
+    const batchDeleteData = [];
+    const pagesToFree = [];
+    let deletedCount = 0;
+    for (const [pageId, items] of collections) {
+      const page = await this.pfs.get(pageId, true, tx);
+      if (!this.factory.isDataPage(page)) {
+        continue;
+      }
+      let pageModified = false;
+      for (const item of items) {
+        const row = this.dataPageManager.getRow(page, item.slotIndex);
+        if (this.rowManager.getDeletedFlag(row)) {
+          continue;
+        }
+        if (this.rowManager.getOverflowFlag(row)) {
+          const overflowPageId = bytesToNumber(this.rowManager.getBody(row));
+          await this.pfs.freeChain(overflowPageId, tx);
+        }
+        this.rowManager.setDeletedFlag(row, true);
+        pageModified = true;
+        this.setRID(pageId, item.slotIndex);
+        batchDeleteData.push([this.getRID(), item.pk]);
+        deletedCount++;
+      }
+      if (pageModified) {
+        await this.pfs.setPage(pageId, page, tx);
+      }
+      if (pageId !== lastInsertPageId) {
+        const insertedRowCount = this.dataPageManager.getInsertedRowCount(page);
+        let allDeleted = true;
+        let i = 0;
+        while (i < insertedRowCount) {
+          const slotRow = this.dataPageManager.getRow(page, i);
+          if (!this.rowManager.getDeletedFlag(slotRow)) {
+            allDeleted = false;
+            break;
+          }
+          i++;
+        }
+        if (allDeleted) {
+          pagesToFree.push(pageId);
+        }
+      }
+    }
+    if (batchDeleteData.length === 0) {
+      return;
+    }
+    await this.bptree.batchDelete(batchDeleteData);
+    if (decrementRowCount) {
+      const freshMetadataPage = await this.pfs.getMetadata(true, tx);
+      const currentRowCount = this.metadataPageManager.getRowCount(freshMetadataPage);
+      this.metadataPageManager.setRowCount(freshMetadataPage, currentRowCount - deletedCount);
+      await this.pfs.setMetadata(freshMetadataPage, tx);
+    }
+    for (const pageId of pagesToFree) {
+      await this.pfs.freeChain(pageId, tx);
+    }
+  }
   /**
    * Looks up the RID corresponding to the PK in the B+ Tree and returns the actual row.
    * @param pk Primary key of the row
@@ -10953,11 +11086,6 @@ var RowTableEngine = class {
   }
 };
 
-// src/utils/catchPromise.ts
-async function catchPromise(promise) {
-  return promise.then((res) => [void 0, res]).catch((reason) => [reason]);
-}
-
 // src/core/transaction/LockManager.ts
 var LockManager = class {
   lock;
@@ -11493,41 +11621,41 @@ var DataplyAPI = class {
       const release = await this.acquireWriteLock();
       const internalTx = this.createTransaction();
       internalTx.__setWriteLockRelease(release);
-      const [error2, result2] = await catchPromise(this.txContext.run(internalTx, () => callback(internalTx)));
-      if (error2) {
+      try {
+        const result = await this.txContext.run(internalTx, () => callback(internalTx));
+        await internalTx.commit();
+        return result;
+      } catch (error) {
         await internalTx.rollback();
-        throw error2;
+        throw error;
       }
-      await internalTx.commit();
-      return result2;
     }
     if (!tx.__hasWriteLockRelease()) {
       const release = await this.acquireWriteLock();
       tx.__setWriteLockRelease(release);
     }
-    const [error, result] = await catchPromise(this.txContext.run(tx, () => callback(tx)));
-    if (error) {
-      throw error;
+    if (this.txContext.get() === tx) {
+      return callback(tx);
     }
-    return result;
+    return this.txContext.run(tx, () => callback(tx));
   }
   async withReadTransaction(callback, tx) {
     this.logger.debug("Running with read transaction");
-    const isInternalTx = !tx;
     if (!tx) {
-      tx = this.createTransaction();
-    }
-    const [error, result] = await catchPromise(this.txContext.run(tx, () => callback(tx)));
-    if (error) {
-      if (isInternalTx) {
-        await tx.rollback();
+      const internalTx = this.createTransaction();
+      try {
+        const result = await this.txContext.run(internalTx, () => callback(internalTx));
+        await internalTx.commit();
+        return result;
+      } catch (error) {
+        await internalTx.rollback();
+        throw error;
       }
-      throw error;
     }
-    if (isInternalTx) {
-      await tx.commit();
+    if (this.txContext.get() === tx) {
+      return callback(tx);
     }
-    return result;
+    return this.txContext.run(tx, () => callback(tx));
   }
   /**
    * Runs a generator callback function within a transaction context.
@@ -11671,6 +11799,23 @@ var DataplyAPI = class {
       await this.rowTableEngine.delete(pk, decrementRowCount, tx2);
     }, tx);
   }
+  /**
+   * Deletes multiple data in batch.
+   * If a transaction is not provided, it internally creates a single transaction to process.
+   * @param pks Array of PKs to delete
+   * @param decrementRowCount Whether to decrement the row count to metadata
+   * @param tx Transaction
+   */
+  async deleteBatch(pks, decrementRowCount, tx) {
+    this.logger.debug(`Deleting batch data: ${pks.length} items`);
+    if (!this.initialized) {
+      throw new Error("Dataply instance is not initialized");
+    }
+    return this.withWriteTransaction(async (tx2) => {
+      decrementRowCount = decrementRowCount ?? true;
+      await this.rowTableEngine.deleteBatch(pks, decrementRowCount, tx2);
+    }, tx);
+  }
   async select(pk, asRaw = false, tx) {
     this.logger.debug(`Selecting data for PK: ${pk}`);
     if (!this.initialized) {
@@ -11796,6 +11941,15 @@ var Dataply = class {
   async delete(pk, tx) {
     return this.api.delete(pk, true, tx);
   }
+  /**
+   * Deletes multiple data in batch.
+   * If a transaction is not provided, it internally creates a single transaction to process.
+   * @param pks Array of PKs to delete
+   * @param tx Transaction
+   */
+  async deleteBatch(pks, tx) {
+    return this.api.deleteBatch(pks, true, tx);
+  }
   async select(pk, asRaw = false, tx) {
     return this.api.select(pk, asRaw, tx);
   }

package/dist/types/core/Dataply.d.ts

@@ -63,6 +63,13 @@ export declare class Dataply {
      * @param tx Transaction
      */
     delete(pk: number, tx?: Transaction): Promise<void>;
+    /**
+     * Deletes multiple data in batch.
+     * If a transaction is not provided, it internally creates a single transaction to process.
+     * @param pks Array of PKs to delete
+     * @param tx Transaction
+     */
+    deleteBatch(pks: number[], tx?: Transaction): Promise<void>;
     /**
      * Selects data.
      * @param pk PK of the data to select

package/dist/types/core/DataplyAPI.d.ts

@@ -162,6 +162,14 @@ export declare class DataplyAPI {
      * @param tx Transaction
      */
     delete(pk: number, decrementRowCount?: boolean, tx?: Transaction): Promise<void>;
+    /**
+     * Deletes multiple data in batch.
+     * If a transaction is not provided, it internally creates a single transaction to process.
+     * @param pks Array of PKs to delete
+     * @param decrementRowCount Whether to decrement the row count to metadata
+     * @param tx Transaction
+     */
+    deleteBatch(pks: number[], decrementRowCount?: boolean, tx?: Transaction): Promise<void>;
     /**
      * Selects data.
      * @param pk PK of the data to select

package/dist/types/core/RowTableEngine.d.ts

@@ -111,6 +111,13 @@ export declare class RowTableEngine {
      * @param tx Transaction
      */
     delete(pk: number, decrementRowCount: boolean, tx: Transaction): Promise<void>;
+    /**
+     * Deletes multiple data in batch.
+     * @param pks Array of PKs to delete
+     * @param decrementRowCount Whether to decrement the row count to metadata
+     * @param tx Transaction
+     */
+    deleteBatch(pks: number[], decrementRowCount: boolean, tx: Transaction): Promise<void>;
     /**
      * Looks up the RID corresponding to the PK in the B+ Tree and returns the actual row.
      * @param pk Primary key of the row

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.26-alpha.13",
+  "version": "0.0.26-alpha.15",
   "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.7",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^9.0.4-alpha.2"
+    "serializable-bptree": "^9.0.4-alpha.3"
   }
 }