serializable-bptree 1.1.0 → 2.0.0

package/README.md

@@ -59,7 +59,7 @@ tree.where({ gt: 0, lt: 4 }) // [{ key: 'a', value: 1 }, { key: 'c', value: 3 }]
 
 ## Why use a `serializable-bptree`?
 
-Firstly, in most cases, there is no need to use a B+tree in JavaScript. This is because there is a great alternative, the Map object. Nonetheless, if you need to retrieve values in a sorted order, a B+tree can be a good solution. These cases are often related to databases, and you may want to store this state not just in memory, but on a remote server or in a file. In this case, `serializable-bptree` can help you.
+Firstly, in most cases, there is no need to use a B+tree in JavaScript. This is because there is a great alternative, the Map object. Nonetheless, if you need to retrieve values in a sorted order, a B+tree can be a good solution. These cases are often related to databases, and you may want to store this state not just in memory, but on a remote server or in a file. In this case, **serializable-bptree** can help you.
 
 ## How to use
 
@@ -77,7 +77,7 @@ import { BPTree } from 'serializable-bptree'
 
 ```html
 <script type="module">
-  import { BPTree } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@1.x.x/dist/esm/index.min.js'
+  import { BPTree, ValueComparator, NumericComparator, StringComparator, InMemoryStoreStrategy } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@1.x.x/dist/esm/index.min.js'
 </script>
 ```
 
@@ -85,15 +85,15 @@ import { BPTree } from 'serializable-bptree'
 
 ### Value comparator
 
-B+tree needs to keep values in sorted order. Therefore, a process to compare the sizes of values is needed, and that role is played by the `ValueComparator`.
+B+tree needs to keep values in sorted order. Therefore, a process to compare the sizes of values is needed, and that role is played by the **ValueComparator**.
 
-Commonly used numerical and string comparisons are natively supported by the `serializable-bptree` library. Use it as follows:
+Commonly used numerical and string comparisons are natively supported by the **serializable-bptree** library. Use it as follows:
 
 ```typescript
 import { NumericComparator, StringComparator } from 'serializable-bptree'
 ```
 
-However, you may want to sort complex objects other than numbers and strings. For example, if you want to sort by the `age` property order of an object, you need to create a new class that inherits from the `ValueComparator` class. Use it as follows:
+However, you may want to sort complex objects other than numbers and strings. For example, if you want to sort by the **age** property order of an object, you need to create a new class that inherits from the **ValueComparator** class. Use it as follows:
 
 ```typescript
 import { ValueComparator } from 'serializable-bptree'
@@ -103,13 +103,15 @@ interface MyObject {
   name: string
 }
 
-class AgeComparator {
+class AgeComparator extends ValueComparator<MyObject> {
   asc(a: MyObject, b: MyObject): number {
     return a.age - b.age
   }
 }
 ```
 
+The **asc** method should return values in ascending order. If the return value is negative, it means that the parameter **a** is smaller than **b**. If the return value is positive, it means that **a** is greater than **b**. If the return value is **0**, it indicates that **a** and **b** are of the same size.
+
 ### Serialize strategy
 
 A B+tree instance is made up of numerous nodes. You would want to store this value when such nodes are created or updated. Let's assume you want to save it to a file.
@@ -132,7 +134,7 @@ What does this method mean? And why do we need to construct such a method?
 
 #### id(): `number`
 
-When a node is created in the B+tree, the node needs a unique value to represent itself. This is the `node.id` attribute, and you can specify this attribute yourself. For example, it could be implemented like this.
+When a node is created in the B+tree, the node needs a unique value to represent itself. This is the **node.id** attribute, and you can specify this attribute yourself. For example, it could be implemented like this.
 
 ```typescript
 id(): number {
@@ -142,7 +144,9 @@ id(): number {
 }
 ```
 
