@nxtedition/rocksdb 5.2.16 → 5.2.26

package/binding.cc

@@ -30,7 +30,6 @@ public:
 
 struct Database;
 struct Iterator;
-static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb);
 
 #define NAPI_DB_CONTEXT() \
   Database* database = nullptr; \
@@ -41,7 +40,7 @@ static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb);
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
 #define NAPI_BATCH_CONTEXT() \
-  leveldb::WriteBatch* batch = nullptr; \
+  rocksdb::WriteBatch* batch = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&batch));
 
 static bool IsString (napi_env env, napi_value value) {
@@ -92,8 +91,7 @@ static napi_value GetProperty (napi_env env, napi_value obj, const std::string&
   return value;
 }
 
-static bool BooleanProperty (napi_env env, napi_value obj, const std::string& key,
-                             bool defaultValue) {
+static bool BooleanProperty (napi_env env, napi_value obj, const std::string& key, bool defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     bool result;
@@ -117,8 +115,7 @@ static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string& o
   return false;
 }
 
-static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string& key,
-                                uint32_t defaultValue) {
+static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string& key, uint32_t defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
@@ -129,8 +126,7 @@ static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string&
   return defaultValue;
 }
 
-static int Int32Property (napi_env env, napi_value obj, const std::string& key,
-                          int defaultValue) {
+static int Int32Property (napi_env env, napi_value obj, const std::string& key, int defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int result;
@@ -158,7 +154,7 @@ static std::string ToString (napi_env env, napi_value from, const std::string& d
   return defaultValue;
 }
 
-static std::string StringProperty (napi_env env, napi_value obj, const std::string& key) {
+static std::string StringProperty (napi_env env, napi_value obj, const std::string& key, const std::string& defaultValue = "") {
   if (HasProperty(env, obj, key)) {
     napi_value value = GetProperty(env, obj, key);
     if (IsString(env, value)) {
@@ -166,7 +162,7 @@ static std::string StringProperty (napi_env env, napi_value obj, const std::stri
     }
   }
 
-  return "";
+  return defaultValue;
 }
 
 static size_t StringOrBufferLength (napi_env env, napi_value value) {
@@ -211,10 +207,7 @@ static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
   return result;
 }
 
-static napi_status CallFunction (napi_env env,
-                                 napi_value callback,
-                                 const int argc,
-                                 napi_value* argv) {
+static napi_status CallFunction (napi_env env, napi_value callback, const int argc, napi_value* argv) {
   napi_value global;
   napi_get_global(env, &global);
   return napi_call_function(env, global, callback, argc, argv, nullptr);
@@ -233,72 +226,60 @@ void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
  * Base worker class. Handles the async work. Derived classes can override the
  * following virtual methods (listed in the order in which they're called):
  *
- * - DoExecute (abstract, worker pool thread): main work
- * - HandleOKCallback (main thread): call JS callback on success
- * - HandleErrorCallback (main thread): call JS callback on error
- * - DoFinally (main thread): do cleanup regardless of success
+ * - Execute (abstract, worker pool thread): main work
+ * - Then (main thread): call JS callback on success
+ * - Catch (main thread): call JS callback on error
+ * - Finally (main thread): do cleanup regardless of success
  */
 struct BaseWorker {
-  // Note: storing env is discouraged as we'd end up using it in unsafe places.
   BaseWorker (napi_env env,
               Database* database,
               napi_value callback,
-              const char* resourceName)
+              const std::string& resourceName)
     : database_(database) {
     NAPI_STATUS_THROWS_VOID(napi_create_reference(env, callback, 1, &callbackRef_));
     napi_value asyncResourceName;
-    NAPI_STATUS_THROWS_VOID(napi_create_string_utf8(env, resourceName,
-                                               NAPI_AUTO_LENGTH,
-                                               &asyncResourceName));
+    NAPI_STATUS_THROWS_VOID(napi_create_string_utf8(env, resourceName.data(),
+                                                    NAPI_AUTO_LENGTH,
+                                                    &asyncResourceName));
     NAPI_STATUS_THROWS_VOID(napi_create_async_work(env, callback,
-                                              asyncResourceName,
-                                              BaseWorker::Execute,
-                                              BaseWorker::Complete,
-                                              this, &asyncWork_));
+                                                   asyncResourceName,
+                                                   BaseWorker::Execute,
+                                                   BaseWorker::Complete,
+                                                   this, &asyncWork_));
   }
 
   virtual ~BaseWorker () {}
 
   static void Execute (napi_env env, void* data) {
     auto self = reinterpret_cast<BaseWorker*>(data);
-
-    // Don't pass env to DoExecute() because use of Node-API
-    // methods should generally be avoided in async work.
-    self->DoExecute();
+    self->status_ = self->Execute();
   }
 
-  bool SetStatus (const leveldb::Status& status) {
-    status_ = status;
-    return status.ok();
-  }
-
-  virtual void DoExecute () = 0;
-
   static void Complete (napi_env env, napi_status status, void* data) {
     auto self = reinterpret_cast<BaseWorker*>(data);
 
-    self->DoComplete(env);
-    self->DoFinally(env);
-  }
-
-  void DoComplete (napi_env env) {
     napi_value callback;
-    napi_get_reference_value(env, callbackRef_, &callback);
+    napi_get_reference_value(env, self->callbackRef_, &callback);
 
-    if (status_.ok()) {
-      HandleOKCallback(env, callback);
+    if (self->status_.ok()) {
+      self->Then(env, callback);
     } else {
-      HandleErrorCallback(env, callback);
+      self->Catch(env, callback);
     }
+
+    self->Finally(env);
   }
 
-  virtual void HandleOKCallback (napi_env env, napi_value callback) {
+  virtual rocksdb::Status Execute () = 0;
+
+  virtual void Then (napi_env env, napi_value callback) {
     napi_value argv;
     napi_get_null(env, &argv);
     CallFunction(env, callback, 1, &argv);
   }
 
-  virtual void HandleErrorCallback (napi_env env, napi_value callback) {
+  virtual void Catch (napi_env env, napi_value callback) {
     napi_value argv;
 
     const auto msg = status_.ToString();
@@ -324,7 +305,7 @@ struct BaseWorker {
     CallFunction(env, callback, 1, &argv);
   }
 
-  virtual void DoFinally (napi_env env) {
+  virtual void Finally (napi_env env) {
     napi_delete_reference(env, callbackRef_);
     napi_delete_async_work(env, asyncWork_);
 
@@ -340,29 +321,21 @@ struct BaseWorker {
 private:
   napi_ref callbackRef_;
   napi_async_work asyncWork_;
-  leveldb::Status status_;
+  rocksdb::Status status_;
 };
 
-/**
- * Owns the LevelDB storage, cache, filter policy and iterators.
- */
 struct Database {
-  Database ()
-    : pendingCloseWorker_(nullptr),
-      ref_(nullptr),
-      priorityWork_(0) {}
-
-  leveldb::Status Open (const leveldb::Options& options,
+  rocksdb::Status Open (const rocksdb::Options& options,
                         const bool readOnly,
                         const char* location) {
     if (readOnly) {
-      leveldb::DB* db = nullptr;
+      rocksdb::DB* db = nullptr;
       const auto status = rocksdb::DB::OpenForReadOnly(options, location, &db);
       db_.reset(db);
       return status;
     } else {
-      leveldb::DB* db = nullptr;
-      const auto status = leveldb::DB::Open(options, location, &db);
+      rocksdb::DB* db = nullptr;
+      const auto status = rocksdb::DB::Open(options, location, &db);
       db_.reset(db);
       return status;
     }
@@ -372,36 +345,36 @@ struct Database {
     db_.reset();
   }
 
-  leveldb::Status Put (const leveldb::WriteOptions& options,
+  rocksdb::Status Put (const rocksdb::WriteOptions& options,
                        const std::string& key,
                        const std::string& value) {
     return db_->Put(options, db_->DefaultColumnFamily(), key, value);
   }
 
-  leveldb::Status Get (const leveldb::ReadOptions& options,
+  rocksdb::Status Get (const rocksdb::ReadOptions& options,
                        const std::string& key,
                        rocksdb::PinnableSlice& value) {
     return db_->Get(options, db_->DefaultColumnFamily(), key, &value);
   }
 
-  leveldb::Status Del (const leveldb::WriteOptions& options,
+  rocksdb::Status Del (const rocksdb::WriteOptions& options,
                        const std::string& key) {
     return db_->Delete(options, db_->DefaultColumnFamily(), key);
   }
 
-  leveldb::Status WriteBatch (const leveldb::WriteOptions& options,
-                              leveldb::WriteBatch* batch) {
+  rocksdb::Status WriteBatch (const rocksdb::WriteOptions& options,
+                              rocksdb::WriteBatch* batch) {
     return db_->Write(options, batch);
   }
 
-  uint64_t ApproximateSize (const leveldb::Range* range) {
+  uint64_t ApproximateSize (const rocksdb::Range* range) {
     uint64_t size = 0;
     db_->GetApproximateSizes(range, 1, &size);
     return size;
   }
 
-  void CompactRange (const leveldb::Slice* start,
-                     const leveldb::Slice* end) {
+  void CompactRange (const rocksdb::Slice* start,
+                     const rocksdb::Slice* end) {
     rocksdb::CompactRangeOptions options;
     db_->CompactRange(options, start, end);
   }
@@ -410,15 +383,15 @@ struct Database {
     db_->GetProperty(property, &value);
   }
 
-  const leveldb::Snapshot* NewSnapshot () {
+  const rocksdb::Snapshot* NewSnapshot () {
     return db_->GetSnapshot();
   }
 
-  leveldb::Iterator* NewIterator (const leveldb::ReadOptions& options) {
+  rocksdb::Iterator* NewIterator (const rocksdb::ReadOptions& options) {
     return db_->NewIterator(options);
   }
 
-  void ReleaseSnapshot (const leveldb::Snapshot* snapshot) {
+  void ReleaseSnapshot (const rocksdb::Snapshot* snapshot) {
     return db_->ReleaseSnapshot(snapshot);
   }
 
@@ -433,11 +406,11 @@ struct Database {
   }
 
   void IncrementPriorityWork (napi_env env) {
-    napi_reference_ref(env, ref_, &priorityWork_);
+    napi_reference_ref(env, prioritRef_, &priorityWork_);
   }
 
   void DecrementPriorityWork (napi_env env) {
-    napi_reference_unref(env, ref_, &priorityWork_);
+    napi_reference_unref(env, prioritRef_, &priorityWork_);
 
     if (priorityWork_ == 0 && pendingCloseWorker_) {
       pendingCloseWorker_->Queue(env);
@@ -449,13 +422,13 @@ struct Database {
     return priorityWork_ > 0;
   }
 
-  std::unique_ptr<leveldb::DB> db_;
+  std::unique_ptr<rocksdb::DB> db_;
   BaseWorker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
-  napi_ref ref_;
+  napi_ref prioritRef_;
 
 private:
-  uint32_t priorityWork_;
+  uint32_t priorityWork_ = 0;
 };
 
 /**
@@ -464,14 +437,14 @@ private:
 struct PriorityWorker : public BaseWorker {
   PriorityWorker (napi_env env, Database* database, napi_value callback, const char* resourceName)
     : BaseWorker(env, database, callback, resourceName) {
-      database_->IncrementPriorityWork(env);
+    database_->IncrementPriorityWork(env);
   }
 
   virtual ~PriorityWorker () {}
 
-  void DoFinally (napi_env env) override {
+  void Finally (napi_env env) override {
     database_->DecrementPriorityWork(env);
-    BaseWorker::DoFinally(env);
+    BaseWorker::Finally(env);
   }
 };
 
@@ -485,77 +458,63 @@ struct BaseIterator {
                const int limit,
                const bool fillCache)
     : database_(database),
-      snapshot_(database->NewSnapshot()),
-      dbIterator_(database->NewIterator([&]{
-        leveldb::ReadOptions options;
-        options.fill_cache = fillCache;
-        options.verify_checksums = false;
-        options.snapshot = snapshot_;
-        return options;
-      }())),
-      didSeek_(false),
-      reverse_(reverse),
       lt_(lt),
       lte_(lte),
       gt_(gt),
       gte_(gte),
-      limit_(limit),
-      count_(0) {
+      snapshot_(database->NewSnapshot(), [this](const rocksdb::Snapshot* ptr) {
+        database_->ReleaseSnapshot(ptr);
+      }),
+      iterator_(database->NewIterator([&]{
+        rocksdb::ReadOptions options;
+        if (lt_ && !lte_) {
+          upper_bound_ = rocksdb::Slice(lt_->data(), lt_->size());
+          options.iterate_upper_bound = &upper_bound_;
+        }
+        if (gte_) {
+          lower_bound_ = rocksdb::Slice(gte_->data(), gte_->size());
+          options.iterate_lower_bound = &lower_bound_;
+        }
+        options.fill_cache = fillCache;
+        options.snapshot = snapshot_.get();
+        return options;
+      }())),
+      reverse_(reverse),
+      limit_(limit) {
   }
 
   virtual ~BaseIterator () {
-    assert(!dbIterator_);
-
-    delete lt_;
-    delete lte_;
-    delete gt_;
-    delete gte_;
+    assert(!iterator_);
   }
 
   bool DidSeek () const {
     return didSeek_;
   }
 
-  /**
-   * Seek to the first relevant key based on range options.
-   */
   void SeekToRange () {
     didSeek_ = true;
 
-    if (!reverse_ && gte_) {
-      dbIterator_->Seek(*gte_);
-    } else if (!reverse_ && gt_) {
-      dbIterator_->Seek(*gt_);
+    if (!reverse_ && gt_ && !gte_) {
+      iterator_->Seek(*gt_);
 
-      if (dbIterator_->Valid() && dbIterator_->key().compare(*gt_) == 0) {
-        dbIterator_->Next();
+      if (iterator_->Valid() && iterator_->key().compare(*gt_) == 0) {
+        iterator_->Next();
       }
     } else if (reverse_ && lte_) {
-      dbIterator_->Seek(*lte_);
+      iterator_->Seek(*lte_);
 
-      if (!dbIterator_->Valid()) {
-        dbIterator_->SeekToLast();
-      } else if (dbIterator_->key().compare(*lte_) > 0) {
-        dbIterator_->Prev();
-      }
-    } else if (reverse_ && lt_) {
-      dbIterator_->Seek(*lt_);
-
-      if (!dbIterator_->Valid()) {
-        dbIterator_->SeekToLast();
-      } else if (dbIterator_->key().compare(*lt_) >= 0) {
-        dbIterator_->Prev();
+      if (!iterator_->Valid()) {
+        iterator_->SeekToLast();
+      } else if (iterator_->key().compare(*lte_) > 0) {
+        iterator_->Prev();
       }
     } else if (reverse_) {
-      dbIterator_->SeekToLast();
+      iterator_->SeekToLast();
     } else {
-      dbIterator_->SeekToFirst();
+      iterator_->SeekToFirst();
     }
   }
 
-  /**
-   * Seek manually (during iteration).
-   */
   void Seek (const std::string& target) {
     didSeek_ = true;
 
@@ -563,17 +522,17 @@ struct BaseIterator {
       return SeekToEnd();
     }
 
-    dbIterator_->Seek(target);
+    iterator_->Seek(target);
 
-    if (dbIterator_->Valid()) {
-      const auto cmp = dbIterator_->key().compare(target);
+    if (iterator_->Valid()) {
+      const auto cmp = iterator_->key().compare(target);
       if (reverse_ ? cmp > 0 : cmp < 0) {
         Next();
       }
     } else {
       SeekToFirst();
-      if (dbIterator_->Valid()) {
-        const auto cmp = dbIterator_->key().compare(target);
+      if (iterator_->Valid()) {
+        const auto cmp = iterator_->key().compare(target);
         if (reverse_ ? cmp > 0 : cmp < 0) {
           SeekToEnd();
         }
@@ -582,15 +541,24 @@ struct BaseIterator {
   }
 
   void Close () {
-    if (dbIterator_) {
-      delete dbIterator_;
-      dbIterator_ = nullptr;
-      database_->ReleaseSnapshot(snapshot_);
-    }
+    snapshot_.reset();
+    iterator_.reset();
   }
 
   bool Valid () const {
-    return dbIterator_->Valid() && !OutOfRange(dbIterator_->key());
+    if (!iterator_->Valid()) {
+      return false;
+    }
+
+    if (lte_ && iterator_->key().compare(*lte_) > 0) {
+      return false;
+    }
+
+    if (!gte_ && gt_ && iterator_->key().compare(*gt_) <= 0) {
+      return false;
+    }
+
+    return true;
   }
 
   bool Increment () {
@@ -598,18 +566,18 @@ struct BaseIterator {
   }
 
   void Next () {
-    if (reverse_) dbIterator_->Prev();
-    else dbIterator_->Next();
+    if (reverse_) iterator_->Prev();
+    else iterator_->Next();
   }
 
   void SeekToFirst () {
-    if (reverse_) dbIterator_->SeekToLast();
-    else dbIterator_->SeekToFirst();
+    if (reverse_) iterator_->SeekToLast();
+    else iterator_->SeekToFirst();
   }
 
   void SeekToLast () {
-    if (reverse_) dbIterator_->SeekToFirst();
-    else dbIterator_->SeekToLast();
+    if (reverse_) iterator_->SeekToFirst();
+    else iterator_->SeekToLast();
   }
 
   void SeekToEnd () {
@@ -617,19 +585,19 @@ struct BaseIterator {
     Next();
   }
 
-  leveldb::Slice CurrentKey () const {
-    return dbIterator_->key();
+  rocksdb::Slice CurrentKey () const {
+    return iterator_->key();
   }
 
-  leveldb::Slice CurrentValue () const {
-    return dbIterator_->value();
+  rocksdb::Slice CurrentValue () const {
+    return iterator_->value();
   }
 
-  leveldb::Status Status () const {
-    return dbIterator_->status();
+  rocksdb::Status Status () const {
+    return iterator_->status();
   }
 
-  bool OutOfRange (const leveldb::Slice& target) const {
+  bool OutOfRange (const rocksdb::Slice& target) const {
     if (lte_) {
       if (target.compare(*lte_) > 0) return true;
     } else if (lt_) {
@@ -648,16 +616,18 @@ struct BaseIterator {
   Database* database_;
 
 private:
-  const leveldb::Snapshot* snapshot_;
-  leveldb::Iterator* dbIterator_;
-  bool didSeek_;
+  const std::unique_ptr<const std::string> lt_;
+  const std::unique_ptr<const std::string> lte_;
+  const std::unique_ptr<const std::string> gt_;
+  const std::unique_ptr<const std::string> gte_;
+  rocksdb::Slice lower_bound_;
+  rocksdb::Slice upper_bound_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
+  std::unique_ptr<rocksdb::Iterator> iterator_;
+  bool didSeek_ = false;
   const bool reverse_;
-  const std::string* lt_;
-  const std::string* lte_;
-  const std::string* gt_;
-  const std::string* gte_;
   const int limit_;
-  int count_;
+  int count_ = 0;
 };
 
 struct Iterator final : public BaseIterator {
@@ -681,9 +651,6 @@ struct Iterator final : public BaseIterator {
       valueAsBuffer_(valueAsBuffer),
       highWaterMarkBytes_(highWaterMarkBytes),
       first_(true),
-      nexting_(false),
-      isClosing_(false),
-      closeWorker_(nullptr),
       ref_(nullptr) {
   }
 
@@ -697,53 +664,12 @@ struct Iterator final : public BaseIterator {
     if (ref_) napi_delete_reference(env, ref_);
   }
 
-  bool ReadMany (uint32_t size) {
-    cache_.clear();
-    cache_.reserve(size * 2);
-    size_t bytesRead = 0;
-
-    while (true) {
-      if (!first_) Next();
-      else first_ = false;
-
-      if (!Valid() || !Increment()) break;
-    
-      if (keys_ && values_) {
-        auto k = CurrentKey();
-        auto v = CurrentValue();
-        cache_.emplace_back(k.data(), k.size());
-        cache_.emplace_back(v.data(), v.size());
-        bytesRead += k.size() + v.size();
-      } else if (keys_) {
-        auto k = CurrentKey();
-        cache_.emplace_back(k.data(), k.size());
-        cache_.push_back({});
-        bytesRead += k.size();
-      } else if (values_) {
-        auto v = CurrentValue();
-        cache_.push_back({});
-        cache_.emplace_back(v.data(), v.size());
-        bytesRead += v.size();
-      }
-
-      if (bytesRead > highWaterMarkBytes_ || cache_.size() / 2 >= size) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
   const bool keys_;
   const bool values_;
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
   const uint32_t highWaterMarkBytes_;
   bool first_;
-  bool nexting_;
-  bool isClosing_;
-  BaseWorker* closeWorker_;
-  std::vector<std::string> cache_;
 
 private:
   napi_ref ref_;
@@ -755,7 +681,7 @@ private:
  * the guarantee that no db operations will be in-flight at this time.
  */
 static void env_cleanup_hook (void* arg) {
-  Database* database = reinterpret_cast<Database*>(arg);
+  auto database = reinterpret_cast<Database*>(arg);
 
   // Do everything that db_close() does but synchronously. We're expecting that GC
   // did not (yet) collect the database because that would be a user mistake (not
@@ -776,15 +702,15 @@ static void env_cleanup_hook (void* arg) {
 
 static void FinalizeDatabase (napi_env env, void* data, void* hint) {
   if (data) {
-    Database* database = (Database*)data;
+    auto database = reinterpret_cast<Database*>(data);
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
-    if (database->ref_) napi_delete_reference(env, database->ref_);
+    if (database->prioritRef_) napi_delete_reference(env, database->prioritRef_);
     delete database;
   }
 }
 
 NAPI_METHOD(db_init) {
-  Database* database = new Database();
+  auto database = new Database();
   napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
 
   napi_value result;
@@ -792,17 +718,12 @@ NAPI_METHOD(db_init) {
                                           FinalizeDatabase,
                                           nullptr, &result));
 
-  // Reference counter to prevent GC of database while priority workers are active
-  NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->ref_));
+  NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->prioritRef_));
 
   return result;
 }
 
-/**
- * Worker class for opening a database.
- * TODO: shouldn't this be a PriorityWorker?
- */
-struct OpenWorker final : public BaseWorker {
+struct OpenWorker final : public PriorityWorker {
   OpenWorker (napi_env env,
               Database* database,
               napi_value callback,
@@ -818,18 +739,18 @@ struct OpenWorker final : public BaseWorker {
               const uint32_t cacheSize,
               const std::string& infoLogLevel,
               const bool readOnly)
-    : BaseWorker(env, database, callback, "leveldown.db.open"),
+    : PriorityWorker(env, database, callback, "leveldown.db.open"),
       readOnly_(readOnly),
       location_(location) {
     options_.create_if_missing = createIfMissing;
     options_.error_if_exists = errorIfExists;
     options_.compression = compression
-      ? leveldb::kSnappyCompression
-      : leveldb::kNoCompression;
+      ? rocksdb::kSnappyCompression
+      : rocksdb::kNoCompression;
     options_.write_buffer_size = writeBufferSize;
     options_.max_open_files = maxOpenFiles;
     options_.max_log_file_size = maxFileSize;
-    options_.paranoid_checks = false;
+    options_.use_adaptive_mutex = true;
 
     if (infoLogLevel.size() > 0) {
       rocksdb::InfoLogLevel lvl = {};
@@ -861,17 +782,19 @@ struct OpenWorker final : public BaseWorker {
     tableOptions.block_size = blockSize;
     tableOptions.block_restart_interval = blockRestartInterval;
     tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
+    tableOptions.format_version = 5;
+    tableOptions.checksum = rocksdb::kxxHash64;
 
     options_.table_factory.reset(
       rocksdb::NewBlockBasedTableFactory(tableOptions)
     );
   }
 
-  void DoExecute () override {
-    SetStatus(database_->Open(options_, readOnly_, location_.c_str()));
+  rocksdb::Status Execute () override {
+    return database_->Open(options_, readOnly_, location_.c_str());
   }
 
-  leveldb::Options options_;
+  rocksdb::Options options_;
   const bool readOnly_;
   const std::string location_;
 };
@@ -916,8 +839,9 @@ struct CloseWorker final : public BaseWorker {
                napi_value callback)
     : BaseWorker(env, database, callback, "leveldown.db.close") {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     database_->CloseDatabase();
+    return rocksdb::Status::OK();
   }
 };
 
@@ -931,13 +855,6 @@ NAPI_METHOD(db_close) {
 
   const auto callback = argv[1];
 
-  napi_value noop;
-  napi_create_function(env, nullptr, 0, noop_callback, nullptr, &noop);
-
-  for (auto it : database->iterators_) {
-    iterator_do_close(env, it, noop);
-  }
-  
   auto worker = new CloseWorker(env, database, callback);
 
   if (!database->HasPriorityWork()) {
@@ -960,10 +877,10 @@ struct PutWorker final : public PriorityWorker {
       key_(key), value_(value), sync_(sync) {
   }
 
-  void DoExecute () override {
-    leveldb::WriteOptions options;
+  rocksdb::Status Execute () override {
+    rocksdb::WriteOptions options;
     options.sync = sync_;
-    SetStatus(database_->Put(options, key_, value_));
+    return database_->Put(options, key_, value_);
   }
 
   const std::string key_;
@@ -997,13 +914,13 @@ struct GetWorker final : public PriorityWorker {
       key_(key), asBuffer_(asBuffer), fillCache_(fillCache) {
   }
 
-  void DoExecute () override {
-    leveldb::ReadOptions options;
+  rocksdb::Status Execute () override {
+    rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
-    SetStatus(database_->Get(options, key_, value_));
+    return database_->Get(options, key_, value_);
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
+  void Then (napi_env env, napi_value callback) override {
     napi_value argv[2];
     napi_get_null(env, &argv[0]);
     Convert(env, std::move(value_), asBuffer_, argv[1]);
@@ -1052,44 +969,39 @@ struct GetManyWorker final : public PriorityWorker {
     }
   }
 
-  void DoExecute () override {
-    cache_.reserve(keys_.size());
-
-    leveldb::ReadOptions options;
+  rocksdb::Status Execute () override {
+    rocksdb::ReadOptions options;
     options.snapshot = snapshot_;
     options.fill_cache = fillCache_;
     
-    rocksdb::PinnableSlice value;
+    status_ = database_->db_->MultiGet(
+      options,
+      std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()),
+      &values_
+    );
 
-    for (const auto& key: keys_) {
-      const auto status = database_->Get(options, key, value);
+    database_->ReleaseSnapshot(snapshot_);
+    snapshot_ = nullptr;
 
-      if (status.ok()) {
-        cache_.emplace_back(std::move(value));
-      } else if (status.IsNotFound()) {
-        cache_.emplace_back(nullptr);
-      } else {
-        SetStatus(status);
-        break;
+    for (auto status : status_) {
+      if (!status.ok() && !status.IsNotFound()) {
+        return status;
       }
-
-      value.Reset();
     }
 
-    database_->ReleaseSnapshot(snapshot_);
-    snapshot_ = nullptr;
+    return rocksdb::Status::OK();
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
-    const auto size = cache_.size();
+  void Then (napi_env env, napi_value callback) override {
+    const auto size = values_.size();
 
     napi_value array;
     napi_create_array_with_length(env, size, &array);
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
-      if (cache_[idx].GetSelf() != nullptr) {
-        Convert(env, cache_[idx], valueAsBuffer_, element);
+      if (status_[idx].ok()) {
+        Convert(env, values_[idx], valueAsBuffer_, element);
       } else {
         napi_get_undefined(env, &element);
       }
@@ -1104,10 +1016,11 @@ struct GetManyWorker final : public PriorityWorker {
 
 private:
   const std::vector<std::string> keys_;
+  std::vector<std::string> values_;
+  std::vector<rocksdb::Status> status_;
   const bool valueAsBuffer_;
-  std::vector<rocksdb::PinnableSlice> cache_;
   const bool fillCache_;
-  const leveldb::Snapshot* snapshot_;
+  const rocksdb::Snapshot* snapshot_;
 };
 
 NAPI_METHOD(db_get_many) {
@@ -1136,10 +1049,10 @@ struct DelWorker final : public PriorityWorker {
       key_(key), sync_(sync) {
   }
 
-  void DoExecute () override {
-    leveldb::WriteOptions options;
+  rocksdb::Status Execute () override {
+    rocksdb::WriteOptions options;
     options.sync = sync_;
-    SetStatus(database_->Del(options, key_));
+    return database_->Del(options, key_);
   }
 
   const std::string key_;
@@ -1174,16 +1087,16 @@ struct ClearWorker final : public PriorityWorker {
       iterator_(database, reverse, lt, lte, gt, gte, limit, false) {
   }
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     iterator_.SeekToRange();
 
     // TODO: add option
     const uint32_t hwm = 16 * 1024;
-    leveldb::WriteBatch batch;
-
-    leveldb::WriteOptions options;
-    options.sync = false;
 
+    rocksdb::WriteBatch batch;
+    rocksdb::WriteOptions options;
+    rocksdb::Status status;
+    
     while (true) {
       size_t bytesRead = 0;
 
@@ -1194,11 +1107,13 @@ struct ClearWorker final : public PriorityWorker {
         iterator_.Next();
       }
 
-      if (!SetStatus(iterator_.Status()) || bytesRead == 0) {
+      status = iterator_.Status();
+      if (!status.ok() || bytesRead == 0) {
         break;
       }
 
-      if (!SetStatus(database_->WriteBatch(options, &batch))) {
+      status = database_->WriteBatch(options, &batch);
+      if (!status.ok()) {
         break;
       }
 
@@ -1206,6 +1121,8 @@ struct ClearWorker final : public PriorityWorker {
     }
 
     iterator_.Close();
+
+    return status;
   }
 
 private:
@@ -1242,12 +1159,13 @@ struct ApproximateSizeWorker final : public PriorityWorker {
     : PriorityWorker(env, database, callback, "rocks_level.db.approximate_size"),
       start_(start), end_(end) {}
 
-  void DoExecute () override {
-    leveldb::Range range(start_, end_);
+  rocksdb::Status Execute () override {
+    rocksdb::Range range(start_, end_);
     size_ = database_->ApproximateSize(&range);
+    return rocksdb::Status::OK();
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
+  void Then (napi_env env, napi_value callback) override {
     napi_value argv[2];
     napi_get_null(env, &argv[0]);
     napi_create_int64(env, size_, &argv[1]);
@@ -1282,10 +1200,11 @@ struct CompactRangeWorker final : public PriorityWorker {
     : PriorityWorker(env, database, callback, "rocks_level.db.compact_range"),
       start_(start), end_(end) {}
 
-  void DoExecute () override {
-    leveldb::Slice start = start_;
-    leveldb::Slice end = end_;
+  rocksdb::Status Execute () override {
+    rocksdb::Slice start = start_;
+    rocksdb::Slice end = end_;
     database_->CompactRange(&start, &end);
+    return rocksdb::Status::OK();
   }
 
   const std::string start_;
@@ -1330,9 +1249,9 @@ struct DestroyWorker final : public BaseWorker {
 
   ~DestroyWorker () {}
 
-  void DoExecute () override {
-    leveldb::Options options;
-    SetStatus(leveldb::DestroyDB(location_, options));
+  rocksdb::Status Execute () override {
+    rocksdb::Options options;
+    return rocksdb::DestroyDB(location_, options);
   }
 
   const std::string location_;
@@ -1357,9 +1276,9 @@ struct RepairWorker final : public BaseWorker {
     : BaseWorker(env, nullptr, callback, "rocks_level.repair_db"),
       location_(location) {}
 
-  void DoExecute () override {
-    leveldb::Options options;
-    SetStatus(leveldb::RepairDB(location_, options));
+  rocksdb::Status Execute () override {
+    rocksdb::Options options;
+    return rocksdb::RepairDB(location_, options);
   }
 
   const std::string location_;
@@ -1422,10 +1341,6 @@ NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  if (iterator->isClosing_) {
-    napi_throw_error(env, nullptr, "iterator has closed");
-  }
-
   const auto target = ToString(env, argv[1]);
   iterator->first_ = true;
   iterator->Seek(target);
@@ -1440,41 +1355,28 @@ struct CloseIteratorWorker final : public BaseWorker {
     : BaseWorker(env, iterator->database_, callback, "leveldown.iterator.end"),
       iterator_(iterator) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     iterator_->Close();
+    return rocksdb::Status::OK();
   }
 
-  void DoFinally (napi_env env) override {
+  void Finally (napi_env env) override {
     iterator_->Detach(env);
-    BaseWorker::DoFinally(env);
+    BaseWorker::Finally(env);
   }
 
 private:
   Iterator* iterator_;
 };
 
-/**
- * Called by NAPI_METHOD(iterator_) and also when closing
- * open iterators during NAPI_METHOD(db_close).
- */
-static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb) {
-  if (!iterator->isClosing_) {
-    auto worker = new CloseIteratorWorker(env, iterator, cb);
-    iterator->isClosing_ = true;
-
-    if (iterator->nexting_) {
-      iterator->closeWorker_ = worker;
-    } else {
-      worker->Queue(env);
-    }
-  }
-}
-
 NAPI_METHOD(iterator_close) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  iterator_do_close(env, iterator, argv[1]);
+  const auto callback = argv[1];
+
+  auto worker = new CloseIteratorWorker(env, iterator, callback);
+  worker->Queue(env);
 
   return 0;
 }
@@ -1486,63 +1388,83 @@ struct NextWorker final : public BaseWorker {
               napi_value callback)
     : BaseWorker(env, iterator->database_, callback,
                  "leveldown.iterator.next"),
-      iterator_(iterator), size_(size), ok_() {}
+      iterator_(iterator), size_(size) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     if (!iterator_->DidSeek()) {
       iterator_->SeekToRange();
     }
 
     // Limit the size of the cache to prevent starving the event loop
     // in JS-land while we're recursively calling process.nextTick().
-    ok_ = iterator_->ReadMany(size_);
 
-    if (!ok_) {
-      SetStatus(iterator_->Status());
+    finished_ = false;
+    cache_.reserve(size_ * 2);
+    size_t bytesRead = 0;
+
+    while (true) {
+      if (!iterator_->first_) iterator_->Next();
+      else iterator_->first_ = false;
+
+      if (!iterator_->Valid() || !iterator_->Increment()) break;
+    
+      if (iterator_->keys_ && iterator_->values_) {
+        auto k = iterator_->CurrentKey();
+        auto v = iterator_->CurrentValue();
+        cache_.emplace_back(k.data(), k.size());
+        cache_.emplace_back(v.data(), v.size());
+        bytesRead += k.size() + v.size();
+      } else if (iterator_->keys_) {
+        auto k = iterator_->CurrentKey();
+        cache_.emplace_back(k.data(), k.size());
+        cache_.push_back({});
+        bytesRead += k.size();
+      } else if (iterator_->values_) {
+        auto v = iterator_->CurrentValue();
+        cache_.push_back({});
+        cache_.emplace_back(v.data(), v.size());
+        bytesRead += v.size();
+      }
+
+      if (bytesRead > iterator_->highWaterMarkBytes_ || cache_.size() / 2 >= size_) {
+        finished_ = true;
+        return rocksdb::Status::OK();
+      }
     }
+
+    return iterator_->Status();
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
-    const auto size = iterator_->cache_.size();
+  void Then (napi_env env, napi_value callback) override {
+    const auto size = cache_.size();
     napi_value result;
     napi_create_array_with_length(env, size, &result);
 
-    for (size_t idx = 0; idx < iterator_->cache_.size(); idx += 2) {
+    for (size_t idx = 0; idx < cache_.size(); idx += 2) {
       napi_value key;
       napi_value val;
 
-      Convert(env, iterator_->cache_[idx + 0], iterator_->keyAsBuffer_, key);
-      Convert(env, iterator_->cache_[idx + 1], iterator_->valueAsBuffer_, val);
+      Convert(env, cache_[idx + 0], iterator_->keyAsBuffer_, key);
+      Convert(env, cache_[idx + 1], iterator_->valueAsBuffer_, val);
 
       napi_set_element(env, result, static_cast<int>(idx + 0), key);
       napi_set_element(env, result, static_cast<int>(idx + 1), val);
     }
 
-    iterator_->cache_.clear();
+    cache_.clear();
 
     napi_value argv[3];
     napi_get_null(env, &argv[0]);
     argv[1] = result;
-    napi_get_boolean(env, !ok_, &argv[2]);
+    napi_get_boolean(env, !finished_, &argv[2]);
     CallFunction(env, callback, 3, argv);
   }
 
-  void DoFinally (napi_env env) override {
-    // clean up & handle the next/end state
-    iterator_->nexting_ = false;
-
-    if (iterator_->closeWorker_) {
-      iterator_->closeWorker_->Queue(env);
-      iterator_->closeWorker_ = nullptr;
-    }
-
-    BaseWorker::DoFinally(env);
-  }
-
 private:
-  Iterator* iterator_;
-  uint32_t size_;
-  bool ok_;
+  std::vector<std::string> cache_;
+  Iterator* iterator_ = nullptr;
+  uint32_t size_ = 0;
+  bool finished_ = false;
 };
 
 NAPI_METHOD(iterator_nextv) {
@@ -1555,48 +1477,63 @@ NAPI_METHOD(iterator_nextv) {
 
   const auto callback = argv[2];
 
-  if (iterator->isClosing_) {
-    napi_value argv = CreateCodeError(env, "LEVEL_ITERATOR_NOT_OPEN", "Iterator is not open");
-    NAPI_STATUS_THROWS(CallFunction(env, callback, 1, &argv));
-    return 0;
-  }
-
   auto worker = new NextWorker(env, iterator, size, callback);
-  iterator->nexting_ = true;
   worker->Queue(env);
 
   return 0;
 }
 
-/**
- * Worker class for batch write operation.
- */
 struct BatchWorker final : public PriorityWorker {
   BatchWorker (napi_env env,
                Database* database,
                napi_value callback,
-               leveldb::WriteBatch* batch,
-               const bool sync,
-               const bool hasData)
-    : PriorityWorker(env, database, callback, "rocks_level.batch.do"),
-      batch_(batch), hasData_(hasData) {
-    options_.sync = sync;
-  }
+               napi_value array,
+               const bool sync)
+    : PriorityWorker(env, database, callback, "rocks_level.batch.do"), sync_(sync) {
+    uint32_t length;
+    NAPI_STATUS_THROWS_VOID(napi_get_array_length(env, array, &length));
+
+    for (uint32_t i = 0; i < length; i++) {
+      napi_value element;
+      NAPI_STATUS_THROWS_VOID(napi_get_element(env, array, i, &element));
+
+      if (!IsObject(env, element)) continue;
+
+      const auto type = StringProperty(env, element, "type");
+
+      if (type == "del") {
+        if (!HasProperty(env, element, "key")) continue;
+        const auto key = ToString(env, GetProperty(env, element, "key"));
+
+        batch_.Delete(key);
+        if (!hasData_) hasData_ = true;
+      } else if (type == "put") {
+        if (!HasProperty(env, element, "key")) continue;
+        if (!HasProperty(env, element, "value")) continue;
+
+        const auto key = ToString(env, GetProperty(env, element, "key"));
+        const auto value = ToString(env, GetProperty(env, element, "value"));
 
-  ~BatchWorker () {
-    delete batch_;
+        batch_.Put(key, value);
+        if (!hasData_) hasData_ = true;
+      }
+    }
   }
 
-  void DoExecute () override {
-    if (hasData_) {
-      SetStatus(database_->WriteBatch(options_, batch_));
+  rocksdb::Status Execute () override {
+    if (!hasData_) {
+      return rocksdb::Status::OK();
     }
+
+    rocksdb::WriteOptions options;
+    options.sync = sync_;
+    return database_->WriteBatch(options, &batch_);
   }
 
 private:
-  leveldb::WriteOptions options_;
-  leveldb::WriteBatch* batch_;
-  const bool hasData_;
+  rocksdb::WriteBatch batch_;
+  const bool sync_;
+  bool hasData_;
 };
 
 NAPI_METHOD(batch_do) {
@@ -1607,39 +1544,7 @@ NAPI_METHOD(batch_do) {
   const auto sync = BooleanProperty(env, argv[2], "sync", false);
   const auto callback = argv[3];
 
-  uint32_t length;
-  napi_get_array_length(env, array, &length);
-
-  leveldb::WriteBatch* batch = new leveldb::WriteBatch();
-  bool hasData = false;
-
-  for (uint32_t i = 0; i < length; i++) {
-    napi_value element;
-    napi_get_element(env, array, i, &element);
-
-    if (!IsObject(env, element)) continue;
-
-    std::string type = StringProperty(env, element, "type");
-
-    if (type == "del") {
-      if (!HasProperty(env, element, "key")) continue;
-      const auto key = ToString(env, GetProperty(env, element, "key"));
-
-      batch->Delete(key);
-      if (!hasData) hasData = true;
-    } else if (type == "put") {
-      if (!HasProperty(env, element, "key")) continue;
-      if (!HasProperty(env, element, "value")) continue;
-
-      const auto key = ToString(env, GetProperty(env, element, "key"));
-      const auto value = ToString(env, GetProperty(env, element, "value"));
-
-      batch->Put(key, value);
-      if (!hasData) hasData = true;
-    }
-  }
-
-  auto worker = new BatchWorker(env, database, callback, batch, sync, hasData);
+  auto worker = new BatchWorker(env, database, callback, array, sync);
   worker->Queue(env);
 
   return 0;
@@ -1647,7 +1552,7 @@ NAPI_METHOD(batch_do) {
 
 static void FinalizeBatch (napi_env env, void* data, void* hint) {
   if (data) {
-    delete reinterpret_cast<leveldb::WriteBatch*>(data);
+    delete reinterpret_cast<rocksdb::WriteBatch*>(data);
   }
 }
 
@@ -1655,12 +1560,10 @@ NAPI_METHOD(batch_init) {
   NAPI_ARGV(1);
   NAPI_DB_CONTEXT();
 
-  auto batch = new leveldb::WriteBatch();
+  auto batch = new rocksdb::WriteBatch();
 
   napi_value result;
-  NAPI_STATUS_THROWS(napi_create_external(env, batch,
-                                          FinalizeBatch,
-                                          nullptr, &result));
+  NAPI_STATUS_THROWS(napi_create_external(env, batch, FinalizeBatch, nullptr, &result));
   return result;
 }
 
@@ -1711,19 +1614,19 @@ struct BatchWriteWorker final : public PriorityWorker {
     NAPI_STATUS_THROWS_VOID(napi_create_reference(env, batch, 1, &batchRef_));
   }
 
-  void DoExecute () override {
-    leveldb::WriteOptions options;
+  rocksdb::Status Execute () override {
+    rocksdb::WriteOptions options;
     options.sync = sync_;
-    SetStatus(database_->WriteBatch(options, batch_));
+    return database_->WriteBatch(options, batch_);
   }
 
-  void DoFinally (napi_env env) override {
+  void Finally (napi_env env) override {
     napi_delete_reference(env, batchRef_);
-    PriorityWorker::DoFinally(env);
+    PriorityWorker::Finally(env);
   }
 
 private:
-  leveldb::WriteBatch* batch_;
+  rocksdb::WriteBatch* batch_;
   const bool sync_;
   napi_ref batchRef_;
 };