hyperbee2 2.2.0 → 2.4.1

package/lib/write.js

@@ -2,15 +2,7 @@ const b4a = require('b4a')
 const c = require('compact-encoding')
 const { OP_COHORT } = require('./compression.js')
 const { encodeBlock, TYPE_COMPAT, TYPE_LATEST } = require('./encoding.js')
-const {
-  Pointer,
-  KeyPointer,
-  ValuePointer,
-  TreeNode,
-  TreeNodePointer,
-  INSERTED,
-  NEEDS_SPLIT
-} = require('./tree.js')
+const { Pointer, KeyPointer, ValuePointer, TreeNode, INSERTED, NEEDS_SPLIT } = require('./tree.js')
 
 const PREFERRED_BLOCK_SIZE = 4096
 const INLINE_VALUE_SIZE = 4096
@@ -31,6 +23,7 @@ module.exports = class WriteBatch {
     } = opts
 
     this.tree = tree
+    this.config = tree.config.options(opts)
     this.deltaMax = deltaMax
     this.deltaMin = deltaMin
     this.inlineValueSize = inlineValueSize
@@ -76,7 +69,7 @@ module.exports = class WriteBatch {
     try {
       const ops = this.ops
 
-      const root = await this.tree.bootstrap()
+      const root = await this.tree.bootstrap(this.config)
 
       const length = this._getLength(root)
       const context = this._getContext(root)
@@ -86,7 +79,7 @@ module.exports = class WriteBatch {
       const value = changed ? new TreeNode([], []) : null
 
       this.length = length
-      this.root = new TreeNodePointer(context, 0, seq, 0, changed, value)
+      this.root = context.createTreeNode(0, seq, 0, changed, value)
 
       for (const op of ops) {
         if (op.put) op.applied = await this._put(op.key, op.value)
@@ -113,27 +106,29 @@ module.exports = class WriteBatch {
   async _put(key, value) {
     const stack = []
     const target = key
+    const snap = this.snapshot
+    const conf = this.config
 
     let ptr = this.root
 
     while (true) {
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
-      if (!v.children.length) break
+      const v = await retainAndInflate(ptr, snap, conf)
+      if (!v.children.ulength) break
 
       stack.push(ptr)
 
       let s = 0
-      let e = v.keys.length
+      let e = v.keys.ulength
       let c = 0
 
       while (s < e) {
         const mid = (s + e) >> 1
-        const m = v.keys.get(mid)
+        const m = v.keys.uget(mid)
 
         c = b4a.compare(target, m.key)
 
         if (c === 0) {
-          const existing = await this.snapshot.inflateValue(m)
+          const existing = await snap.inflateValue(m, conf)
           if (b4a.equals(existing, value)) return false
           v.setValue(this.tree.context, mid, value)
           for (let i = 0; i < stack.length; i++) stack[i].changed = true
@@ -145,16 +140,16 @@ module.exports = class WriteBatch {
       }
 
       const i = c < 0 ? e : s
-      ptr = v.children.get(i)
+      ptr = v.children.uget(i)
     }
 
-    const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+    const v = await retainAndInflate(ptr, snap, conf)
     let status = v.insertLeaf(this.tree.context, target, value)
 
     if (status >= 0) {
       // already exists, upsert if changed
-      const m = v.keys.get(status)
-      const existing = await this.snapshot.inflateValue(m)
+      const m = v.keys.uget(status)
+      const existing = await snap.inflateValue(m, conf)
       if (b4a.equals(existing, value)) return false
       v.setValue(this.tree.context, status, value)
     }
@@ -163,20 +158,19 @@ module.exports = class WriteBatch {
     for (let i = 0; i < stack.length; i++) stack[i].changed = true
 
     while (status === NEEDS_SPLIT) {
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+      const v = await retainAndInflate(ptr, snap, conf)
       const parent = stack.pop()
       const { median, right } = v.split(this.tree.context)
 
       if (parent) {
-        const p = parent.value ? this.snapshot.bump(parent) : await this.snapshot.inflate(parent)
+        const p = await retainAndInflate(parent, snap, conf)
         status = p.insertNode(this.tree.context, median, right)
         ptr = parent
       } else {
-        this.root = new TreeNodePointer(this.tree.context, 0, 0, 0, true, new TreeNode([], []))
+        this.root = this.tree.context.createTreeNode(0, 0, 0, true, new TreeNode([], []))
         this.root.value.keys.push(median)
         this.root.value.children.push(ptr)
         this.root.value.children.push(right)
-        this.snapshot.bump(this.root)
         status = INSERTED
       }
     }
@@ -190,19 +184,19 @@ module.exports = class WriteBatch {
     const stack = []
 
     while (true) {
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+      const v = await retainAndInflate(ptr, this.snapshot, this.config)
       stack.push(ptr)
 
       let s = 0
-      let e = v.keys.length
+      let e = v.keys.ulength
       let c = 0
 
       while (s < e) {
         const mid = (s + e) >> 1
-        c = b4a.compare(key, v.keys.get(mid).key)
+        c = b4a.compare(key, v.keys.uget(mid).key)
 
         if (c === 0) {
-          if (v.children.length) await this._setKeyToNearestLeaf(v, mid, stack)
+          if (v.children.ulength) await this._setKeyToNearestLeaf(v, mid, stack)
           else v.removeKey(mid)
           // we mark these as changed late, so we don't rewrite them if it is a 404
           for (let i = 0; i < stack.length; i++) stack[i].changed = true
@@ -214,88 +208,95 @@ module.exports = class WriteBatch {
         else s = mid + 1
       }
 
-      if (!v.children.length) return false
+      if (!v.children.ulength) return false
 
       const i = c < 0 ? e : s
-      ptr = v.children.get(i)
+      ptr = v.children.uget(i)
     }
 
     return false
   }
 
   async _setKeyToNearestLeaf(v, index, stack) {
-    let left = v.children.get(index)
-    let right = v.children.get(index + 1)
+    const snap = this.snapshot
+    const conf = this.config
+
+    let left = v.children.uget(index)
+    let right = v.children.uget(index + 1)
 
     const [ls, rs] = await Promise.all([this._leafSize(left, false), this._leafSize(right, true)])
 
     if (ls < rs) {
       // if fewer leaves on the left
       stack.push(right)
-      let r = right.value ? this.snapshot.bump(right) : await this.snapshot.inflate(right)
-      while (r.children.length) {
-        right = r.children.get(0)
+      let r = await retainAndInflate(right, snap, conf)
+      while (r.children.ulength) {
+        right = r.children.uget(0)
         stack.push(right)
-        r = right.value ? this.snapshot.bump(right) : await this.snapshot.inflate(right)
+        r = await retainAndInflate(right, snap, conf)
       }
       v.keys.set(index, r.keys.shift())
     } else {
       // if fewer leaves on the right
       stack.push(left)
-      let l = left.value ? this.snapshot.bump(left) : await this.snapshot.inflate(left)
-      while (l.children.length) {
-        left = l.children.get(l.children.length - 1)
+      let l = await retainAndInflate(left, snap, conf)
+      while (l.children.ulength) {
+        left = l.children.uget(l.children.ulength - 1)
         stack.push(left)
-        l = left.value ? this.snapshot.bump(left) : await this.snapshot.inflate(left)
+        l = await retainAndInflate(left, snap, conf)
       }
       v.keys.set(index, l.keys.pop())
     }
   }
 
   async _leafSize(ptr, goLeft) {
-    let v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
-    while (v.children.length) {
-      ptr = v.children.get(goLeft ? 0 : v.children.length - 1)
-      v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+    const snap = this.snapshot
+    const conf = this.config
+
+    let v = await retainAndInflate(ptr, snap, conf)
+    while (v.children.ulength) {
+      ptr = v.children.uget(goLeft ? 0 : v.children.ulength - 1)
+      v = await retainAndInflate(ptr, snap, conf)
     }
-    return v.keys.length
+    return v.keys.ulength
   }
 
   async _rebalance(stack) {
     const root = stack[0]
     const minKeys = this.tree.context.minKeys
+    const snap = this.snapshot
+    const conf = this.config
 
     while (stack.length > 1) {
       const ptr = stack.pop()
       const parent = stack[stack.length - 1]
 
-      const v = ptr.value ? this.snapshot.bump(ptr) : await this.snapshot.inflate(ptr)
+      const v = await retainAndInflate(ptr, snap, conf)
 
-      if (v.keys.length >= minKeys) return root
+      if (v.keys.ulength >= minKeys) return root
 
-      const p = parent.value ? this.snapshot.bump(parent) : await this.snapshot.inflate(parent)
+      const p = await retainAndInflate(parent, snap, conf)
 
       let { left, index, right } = v.siblings(p)
 
-      let l = left && (left.value ? this.snapshot.bump(left) : await this.snapshot.inflate(left))
+      let l = left && (await retainAndInflate(left, snap, conf))
 
       // maybe borrow from left sibling?
-      if (l && l.keys.length > minKeys) {
+      if (l && l.keys.ulength > minKeys) {
         left.changed = true
-        v.keys.unshift(p.keys.get(index - 1))
-        if (l.children.length) v.children.unshift(l.children.pop())
+        v.keys.unshift(p.keys.uget(index - 1))
+        if (l.children.ulength) v.children.unshift(l.children.pop())
         p.keys.set(index - 1, l.keys.pop())
         return root
       }
 
-      let r =
-        right && (right.value ? this.snapshot.bump(right) : await this.snapshot.inflate(right))
+      let r = right && (await retainAndInflate(right, snap, conf))
 
       // maybe borrow from right sibling?
-      if (r && r.keys.length > minKeys) {
+      if (r && r.keys.ulength > minKeys) {
         right.changed = true
-        v.keys.push(p.keys.get(index))
-        if (r.children.length) v.children.push(r.children.shift())
+        v.keys.push(p.keys.uget(index))
+        if (r.children.ulength) v.children.push(r.children.shift())
         p.keys.set(index, r.keys.shift())
         return root
       }
@@ -311,15 +312,15 @@ module.exports = class WriteBatch {
       }
 
       left.changed = true
-      l.merge(r, p.keys.get(index))
+      l.merge(r, p.keys.uget(index))
 
       parent.changed = true
       p.removeKey(index)
     }
 
-    const r = root.value ? this.snapshot.bump(root) : await this.snapshot.inflate(root)
+    const r = await retainAndInflate(root, snap, conf)
     // check if the tree shrunk
-    if (!r.keys.length && r.children.length) return r.children.get(0)
+    if (!r.keys.ulength && r.children.ulength) return r.children.uget(0)
     return root
   }
 
@@ -334,19 +335,21 @@ module.exports = class WriteBatch {
       return
     }
 
-    if (!this.root.value) await this.snapshot.inflate(this.root)
+    if (!this.root.value) await this.snapshot.inflate(this.root, this.config)
 
     let update = { size: 0, nodes: [], keys: [], values: [] }
     let minValue = -1
 
+    this.root = this.root.commit()
+
     const batch = [update]
     const stack = [this.root]
     const values = []
 
     const context = this.tree.context.getLocalContext()
-    const activeRequests = this.tree.activeRequests
+    const config = this.tree.config
 
-    await context.update(activeRequests)
+    await context.update(config)
 
     while (stack.length > 0) {
       const node = stack.pop()
@@ -382,8 +385,9 @@ module.exports = class WriteBatch {
       for (let i = 0; i < children.entries.length; i++) {
         const c = children.entries[i]
         if (!c.value || !c.changed) continue
-        children.touch(i)
-        stack.push(c)
+        const node = c.commit()
+        children.touch(i, node)
+        stack.push(node)
       }
     }
 
@@ -486,7 +490,7 @@ module.exports = class WriteBatch {
     const buffers = new Array(blocks.length)
 
     if (blocks.length > 0 && this.length > 0) {
-      const core = this.key ? await context.getCoreOffsetByKey(this.key, activeRequests) : 0
+      const core = this.key ? await context.getCoreOffsetByKey(this.key, config) : 0
       blocks[blocks.length - 1].previous = { core, seq: this.length - 1 }
     }
 
@@ -515,6 +519,9 @@ module.exports = class WriteBatch {
         this.snapshot.bump(node)
       }
     }
+
+    context.cache.retained++
+    context.cache.gc()
   }
 }
 
@@ -597,3 +604,12 @@ function prepareCohorts(context, block, seq, deltas, keys) {
 function supportsCompression(type) {
   return type !== TYPE_COMPAT && type !== 0
 }
+
+async function retainAndInflate(ptr, snap, conf) {
+  if (ptr.value) {
+    ptr.retain()
+    return ptr.value
+  }
+  ptr.retain()
+  return await snap.inflate(ptr, conf)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyperbee2",
-  "version": "2.2.0",
+  "version": "2.4.1",
   "description": "btree",
   "main": "index.js",
   "files": [
@@ -19,6 +19,7 @@
     "b4a": "^1.6.7",
     "compact-encoding": "^2.16.1",
     "hypercore": "^11.15.0",
+    "hypercore-errors": "^1.5.0",
     "hyperschema": "^1.14.0",
     "protocol-buffers-encodings": "^1.2.0",
     "scope-lock": "^1.2.4",