-Or, you could use file input/output to save and load the value of the `before` variable.
+Or, you could use file input/output to save and load the value of the **before** variable.
+
+This method is called before a node is created in the tree. Therefore, it can also be used to allocate space for storing the node.
 
 #### read(id: `number`): `BPTreeNode<K, V>`
 
@@ -158,7 +162,7 @@ read(id: number): BPTreeNode<K, V> {
 }
 ```
 
-This method is called only once when loading a node from a tree instance.
+This method is called only once when loading a node from a tree instance. The loaded node is loaded into memory, and subsequently, when the tree references the node, it operates based on the values in memory **without** re-invoking this method.
 
 #### write(id: `number`, node: `BPTreeNode<K, V>`): `void`
 
@@ -181,7 +185,7 @@ function writeBack(id: number, node: BPTreeNode<K, V>, timer: number) {
 
 ...
 write(id: number, node: BPTreeNode<K, V>): void {
-  const writeBackInterval = 100
+  const writeBackInterval = 10
   writeBack(id, node, writeBackInterval)
 }
 ```
@@ -190,32 +194,32 @@ This kind of delay writing should ideally occur within a few milliseconds. If th
 
 #### readHead(): `SerializeStrategyHead`|`null`
 
-This method is called only once when the tree is created. It's a method to restore the saved tree information. If it is the initial creation and there is no stored root node, it should return `null`.
+This method is called only once when the tree is created. It's a method to restore the saved tree information. If it is the initial creation and there is no stored root node, it should return **null**.
 
-This method should return the value stored in the `writeHead` method.
+This method should return the value stored in the **writeHead** method.
 
 #### writeHead(head: `SerializeStrategyHead`): `void`
 
-This method is called whenever the head information of the tree changes, typically when the root node changes.
+This method is called whenever the head information of the tree changes, typically when the root node changes. This method also works when the tree's **setHeadData** method is called. This is because the method attempts to store head data in the root node.
 
-As a parameter, it receives the header information of the tree. This value should be serialized and stored. Later, the `readHead` method should convert this serialized value into a json format and return it.
+As a parameter, it receives the header information of the tree. This value should be serialized and stored. Later, the **readHead** method should convert this serialized value into a json format and return it.
 
 ### The Default `ValueComparator` and `SerializeStrategy`
 
-To utilize `serializable-bptree`, you need to implement certain functions. However, a few basic helper classes are provided by default.
+To utilize **serializable-bptree**, you need to implement certain functions. However, a few basic helper classes are provided by default.
 
 #### ValueComparator
 
 * `NumericComparator`
 * `StringComparator`
 
-If the values being inserted into the tree are numeric, please use the `NumericComparator` class.
+If the values being inserted into the tree are numeric, please use the **NumericComparator** class.
 
 ```typescript
 import { NumericComparator } from 'serializable-bptree'
 ```
 
-If the values being inserted into the tree can be strings, you can use the `StringComparator` class in this case.
+If the values being inserted into the tree can be strings, you can use the **StringComparator** class in this case.
 
 ```typescript
 import { StringComparator } from 'serializable-bptree'
@@ -225,7 +229,7 @@ import { StringComparator } from 'serializable-bptree'
 
 * `InMemoryStoreStrategy`
 
-As of now, the only class supported by default is the `InMemoryStoreStrategy`. This class is suitable for use when you prefer to operate the tree solely in-memory, similar to a typical B+ tree.
+As of now, the only class supported by default is the **InMemoryStoreStrategy**. This class is suitable for use when you prefer to operate the tree solely in-memory, similar to a typical B+ tree.
 
 ```typescript
 import { InMemoryStoreStrategy } from 'serializable-bptree'

package/dist/cjs/index.js

