serializable-bptree 1.0.2 → 1.0.4

package/dist/cjs/index.js

@@ -189,7 +189,8 @@ var BPTree = class {
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      node = node.keys[0];
+      const keys = node.keys;
+      node = this.getNode(keys[0]);
     }
     return node;
   }
@@ -198,14 +199,15 @@ var BPTree = class {
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
+        const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
-          node = node.keys[i];
+          node = this.getNode(k[i]);
           break;
         } else if (i + 1 === node.values.length) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         }
       }
@@ -257,7 +259,7 @@ var BPTree = class {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node, pointer], [value]);
+      const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -270,9 +272,9 @@ var BPTree = class {
     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) {
+      if (nKeys === node.id) {
         parentNode.values.splice(i, 0, value);
-        parentNode.keys.splice(i + 1, 0, pointer);
+        parentNode.keys.splice(i + 1, 0, pointer.id);
         this._setUpdates(parentNode);
         if (parentNode.keys.length > this.order) {
           const parentPointer = this._createNode([], []);
@@ -288,12 +290,14 @@ var BPTree = class {
           }
           parentNode.keys = parentNode.keys.slice(0, mid + 1);
           for (const k of parentNode.keys) {
-            const key = k;
-            key.parent = parentNode.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentNode.id;
+            this._setUpdates(node2);
           }
           for (const k of parentPointer.keys) {
-            const key = k;
-            key.parent = parentPointer.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentPointer.id;
+            this._setUpdates(node2);
           }
           this._insertInParent(parentNode, midValue, parentPointer);
           this._setCreates(parentPointer);
@@ -317,6 +321,124 @@ var BPTree = class {
   _rangeCondition(condition) {
     return Object.prototype.hasOwnProperty.call(condition, "gt") && Object.prototype.hasOwnProperty.call(condition, "lt");
   }
+  _getKeysFromValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    const node = this._insertableNode(value);
+    const [start, end] = this.search.range(node.values, value);
+    if (start === -1) {
+      return keys;
+    }
+    for (let i = start; i < end; i++) {
+      const pairKeys = node.keys[i];
+      for (const key of pairKeys) {
+        keys.add(key);
+      }
+    }
+    return keys;
+  }
+  _getKeysFromNEValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const pairKeys = node.keys[i];
+        if (this.comparator.isSame(nValue, value) === false) {
+          for (const key of pairKeys) {
+            keys.add(key);
+          }
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromRange(gt, lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromGt(gt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromLt(lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
   _getPairsFromValue(value) {
     const node = this._insertableNode(value);
     const [start, end] = this.search.range(node.values, value);
@@ -435,6 +557,28 @@ var BPTree = class {
     }
     return pairs;
   }
+  /**
+   * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.  
+   * The result is key set instance, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * This method operates much faster than first searching with `where` and then retrieving only the key list.
+   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   */
+  keys(condition) {
+    if (this._equalCondition(condition)) {
+      return this._getKeysFromValue(condition.equal);
+    } else if (this._notEqualCondition(condition)) {
+      return this._getKeysFromNEValue(condition.notEqual);
+    } else if (this._rangeCondition(condition)) {
+      const { gt, lt } = condition;
+      return this._getKeysFromRange(gt, lt);
+    } else if (this._onlyGtCondition(condition)) {
+      return this._getKeysFromGt(condition.gt);
+    } else if (this._onlyLtCondition(condition)) {
+      return this._getKeysFromLt(condition.lt);
+    } else {
+      throw new Error(`The 'condition' parameter is invalid.`);
+    }
+  }
   /**
    * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.  
    * The result includes the key and value attributes, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
@@ -542,7 +686,7 @@ var BPTree = class {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys = node.keys;
-      this.root = keys[0];
+      this.root = this.getNode(keys[0]);
       this.root.parent = 0;
       this._setHeadUpdate(this._headState);
       this._setUpdates(this.root);
@@ -558,13 +702,13 @@ var BPTree = class {
       let postK = null;
       for (let i = 0, len = parentNode.keys.length; i < len; i++) {
         const nKey = parentNode.keys[i];
-        if (nKey === node) {
+        if (nKey === node.id) {
           if (i > 0) {
-            prevNode = parentNode.keys[i - 1];
+            prevNode = this.getNode(parentNode.keys[i - 1]);
             prevK = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = parentNode.keys[i + 1];
+            nextNode = this.getNode(parentNode.keys[i + 1]);
             postK = parentNode.values[i];
           }
         }
@@ -604,10 +748,12 @@ var BPTree = class {
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            key2.parent = pointer.id;
+            const node2 = this.getNode(key2);
+            node2.parent = pointer.id;
+            this._setUpdates(node2);
           }
         }
-        this._deleteEntry(this.getNode(node.parent), node, guess);
+        this._deleteEntry(this.getNode(node.parent), node.id, guess);
         this._setUpdates(pointer);
       } else {
         if (isPredecessor) {
@@ -680,24 +826,24 @@ var BPTree = class {
           this._setUpdates(pointer);
         }
         if (!pointer.leaf) {
-          const keys = pointer.keys;
-          for (const key2 of keys) {
-            key2.parent = pointer.id;
-            this._setUpdates(pointer);
+          for (const key2 of pointer.keys) {
+            const n = this.getNode(key2);
+            n.parent = pointer.id;
+            this._setUpdates(n);
           }
         }
         if (!node.leaf) {
-          const keys = node.keys;
-          for (const key2 of keys) {
-            key2.parent = node.id;
-            this._setUpdates(node);
+          for (const key2 of node.keys) {
+            const n = this.getNode(key2);
+            n.parent = node.id;
+            this._setUpdates(n);
           }
         }
         if (!parentNode.leaf) {
-          const keys = parentNode.keys;
-          for (const key2 of keys) {
-            key2.parent = parentNode.id;
-            this._setUpdates(parentNode);
+          for (const key2 of parentNode.keys) {
+            const n = this.getNode(key2);
+            n.parent = parentNode.id;
+            this._setUpdates(n);
           }
         }
       }

package/dist/esm/index.js

@@ -158,7 +158,8 @@ var BPTree = class {
   leftestNode() {
     let node = this.root;
     while (!node.leaf) {
-      node = node.keys[0];
+      const keys = node.keys;
+      node = this.getNode(keys[0]);
     }
     return node;
   }
@@ -167,14 +168,15 @@ var BPTree = class {
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
+        const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
-          node = node.keys[i];
+          node = this.getNode(k[i]);
           break;
         } else if (i + 1 === node.values.length) {
-          node = node.keys[i + 1];
+          node = this.getNode(k[i + 1]);
           break;
         }
       }
@@ -226,7 +228,7 @@ var BPTree = class {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node, pointer], [value]);
+      const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -239,9 +241,9 @@ var BPTree = class {
     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) {
+      if (nKeys === node.id) {
         parentNode.values.splice(i, 0, value);
-        parentNode.keys.splice(i + 1, 0, pointer);
+        parentNode.keys.splice(i + 1, 0, pointer.id);
         this._setUpdates(parentNode);
         if (parentNode.keys.length > this.order) {
           const parentPointer = this._createNode([], []);
@@ -257,12 +259,14 @@ var BPTree = class {
           }
           parentNode.keys = parentNode.keys.slice(0, mid + 1);
           for (const k of parentNode.keys) {
-            const key = k;
-            key.parent = parentNode.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentNode.id;
+            this._setUpdates(node2);
           }
           for (const k of parentPointer.keys) {
-            const key = k;
-            key.parent = parentPointer.id;
+            const node2 = this.getNode(k);
+            node2.parent = parentPointer.id;
+            this._setUpdates(node2);
           }
           this._insertInParent(parentNode, midValue, parentPointer);
           this._setCreates(parentPointer);
@@ -286,6 +290,124 @@ var BPTree = class {
   _rangeCondition(condition) {
     return Object.prototype.hasOwnProperty.call(condition, "gt") && Object.prototype.hasOwnProperty.call(condition, "lt");
   }
+  _getKeysFromValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    const node = this._insertableNode(value);
+    const [start, end] = this.search.range(node.values, value);
+    if (start === -1) {
+      return keys;
+    }
+    for (let i = start; i < end; i++) {
+      const pairKeys = node.keys[i];
+      for (const key of pairKeys) {
+        keys.add(key);
+      }
+    }
+    return keys;
+  }
+  _getKeysFromNEValue(value) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const pairKeys = node.keys[i];
+        if (this.comparator.isSame(nValue, value) === false) {
+          for (const key of pairKeys) {
+            keys.add(key);
+          }
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromRange(gt, lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromGt(gt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this._insertableNode(gt);
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
+  _getKeysFromLt(lt) {
+    const keys = /* @__PURE__ */ new Set();
+    let node = this.leftestNode();
+    let done = false;
+    let found = false;
+    while (!done) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        const localKeys = node.keys[i];
+        if (this.comparator.isLower(nValue, lt)) {
+          found = true;
+          for (const key of localKeys) {
+            keys.add(key);
+          }
+        } else if (found) {
+          done = true;
+          break;
+        }
+      }
+      if (!node.next) {
+        done = true;
+        break;
+      }
+      node = this.getNode(node.next);
+    }
+    return keys;
+  }
   _getPairsFromValue(value) {
     const node = this._insertableNode(value);
     const [start, end] = this.search.range(node.values, value);
@@ -404,6 +526,28 @@ var BPTree = class {
     }
     return pairs;
   }
+  /**
+   * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.  
+   * The result is key set instance, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * This method operates much faster than first searching with `where` and then retrieving only the key list.
+   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   */
+  keys(condition) {
+    if (this._equalCondition(condition)) {
+      return this._getKeysFromValue(condition.equal);
+    } else if (this._notEqualCondition(condition)) {
+      return this._getKeysFromNEValue(condition.notEqual);
+    } else if (this._rangeCondition(condition)) {
+      const { gt, lt } = condition;
+      return this._getKeysFromRange(gt, lt);
+    } else if (this._onlyGtCondition(condition)) {
+      return this._getKeysFromGt(condition.gt);
+    } else if (this._onlyLtCondition(condition)) {
+      return this._getKeysFromLt(condition.lt);
+    } else {
+      throw new Error(`The 'condition' parameter is invalid.`);
+    }
+  }
   /**
    * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.  
    * The result includes the key and value attributes, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
@@ -511,7 +655,7 @@ var BPTree = class {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys = node.keys;
-      this.root = keys[0];
+      this.root = this.getNode(keys[0]);
       this.root.parent = 0;
       this._setHeadUpdate(this._headState);
       this._setUpdates(this.root);
@@ -527,13 +671,13 @@ var BPTree = class {
       let postK = null;
       for (let i = 0, len = parentNode.keys.length; i < len; i++) {
         const nKey = parentNode.keys[i];
-        if (nKey === node) {
+        if (nKey === node.id) {
           if (i > 0) {
-            prevNode = parentNode.keys[i - 1];
+            prevNode = this.getNode(parentNode.keys[i - 1]);
             prevK = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = parentNode.keys[i + 1];
+            nextNode = this.getNode(parentNode.keys[i + 1]);
             postK = parentNode.values[i];
           }
         }
@@ -573,10 +717,12 @@ var BPTree = class {
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            key2.parent = pointer.id;
+            const node2 = this.getNode(key2);
+            node2.parent = pointer.id;
+            this._setUpdates(node2);
           }
         }
-        this._deleteEntry(this.getNode(node.parent), node, guess);
+        this._deleteEntry(this.getNode(node.parent), node.id, guess);
         this._setUpdates(pointer);
       } else {
         if (isPredecessor) {
@@ -649,24 +795,24 @@ var BPTree = class {
           this._setUpdates(pointer);
         }
         if (!pointer.leaf) {
-          const keys = pointer.keys;
-          for (const key2 of keys) {
-            key2.parent = pointer.id;
-            this._setUpdates(pointer);
+          for (const key2 of pointer.keys) {
+            const n = this.getNode(key2);
+            n.parent = pointer.id;
+            this._setUpdates(n);
           }
         }
         if (!node.leaf) {
-          const keys = node.keys;
-          for (const key2 of keys) {
-            key2.parent = node.id;
-            this._setUpdates(node);
+          for (const key2 of node.keys) {
+            const n = this.getNode(key2);
+            n.parent = node.id;
+            this._setUpdates(n);
           }
         }
         if (!parentNode.leaf) {
-          const keys = parentNode.keys;
-          for (const key2 of keys) {
-            key2.parent = parentNode.id;
-            this._setUpdates(parentNode);
+          for (const key2 of parentNode.keys) {
+            const n = this.getNode(key2);
+            n.parent = parentNode.id;
+            this._setUpdates(n);
           }
         }
       }

package/dist/typings/BPTree.d.ts

@@ -1,7 +1,6 @@
 import { BinarySearch } from './utils/BinarySearch';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
-type BPTreeNodeKey<K, V> = K[] | BPTreeNode<K, V>;
 type BPTreeCondition<V> = {
     gt?: V;
     lt?: V;
@@ -14,21 +13,30 @@ type BPTreePair<K, V> = {
     key: K;
     value: V;
 };
+export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
 export interface BPTreeNode<K, V> {
     id: number;
-    keys: BPTreeNodeKey<K, V>[];
+    keys: number[] | K[][];
     values: V[];
     leaf: boolean;
     parent: number;
     next: number;
 }
+export interface BPTreeInternalNode<K, V> extends BPTreeNode<K, V> {
+    leaf: false;
+    keys: number[];
+}
+export interface BPTreeLeafNode<K, V> extends BPTreeNode<K, V> {
+    leaf: true;
+    keys: K[][];
+}
 export declare class BPTree<K, V> {
     protected readonly strategy: SerializeStrategy<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly search: BinarySearch<V>;
     protected readonly order: number;
-    protected readonly nodes: Map<number, BPTreeNode<K, V>>;
-    protected root: BPTreeNode<K, V>;
+    protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
+    protected root: BPTreeUnknownNode<K, V>;
     private readonly _creates;
     private readonly _updates;
     private _updatedHead;
@@ -46,8 +54,8 @@ export declare class BPTree<K, V> {
     private _emitHeadUpdates;
     private _emitCreates;
     private _emitUpdates;
-    protected getNode(id: number): BPTreeNode<K, V>;
-    protected leftestNode(): BPTreeNode<K, V>;
+    protected getNode(id: number): BPTreeUnknownNode<K, V>;
+    protected leftestNode(): BPTreeLeafNode<K, V>;
     private _insertableNode;
     /**
      * It returns whether there is a value in the tree.
@@ -62,11 +70,23 @@ export declare class BPTree<K, V> {
     private _onlyGtCondition;
     private _onlyLtCondition;
     private _rangeCondition;
+    private _getKeysFromValue;
+    private _getKeysFromNEValue;
+    private _getKeysFromRange;
+    private _getKeysFromGt;
+    private _getKeysFromLt;
     private _getPairsFromValue;
     private _getPairsFromNEValue;
     private _getPairsFromRange;
     private _getPairsFromGt;
     private _getPairsFromLt;
+    /**
+     * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.
+     * The result is key set instance, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+     * This method operates much faster than first searching with `where` and then retrieving only the key list.
+     * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+     */
+    keys(condition: BPTreeCondition<V>): Set<K>;
     /**
      * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.
      * The result includes the key and value attributes, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",