rocksdb-native 2.6.9 → 3.0.0

package/index.js

@@ -1,165 +1,104 @@
-/* global Bare */
-const ReadyResource = require('ready-resource')
-const binding = require('./binding')
 const { ReadBatch, WriteBatch } = require('./lib/batch')
+const ColumnFamily = require('./lib/column-family')
 const Iterator = require('./lib/iterator')
 const Snapshot = require('./lib/snapshot')
+const DBState = require('./lib/state')
 
-module.exports = class RocksDB extends ReadyResource {
-  constructor(
-    path,
-    {
-      // default options, https://github.com/facebook/rocksdb/wiki/Setup-Options-and-Basic-Tuning
-      readOnly = false,
-      createIfMissing = true,
-      maxBackgroundJobs = 6,
-      bytesPerSync = 1048576,
-      // blob options, https://github.com/facebook/rocksdb/wiki/BlobDB
-      enableBlobFiles = false,
-      minBlobSize = 0,
-      blobFileSize = 0,
-      enableBlobGarbageCollection = true,
-      // (block) table options
-      tableBlockSize = 16384,
-      tableCacheIndexAndFilterBlocks = true,
-      tableFormatVersion = 4
-    } = {}
-  ) {
-    super()
-
-    this.path = path
-
-    this.readOnly = readOnly
-    this.createIfMissing = createIfMissing
-    this.maxBackgroundJobs = maxBackgroundJobs
-    this.bytesPerSync = bytesPerSync
-
-    this.enableBlobFiles = enableBlobFiles
-    this.minBlobSize = minBlobSize
-    this.blobFileSize = blobFileSize
-    this.enableBlobGarbageCollection = enableBlobGarbageCollection
-
-    this.tableBlockSize = tableBlockSize
-    this.tableCacheIndexAndFilterBlocks = tableCacheIndexAndFilterBlocks
-    this.tableFormatVersion = tableFormatVersion
-
-    this._snapshots = new Set()
-    this._refs = 0
-    this._resolvePreclose = null
-    this._resolveOnIdle = null
-    this._idlePromise = null
-
-    this._handle = binding.init()
-  }
-
-  async _open() {
-    const opts = new Uint32Array(16)
-
-    opts[0] = this.readOnly ? 1 : 0
-    opts[1] = this.createIfMissing ? 1 : 0
-    opts[2] = this.maxBackgroundJobs
-    opts[3] = this.bytesPerSync & 0xffffffff
-    opts[4] = Math.floor(this.bytesPerSync / 0x100000000)
-    opts[5] = 0
-    opts[6] = this.enableBlobFiles ? 1 : 0
-    opts[7] = this.minBlobSize & 0xffffffff
-    opts[8] = Math.floor(this.minBlobSize / 0x100000000)
-    opts[9] = this.blobFileSize & 0xffffffff
-    opts[10] = Math.floor(this.blobFileSize / 0x100000000)
-    opts[11] = this.enableBlobGarbageCollection ? 1 : 0
-    opts[12] = this.tableBlockSize & 0xffffffff
-    opts[13] = Math.floor(this.tableBlockSize / 0x100000000)
-    opts[14] = this.tableCacheIndexAndFilterBlocks ? 1 : 0
-    opts[15] = this.tableFormatVersion
-
-    const req = { resolve: null, reject: null, handle: null }
-
-    const promise = new Promise((resolve, reject) => {
-      req.resolve = resolve
-      req.reject = reject
-    })
+class RocksDB {
+  constructor(path, opts = {}) {
+    const {
+      columnFamily,
+      state = new DBState(this, path, opts),
+      snapshot = null
+    } = opts
 
-    req.handle = binding.open(this, this._handle, this.path, opts, req, onopen)
+    this._state = state
+    this._snapshot = snapshot
+    this._columnFamily = state.getColumnFamily(columnFamily)
+    this._index = this._state.addSession(this)
+  }
 
-    await promise
+  get opened() {
+    return this._state.opened
+  }
 
-    for (const snapshot of this._snapshots) snapshot._init()
+  get closed() {
+    return this.isRoot() ? this._state.closed : this._destroyed
+  }
 
-    function onopen(err) {
-      if (err) req.reject(new Error(err))
-      else req.resolve()
-    }
+  get path() {
+    return this._state.path
   }
 
-  async _close() {
-    if (this._refs > 0) {
-      await new Promise((resolve) => {
-        this._resolvePreclose = resolve
-      })
-    }
+  get defaultColumnFamily() {
+    return this._columnFamily
+  }
 
-    for (const snapshot of this._snapshots) snapshot.destroy()
+  session({
+    columnFamily = this._columnFamily,
+    snapshot = this._snapshot !== null
+  } = {}) {
+    let snap = null
 
-    const req = { resolve: null, reject: null, handle: null }
+    if (snapshot) {
+      snap = this._snapshot
+      if (snap === null) snap = new Snapshot(this._state)
+      else snap.ref()
+    }
 
-    const promise = new Promise((resolve, reject) => {
-      req.resolve = resolve
-      req.reject = reject
+    return new RocksDB(null, {
+      state: this._state,
+      columnFamily,
+      snapshot: snap
     })
+  }
 
-    req.handle = binding.close(this._handle, req, onclose)
-
-    await promise
-
-    function onclose(err) {
-      if (err) req.reject(new Error(err))
-      else req.resolve()
-    }
+  columnFamily(name) {
+    return this.session({ columnFamily: name })
   }
 
-  _incRef() {
-    if (this.closing !== null) {
-      throw new Error('Database closed')
-    }
+  snapshot() {
+    return this.session({ snapshot: true })
+  }
 
-    this._refs++
+  isRoot() {
+    return this === this._state.db
   }
 
-  _decRef() {
-    if (--this._refs !== 0) return
+  ready() {
+    return this._state.ready()
+  }
 
-    if (this._resolveOnIdle !== null) {
-      const resolve = this._resolveOnIdle
-      this._resolveOnIdle = null
-      this._idlePromise = null
-      resolve()
+  async close({ force } = {}) {
+    if (this._index !== -1) {
+      this._state.removeSession(this)
+      this._index = -1
+      if (this._snapshot) this._snapshot.unref()
     }
 
-    if (this._resolvePreclose !== null) {
-      const resolve = this._resolvePreclose
-      this._resolvePreclose = null
-      resolve()
+    if (force) {
+      for (let i = this._state.sessions.length - 1; i >= 0; i--) {
+        await this._state.sessions[i].close()
+      }
     }
-  }
 
-  isIdle() {
-    return this._refs === 0
+    return this.isRoot() ? this._state.close() : Promise.resolve()
   }
 
-  idle() {
-    if (this.isIdle()) return Promise.resolve()
+  suspend() {
+    return this._state.suspend()
+  }
 
-    if (!this._idlePromise) {
-      this._idlePromise = new Promise((resolve) => {
-        this._resolveOnIdle = resolve
-      })
-    }
+  resume() {
+    return this._state.resume()
+  }
 
-    return this._idlePromise
+  isIdle() {
+    return this._state.refs.isIdle()
   }
 
-  snapshot(opts) {
-    return new Snapshot(this, opts)
+  idle() {
+    return this._state.refs.idle()
   }
 
   iterator(range, opts) {
@@ -168,7 +107,6 @@ module.exports = class RocksDB extends ReadyResource {
 
   async peek(range, opts) {
     for await (const value of this.iterator({ ...range, ...opts, limit: 1 })) {
-      // eslint-disable-line no-unreachable-loop
       return value
     }
 
@@ -184,27 +122,46 @@ module.exports = class RocksDB extends ReadyResource {
   }
 
   async get(key, opts) {
-    const batch = this.read(opts)
-    const value = batch.get(key)
-    await batch.flush()
-    return value
+    const batch = this.read({ ...opts, capacity: 1 })
+    try {
+      const value = batch.get(key)
+      batch.tryFlush()
+      return await value
+    } finally {
+      batch.destroy()
+    }
   }
 
   async put(key, value, opts) {
-    const batch = this.write(opts)
-    batch.put(key, value)
-    await batch.flush()
+    const batch = this.write({ ...opts, capacity: 1 })
+    try {
+      batch.tryPut(key, value)
+      await batch.flush()
+    } finally {
+      batch.destroy()
+    }
   }
 
   async delete(key, opts) {
-    const batch = this.write(opts)
-    batch.delete(key)
-    await batch.flush()
+    const batch = this.write({ ...opts, capacity: 1 })
+    try {
+      batch.tryDelete(key)
+      await batch.flush()
+    } finally {
+      batch.destroy()
+    }
   }
 
   async deleteRange(start, end, opts) {
-    const batch = this.write(opts)
-    batch.deleteRange(start, end)
-    await batch.flush()
+    const batch = this.write({ ...opts, capacity: 1 })
+    try {
+      batch.tryDeleteRange(start, end)
+      await batch.flush()
+    } finally {
+      batch.destroy()
+    }
   }
 }
+
+module.exports = exports = RocksDB
+exports.ColumnFamily = ColumnFamily

package/lib/batch.js

@@ -1,23 +1,23 @@
 const c = require('compact-encoding')
-const b4a = require('b4a')
 const binding = require('../binding')
 
-const empty = b4a.alloc(0)
-const emptyPromise = Promise.resolve()
+const empty = Buffer.alloc(0)
+const resolved = Promise.resolve()
 
 class RocksDBBatch {
   constructor(db, opts = {}) {
     const {
+      columnFamily = db.defaultColumnFamily,
       capacity = 8,
       encoding = null,
       keyEncoding = encoding,
-      valueEncoding = encoding,
-      autoDestroy = true
+      valueEncoding = encoding
     } = opts
 
-    db._incRef()
+    db._state.ref()
 
-    this._db = db
+    this._state = db._state
+    this._columnFamily = columnFamily
     this._destroyed = false
     this._capacity = capacity
     this._operations = []
@@ -25,27 +25,25 @@ class RocksDBBatch {
 
     this._keyEncoding = keyEncoding
     this._valueEncoding = valueEncoding
-    this._autoDestroy = autoDestroy !== false
 
     this._enqueuePromise = this._enqueuePromise.bind(this)
 
     this._request = null
-    this._resolveRequest = null
+    this._resolve = null
 
     this._handle = null
     this._buffer = null
 
-    if (db.opened === true) this.ready()
+    if (this._state.opened === true) this.ready()
   }
 
   _onfinished() {
-    const resolve = this._resolveRequest
+    const resolve = this._resolve
 
     this._operations = []
     this._promises = []
     this._request = null
-    this._resolveRequest = null
-    if (this._autoDestroy) this.destroy()
+    this._resolve = null
 
     if (resolve !== null) resolve()
   }
@@ -63,34 +61,38 @@ class RocksDBBatch {
   async ready() {
     if (this._handle !== null) return
 
-    if (this._db.opened === false) await this._db.ready()
+    if (this._state.opened === false) await this._state.ready()
 
     this._init()
   }
 
   destroy() {
-    if (this._request) throw new Error('Batch already flushed')
+    if (this._request) throw new Error('Request in progress')
     if (this._destroyed) return
+
     this._destroyed = true
-    this._db._decRef()
+
+    this._state.unref()
   }
 
   flush() {
+    if (this._request) throw new Error('Request in progress')
     if (this._destroyed) throw new Error('Batch is destroyed')
-    if (this._request) throw new Error('Request already in progress')
 
     this._request = new Promise((resolve) => {
-      this._resolveRequest = resolve
+      this._resolve = resolve
     })
+
     this._flush()
 
     return this._request
   }
 
   tryFlush() {
-    if (this._request) throw new Error('Request already in progress')
+    if (this._request) throw new Error('Request in progress')
+
+    this._request = resolved
 
-    this._request = emptyPromise
     this._flush()
   }
 
@@ -104,14 +106,14 @@ class RocksDBBatch {
 
   _encodeKey(k) {
     if (this._keyEncoding) return c.encode(this._keyEncoding, k)
-    if (typeof k === 'string') return b4a.from(k)
+    if (typeof k === 'string') return Buffer.from(k)
     return k
   }
 
   _encodeValue(v) {
     if (this._valueEncoding) return c.encode(this._valueEncoding, v)
     if (v === null) return empty
-    if (typeof v === 'string') return b4a.from(v)
+    if (typeof v === 'string') return Buffer.from(v)
     return v
   }
 
@@ -122,12 +124,10 @@ class RocksDBBatch {
 }
 
 exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
-  constructor(db, opts = {}) {
-    const { snapshot = null } = opts
-
+  constructor(db, opts) {
     super(db, opts)
 
-    this._snapshot = snapshot
+    this._snapshot = db._snapshot
   }
 
   _init() {
@@ -145,7 +145,7 @@ exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
     await super._flush()
 
     binding.read(
-      this._db._handle,
+      this._state.handle,
       this._handle,
       this._operations,
       this._snapshot ? this._snapshot._handle : null,
@@ -166,7 +166,7 @@ exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
         promise.resolve(
           values[i].byteLength === 0
             ? null
-            : this._decodeValue(b4a.from(values[i]))
+            : this._decodeValue(Buffer.from(values[i]))
         )
     }
 
@@ -178,7 +178,10 @@ exports.ReadBatch = class RocksDBReadBatch extends RocksDBBatch {
 
     const promise = new Promise(this._enqueuePromise)
 
-    this._operations.push(new RocksDBGet(this._encodeKey(key)))
+    this._operations.push(
+      new RocksDBGet(this._encodeKey(key), this._columnFamily)
+    )
+
     this._resize()
 
     return promise
@@ -201,7 +204,7 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     await super._flush()
 
     binding.write(
-      this._db._handle,
+      this._state.handle,
       this._handle,
       this._operations,
       this,
@@ -227,8 +230,13 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     const promise = new Promise(this._enqueuePromise)
 
     this._operations.push(
-      new RocksDBPut(this._encodeKey(key), this._encodeValue(value))
+      new RocksDBPut(
+        this._encodeKey(key),
+        this._encodeValue(value),
+        this._columnFamily
+      )
     )
+
     this._resize()
 
     return promise
@@ -238,9 +246,15 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     if (this._request) throw new Error('Request already in progress')
 
     this._operations.push(
-      new RocksDBPut(this._encodeKey(key), this._encodeValue(value))
+      new RocksDBPut(
+        this._encodeKey(key),
+        this._encodeValue(value),
+        this._columnFamily
+      )
     )
+
     this._promises.push(null)
+
     this._resize()
   }
 
@@ -249,7 +263,10 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
 
     const promise = new Promise(this._enqueuePromise)
 
-    this._operations.push(new RocksDBDelete(this._encodeKey(key)))
+    this._operations.push(
+      new RocksDBDelete(this._encodeKey(key), this._columnFamily)
+    )
+
     this._resize()
 
     return promise
@@ -258,8 +275,12 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
   tryDelete(key) {
     if (this._request) throw new Error('Request already in progress')
 
-    this._operations.push(new RocksDBDelete(this._encodeKey(key)))
+    this._operations.push(
+      new RocksDBDelete(this._encodeKey(key), this._columnFamily)
+    )
+
     this._promises.push(null)
+
     this._resize()
   }
 
@@ -269,8 +290,13 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     const promise = new Promise(this._enqueuePromise)
 
     this._operations.push(
-      new RocksDBDeleteRange(this._encodeKey(start), this._encodeKey(end))
+      new RocksDBDeleteRange(
+        this._encodeKey(start),
+        this._encodeKey(end),
+        this._columnFamily
+      )
     )
+
     this._resize()
 
     return promise
@@ -280,16 +306,23 @@ exports.WriteBatch = class RocksDBWriteBatch extends RocksDBBatch {
     if (this._request) throw new Error('Request already in progress')
 
     this._operations.push(
-      new RocksDBDeleteRange(this._encodeKey(start), this._encodeKey(end))
+      new RocksDBDeleteRange(
+        this._encodeKey(start),
+        this._encodeKey(end),
+        this._columnFamily
+      )
     )
+
     this._promises.push(null)
+
     this._resize()
   }
 }
 
 class RocksDBGet {
-  constructor(key) {
+  constructor(key, columnFamily) {
     this.key = key
+    this.columnFamily = columnFamily._handle
   }
 
   get type() {
@@ -298,9 +331,10 @@ class RocksDBGet {
 }
 
 class RocksDBPut {
-  constructor(key, value) {
+  constructor(key, value, columnFamily) {
     this.key = key
     this.value = value
+    this.columnFamily = columnFamily._handle
   }
 
   get type() {
@@ -309,8 +343,9 @@ class RocksDBPut {
 }
 
 class RocksDBDelete {
-  constructor(key) {
+  constructor(key, columnFamily) {
     this.key = key
+    this.columnFamily = columnFamily._handle
   }
 
   get type() {
@@ -319,9 +354,10 @@ class RocksDBDelete {
 }
 
 class RocksDBDeleteRange {
-  constructor(start, end) {
+  constructor(start, end, columnFamily) {
     this.start = start
     this.end = end
+    this.columnFamily = columnFamily._handle
   }
 
   get type() {

package/lib/column-family.js

@@ -0,0 +1,56 @@
+const binding = require('../binding')
+
+class RocksDBColumnFamily {
+  constructor(name, opts = {}) {
+    const {
+      // Blob options
+      enableBlobFiles = false,
+      minBlobSize = 0,
+      blobFileSize = 0,
+      enableBlobGarbageCollection = true,
+      // Block table options
+      tableBlockSize = 16384,
+      tableCacheIndexAndFilterBlocks = true,
+      tableFormatVersion = 4,
+      // In case we are cloning
+      settings = null
+    } = opts
+
+    this._name = name
+    this._settings =
+      settings ||
+      Uint32Array.from([
+        0,
+        enableBlobFiles ? 1 : 0,
+        minBlobSize & 0xffffffff,
+        Math.floor(minBlobSize / 0x100000000),
+        blobFileSize & 0xffffffff,
+        Math.floor(blobFileSize / 0x100000000),
+        enableBlobGarbageCollection ? 1 : 0,
+        tableBlockSize & 0xffffffff,
+        Math.floor(tableBlockSize / 0x100000000),
+        tableCacheIndexAndFilterBlocks ? 1 : 0,
+        tableFormatVersion
+      ])
+
+    this._handle = binding.columnFamilyInit(name, this._settings)
+  }
+
+  cloneSettings(name) {
+    return new RocksDBColumnFamily(name, { settings: this._settings })
+  }
+
+  get name() {
+    return this._name
+  }
+
+  destroy() {
+    if (this._handle === null) return
+
+    binding.columnFamilyDestroy(this._handle)
+
+    this._handle = null
+  }
+}
+
+module.exports = RocksDBColumnFamily