dataply 0.0.3 → 0.0.5

package/dist/cjs/index.js

@@ -46,6 +46,7 @@ __export(src_exports, {
   SerializeStrategyAsync: () => SerializeStrategyAsync,
   SerializeStrategySync: () => SerializeStrategySync,
   StringComparator: () => StringComparator,
+  Transaction: () => Transaction,
   ValueComparator: () => ValueComparator
 });
 module.exports = __toCommonJS(src_exports);
@@ -781,6 +782,9 @@ var BPTreeSync = class extends BPTree {
           guess = prevValue;
         }
       }
+      if (!pointer) {
+        return;
+      }
       if (node.values.length + pointer.values.length < this.order) {
         if (!isPredecessor) {
           const pTemp = pointer;
@@ -920,45 +924,66 @@ var BPTreeSync = class extends BPTree {
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
+      if (pointer.leaf) {
+        node.next = pointer.id;
+        pointer.prev = node.id;
+      }
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
       return;
     }
     const parentNode = this.getNode(node.parent);
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      const nKeys = parentNode.keys[i];
-      if (nKeys === node.id) {
-        parentNode.values.splice(i, 0, value);
-        parentNode.keys.splice(i + 1, 0, pointer.id);
-        this.bufferForNodeUpdate(parentNode);
-        if (parentNode.keys.length > this.order) {
-          const parentPointer = this._createNode(false, [], []);
-          parentPointer.parent = parentNode.parent;
-          const mid = Math.ceil(this.order / 2) - 1;
-          parentPointer.values = parentNode.values.slice(mid + 1);
-          parentPointer.keys = parentNode.keys.slice(mid + 1);
-          const midValue = parentNode.values[mid];
-          if (mid === 0) {
-            parentNode.values = parentNode.values.slice(0, mid + 1);
-          } else {
-            parentNode.values = parentNode.values.slice(0, mid);
-          }
-          parentNode.keys = parentNode.keys.slice(0, mid + 1);
-          for (const k of parentNode.keys) {
-            const node2 = this.getNode(k);
-            node2.parent = parentNode.id;
-            this.bufferForNodeUpdate(node2);
-          }
-          for (const k of parentPointer.keys) {
-            const node2 = this.getNode(k);
-            node2.parent = parentPointer.id;
-            this.bufferForNodeUpdate(node2);
-          }
-          this._insertInParent(parentNode, midValue, parentPointer);
-          this.bufferForNodeUpdate(parentNode);
-        }
+    let insertIndex = 0;
+    for (let i = 0; i < parentNode.values.length; i++) {
+      if (this.comparator.asc(value, parentNode.values[i]) > 0) {
+        insertIndex = i + 1;
+      } else {
+        break;
+      }
+    }
+    parentNode.values.splice(insertIndex, 0, value);
+    parentNode.keys.splice(insertIndex + 1, 0, pointer.id);
+    pointer.parent = parentNode.id;
+    if (pointer.leaf) {
+      const leftSiblingId = parentNode.keys[insertIndex];
+      const rightSiblingId = parentNode.keys[insertIndex + 2];
+      if (leftSiblingId) {
+        const leftSibling = this.getNode(leftSiblingId);
+        pointer.prev = leftSibling.id;
+        pointer.next = leftSibling.next;
+        leftSibling.next = pointer.id;
+        this.bufferForNodeUpdate(leftSibling);
+      }
+      if (rightSiblingId) {
+        const rightSibling = this.getNode(rightSiblingId);
+        rightSibling.prev = pointer.id;
+        this.bufferForNodeUpdate(rightSibling);
       }
     }
+    this.bufferForNodeUpdate(parentNode);
+    this.bufferForNodeUpdate(pointer);
+    if (parentNode.keys.length > this.order) {
+      const parentPointer = this._createNode(false, [], []);
+      parentPointer.parent = parentNode.parent;
+      const mid = Math.ceil(this.order / 2) - 1;
+      parentPointer.values = parentNode.values.slice(mid + 1);
+      parentPointer.keys = parentNode.keys.slice(mid + 1);
+      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 node2 = this.getNode(k);
+        node2.parent = parentNode.id;
+        this.bufferForNodeUpdate(node2);
+      }
+      for (const k of parentPointer.keys) {
+        const node2 = this.getNode(k);
+        node2.parent = parentPointer.id;
+        this.bufferForNodeUpdate(node2);
+      }
+      this._insertInParent(parentNode, midValue, parentPointer);
+      this.bufferForNodeUpdate(parentNode);
+    }
   }
   init() {
     const head = this.strategy.readHead();
@@ -979,6 +1004,9 @@ var BPTreeSync = class extends BPTree {
     }
   }
   getNode(id) {
+    if (this._nodeUpdateBuffer.has(id)) {
+      return this._nodeUpdateBuffer.get(id);
+    }
     if (this._nodeCreateBuffer.has(id)) {
       return this._nodeCreateBuffer.get(id);
     }
@@ -986,7 +1014,7 @@ var BPTreeSync = class extends BPTree {
     return cache.raw;
   }
   insertableNode(value) {
-    let node = this.root;
+    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];
@@ -1123,21 +1151,14 @@ var BPTreeSync = class extends BPTree {
         [],
         true,
         before.parent,
-        before.next,
-        before.id
+        null,
+        null
       );
       const mid = Math.ceil(this.order / 2) - 1;
-      const beforeNext = before.next;
       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);
-      before.next = after.id;
-      if (beforeNext) {
-        const node = this.getNode(beforeNext);
-        node.prev = after.id;
-        this.bufferForNodeUpdate(node);
-      }
       this._insertInParent(before, after.values[0], after);
       this.bufferForNodeUpdate(before);
     }
