serializable-bptree 5.0.5 → 5.1.1

package/README.md

@@ -63,6 +63,9 @@ tree.where({ equal: 1 }) // Map([{ key: 'a', value: 1 }])
 tree.where({ gt: 1 }) // Map([{ key: 'c', value: 3 }])
 tree.where({ lt: 2 }) // Map([{ key: 'a', value: 1 }])
 tree.where({ gt: 0, lt: 4 }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
+tree.where({ or: [3, 1] }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
+
+tree.clear()
 ```
 
 ## Why use a `serializable-bptree`?
@@ -320,32 +323,64 @@ import {
 
 ## Data Query Condition Clause
 
-This library supports various conditional clauses. Currently, it supports **gte**, **gt**, **lte**, **lt**, **equal**, **notEqual**, and **like** conditions. Each condition is as follows:
+This library supports various conditional clauses. Currently, it supports **gte**, **gt**, **lte**, **lt**, **equal**, **notEqual**, **or**, and **like** conditions. Each condition is as follows:
 
 ### `gte`
 
 Queries values that are greater than or equal to the given value.
 
+```typescript
+tree.where({ gte: 1 })
+```
+
 ### `gt`
 
 Queries values that are greater than the given value.
 
+```typescript
+tree.where({ gt: 1 })
+```
+
 ### `lte`
 
 Queries values that are less than or equal to the given value.
 
+```typescript
+tree.where({ lte: 5 })
+```
+
 ### `lt`
 
 Queries values that are less than the given value.
 
+```typescript
+tree.where({ lt: 5 })
+```
+
 ### `equal`
 
 Queries values that match the given value.
 
+```typescript
+tree.where({ equal: 3 })
+```
+
 ### `notEqual`
 
 Queries values that do not match the given value.
 
+```typescript
+tree.where({ notEqual: 3 })
+```
+
+### `or`
+
+Queries values that satisfy at least one of the given conditions. It accepts an array of conditions, and if any of these conditions are met, the data is included in the result.
+
+```typescript
+tree.where({ or:  [1, 2, 3] })
+```
+
 ### `like`
 
 Queries values that contain the given value in a manner similar to regular expressions. Special characters such as % and _ can be used.
@@ -357,6 +392,13 @@ Using **p_t**, it can match any string where the underscore is replaced by any c
 
 You can obtain matching data by combining these condition clauses. If there are multiple conditions, an **AND** operation is used to retrieve only the data that satisfies all conditions.
 
+```typescript
+tree.where({ like: 'hello%' })
+tree.where({ like: 'he__o%' })
+tree.where({ like: '%world!' })
+tree.where({ like: '%lo, wor%' })
+```
+
 ## Using Asynchronously
 
 Support for asynchronous trees has been available since version 3.0.0. Asynchronous is useful for operations with delays, such as file input/output and remote storage. Here is an example of how to use it:
@@ -421,6 +463,8 @@ await tree.where({ equal: 1 }) // Map([{ key: 'a', value: 1 }])
 await tree.where({ gt: 1 }) // Map([{ key: 'c', value: 3 }])
 await tree.where({ lt: 2 }) // Map([{ key: 'a', value: 1 }])
 await tree.where({ gt: 0, lt: 4 }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
+
+tree.clear()
 ```
 
 The implementation method for asynchronous operations is not significantly different. The **-Async** suffix is used instead of the **-Sync** suffix in the **BPTree** and **SerializeStrategy** classes. The only difference is that the methods become asynchronous. The **ValueComparator** class and similar value comparators do not use asynchronous operations.