@@ -97,6 +97,51 @@ var BPTree = class {
   _creates;
   _updates;
   _updatedHead;
+  _verifierMap = {
+    gt: (nv, v) => this.comparator.isHigher(nv, v),
+    gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
+    lt: (nv, v) => this.comparator.isLower(nv, v),
+    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
+    equal: (nv, v) => this.comparator.isSame(nv, v),
+    notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
+    like: (nv, v) => {
+      const nodeValue = nv.toString();
+      const value = v.toString();
+      const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+      const regex = new RegExp(`^${pattern}$`, "i");
+      return regex.test(nodeValue);
+    }
+  };
+  _verifierStartNode = {
+    gt: (v) => this.insertableNode(v),
+    gte: (v) => this.insertableNode(v),
+    // todo
+    lt: (v) => this.insertableNode(v),
+    lte: (v) => this.insertableNode(v),
+    // todo
+    equal: (v) => this.insertableNode(v),
+    notEqual: (v) => this.leftestNode(),
+    like: (v) => this.leftestNode()
+    // todo
+  };
+  _verifierDirection = {
+    gt: 1,
+    gte: 1,
+    lt: -1,
+    lte: -1,
+    equal: 1,
+    notEqual: 1,
+    like: 1
+  };
+  _verifierFullSearch = {
+    gt: false,
+    gte: false,
+    lt: false,
+    lte: false,
+    equal: false,
+    notEqual: true,
+    like: true
+  };
   _createNodeId() {
     const id = this.strategy.id();
     if (id === 0) {
@@ -104,7 +149,7 @@ var BPTree = class {
     }
     return id;
   }
-  _createNode(keys, values, leaf = false, parent = 0, next = 0) {
+  _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
     const id = this._createNodeId();
     const node = {
       id,
@@ -112,7 +157,8 @@ var BPTree = class {
       values,
       leaf,
       parent,
-      next
+      next,
+      prev
     };
     this.nodes.set(id, node);
     return node;
@@ -199,7 +245,7 @@ var BPTree = class {
     }
     return node;
   }
-  _insertableNode(value) {
+  insertableNode(value) {
     let node = this.root;
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
@@ -225,7 +271,7 @@ var BPTree = class {
    * @param value The value to search for.
    */
   exists(key, value) {
-    const node = this._insertableNode(value);
+    const node = this.insertableNode(value);
     for (let i = 0, len = node.values.length; i < len; i++) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
@@ -311,218 +357,50 @@ var BPTree = class {
       }
     }
   }
-  _equalCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "equal");
-  }
-  _notEqualCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "notEqual");
-  }
-  _onlyGtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "gt") && !Object.prototype.hasOwnProperty.call(condition, "lt");
-  }
-  _onlyLtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "lt") && !Object.prototype.hasOwnProperty.call(condition, "gt");
-  }
-  _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);
-    if (start === -1) {
-      return [];
-    }
-    const pairs = [];
-    for (let i = start; i < end; i++) {
-      const keys = node.keys[i];
-      for (const key of keys) {
-        pairs.push({ key, value });
-      }
-    }
-    return pairs;
-  }
-  _getPairsFromNEValue(value) {
+  _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    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 keys = node.keys[i];
-        if (this.comparator.isSame(nValue, value) === false) {
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
-          }
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return pairs;
-  }
-  _getPairsFromRange(gt, lt) {
-    const pairs = [];
-    let node = this._insertableNode(gt);
+    let node = startNode;
     let done = false;
     let found = false;
     while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
+      let i = node.values.length;
+      while (i--) {
         const nValue = node.values[i];
         const keys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
+        if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          let j = keys.length;
+          while (j--) {
+            pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
       }
-      if (!node.next) {
+      if (!node.prev) {
         done = true;
         break;
       }
-      node = this.getNode(node.next);
+      node = this.getNode(node.prev);
     }
-    return pairs;
+    return pairs.reverse();
   }
-  _getPairsFromGt(gt) {
+  _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    let node = this._insertableNode(gt);
+    let node = startNode;
     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 keys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt)) {
+        if (comparator(nValue, value)) {
           found = true;
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
@@ -535,75 +413,62 @@ var BPTree = class {
     }
     return pairs;
   }
-  _getPairsFromLt(lt) {
-    const pairs = [];
-    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 keys = node.keys[i];
-        if (this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
+  getPairs(value, startNode, fullSearch, comparator, direction) {
+    switch (direction) {
+      case -1:
+        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+      case 1:
+        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
-    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.
+   * The result is key set instance, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` 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.
+   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` 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.`);
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this._verifierStartNode[key](value);
+      const direction = this._verifierDirection[key];
+      const fullSearch = this._verifierFullSearch[key];
+      const comparator = this._verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      if (result === null) {
+        result = pairs.map((pair) => pair.key);
+      } else {
+        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+      }
     }
+    return new Set(result ?? []);
   }
   /**
    * 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.
-   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * The result includes the key and value attributes, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
    */
   where(condition) {
-    if (this._equalCondition(condition)) {
-      return this._getPairsFromValue(condition.equal);
-    } else if (this._notEqualCondition(condition)) {
-      return this._getPairsFromNEValue(condition.notEqual);
-    } else if (this._rangeCondition(condition)) {
-      const { gt, lt } = condition;
-      return this._getPairsFromRange(gt, lt);
-    } else if (this._onlyGtCondition(condition)) {
-      return this._getPairsFromGt(condition.gt);
-    } else if (this._onlyLtCondition(condition)) {
-      return this._getPairsFromLt(condition.lt);
-    } else {
-      throw new Error(`The 'condition' parameter is invalid.`);
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this._verifierStartNode[key](value);
+      const direction = this._verifierDirection[key];
+      const fullSearch = this._verifierFullSearch[key];
+      const comparator = this._verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      if (result === null) {
+        result = pairs;
+      } else {
+        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+      }
     }
+    return result ?? [];
   }
   /**
    * You enter the key and value as a pair. You can later search for the pair by value.
@@ -612,7 +477,7 @@ var BPTree = class {
    * @param value The value of the pair.
    */
   insert(key, value) {
-    const before = this._insertableNode(value);
+    const before = this.insertableNode(value);
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = this._createNode(
@@ -620,14 +485,21 @@ var BPTree = class {
         [],
         true,
         before.parent,
-        before.next
+        before.next,
+        before.id
       );
       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._setUpdates(node);
+      }
       this._insertInParent(before, after.values[0], after);
       this._setCreates(after);
       this._setUpdates(before);
@@ -642,7 +514,7 @@ var BPTree = class {
    * @param value The value of the pair.
    */
   delete(key, value) {
-    const node = this._insertableNode(value);
+    const node = this.insertableNode(value);
     let i = node.values.length;
     while (i--) {
       const nValue = node.values[i];
@@ -703,18 +575,18 @@ var BPTree = class {
       let parentNode = this.getNode(node.parent);
       let prevNode = null;
       let nextNode = null;
-      let prevK = null;
-      let postK = null;
+      let prevValue = null;
+      let postValue = null;
       for (let i = 0, len = parentNode.keys.length; i < len; i++) {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
             prevNode = this.getNode(parentNode.keys[i - 1]);
-            prevK = parentNode.values[i - 1];
+            prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
             nextNode = this.getNode(parentNode.keys[i + 1]);
-            postK = parentNode.values[i];
+            postValue = parentNode.values[i];
           }
         }
       }
@@ -722,19 +594,19 @@ var BPTree = class {
       let guess;
       if (prevNode === null) {
         pointer = nextNode;
-        guess = postK;
+        guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
         pointer = prevNode;
-        guess = prevK;
+        guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
           pointer = nextNode;
-          guess = postK;
+          guess = postValue;
         } else {
           isPredecessor = true;
           pointer = prevNode;
-          guess = prevK;
+          guess = prevValue;
         }
       }
       if (node.values.length + pointer.values.length < this.order) {
@@ -748,6 +620,20 @@ var BPTree = class {
           pointer.values.push(guess);
         } else {
           pointer.next = node.next;
+          pointer.prev = node.id;
+          if (pointer.next) {
+            const n = this.getNode(node.next);
+            n.prev = pointer.id;
+            this._setUpdates(n);
+          }
+          if (pointer.prev) {
+            const n = this.getNode(node.id);
+            n.next = pointer.id;
+            this._setUpdates(n);
+          }
+          if (isPredecessor) {
+            pointer.prev = 0;
+          }
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {

package/dist/esm/index.js

@@ -66,6 +66,51 @@ var BPTree = class {
   _creates;
   _updates;
   _updatedHead;
+  _verifierMap = {
+    gt: (nv, v) => this.comparator.isHigher(nv, v),
+    gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
+    lt: (nv, v) => this.comparator.isLower(nv, v),
+    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
+    equal: (nv, v) => this.comparator.isSame(nv, v),
+    notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
+    like: (nv, v) => {
+      const nodeValue = nv.toString();
+      const value = v.toString();
+      const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+      const regex = new RegExp(`^${pattern}$`, "i");
+      return regex.test(nodeValue);
+    }
+  };
+  _verifierStartNode = {
+    gt: (v) => this.insertableNode(v),
+    gte: (v) => this.insertableNode(v),
+    // todo
+    lt: (v) => this.insertableNode(v),
+    lte: (v) => this.insertableNode(v),
+    // todo
+    equal: (v) => this.insertableNode(v),
+    notEqual: (v) => this.leftestNode(),
+    like: (v) => this.leftestNode()
+    // todo
+  };
+  _verifierDirection = {
+    gt: 1,
+    gte: 1,
+    lt: -1,
+    lte: -1,
+    equal: 1,
+    notEqual: 1,
+    like: 1
+  };
+  _verifierFullSearch = {
+    gt: false,
+    gte: false,
+    lt: false,
+    lte: false,
+    equal: false,
+    notEqual: true,
+    like: true
+  };
   _createNodeId() {
     const id = this.strategy.id();
     if (id === 0) {
@@ -73,7 +118,7 @@ var BPTree = class {
     }
     return id;
   }
-  _createNode(keys, values, leaf = false, parent = 0, next = 0) {
+  _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
     const id = this._createNodeId();
     const node = {
       id,
@@ -81,7 +126,8 @@ var BPTree = class {
       values,
       leaf,
       parent,
-      next
+      next,
+      prev
     };
     this.nodes.set(id, node);
     return node;
@@ -168,7 +214,7 @@ var BPTree = class {
     }
     return node;
   }
-  _insertableNode(value) {
+  insertableNode(value) {
     let node = this.root;
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
@@ -194,7 +240,7 @@ var BPTree = class {
    * @param value The value to search for.
    */
   exists(key, value) {
-    const node = this._insertableNode(value);
+    const node = this.insertableNode(value);
     for (let i = 0, len = node.values.length; i < len; i++) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
@@ -280,218 +326,50 @@ var BPTree = class {
       }
     }
   }
-  _equalCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "equal");
-  }
-  _notEqualCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "notEqual");
-  }
-  _onlyGtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "gt") && !Object.prototype.hasOwnProperty.call(condition, "lt");
-  }
-  _onlyLtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "lt") && !Object.prototype.hasOwnProperty.call(condition, "gt");
-  }
-  _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);
-    if (start === -1) {
-      return [];
-    }
-    const pairs = [];
-    for (let i = start; i < end; i++) {
-      const keys = node.keys[i];
-      for (const key of keys) {
-        pairs.push({ key, value });
-      }
-    }
-    return pairs;
-  }
-  _getPairsFromNEValue(value) {
+  _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    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 keys = node.keys[i];
-        if (this.comparator.isSame(nValue, value) === false) {
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
-          }
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return pairs;
-  }
-  _getPairsFromRange(gt, lt) {
-    const pairs = [];
-    let node = this._insertableNode(gt);
+    let node = startNode;
     let done = false;
     let found = false;
     while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
+      let i = node.values.length;
+      while (i--) {
         const nValue = node.values[i];
         const keys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
+        if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          let j = keys.length;
+          while (j--) {
+            pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
       }
-      if (!node.next) {
+      if (!node.prev) {
         done = true;
         break;
       }
-      node = this.getNode(node.next);
+      node = this.getNode(node.prev);
     }
-    return pairs;
+    return pairs.reverse();
   }
-  _getPairsFromGt(gt) {
+  _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    let node = this._insertableNode(gt);
+    let node = startNode;
     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 keys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt)) {
+        if (comparator(nValue, value)) {
           found = true;
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
@@ -504,75 +382,62 @@ var BPTree = class {
     }
     return pairs;
   }
-  _getPairsFromLt(lt) {
-    const pairs = [];
-    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 keys = node.keys[i];
-        if (this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
+  getPairs(value, startNode, fullSearch, comparator, direction) {
+    switch (direction) {
+      case -1:
+        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+      case 1:
+        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
-    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.
+   * The result is key set instance, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` 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.
+   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` 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.`);
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this._verifierStartNode[key](value);
+      const direction = this._verifierDirection[key];
+      const fullSearch = this._verifierFullSearch[key];
+      const comparator = this._verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      if (result === null) {
+        result = pairs.map((pair) => pair.key);
+      } else {
+        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+      }
     }
+    return new Set(result ?? []);
   }
   /**
    * 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.
-   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * The result includes the key and value attributes, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
    */
   where(condition) {
-    if (this._equalCondition(condition)) {
-      return this._getPairsFromValue(condition.equal);
-    } else if (this._notEqualCondition(condition)) {
-      return this._getPairsFromNEValue(condition.notEqual);
-    } else if (this._rangeCondition(condition)) {
-      const { gt, lt } = condition;
-      return this._getPairsFromRange(gt, lt);
-    } else if (this._onlyGtCondition(condition)) {
-      return this._getPairsFromGt(condition.gt);
-    } else if (this._onlyLtCondition(condition)) {
-      return this._getPairsFromLt(condition.lt);
-    } else {
-      throw new Error(`The 'condition' parameter is invalid.`);
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this._verifierStartNode[key](value);
+      const direction = this._verifierDirection[key];
+      const fullSearch = this._verifierFullSearch[key];
+      const comparator = this._verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      if (result === null) {
+        result = pairs;
+      } else {
+        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+      }
     }
+    return result ?? [];
   }
   /**
    * You enter the key and value as a pair. You can later search for the pair by value.
@@ -581,7 +446,7 @@ var BPTree = class {
    * @param value The value of the pair.
    */
   insert(key, value) {
-    const before = this._insertableNode(value);
+    const before = this.insertableNode(value);
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = this._createNode(
@@ -589,14 +454,21 @@ var BPTree = class {
         [],
         true,
         before.parent,
-        before.next
+        before.next,
+        before.id
       );
       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._setUpdates(node);
+      }
       this._insertInParent(before, after.values[0], after);
       this._setCreates(after);
       this._setUpdates(before);
@@ -611,7 +483,7 @@ var BPTree = class {
    * @param value The value of the pair.
    */
   delete(key, value) {
-    const node = this._insertableNode(value);
+    const node = this.insertableNode(value);
     let i = node.values.length;
     while (i--) {
       const nValue = node.values[i];
@@ -672,18 +544,18 @@ var BPTree = class {
       let parentNode = this.getNode(node.parent);
       let prevNode = null;
       let nextNode = null;
-      let prevK = null;
-      let postK = null;
+      let prevValue = null;
+      let postValue = null;
       for (let i = 0, len = parentNode.keys.length; i < len; i++) {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
             prevNode = this.getNode(parentNode.keys[i - 1]);
-            prevK = parentNode.values[i - 1];
+            prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
             nextNode = this.getNode(parentNode.keys[i + 1]);
-            postK = parentNode.values[i];
+            postValue = parentNode.values[i];
           }
         }
       }
@@ -691,19 +563,19 @@ var BPTree = class {
       let guess;
       if (prevNode === null) {
         pointer = nextNode;
-        guess = postK;
+        guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
         pointer = prevNode;
-        guess = prevK;
+        guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
           pointer = nextNode;
-          guess = postK;
+          guess = postValue;
         } else {
           isPredecessor = true;
           pointer = prevNode;
-          guess = prevK;
+          guess = prevValue;
         }
       }
       if (node.values.length + pointer.values.length < this.order) {
@@ -717,6 +589,20 @@ var BPTree = class {
           pointer.values.push(guess);
         } else {
           pointer.next = node.next;
+          pointer.prev = node.id;
+          if (pointer.next) {
+            const n = this.getNode(node.next);
+            n.prev = pointer.id;
+            this._setUpdates(n);
+          }
+          if (pointer.prev) {
+            const n = this.getNode(node.id);
+            n.next = pointer.id;
+            this._setUpdates(n);
+          }
+          if (isPredecessor) {
+            pointer.prev = 0;
+          }
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {

package/dist/typings/BPTree.d.ts

@@ -2,14 +2,22 @@ import type { Json } from './utils/types';
 import { BinarySearch } from './utils/BinarySearch';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
-type BPTreeCondition<V> = {
-    gt?: V;
-    lt?: V;
-} | {
+type BPTreeCondition<V> = Partial<{
+    /** Searches for pairs greater than the given value. */
+    gt: V;
+    /** Searches for pairs less than the given value. */
+    lt: V;
+    /** Searches for pairs greater than or equal to the given value. */
+    gte: V;
+    /** Searches for pairs less than or equal to the given value. */
+    lte: V;
+    /** "Searches for pairs equal to the given value. */
     equal: V;
-} | {
+    /** Searches for pairs not equal to the given value. */
     notEqual: V;
-};
+    /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
+    like: V;
+}>;
 type BPTreePair<K, V> = {
     key: K;
     value: V;
@@ -22,6 +30,7 @@ export interface BPTreeNode<K, V> {
     leaf: boolean;
     parent: number;
     next: number;
+    prev: number;
 }
 export interface BPTreeInternalNode<K, V> extends BPTreeNode<K, V> {
     leaf: false;
@@ -42,6 +51,10 @@ export declare class BPTree<K, V> {
     private readonly _creates;
     private readonly _updates;
     private _updatedHead;
+    private readonly _verifierMap;
+    private readonly _verifierStartNode;
+    private readonly _verifierDirection;
+    private readonly _verifierFullSearch;
     private _createNodeId;
     private _createNode;
     /**
@@ -58,7 +71,7 @@ export declare class BPTree<K, V> {
     private _emitUpdates;
     protected getNode(id: number): BPTreeUnknownNode<K, V>;
     protected leftestNode(): BPTreeLeafNode<K, V>;
-    private _insertableNode;
+    protected insertableNode(value: V): BPTreeLeafNode<K, V>;
     /**
      * It returns whether there is a value in the tree.
      * @param key The key value to search for.
@@ -67,32 +80,20 @@ export declare class BPTree<K, V> {
     exists(key: K, value: V): boolean;
     private _insertAtLeaf;
     private _insertInParent;
-    private _equalCondition;
-    private _notEqualCondition;
-    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;
+    private _getPairsRightToLeft;
+    private _getPairsLeftToRight;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): BPTreePair<K, V>[];
     /**
      * 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.
+     * The result is key set instance, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` 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.
+     * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` 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.
-     * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+     * The result includes the key and value attributes, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+     * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
      */
     where(condition: BPTreeCondition<V>): BPTreePair<K, V>[];
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -17,6 +17,7 @@
     "serializable-bptree",
     "b-plus-tree",
     "serialize",
+    "serialization",
     "store",
     "btree",
     "bptree",