@@ -1647,6 +1668,9 @@ var BPTreeAsync = class extends BPTree {
           guess = prevValue;
         }
       }
+      if (!pointer) {
+        return;
+      }
       if (node.values.length + pointer.values.length < this.order) {
         if (!isPredecessor) {
           const pTemp = pointer;
@@ -1786,45 +1810,66 @@ var BPTreeAsync = class extends BPTree {
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
+      if (pointer.leaf) {
+        node.next = pointer.id;
+        pointer.prev = node.id;
+      }
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
       return;
     }
     const parentNode = await this.getNode(node.parent);
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      const nKeys = parentNode.keys[i];
-      if (nKeys === node.id) {
-        parentNode.values.splice(i, 0, value);
-        parentNode.keys.splice(i + 1, 0, pointer.id);
-        this.bufferForNodeUpdate(parentNode);
-        if (parentNode.keys.length > this.order) {
-          const parentPointer = await this._createNode(false, [], []);
-          parentPointer.parent = parentNode.parent;
-          const mid = Math.ceil(this.order / 2) - 1;
-          parentPointer.values = parentNode.values.slice(mid + 1);
-          parentPointer.keys = parentNode.keys.slice(mid + 1);
-          const midValue = parentNode.values[mid];
-          if (mid === 0) {
-            parentNode.values = parentNode.values.slice(0, mid + 1);
-          } else {
-            parentNode.values = parentNode.values.slice(0, mid);
-          }
-          parentNode.keys = parentNode.keys.slice(0, mid + 1);
-          for (const k of parentNode.keys) {
-            const node2 = await this.getNode(k);
-            node2.parent = parentNode.id;
-            this.bufferForNodeUpdate(node2);
-          }
-          for (const k of parentPointer.keys) {
-            const node2 = await this.getNode(k);
-            node2.parent = parentPointer.id;
-            this.bufferForNodeUpdate(node2);
-          }
-          await this._insertInParent(parentNode, midValue, parentPointer);
-          this.bufferForNodeUpdate(parentNode);
-        }
+    let insertIndex = 0;
+    for (let i = 0; i < parentNode.values.length; i++) {
+      if (this.comparator.asc(value, parentNode.values[i]) > 0) {
+        insertIndex = i + 1;
+      } else {
+        break;
+      }
+    }
+    parentNode.values.splice(insertIndex, 0, value);
+    parentNode.keys.splice(insertIndex + 1, 0, pointer.id);
+    pointer.parent = parentNode.id;
+    if (pointer.leaf) {
+      const leftSiblingId = parentNode.keys[insertIndex];
+      const rightSiblingId = parentNode.keys[insertIndex + 2];
+      if (leftSiblingId) {
+        const leftSibling = await this.getNode(leftSiblingId);
+        pointer.prev = leftSibling.id;
+        pointer.next = leftSibling.next;
+        leftSibling.next = pointer.id;
+        this.bufferForNodeUpdate(leftSibling);
+      }
+      if (rightSiblingId) {
+        const rightSibling = await this.getNode(rightSiblingId);
+        rightSibling.prev = pointer.id;
+        this.bufferForNodeUpdate(rightSibling);
       }
     }
+    this.bufferForNodeUpdate(parentNode);
+    this.bufferForNodeUpdate(pointer);
+    if (parentNode.keys.length > this.order) {
+      const parentPointer = await this._createNode(false, [], []);
+      parentPointer.parent = parentNode.parent;
+      const mid = Math.ceil(this.order / 2) - 1;
+      parentPointer.values = parentNode.values.slice(mid + 1);
+      parentPointer.keys = parentNode.keys.slice(mid + 1);
+      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 node2 = await this.getNode(k);
+        node2.parent = parentNode.id;
+        this.bufferForNodeUpdate(node2);
+      }
+      for (const k of parentPointer.keys) {
+        const node2 = await this.getNode(k);
+        node2.parent = parentPointer.id;
+        this.bufferForNodeUpdate(node2);
+      }
+      await this._insertInParent(parentNode, midValue, parentPointer);
+      this.bufferForNodeUpdate(parentNode);
+    }
   }
   async init() {
     const head = await this.strategy.readHead();
@@ -1845,6 +1890,9 @@ var BPTreeAsync = class extends BPTree {
     }
   }
   async getNode(id) {
+    if (this._nodeUpdateBuffer.has(id)) {
+      return this._nodeUpdateBuffer.get(id);
+    }
     if (this._nodeCreateBuffer.has(id)) {
       return this._nodeCreateBuffer.get(id);
     }
@@ -1852,7 +1900,7 @@ var BPTreeAsync = class extends BPTree {
     return cache.raw;
   }
   async insertableNode(value) {
-    let node = this.root;
+    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];
@@ -1994,21 +2042,14 @@ var BPTreeAsync = class extends BPTree {
           [],
           true,
           before.parent,
-          before.next,
-          before.id
+          null,
+          null
         );
         const mid = Math.ceil(this.order / 2) - 1;
-        const beforeNext = before.next;
         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);
-        before.next = after.id;
-        if (beforeNext) {
-          const node = await this.getNode(beforeNext);
-          node.prev = after.id;
-          this.bufferForNodeUpdate(node);
-        }
         await this._insertInParent(before, after.values[0], after);
         this.bufferForNodeUpdate(before);
       }
