hyperbee2 1.1.2 → 2.0.0

package/lib/ranges.js

@@ -0,0 +1,144 @@
+const { Readable } = require('streamx')
+const b4a = require('b4a')
+
+class RangeIterator {
+  constructor(tree, { activeRequests = [], reverse = false, limit = -1, gte, gt, lte, lt } = {}) {
+    this.tree = tree
+    this.root = null
+    this.stack = []
+    this.activeRequests = activeRequests
+    this.reverse = reverse
+    this.limit = limit
+    this.start = gte || gt || null
+    this.end = lte || lt || null
+    this.inclusive = !!(reverse ? lte : gte)
+    this.compare = (reverse ? gte : lte) ? 0 : -1
+  }
+
+  async open() {
+    if (!this.root) this.root = await this.tree.bootstrap(this.activeRequests)
+    if (!this.root) return
+
+    if (this.limit === 0) return
+
+    this.stack.push({ node: this.root, offset: 0 })
+
+    if (this.reverse ? !this.end : !this.start) return
+
+    const offset = this.inclusive ? 0 : 1
+
+    while (true) {
+      const top = this.stack[this.stack.length - 1]
+      const v = top.node.value
+        ? this.tree.bump(top.node)
+        : await this.tree.inflate(top.node, this.activeRequests)
+
+      for (let i = 0; i < v.keys.length; i++) {
+        const j = this.reverse ? v.keys.length - 1 - i : i
+
+        const c = this.reverse
+          ? b4a.compare(v.keys.get(j).key, this.end)
+          : b4a.compare(this.start, v.keys.get(j).key)
+
+        if (c < 0) break
+        top.offset = 2 * i + 1 + (c === 0 ? offset : 1)
+      }
+
+      const child = (top.offset & 1) === 0
+      const k = top.offset >> 1
+
+      if (!child || k >= v.children.length) break
+
+      const j = this.reverse ? v.children.length - 1 - k : k
+
+      this.stack.push({
+        node: v.children.get(j),
+        offset: 0
+      })
+
+      top.offset++
+    }
+  }
+
+  async next() {
+    const key = await this.nextKey()
+    return key === null ? key : this.tree.finalizeKeyPointer(key, this.activeRequests)
+  }
+
+  async nextKey() {
+    while (this.stack.length && (this.limit === -1 || this.limit > 0)) {
+      const top = this.stack.pop()
+      const v = top.node.value
+        ? this.tree.bump(top.node)
+        : await this.tree.inflate(top.node, this.activeRequests)
+
+      const offset = top.offset++
+      const child = (offset & 1) === 0
+      const k = offset >> 1
+
+      if (child) {
+        this.stack.push(top)
+        if (k < v.children.length) {
+          const j = this.reverse ? v.children.length - 1 - k : k
+          this.stack.push({ node: v.children.get(j), offset: 0 })
+        }
+        continue
+      }
+
+      if (k < v.keys.length) {
+        const j = this.reverse ? v.keys.length - 1 - k : k
+
+        const data = top.node.value.keys.get(j)
+
+        const c = this.reverse
+          ? this.start
+            ? b4a.compare(this.start, data.key)
+            : -1
+          : this.end
+            ? b4a.compare(data.key, this.end)
+            : -1
+
+        if (c > this.compare) break
+
+        this.stack.push(top)
+        if (this.limit !== -1) this.limit--
+        return data
+      }
+    }
+
+    return null
+  }
+}
+
+class RangeStream extends Readable {
+  constructor(tree, options = {}) {
+    const { highWaterMark } = options
+    super({ eagerOpen: true, highWaterMark })
+
+    this.tree = tree
+    this.iterator = new RangeIterator(tree, options)
+  }
+
+  async _open(cb) {
+    try {
+      await this.iterator.open()
+    } catch (err) {
+      cb(err)
+      return
+    }
+    cb(null)
+  }
+
+  async _read(cb) {
+    try {
+      this.push(await this.iterator.next())
+    } catch (err) {
+      cb(err)
+      return
+    }
+    cb(null)
+  }
+}
+
+exports.RangeIterator = RangeIterator
+exports.RangeStream = RangeStream

