Support ioredis and sqlite3

Author: vweevers

README.md

@@ -30,7 +30,8 @@ Yields:
 - Derives plot labels from benchmark metadata (package, platform, ..)
 - Uses unique temporary directories for every db
 - Can optionally wrap the db in `encoding-down` and/or `levelup`
-- Also takes `level` or something else that's already a `levelup` interface.
+- Also takes `level` or something else that's already a `levelup` interface
+- Also takes `ioredis` and `sqlite3` (see [`third-party/`](./third-party)).
 
 ## Usage
 

lib/run.js

@@ -22,11 +22,18 @@ module.exports = function (benchmark, targetId, options) {
 
   // Load target module from working directory
   const cwd = process.cwd()
-  const target = from(cwd, targetId)
   const targetPkg = resolve(targetId + '/package.json', { basedir: cwd })
   const targetDir = path.dirname(targetPkg)
   const { name, version } = require(targetPkg)
 
+  let target = from(cwd, targetId)
+
+  if (targetId === 'sqlite3' || name === 'sqlite3') {
+    target = require('../third-party/sqlite3')(target)
+  } else if (targetId === 'ioredis' || name === 'ioredis') {
+    target = require('../third-party/ioredis')(target)
+  }
+
   if (typeof target !== 'function') {
     throw new Error('Target must export a function')
   }

package.json

@@ -30,6 +30,7 @@
   "devDependencies": {
     "dependency-check": "^3.3.0",
     "hallmark": "^0.1.0",
+    "haredis-tmp": "github:vweevers/haredis-tmp#feat/windows-support",
     "level-community": "^3.0.0",
     "nyc": "^14.1.1",
     "standard": "^12.0.1",

third-party/README.md

@@ -0,0 +1,27 @@
+# Third party
+
+This directory contains thin wrappers (that intentionally _don't_ implement the full `abstract-leveldown` interface) around third-party databases and libraries like [`ioredis`](https://github.com/luin/ioredis) and [`sqlite3`](https://github.com/mapbox/node-sqlite3), to be able to run `level-bench` on them for comparison.
+
+## Supported benchmarks (so far)
+
+The `write` benchmark on `ioredis` (`redis-server` must be available in `PATH`):
+
+```
+npm i ioredis leveldown
+level-bench run write ioredis
+level-bench run write leveldown
+level-bench plot write
+```
+
+![write.ioredis-vs-leveldown](img/write.ioredis-vs-leveldown.png)
+
+The `write` benchmark on `sqlite3` (100-1000x slower than `leveldown`, lower the amount of operations with `-n`):
+
+```
+npm i sqlite3 leveldown
+level-bench run write sqlite3 -b [-n 2e4]
+level-bench run write leveldown -b [-n 2e4]
+level-bench plot write
+```
+
+![write.sqlite3-vs-leveldown](img/write.sqlite3-vs-leveldown.png)

third-party/img/write.ioredis-vs-leveldown.png

@@ -0,0 +1,66 @@
+'use strict'
+
+// Note: redis-server must be available in PATH
+const tmpRedis = require('haredis-tmp')
+
+module.exports = function inject (ioredis) {
+  return function (location, options, callback) {
+    let redis
+    let shutdown
+
+    // Expire keys (which is cheap) to avoid blowing up memory
+    const ttlSeconds = options.ttl || 10
+    const port = options.port || 6389
+
+    // "For better performance. Recommended to be enabled when handling large
+    // array response and you don't need the buffer support."
+    const dropBufferSupport = !!options.dropBufferSupport
+
+    const wrapper = {
+      status: 'new',
+
+      open: function (options, callback) {
+        wrapper.status = 'opening'
+
+        tmpRedis([port], { verbose: true }, function (err, path, shutdown_) {
+          if (err) return callback(err)
+
+          shutdown = shutdown_
+          redis = new ioredis({
+            port,
+            retryStrategy: () => false,
+            maxRetriesPerRequest: 0,
+            autoResubscribe: false,
+            autoResendUnfulfilledCommands: false,
+            enableOfflineQueue: false,
+            dropBufferSupport
+          })
+
+          redis.once('ready', function () {
+            wrapper.status = 'open'
+            callback(null, wrapper)
+          })
+
+          // ioredis swallows errors if there's no listener
+          redis.on('error', function (err) {
+            throw err
+          })
+        })
+      },
+
+      put: function (key, value/*, options */, callback) {
+        redis.set(key, value, 'EX', ttlSeconds, callback)
+      },
+
+      close: function (callback) {
+        redis.disconnect()
+        shutdown(callback)
+      },
+
+      // Trick reachdown
+      _iterator: function () {}
+    }
+
+    return wrapper
+  }
+}

third-party/img/write.sqlite3-vs-leveldown.png

@@ -0,0 +1,57 @@
+'use strict'
+
+const path = require('path')
+
+module.exports = function inject (sqlite3) {
+  return function (location, options, callback) {
+    let db
+    let firstPut = true
+
+    const wrapper = {
+      // So that benchmarks can determine the size of the database.
+      location,
+      status: 'new',
+
+      open: function (options, callback) {
+        wrapper.status = 'opening'
+
+        db = new sqlite3.Database(path.join(location, 'sqlite.db'), function (err) {
+          if (err) return callback(err)
+
+          db.run('CREATE TABLE bench (key VARCHAR(16), value VARCHAR(200))', function (err) {
+            if (err) return callback(err)
+
+            setImmediate(function () {
+              wrapper.status = 'open'
+              callback(null, wrapper)
+            })
+          })
+        })
+      },
+
+      put: function (key, value/*, options */, callback) {
+        if (firstPut) {
+          firstPut = false
+
+          // TODO: expose this fact to benchmarks
+          if (typeof key !== 'string') throw new TypeError('Key type not supported')
+          if (typeof value !== 'string') throw new TypeError('Value type not supported')
+
+          if (key.length > 16) throw new RangeError('Key is too long')
+          if (value.length > 200) throw new RangeError('Value is too long')
+        }
+
+        db.exec(`INSERT INTO bench VALUES("${key}","${value}")`, callback)
+      },
+
+      close: function (callback) {
+        db.close(callback)
+      },
+
+      // Trick reachdown
+      _iterator: function () {}
+    }
+
+    return wrapper
+  }
+}