dataply 0.0.26-alpha.1 → 0.0.26-alpha.3

package/dist/cjs/index.js

@@ -49,6 +49,8 @@ __export(src_exports, {
   IndexPageManager: () => IndexPageManager,
   InvertedWeakMap: () => InvertedWeakMap,
   LRUMap: () => LRUMap2,
+  Logger: () => Logger,
+  LoggerManager: () => LoggerManager,
   MVCCStrategy: () => MVCCStrategy2,
   MVCCTransaction: () => MVCCTransaction2,
   MetadataPageManager: () => MetadataPageManager,
@@ -1954,30 +1956,22 @@ var BPTreeTransaction = class _BPTreeTransaction {
    */
   _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;
+      const { index, found } = this._binarySearchValues(leaf.values, value);
+      if (found) {
+        if (leaf.keys[index].includes(key)) {
+          return false;
         }
+        leaf.keys[index].push(key);
+        return true;
       }
+      leaf.values.splice(index, 0, value);
+      leaf.keys.splice(index, 0, [key]);
+      return true;
     } else {
       leaf.values = [value];
       leaf.keys = [[key]];
       return true;
     }
-    return false;
   }
   _cloneNode(node) {
     return JSON.parse(JSON.stringify(node));
@@ -2268,12 +2262,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
-      for (const k of parentNode.keys) {
-        const n = this._cloneNode(this.getNode(k));
-        n.parent = parentNode.id;
-        this._updateNode(n);
-      }
-      for (const k of newSiblingNodeRecursive.keys) {
+      for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+        const k = newSiblingNodeRecursive.keys[i];
         const n = this._cloneNode(this.getNode(k));
         n.parent = newSiblingNodeRecursive.id;
         this._updateNode(n);
@@ -2355,7 +2345,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
             yield [keys[j], nValue];
           }
         }
@@ -2434,7 +2424,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     while (true) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const keys = node.keys[i];
-        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+        for (let j = 0, len2 = keys.length; j < len2; j++) {
           if (keys[j] === key) {
             return node.values[i];
           }
@@ -2543,8 +2533,16 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     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) {
-      const targetLeaf = this.locateLeaf(value);
+    let cachedLeafId = null;
+    let cachedLeafMaxValue = null;
+    for (let i = 0, len = sorted.length; i < len; i++) {
+      const [key, value] = sorted[i];
+      let targetLeaf;
+      if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+        targetLeaf = currentLeaf;
+      } else {
+        targetLeaf = this.locateLeaf(value);
+      }
       if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
       } else {
         if (currentLeaf !== null && modified) {
@@ -2553,8 +2551,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         currentLeaf = this._cloneNode(targetLeaf);
         modified = false;
       }
+      cachedLeafId = currentLeaf.id;
       const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
       modified = modified || changed;
+      cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
       if (currentLeaf.values.length === this.order) {
         this._updateNode(currentLeaf);
         let after = this._createNode(
@@ -2575,6 +2575,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         this._updateNode(after);
         this._insertInParent(currentLeaf, after.values[0], after);
         currentLeaf = null;
+        cachedLeafId = null;
+        cachedLeafMaxValue = null;
         modified = false;
       }
     }
@@ -2582,6 +2584,85 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._updateNode(currentLeaf);
     }
   }
