@nxtedition/rocksdb 5.2.2 → 5.2.13

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/lib/README

@@ -0,0 +1,13 @@
+The files in this directory originally come from
+https://github.com/percona/PerconaFT/.
+
+This directory only includes the "locktree" part of PerconaFT, and its
+dependencies.
+
+The following modifications were made:
+- Make locktree usable outside of PerconaFT library
+- Add shared read-only lock support
+
+The files named *_subst.* are substitutes of the PerconaFT's files, they
+contain replacements of PerconaFT's functionality.
+

package/deps/rocksdb/rocksdb.gyp

@@ -13,7 +13,10 @@
         ]
     }
   , 'defines': [
-        'SNAPPY=1'
+        'SNAPPY=1',
+        'ROCKSDB_BACKTRACE=1',
+        'ROCKSDB_SUPPORT_THREAD_LOCAL=1',
+        'USE_SSE=1'
     ]
   , 'include_dirs': [
         'rocksdb/'
@@ -73,16 +76,12 @@
           , 'defines': [
                 'ROCKSDB_PLATFORM_POSIX=1'
             ]
-          , 'ccflags': [
-                '-fno-builtin-memcmp'
-              , '-fPIC'
-            ]
-          , 'cflags': [ '-std=c++0x' ]
+          , 'ccflags': []
+          , 'cflags': [ '-std=c++17' ]
           , 'cflags!': [ '-fno-tree-vrp', '-fno-rtti' ]
           , 'cflags_cc!': [ '-fno-rtti' ]
-          # , 'cflags_cc+': [ '-frtti' ]
         }]