package/lib/tree.js

@@ -1,29 +1,22 @@
 const b4a = require('b4a')
+const { CompressedArray } = require('./compression.js')
 
-const T = 5
-const MIN_KEYS = T - 1
-const MAX_CHILDREN = MIN_KEYS * 2 + 1
+const INSERTED = -1
+const NEEDS_SPLIT = -2
 
-const UNCHANGED = 0
-const CHANGED = 1
-const NEEDS_SPLIT = 2
-
-class DataPointer {
-  constructor(context, core, seq, offset, changed, key, value) {
+class ValuePointer {
+  constructor(context, core, seq, offset, split) {
     this.context = context
 
     this.core = core
     this.seq = seq
     this.offset = offset
-    this.changed = changed
-
-    this.key = key
-    this.value = value
+    this.split = split
   }
 }
 
-class TreeNodePointer {
-  constructor(context, core, seq, offset, changed, value) {
+class Pointer {
+  constructor(context, core, seq, offset, changed) {
     this.context = context
 
     this.core = core
@@ -31,68 +24,121 @@ class TreeNodePointer {
     this.offset = offset
     this.changed = changed
 
+    this.changedBy = null
+  }
+}
+
+class KeyPointer extends Pointer {
+  constructor(context, core, seq, offset, changed, key, value, valuePointer) {
+    super(context, core, seq, offset, changed)
+
+    this.key = key
+    this.value = value
+    this.valuePointer = valuePointer
+  }
+
+  // TODO: remove, left here for easier debugging for now
+  // [Symbol.for('nodejs.util.inspect.custom')]() {
+  //   return (
+  //     `[KeyPointer core=${this.core} seq=${this.seq}, offset=${this.offset}, key="${b4a.toString(this.key)}"]`
+  //   )
+  // }
+}
+
+class TreeNodePointer extends Pointer {
+  constructor(context, core, seq, offset, changed, value) {
+    super(context, core, seq, offset, changed)
+
     this.value = value
 
     this.next = null
     this.prev = null
   }
+
+  // TODO: remove, left here for easier debugging for now
+  // [Symbol.for('nodejs.util.inspect.custom')]() {
+  //   return (
+  //     `[TreeNodePointer core=${this.core} seq=${this.seq} offset=${this.offset} changed=${this.changed}]`
+  //   )
+  // }
 }
 
 class TreeNode {
   constructor(keys, children) {
-    this.keys = keys
-    this.children = children
+    this.keys = new CompressedArray(keys)
+    this.children = new CompressedArray(children)
   }
 
   isEmpty() {
     return this.keys.length === 0 && this.children.length === 0
   }
 
-  put(context, key, value, child) {
+  insertLeaf(context, key, value) {
     let s = 0
     let e = this.keys.length
-    let c
+    let c = 0
 
     while (s < e) {
       const mid = (s + e) >> 1
-      const k = this.keys[mid]
+      const k = this.keys.get(mid)
 
       c = b4a.compare(key, k.key)
 
-      if (c === 0) {
-        if (b4a.equals(k.value, value)) return UNCHANGED
-        this.keys[mid] = new DataPointer(context, 0, 0, 0, true, key, value)
-        return CHANGED
-      }
+      if (c === 0) return mid
 
       if (c < 0) e = mid
       else s = mid + 1
     }
 
     const i = c < 0 ? e : s
-    this.keys.splice(i, 0, new DataPointer(context, 0, 0, 0, true, key, value))
-    if (child) this.children.splice(i + 1, 0, child)
+    this.keys.insert(i, new KeyPointer(context, 0, 0, 0, true, key, value, null))
 
-    return this.keys.length < MAX_CHILDREN ? CHANGED : NEEDS_SPLIT
+    return this.keys.length <= context.maxKeys ? INSERTED : NEEDS_SPLIT
+  }
+
+  insertNode(context, keyPointer, treePointer) {
+    let s = 0
+    let e = this.keys.length
+    let c = 0
+
+    while (s < e) {
+      const mid = (s + e) >> 1
+      const k = this.keys.get(mid)
+
+      c = b4a.compare(keyPointer.key, k.key)
+
+      if (c === 0) return mid
+
+      if (c < 0) e = mid
+      else s = mid + 1
+    }
+
+    const i = c < 0 ? e : s
+    this.keys.insert(i, keyPointer)
+    this.children.insert(i + 1, treePointer)
+
+    return this.keys.length <= context.maxKeys ? INSERTED : NEEDS_SPLIT
   }
 
   setValue(context, i, value) {
-    this.keys[i] = new DataPointer(context, 0, 0, 0, true, this.keys[i].key, value)
+    this.keys.set(i, new KeyPointer(context, 0, 0, 0, true, this.keys.get(i).key, value, null))
   }
 
   removeKey(i) {
-    this.keys.splice(i, 1)
+    this.keys.delete(i)
     if (this.children.length) {
-      this.children.splice(i + 1, 1)
+      this.children.delete(i + 1)
     }
   }
 
   siblings(parent) {
-    for (let i = 0; i < parent.children.length; i++) {
-      if (parent.children[i].value !== this) continue // TODO: move to a seq/offset check instead
+    const pc = parent.children
 
-      const left = i ? parent.children[i - 1] : null
-      const right = i < parent.children.length - 1 ? parent.children[i + 1] : null
+    for (let i = 0; i < pc.length; i++) {
+      if (pc.get(i).value !== this) continue // TODO: move to a seq/offset check instead
+
+      const left = i ? pc.get(i - 1) : null
+      const right = i < pc.length - 1 ? pc.get(i + 1) : null
       return { left, index: i, right }
     }
 
@@ -101,23 +147,29 @@ class TreeNode {
   }
 
   merge(node, median) {
+    const keys = node.keys
+    const children = node.children
+
     this.keys.push(median)
-    for (let i = 0; i < node.keys.length; i++) this.keys.push(node.keys[i])
-    for (let i = 0; i < node.children.length; i++) this.children.push(node.children[i])
+
+    for (let i = 0; i < keys.length; i++) this.keys.push(keys.get(i))
+    for (let i = 0; i < children.length; i++) this.children.push(children.get(i))
   }
 
   split(context) {
     const len = this.keys.length >> 1
     const right = new TreeNodePointer(context, 0, 0, 0, true, new TreeNode([], []))
 
-    while (right.value.keys.length < len) right.value.keys.push(this.keys.pop())
-    right.value.keys.reverse()
+    const k = []
+    while (k.length < len) k.push(this.keys.pop())
+    for (let i = k.length - 1; i >= 0; i--) right.value.keys.push(k[i])
 
     const median = this.keys.pop()
 
     if (this.children.length) {
-      while (right.value.children.length < len + 1) right.value.children.push(this.children.pop())
-      right.value.children.reverse()
+      const c = []
+      while (c.length < len + 1) c.push(this.children.pop())
+      for (let i = c.length - 1; i >= 0; i--) right.value.children.push(c[i])
     }
 
     return {
@@ -128,16 +180,13 @@ class TreeNode {
   }
 }
 
-exports.T = T
-exports.MIN_KEYS = MIN_KEYS
-exports.MAX_CHILDREN = MAX_CHILDREN
-
-exports.UNCHANGED = UNCHANGED
-exports.CHANGED = CHANGED
+exports.INSERTED = INSERTED
 exports.NEEDS_SPLIT = NEEDS_SPLIT
 
 exports.TreeNodePointer = TreeNodePointer
 exports.TreeNode = TreeNode
-exports.DataPointer = DataPointer
+exports.KeyPointer = KeyPointer
+exports.ValuePointer = ValuePointer
+exports.Pointer = Pointer
 
 exports.EMPTY = new TreeNodePointer(null, 0, 0, 0, false, null)