+  bulkLoad(entries) {
+    if (entries.length === 0) return;
+    const root = this.getNode(this.rootId);
+    if (!root.leaf || root.values.length > 0) {
+      throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+    }
+    const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+    const grouped = [];
+    for (let i = 0, len = sorted.length; i < len; i++) {
+      const [key, value] = sorted[i];
+      const last = grouped[grouped.length - 1];
+      if (last && this.comparator.isSame(last.value, value)) {
+        if (!last.keys.includes(key)) {
+          last.keys.push(key);
+        }
+      } else {
+        grouped.push({ keys: [key], value });
+      }
+    }
+    this._deleteNode(root);
+    const maxLeafSize = this.order - 1;
+    const leaves = [];
+    for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+      const chunk = grouped.slice(i, i + maxLeafSize);
+      const leafKeys = chunk.map((g) => g.keys);
+      const leafValues = chunk.map((g) => g.value);
+      const leaf = this._createNode(
+        true,
+        leafKeys,
+        leafValues,
+        null,
+        null,
+        null
+      );
+      leaves.push(leaf);
+    }
+    for (let i = 0, len = leaves.length; i < len; i++) {
+      if (i > 0) {
+        leaves[i].prev = leaves[i - 1].id;
+      }
+      if (i < len - 1) {
+        leaves[i].next = leaves[i + 1].id;
+      }
+      this._updateNode(leaves[i]);
+    }
+    let currentLevel = leaves;
+    while (currentLevel.length > 1) {
+      const nextLevel = [];
+      for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+        const children = currentLevel.slice(i, i + this.order);
+        const childIds = children.map((c) => c.id);
+        const separators = [];
+        for (let j = 1, len2 = children.length; j < len2; j++) {
+          separators.push(children[j].values[0]);
+        }
+        const internalNode = this._createNode(
+          false,
+          childIds,
+          separators,
+          null,
+          null,
+          null
+        );
+        for (let j = 0, len2 = children.length; j < len2; j++) {
+          const child = children[j];
+          child.parent = internalNode.id;
+          this._updateNode(child);
+        }
+        nextLevel.push(internalNode);
+      }
+      currentLevel = nextLevel;
+    }
+    const newRoot = currentLevel[0];
+    this._writeHead({
+      root: newRoot.id,
+      order: this.order,
+      data: this.strategy.head.data
+    });
+  }
   _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -2685,7 +2766,8 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         siblingNode.values.push(...node.values);
         if (!siblingNode.leaf) {
           const keys = siblingNode.keys;
-          for (const key2 of keys) {
+          for (let i = 0, len = keys.length; i < len; i++) {
+            const key2 = keys[i];
             const node2 = this._cloneNode(this.getNode(key2));
             node2.parent = siblingNode.id;
             this._updateNode(node2);
@@ -2753,21 +2835,24 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
           this._updateNode(siblingNode);
         }
         if (!siblingNode.leaf) {
-          for (const key2 of siblingNode.keys) {
+          for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+            const key2 = siblingNode.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = siblingNode.id;
             this._updateNode(n);
           }
         }
         if (!node.leaf) {
-          for (const key2 of node.keys) {
+          for (let i = 0, len = node.keys.length; i < len; i++) {
+            const key2 = node.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = node.id;
             this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
-          for (const key2 of parentNode.keys) {
+          for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+            const key2 = parentNode.keys[i];
             const n = this._cloneNode(this.getNode(key2));
             n.parent = parentNode.id;
             this._updateNode(n);
@@ -2941,6 +3026,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  bulkLoad(entries) {
+    const tx = this.createTransaction();
+    tx.bulkLoad(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;
@@ -3354,12 +3447,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
-      for (const k of parentNode.keys) {
-        const n = this._cloneNode(await this.getNode(k));
-        n.parent = parentNode.id;
-        await this._updateNode(n);
-      }
-      for (const k of newSiblingNodeRecursive.keys) {
+      for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+        const k = newSiblingNodeRecursive.keys[i];
         const n = this._cloneNode(await this.getNode(k));
         n.parent = newSiblingNodeRecursive.id;
         await this._updateNode(n);
@@ -3451,7 +3540,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         for (let i = 0; i < len; i++) {
           const nValue = node.values[i];
           const keys = node.keys[i];
-          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
             yield [keys[j], nValue];
           }
         }
@@ -3529,7 +3618,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     while (true) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const keys = node.keys[i];
-        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+        for (let j = 0, len2 = keys.length; j < len2; j++) {
           if (keys[j] === key) {
             return node.values[i];
           }
@@ -3641,8 +3730,16 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       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) {
-        const targetLeaf = await this.locateLeaf(value);
+      let cachedLeafId = null;
+      let cachedLeafMaxValue = null;
+      for (let i = 0, len = sorted.length; i < len; i++) {
+        const [key, value] = sorted[i];
+        let targetLeaf;
+        if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+          targetLeaf = currentLeaf;
+        } else {
+          targetLeaf = await this.locateLeaf(value);
+        }
         if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
         } else {
           if (currentLeaf !== null && modified) {
@@ -3651,8 +3748,10 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           currentLeaf = this._cloneNode(targetLeaf);
           modified = false;
         }
+        cachedLeafId = currentLeaf.id;
         const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
         modified = modified || changed;
+        cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
         if (currentLeaf.values.length === this.order) {
           await this._updateNode(currentLeaf);
           let after = await this._createNode(
@@ -3673,6 +3772,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           await this._updateNode(after);
           await this._insertInParent(currentLeaf, after.values[0], after);
           currentLeaf = null;
+          cachedLeafId = null;
+          cachedLeafMaxValue = null;
           modified = false;
         }
       }
@@ -3681,6 +3782,87 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       }
     });
   }
+  async bulkLoad(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      const root = await this.getNode(this.rootId);
+      if (!root.leaf || root.values.length > 0) {
+        throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+      }
+      const sorted = [...entries].sort((a, b) => this.comparator.asc(a[1], b[1]));
+      const grouped = [];
+      for (let i = 0, len = sorted.length; i < len; i++) {
+        const [key, value] = sorted[i];
+        const last = grouped[grouped.length - 1];
+        if (last && this.comparator.isSame(last.value, value)) {
+          if (!last.keys.includes(key)) {
+            last.keys.push(key);
+          }
+        } else {
+          grouped.push({ keys: [key], value });
+        }
+      }
+      await this._deleteNode(root);
+      const maxLeafSize = this.order - 1;
+      const leaves = [];
+      for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+        const chunk = grouped.slice(i, i + maxLeafSize);
+        const leafKeys = chunk.map((g) => g.keys);
+        const leafValues = chunk.map((g) => g.value);
+        const leaf = await this._createNode(
+          true,
+          leafKeys,
+          leafValues,
+          null,
+          null,
+          null
+        );
+        leaves.push(leaf);
+      }
+      for (let i = 0, len = leaves.length; i < len; i++) {
+        if (i > 0) {
+          leaves[i].prev = leaves[i - 1].id;
+        }
+        if (i < len - 1) {
+          leaves[i].next = leaves[i + 1].id;
+        }
+        await this._updateNode(leaves[i]);
+      }
+      let currentLevel = leaves;
+      while (currentLevel.length > 1) {
+        const nextLevel = [];
+        for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+          const children = currentLevel.slice(i, i + this.order);
+          const childIds = children.map((c) => c.id);
+          const separators = [];
+          for (let j = 1, len2 = children.length; j < len2; j++) {
+            separators.push(children[j].values[0]);
+          }
+          const internalNode = await this._createNode(
+            false,
+            childIds,
+            separators,
+            null,
+            null,
+            null
+          );
+          for (let j = 0, len2 = children.length; j < len2; j++) {
+            const child = children[j];
+            child.parent = internalNode.id;
+            await this._updateNode(child);
+          }
+          nextLevel.push(internalNode);
+        }
+        currentLevel = nextLevel;
+      }
+      const newRoot = currentLevel[0];
+      await this._writeHead({
+        root: newRoot.id,
+        order: this.order,
+        data: this.strategy.head.data
+      });
+    });
+  }
   async _deleteEntry(node, key) {
     if (!node.leaf) {
       let keyIndex = -1;
@@ -3784,7 +3966,8 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         siblingNode.values.push(...node.values);
         if (!siblingNode.leaf) {
           const keys = siblingNode.keys;
-          for (const key2 of keys) {
+          for (let i = 0, len = keys.length; i < len; i++) {
+            const key2 = keys[i];
             const node2 = this._cloneNode(await this.getNode(key2));
             node2.parent = siblingNode.id;
             await this._updateNode(node2);
@@ -3852,21 +4035,24 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           await this._updateNode(siblingNode);
         }
         if (!siblingNode.leaf) {
-          for (const key2 of siblingNode.keys) {
+          for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+            const key2 = siblingNode.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = siblingNode.id;
             await this._updateNode(n);
           }
         }
         if (!node.leaf) {
-          for (const key2 of node.keys) {
+          for (let i = 0, len = node.keys.length; i < len; i++) {
+            const key2 = node.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = node.id;
             await this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
-          for (const key2 of parentNode.keys) {
+          for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+            const key2 = parentNode.keys[i];
             const n = this._cloneNode(await this.getNode(key2));
             n.parent = parentNode.id;
             await this._updateNode(n);
@@ -4048,6 +4234,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async bulkLoad(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.bulkLoad(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;
@@ -10528,6 +10724,8 @@ var GlobalTransaction = class {
   IndexPageManager,
   InvertedWeakMap,
   LRUMap,
+  Logger,
+  LoggerManager,
   MVCCStrategy,
   MVCCTransaction,
   MetadataPageManager,

package/dist/types/index.d.ts

@@ -2,9 +2,10 @@ export * from 'serializable-bptree';
 export * from 'ryoiki';
 export * from 'cache-entanglement';
 export * from 'mvcc-api';
-export type { DataplyOptions } from './types';
+export type { DataplyOptions, LogLevel } from './types';
 export * from './core/Page';
 export { Dataply } from './core/Dataply';
 export { DataplyAPI } from './core/DataplyAPI';
 export { Transaction } from './core/transaction/Transaction';
 export { GlobalTransaction } from './core/transaction/GlobalTransaction';
+export { Logger, LoggerManager } from './core/Logger';

package/package.json

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