@@ -5289,11 +5330,8 @@ var PageFileSystem = class {
       const chunk = data.subarray(dataOffset, dataOffset + writeSize);
       page.set(chunk, bodyStart + currentOffset);
       const currentUsedSize = currentOffset + writeSize;
-      const currentRemaining = manager.getRemainingCapacity(page);
       const newRemaining = bodySize - currentUsedSize;
-      if (newRemaining < currentRemaining) {
-        manager.setRemainingCapacity(page, newRemaining);
-      }
+      manager.setRemainingCapacity(page, newRemaining);
       await this.setPage(currentPageId, page, tx);
       dataOffset += writeSize;
       currentOffset = 0;
@@ -5307,6 +5345,20 @@ var PageFileSystem = class {
         } else {
           currentPageId = nextPageId;
         }
+      } else {
+        let nextPageId = manager.getNextPageId(page);
+        if (nextPageId !== -1) {
+          let pendingFreePageId = nextPageId;
+          while (pendingFreePageId !== -1) {
+            const pendingPage = await this.get(pendingFreePageId, tx);
+            const pendingManager = this.pageFactory.getManager(pendingPage);
+            const next = pendingManager.getNextPageId(pendingPage);
+            await this.setFreePage(pendingFreePageId, tx);
+            pendingFreePageId = next;
+          }
+          manager.setNextPageId(page, -1);
+          await this.setPage(currentPageId, page, tx);
+        }
       }
     }
   }
@@ -5408,7 +5460,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     const values = this.indexPageManger.getValues(page);
     let res;
     if (isLeaf) res = {
-      leaf: isLeaf,
+      leaf: true,
       id: indexId + "",
       parent: parentIndexId ? parentIndexId + "" : null,
       next: nextIndexId ? nextIndexId + "" : null,
@@ -5417,7 +5469,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
       values
     };
     else res = {
-      leaf: isLeaf,
+      leaf: false,
       id: indexId + "",
       parent: parentIndexId ? parentIndexId + "" : null,
       next: nextIndexId ? nextIndexId + "" : null,
@@ -5464,7 +5516,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
   }
   async delete(id) {
     const tx = TxContext.get();
-    const manager = this.factory.getManagerFromType(PageManager.CONSTANT.PAGE_TYPE_EMPTY);
+    const manager = this.factory.getManagerFromType(PageManager.CONSTANT.PAGE_TYPE_INDEX);
     let pageId = +id;
     while (true) {
       const page = await this.pfs.get(pageId, tx);
@@ -6606,5 +6658,6 @@ var GlobalTransaction = class {
   SerializeStrategyAsync,
   SerializeStrategySync,
   StringComparator,
+  Transaction,
   ValueComparator
 });

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

@@ -0,0 +1,6 @@
+import { BPTreeAsync } from 'serializable-bptree';
+export declare class RowIndexBPTree<K, V, C> extends BPTreeAsync<K, V> {
+    private _bindContext?;
+    bindContext(context?: C): void;
+    getContext(): C | undefined;
+}

package/dist/types/index.d.ts

@@ -4,4 +4,5 @@ export * from 'cache-entanglement';
 export type { DataplyOptions } from './types';
 export { Dataply } from './core/Dataply';
 export { DataplyAPI } from './core/DataplyAPI';
+export { Transaction } from './core/transaction/Transaction';
 export { GlobalTransaction } from './core/transaction/GlobalTransaction';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -47,6 +47,6 @@
     "cache-entanglement": "^1.7.1",
     "hookall": "^2.2.0",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^5.2.1"
+    "serializable-bptree": "^6.0.2"
   }
 }