-      , ['OS != "win"' and 'OS != "freebsd"', {
+      , ['OS != "win"', {
             'cflags': [
                 '-Wno-sign-compare'
               , '-Wno-unused-but-set-variable'
@@ -91,66 +90,50 @@
       , ['OS == "linux"', {
             'defines': [
                 'OS_LINUX=1',
-                'ROCKSDB_LIB_IO_POSIX=1'
-            ]
-          , 'libraries': [
-                '-lpthread'
+                'ROCKSDB_LIB_IO_POSIX=1',
+                'ROCKSDB_FALLOCATE_PRESENT=1',
+                'ROCKSDB_MALLOC_USABLE_SIZE=1',
+                'ROCKSDB_PTHREAD_ADAPTIVE_MUTEX=1',
+                'ROCKSDB_RANGESYNC_PRESENT=1',
+                'ROCKSDB_SCHED_GETCPU_PRESENT=1',
+                # 'ROCKSDB_IOURING_PRESENT=1',
+                # 'HAVE_SSE42=1',
+                'HAVE_BMI=1',
+                'HAVE_LZCNT=1'
+                'HAVE_AVX2=1',
+                'HAVE_PCLMUL=1',
+                'HAVE_UINT128_EXTENSION=1',
+                'HAVE_ALIGNED_NEW=1',
+                # 'LIBURING=1'
+                # 'NUMA=1'
+                'ROCKSDB_PLATFORM_POSIX=1',
+                'ROCKSDB_LIB_IO_POSIX=1',
+                # "-TBB=1",
             ]
           , 'ccflags': [
-                '-pthread'
-                '-fexceptions'
+                '-flto'
+              , '-pthread'
+              , '-msse4.2'
+              , '-mpclmul'
+              , '-mavx2'
+              , '-mbmi'
+              , '-mlzcnt'
+              , '-fexceptions'
+              , '-faligned-new'
+              , '-latomic'
             ]
           , 'cflags!': [ '-fno-exceptions' ]
           , 'cflags_cc!': [ '-fno-exceptions' ]
-        }]
-      , ['OS == "freebsd"', {
-            'defines': [
-                'OS_FREEBSD=1'
-              , '_REENTRANT=1'
-            ]
-          , 'libraries': [
-                '-lpthread'
-            ]
-          , 'ccflags': [
-                '-pthread'
-            ]
-          , 'cflags': [
-                '-Wno-sign-compare'
-            ]
-        }]
-      , ['OS == "openbsd"', {
-            'defines': [
-                'OS_OPENBSD=1'
-              , '_REENTRANT=1'
-            ]
-          , 'libraries': [
-                '-lpthread'
-            ]
-          , 'ccflags': [
-                '-pthread'
-            ]
-          , 'cflags': [
-                '-Wno-sign-compare'
-            ]
-        }]
-      , ['OS == "solaris"', {
-            'defines': [
-                'OS_SOLARIS=1'
-              , '_REENTRANT=1'
-            ]
-          , 'libraries': [
-                '-lrt'
-              , '-lpthread'
-            ]
-          , 'ccflags': [
-                '-pthread'
+          , 'ldflags': [ 
+                '-flto'
+              , '-fuse-linker-plugin'
             ]
         }]
       , ['OS == "mac"', {
             'defines': [
                 'OS_MACOSX=1',
-                'ROCKSDB_LIB_IO_POSIX=1',
-                'ROCKSDB_BACKTRACE=1'
+                'DROCKSDB_PLATFORM_POSIX=1',
+                'ROCKSDB_LIB_IO_POSIX=1'
             ]
           , 'libraries': []
           , 'ccflags': []
@@ -161,18 +144,17 @@
                   , '-Wno-unused-function'
                 ]
                 , 'OTHER_CPLUSPLUSFLAGS': [
-                    '-mmacosx-version-min=10.8'
-                  , '-std=c++11'
+                    '-mmacosx-version-min=10.14'
+                  , '-std=c++17'
                   , '-stdlib=libc++'
                   , '-fno-omit-frame-pointer'
                   , '-momit-leaf-frame-pointer'
                   , '-arch x86_64'
                   , '-arch arm64'
                 ]
-# , 'OTHER_LDFLAGS': ['-stdlib=libc++']
                 , 'GCC_ENABLE_CPP_RTTI': 'YES'
                 , 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES'
-                , 'MACOSX_DEPLOYMENT_TARGET': '10.8'
+                , 'MACOSX_DEPLOYMENT_TARGET': '10.14'
             }
         }]
     ]

package/deps/snappy/snappy-1.1.7/README.md

@@ -0,0 +1,149 @@
+Snappy, a fast compressor/decompressor.
+
+
+Introduction
+============
+
+Snappy is a compression/decompression library. It does not aim for maximum
+compression, or compatibility with any other compression library; instead,
+it aims for very high speeds and reasonable compression. For instance,
+compared to the fastest mode of zlib, Snappy is an order of magnitude faster
+for most inputs, but the resulting compressed files are anywhere from 20% to
+100% bigger. (For more information, see "Performance", below.)
+
+Snappy has the following properties:
+
+ * Fast: Compression speeds at 250 MB/sec and beyond, with no assembler code.
+   See "Performance" below.
+ * Stable: Over the last few years, Snappy has compressed and decompressed
+   petabytes of data in Google's production environment. The Snappy bitstream
+   format is stable and will not change between versions.
+ * Robust: The Snappy decompressor is designed not to crash in the face of
+   corrupted or malicious input.
+ * Free and open source software: Snappy is licensed under a BSD-type license.
+   For more information, see the included COPYING file.
+
+Snappy has previously been called "Zippy" in some Google presentations
+and the like.
+
+
+Performance
+===========
+
+Snappy is intended to be fast. On a single core of a Core i7 processor
+in 64-bit mode, it compresses at about 250 MB/sec or more and decompresses at
+about 500 MB/sec or more. (These numbers are for the slowest inputs in our
+benchmark suite; others are much faster.) In our tests, Snappy usually
+is faster than algorithms in the same class (e.g. LZO, LZF, QuickLZ,
+etc.) while achieving comparable compression ratios.
+
+Typical compression ratios (based on the benchmark suite) are about 1.5-1.7x
+for plain text, about 2-4x for HTML, and of course 1.0x for JPEGs, PNGs and
+other already-compressed data. Similar numbers for zlib in its fastest mode
+are 2.6-2.8x, 3-7x and 1.0x, respectively. More sophisticated algorithms are
+capable of achieving yet higher compression rates, although usually at the
+expense of speed. Of course, compression ratio will vary significantly with
+the input.
+
+Although Snappy should be fairly portable, it is primarily optimized
+for 64-bit x86-compatible processors, and may run slower in other environments.
+In particular:
+
+ - Snappy uses 64-bit operations in several places to process more data at
+   once than would otherwise be possible.
+ - Snappy assumes unaligned 32- and 64-bit loads and stores are cheap.
+   On some platforms, these must be emulated with single-byte loads
+   and stores, which is much slower.
+ - Snappy assumes little-endian throughout, and needs to byte-swap data in
+   several places if running on a big-endian platform.
+
+Experience has shown that even heavily tuned code can be improved.
+Performance optimizations, whether for 64-bit x86 or other platforms,
+are of course most welcome; see "Contact", below.
+
+
+Building
+========
+
+CMake is supported and autotools will soon be deprecated.
+You need CMake 3.4 or above to build:
+
+  mkdir build
+  cd build && cmake ../ && make
+
+
+Usage
+=====
+
+Note that Snappy, both the implementation and the main interface,
+is written in C++. However, several third-party bindings to other languages
+are available; see the home page at http://google.github.io/snappy/
+for more information. Also, if you want to use Snappy from C code, you can
+use the included C bindings in snappy-c.h.
+
+To use Snappy from your own C++ program, include the file "snappy.h" from
+your calling file, and link against the compiled library.
+
+There are many ways to call Snappy, but the simplest possible is
+
+  snappy::Compress(input.data(), input.size(), &output);
+
+and similarly
+
+  snappy::Uncompress(input.data(), input.size(), &output);
+
+where "input" and "output" are both instances of std::string.
+
+There are other interfaces that are more flexible in various ways, including
+support for custom (non-array) input sources. See the header file for more
+information.
+
+
+Tests and benchmarks
+====================
+
+When you compile Snappy, snappy_unittest is compiled in addition to the
+library itself. You do not need it to use the compressor from your own library,
+but it contains several useful components for Snappy development.
+
+First of all, it contains unit tests, verifying correctness on your machine in
+various scenarios. If you want to change or optimize Snappy, please run the
+tests to verify you have not broken anything. Note that if you have the
+Google Test library installed, unit test behavior (especially failures) will be
+significantly more user-friendly. You can find Google Test at
+
+  http://github.com/google/googletest
+
+You probably also want the gflags library for handling of command-line flags;
+you can find it at
+
+  http://gflags.github.io/gflags/
+
+In addition to the unit tests, snappy contains microbenchmarks used to
+tune compression and decompression performance. These are automatically run
+before the unit tests, but you can disable them using the flag
+--run_microbenchmarks=false if you have gflags installed (otherwise you will
+need to edit the source).
+
+Finally, snappy can benchmark Snappy against a few other compression libraries
+(zlib, LZO, LZF, and QuickLZ), if they were detected at configure time.
+To benchmark using a given file, give the compression algorithm you want to test
+Snappy against (e.g. --zlib) and then a list of one or more file names on the
+command line. The testdata/ directory contains the files used by the
+microbenchmark, which should provide a reasonably balanced starting point for
+benchmarking. (Note that baddata[1-3].snappy are not intended as benchmarks; they
+are used to verify correctness in the presence of corrupted data in the unit
+test.)
+
+
+Contact
+=======
+
+Snappy is distributed through GitHub. For the latest version, a bug tracker,
+and other information, see
+
+  http://google.github.io/snappy/
+
+or the repository at
+
+  https://github.com/google/snappy

package/index.js

@@ -0,0 +1,189 @@
+'use strict'
+
+const { AbstractLevel } = require('abstract-level')
+const ModuleError = require('module-error')
+const { fromCallback } = require('catering')
+const fs = require('fs')
+const binding = require('./binding')
+const { ChainedBatch } = require('./chained-batch')
+const { Iterator } = require('./iterator')
+
+const kPromise = Symbol('promise')
+const kContext = Symbol('context')
+const kLocation = Symbol('location')
+
+class RocksLevel extends AbstractLevel {
+  constructor (location, options, _) {
+    // To help migrating to abstract-level
+    if (typeof options === 'function' || typeof _ === 'function') {
+      throw new ModuleError('The levelup-style callback argument has been removed', {
+        code: 'LEVEL_LEGACY'
+      })
+    }
+
+    if (typeof location !== 'string' || location === '') {
+      throw new TypeError("The first argument 'location' must be a non-empty string")
+    }
+
+    super({
+      encodings: {
+        buffer: true,
+        utf8: true
+      },
+      seek: true,
+      createIfMissing: true,
+      errorIfExists: true,
+      additionalMethods: {
+        approximateSize: true,
+        compactRange: true
+      }
+    }, options)
+
+    this[kLocation] = location
+    this[kContext] = binding.db_init()
+  }
+
+  get location () {
+    return this[kLocation]
+  }
+
+  _open (options, callback) {
+    if (options.createIfMissing) {
+      fs.mkdir(this[kLocation], { recursive: true }, (err) => {
+        if (err) return callback(err)
+        binding.db_open(this[kContext], this[kLocation], options, callback)
+      })
+    } else {
+      binding.db_open(this[kContext], this[kLocation], options, callback)
+    }
+  }
+
+  _close (callback) {
+    binding.db_close(this[kContext], callback)
+  }
+
+  _put (key, value, options, callback) {
+    binding.db_put(this[kContext], key, value, options, callback)
+  }
+
+  _get (key, options, callback) {
+    binding.db_get(this[kContext], key, options, callback)
+  }
+
+  _getMany (keys, options, callback) {
+    binding.db_get_many(this[kContext], keys, options, callback)
+  }
+
+  _del (key, options, callback) {
+    binding.db_del(this[kContext], key, options, callback)
+  }
+
+  _clear (options, callback) {
+    binding.db_clear(this[kContext], options, callback)
+  }
+
+  _chainedBatch () {
+    return new ChainedBatch(this, this[kContext])
+  }
+
+  _batch (operations, options, callback) {
+    binding.batch_do(this[kContext], operations, options, callback)
+  }
+
+  approximateSize (start, end, options, callback) {
+    if (arguments.length < 2 || typeof start === 'function' || typeof end === 'function') {
+      throw new TypeError("The arguments 'start' and 'end' are required")
+    } else if (typeof options === 'function') {
+      callback = options
+      options = null
+    } else if (typeof options !== 'object') {
+      options = null
+    }
+
+    callback = fromCallback(callback, kPromise)
+
+    if (this.status === 'opening') {
+      this.defer(() => this.approximateSize(start, end, options, callback))
+    } else if (this.status !== 'open') {
+      this.nextTick(callback, new ModuleError('Database is not open: cannot call approximateSize()', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      }))
+    } else {
+      const keyEncoding = this.keyEncoding(options && options.keyEncoding)
+      start = keyEncoding.encode(start)
+      end = keyEncoding.encode(end)
+      binding.db_approximate_size(this[kContext], start, end, callback)
+    }
+
+    return callback[kPromise]
+  }
+
+  compactRange (start, end, options, callback) {
+    if (arguments.length < 2 || typeof start === 'function' || typeof end === 'function') {
+      throw new TypeError("The arguments 'start' and 'end' are required")
+    } else if (typeof options === 'function') {
+      callback = options
+      options = null
+    } else if (typeof options !== 'object') {
+      options = null
+    }
+
+    callback = fromCallback(callback, kPromise)
+
+    if (this.status === 'opening') {
+      this.defer(() => this.compactRange(start, end, options, callback))
+    } else if (this.status !== 'open') {
+      this.nextTick(callback, new ModuleError('Database is not open: cannot call compactRange()', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      }))
+    } else {
+      const keyEncoding = this.keyEncoding(options && options.keyEncoding)
+      start = keyEncoding.encode(start)
+      end = keyEncoding.encode(end)
+      binding.db_compact_range(this[kContext], start, end, callback)
+    }
+
+    return callback[kPromise]
+  }
+
+  getProperty (property) {
+    if (typeof property !== 'string') {
+      throw new TypeError("The first argument 'property' must be a string")
+    }
+
+    // Is synchronous, so can't be deferred
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    return binding.db_get_property(this[kContext], property)
+  }
+
+  _iterator (options) {
+    return new Iterator(this, this[kContext], options)
+  }
+
+  static destroy (location, callback) {
+    if (typeof location !== 'string' || location === '') {
+      throw new TypeError("The first argument 'location' must be a non-empty string")
+    }
+
+    callback = fromCallback(callback, kPromise)
+    binding.destroy_db(location, callback)
+    return callback[kPromise]
+  }
+
+  static repair (location, callback) {
+    if (typeof location !== 'string' || location === '') {
+      throw new TypeError("The first argument 'location' must be a non-empty string")
+    }
+
+    callback = fromCallback(callback, kPromise)
+    binding.repair_db(location, callback)
+    return callback[kPromise]
+  }
+}
+
+exports.RocksLevel = RocksLevel

package/iterator.js

@@ -1,19 +1,31 @@
 'use strict'
 
-const { AbstractIterator } = require('abstract-leveldown')
+const { AbstractIterator } = require('abstract-level')
 const binding = require('./binding')
 
 const kContext = Symbol('context')
-const kFinalized = Symbol('finalized')
+const kCache = Symbol('cache')
+const kFinished = Symbol('finished')
+const kFirst = Symbol('first')
+const kPosition = Symbol('position')
+const kHandleNext = Symbol('handleNext')
+const kHandleNextv = Symbol('handleNextv')
+const kCallback = Symbol('callback')
+const empty = []
 
 class Iterator extends AbstractIterator {
-  constructor (db, options) {
-    super(db)
+  constructor (db, context, options) {
+    super(db, options)
 
-    this[kContext] = binding.iterator_init(db.context, options)
-    this[kFinalized] = false
+    this[kContext] = binding.iterator_init(context, options)
 
-    this.cache = null
+    this[kHandleNext] = this[kHandleNext].bind(this)
+    this[kHandleNextv] = this[kHandleNextv].bind(this)
+    this[kCallback] = null
+    this[kFirst] = true
+    this[kCache] = empty
+    this[kFinished] = false
+    this[kPosition] = 0
   }
 
   _seek (target) {
@@ -21,35 +33,87 @@ class Iterator extends AbstractIterator {
       throw new Error('cannot seek() to an empty target')
     }
 
-    this.cache = null
+    this[kFirst] = true
+    this[kCache] = empty
+    this[kFinished] = false
+    this[kPosition] = 0
+
     binding.iterator_seek(this[kContext], target)
-    this[kFinalized] = false
   }
 
   _next (callback) {
-    if (this.cache && this.cache.length) {
-      process.nextTick(callback, null, this.cache.pop(), this.cache.pop())
-    } else if (this[kFinalized]) {
+    if (this[kPosition] < this[kCache].length) {
+      const key = this[kCache][this[kPosition]++]
+      const val = this[kCache][this[kPosition]++]
+      process.nextTick(callback, null, key, val)
+    } else if (this[kFinished]) {
       process.nextTick(callback)
     } else {
-      binding.iterator_nextv(this[kContext], 1000, (err, array, finished) => {
-        if (err) {
-          callback(err)
-        } else {
-          this.cache = array
-          this[kFinalized] = finished
-          this._next(callback)
-        }
-      })
+      this[kCallback] = callback
+
+      if (this[kFirst]) {
+        // It's common to only want one entry initially or after a seek()
+        this[kFirst] = false
+        binding.iterator_nextv(this[kContext], 1, this[kHandleNext])
+      } else {
+        // Limit the size of the cache to prevent starving the event loop
+        // while we're recursively calling process.nextTick().
+        binding.iterator_nextv(this[kContext], 1000, this[kHandleNext])
+      }
     }
 
     return this
   }
 
-  _end (callback) {
-    this.cache = null
+  [kHandleNext] (err, items, finished) {
+    const callback = this[kCallback]
+    if (err) return callback(err)
+
+    this[kCache] = items
+    this[kFinished] = finished
+    this[kPosition] = 0
+
+    this._next(callback)
+  }
+
+  _nextv (size, options, callback) {
+    if (this[kFinished]) {
+      process.nextTick(callback, null, [])
+    } else {
+      this[kCallback] = callback
+      this[kFirst] = false
+      binding.iterator_nextv(this[kContext], size, this[kHandleNextv])
+    }
+  }
+
+  [kHandleNextv] (err, items, finished) {
+    const callback = this[kCallback]
+    if (err) return callback(err)
+    this[kFinished] = finished
+
+    const entries = []
+    for (let n = 0; n < items.length; n += 2) {
+      entries.push([items[n + 0], items[n + 1]])
+    }
+
+    callback(null, entries)
+  }
+
+  _close (callback) {
+    this[kCache] = empty
+    this[kCallback] = null
+
     binding.iterator_close(this[kContext], callback)
   }
+
+  _end (callback) {
+    this._close(callback)
+  }
+
+  // Undocumented, exposed for tests only
+  get cached () {
+    return (this[kCache].length - this[kPosition]) / 2
+  }
 }
 
-module.exports = Iterator
+exports.Iterator = Iterator