@nxtedition/rocksdb 5.2.17 → 5.2.27

package/binding.cc

@@ -16,10 +16,12 @@
 
 namespace leveldb = rocksdb;
 
+#include <array>
 #include <set>
 #include <memory>
 #include <string>
 #include <vector>
+#include <optional>
 
 class NullLogger : public rocksdb::Logger {
 public:
@@ -30,7 +32,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 +42,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) {
@@ -62,7 +63,7 @@ static bool IsObject (napi_env env, napi_value value) {
   return type == napi_object;
 }
 
-static napi_value CreateError (napi_env env, const std::string& str) {
+static napi_value CreateError (napi_env env, const std::string_view& str) {
   napi_value msg;
   napi_create_string_utf8(env, str.data(), str.size(), &msg);
   napi_value error;
@@ -70,7 +71,7 @@ static napi_value CreateError (napi_env env, const std::string& str) {
   return error;
 }
 
-static napi_value CreateCodeError (napi_env env, const std::string& code, const std::string& msg) {
+static napi_value CreateCodeError (napi_env env, const std::string_view& code, const std::string_view& msg) {
   napi_value codeValue;
   napi_create_string_utf8(env, code.data(), code.size(), &codeValue);
   napi_value msgValue;
@@ -80,20 +81,19 @@ static napi_value CreateCodeError (napi_env env, const std::string& code, const
   return error;
 }
 
-static bool HasProperty (napi_env env, napi_value obj, const std::string& key) {
+static bool HasProperty (napi_env env, napi_value obj, const std::string_view& key) {
   bool has = false;
   napi_has_named_property(env, obj, key.data(), &has);
   return has;
 }
 
-static napi_value GetProperty (napi_env env, napi_value obj, const std::string& key) {
+static napi_value GetProperty (napi_env env, napi_value obj, const std::string_view& key) {
   napi_value value;
   napi_get_named_property(env, obj, key.data(), &value);
   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_view& key, bool defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     bool result;
@@ -104,7 +104,7 @@ static bool BooleanProperty (napi_env env, napi_value obj, const std::string& ke
   return defaultValue;
 }
 
-static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string& option) {
+static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string_view& option) {
   napi_value value;
   size_t size;
 
@@ -117,8 +117,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_view& key, uint32_t defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
@@ -129,8 +128,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_view& key, int defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int result;
@@ -146,7 +144,7 @@ static std::string ToString (napi_env env, napi_value from, const std::string& d
     size_t length = 0;
     napi_get_value_string_utf8(env, from, nullptr, 0, &length);
     std::string value(length, '\0');
-    napi_get_value_string_utf8( env, from, &value[0], value.length() + 1, &length);
+    napi_get_value_string_utf8(env, from, &value[0], value.length() + 1, &length);
     return value;
   } else if (IsBuffer(env, from)) {
     char* buf = nullptr;
@@ -158,7 +156,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_view& key, const std::string& defaultValue = "") {
   if (HasProperty(env, obj, key)) {
     napi_value value = GetProperty(env, obj, key);
     if (IsString(env, value)) {
@@ -166,7 +164,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) {
@@ -182,13 +180,13 @@ static size_t StringOrBufferLength (napi_env env, napi_value value) {
   return size;
 }
 
-static std::string* RangeOption (napi_env env, napi_value opts, const std::string& name) {
+static std::optional<std::string> RangeOption (napi_env env, napi_value opts, const std::string_view& name) {
   if (HasProperty(env, opts, name)) {
     const auto value = GetProperty(env, opts, name);
-    return new std::string(ToString(env, value));
+    return std::string(ToString(env, value));
   }
 
-  return nullptr;
+  return {};
 }
 
 static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
@@ -211,15 +209,38 @@ 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);
 }
 
+static napi_value ToError(napi_env env, const rocksdb::Status& status) {
+  if (status.ok()) {
+    return 0;
+  }
+
+  const auto msg = status.ToString();
+
+  if (status.IsNotFound()) {
+    return CreateCodeError(env, "LEVEL_NOT_FOUND", msg);
+  } else if (status.IsCorruption()) {
+    return CreateCodeError(env, "LEVEL_CORRUPTION", msg);
+  } else if (status.IsIOError()) {
+    if (msg.find("IO error: lock ") != std::string::npos) { // env_posix.cc
+      return CreateCodeError(env, "LEVEL_LOCKED", msg);
+    } else if (msg.find("IO error: LockFile ") != std::string::npos) { // env_win.cc
+      return CreateCodeError(env, "LEVEL_LOCKED", msg);
+    } else if (msg.find("IO error: While lock file") != std::string::npos) { // env_mac.cc
+      return CreateCodeError(env, "LEVEL_LOCKED", msg);
+    } else {
+      return CreateCodeError(env, "LEVEL_IO_ERROR", msg);
+    }
+  }
+
+  return CreateError(env, msg);
+}
+
 template <typename T>
 void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
   if (asBuffer) {
@@ -229,106 +250,98 @@ void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
   }
 }
 
+struct NapiSlice : public rocksdb::Slice {
+  NapiSlice (napi_env env, napi_value from) {
+    if (IsString(env, from)) {
+      napi_get_value_string_utf8(env, from, nullptr, 0, &size_);
+      char* data;
+      if (size_ + 1 < stack_.size()) {
+        data = stack_.data();
+      } else {
+        heap_.reset(new char[size_ + 1]);
+        data = heap_.get();
+      }
+      data[size_] = 0;
+      napi_get_value_string_utf8(env, from, data, size_ + 1, &size_);
+      data_ = data;
+    } else if (IsBuffer(env, from)) {
+      void* data;
+      napi_get_buffer_info(env, from, &data, &size_);
+      data_ = static_cast<char*>(data);
+    }
+  }
+  
+  std::unique_ptr<char[]> heap_;
+  std::array<char, 8192> stack_;
+};
+
 /**
  * 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
+ * - OnOk (main thread): call JS callback on success
+ * - OnError (main thread): call JS callback on error
+ * - Destroy (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(*self->database_);
   }
 
-  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->OnOk(env, callback);
     } else {
-      HandleErrorCallback(env, callback);
+      self->OnError(env, callback, ToError(env, self->status_));
     }
+
+    self->Destroy(env);
+
+    napi_delete_reference(env, self->callbackRef_);
+    napi_delete_async_work(env, self->asyncWork_);
+
+    delete self;
   }
 
-  virtual void HandleOKCallback (napi_env env, napi_value callback) {
+  virtual rocksdb::Status Execute (Database& database) = 0;
+
+  virtual void OnOk (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) {
-    napi_value argv;
-
-    const auto msg = status_.ToString();
-
-    if (status_.IsNotFound()) {
-      argv = CreateCodeError(env, "LEVEL_NOT_FOUND", msg);
-    } else if (status_.IsCorruption()) {
-      argv = CreateCodeError(env, "LEVEL_CORRUPTION", msg);
-    } else if (status_.IsIOError()) {
-      if (msg.find("IO error: lock ") != std::string::npos) { // env_posix.cc
-        argv = CreateCodeError(env, "LEVEL_LOCKED", msg);
-      } else if (msg.find("IO error: LockFile ") != std::string::npos) { // env_win.cc
-        argv = CreateCodeError(env, "LEVEL_LOCKED", msg);
-      } else if (msg.find("IO error: While lock file") != std::string::npos) { // env_mac.cc
-        argv = CreateCodeError(env, "LEVEL_LOCKED", msg);
-      } else {
-        argv = CreateCodeError(env, "LEVEL_IO_ERROR", msg);
-      }
-    } else {
-      argv = CreateError(env, msg);
-    }
-
-    CallFunction(env, callback, 1, &argv);
+  virtual void OnError (napi_env env, napi_value callback, napi_value err) {
+    CallFunction(env, callback, 1, &err);
   }
 
-  virtual void DoFinally (napi_env env) {
-    napi_delete_reference(env, callbackRef_);
-    napi_delete_async_work(env, asyncWork_);
-
-    delete this;
+  virtual void Destroy (napi_env env) {
   }
 
   void Queue (napi_env env) {
@@ -336,33 +349,24 @@ struct BaseWorker {
   }
 
   Database* database_;
-
 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,56 +376,6 @@ struct Database {
     db_.reset();
   }
 
-  leveldb::Status Put (const leveldb::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,
-                       const std::string& key,
-                       rocksdb::PinnableSlice& value) {
-    return db_->Get(options, db_->DefaultColumnFamily(), key, &value);
-  }
-
-  leveldb::Status Del (const leveldb::WriteOptions& options,
-                       const std::string& key) {
-    return db_->Delete(options, db_->DefaultColumnFamily(), key);
-  }
-
-  leveldb::Status WriteBatch (const leveldb::WriteOptions& options,
-                              leveldb::WriteBatch* batch) {
-    return db_->Write(options, batch);
-  }
-
-  uint64_t ApproximateSize (const leveldb::Range* range) {
-    uint64_t size = 0;
-    db_->GetApproximateSizes(range, 1, &size);
-    return size;
-  }
-
-  void CompactRange (const leveldb::Slice* start,
-                     const leveldb::Slice* end) {
-    rocksdb::CompactRangeOptions options;
-    db_->CompactRange(options, start, end);
-  }
-
-  void GetProperty (const std::string& property, std::string& value) {
-    db_->GetProperty(property, &value);
-  }
-
-  const leveldb::Snapshot* NewSnapshot () {
-    return db_->GetSnapshot();
-  }
-
-  leveldb::Iterator* NewIterator (const leveldb::ReadOptions& options) {
-    return db_->NewIterator(options);
-  }
-
-  void ReleaseSnapshot (const leveldb::Snapshot* snapshot) {
-    return db_->ReleaseSnapshot(snapshot);
-  }
-
   void AttachIterator (napi_env env, Iterator* iterator) {
     iterators_.insert(iterator);
     IncrementPriorityWork(env);
@@ -433,11 +387,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 +403,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,133 +418,113 @@ 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 Destroy (napi_env env) override {
     database_->DecrementPriorityWork(env);
-    BaseWorker::DoFinally(env);
+    BaseWorker::Destroy(env);
   }
 };
 
 struct BaseIterator {
   BaseIterator(Database* database,
                const bool reverse,
-               const std::string* lt,
-               const std::string* lte,
-               const std::string* gt,
-               const std::string* gte,
+               const std::optional<std::string>& lt,
+               const std::optional<std::string>& lte,
+               const std::optional<std::string>& gt,
+               const std::optional<std::string>& gte,
                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_->db_->GetSnapshot(), [this](const rocksdb::Snapshot* ptr) {
+        database_->db_->ReleaseSnapshot(ptr);
+      }),
+      iterator_(database->db_->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_);
-
-      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();
-      }
+      iterator_->SeekForPrev(*lte_);
     } else if (reverse_) {
-      dbIterator_->SeekToLast();
+      iterator_->SeekToLast();
     } else {
-      dbIterator_->SeekToFirst();
+      iterator_->SeekToFirst();
     }
   }
 
-  /**
-   * Seek manually (during iteration).
-   */
   void Seek (const std::string& target) {
     didSeek_ = true;
 
-    if (OutOfRange(target)) {
-      return SeekToEnd();
-    }
-
-    dbIterator_->Seek(target);
+    // TODO (fix): Only check for (gt && !gte) and lte.
+    // See, https://github.com/facebook/rocksdb/issues/9904.
 
-    if (dbIterator_->Valid()) {
-      const auto cmp = dbIterator_->key().compare(target);
-      if (reverse_ ? cmp > 0 : cmp < 0) {
-        Next();
-      }
+    if (OutOfRange(target)) {
+      SeekToLast();
+      Next();
+    } else if (reverse_) {
+      iterator_->SeekForPrev(target);
     } else {
-      SeekToFirst();
-      if (dbIterator_->Valid()) {
-        const auto cmp = dbIterator_->key().compare(target);
-        if (reverse_ ? cmp > 0 : cmp < 0) {
-          SeekToEnd();
-        }
-      }
+      iterator_->Seek(target);
     }
   }
 
   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,38 +532,33 @@ 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();
-  }
-
-  void SeekToEnd () {
-    SeekToLast();
-    Next();
+    if (reverse_) iterator_->SeekToFirst();
+    else iterator_->SeekToLast();
   }
 
-  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 +577,18 @@ struct BaseIterator {
   Database* database_;
 
 private:
-  const leveldb::Snapshot* snapshot_;
-  leveldb::Iterator* dbIterator_;
-  bool didSeek_;
+  const std::optional<std::string> lt_;
+  const std::optional<std::string> lte_;
+  const std::optional<std::string> gt_;
+  const std::optional<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 {
@@ -666,10 +597,10 @@ struct Iterator final : public BaseIterator {
             const bool keys,
             const bool values,
             const int limit,
-            const std::string* lt,
-            const std::string* lte,
-            const std::string* gt,
-            const std::string* gte,
+            const std::optional<std::string>& lt,
+            const std::optional<std::string>& lte,
+            const std::optional<std::string>& gt,
+            const std::optional<std::string>& gte,
             const bool fillCache,
             const bool keyAsBuffer,
             const bool valueAsBuffer,
@@ -681,9 +612,6 @@ struct Iterator final : public BaseIterator {
       valueAsBuffer_(valueAsBuffer),
       highWaterMarkBytes_(highWaterMarkBytes),
       first_(true),
-      nexting_(false),
-      isClosing_(false),
-      closeWorker_(nullptr),
       ref_(nullptr) {
   }
 
@@ -697,53 +625,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 +642,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 +663,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 +679,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 +700,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 = {};
@@ -869,11 +751,11 @@ struct OpenWorker final : public BaseWorker {
     );
   }
 
-  void DoExecute () override {
-    SetStatus(database_->Open(options_, readOnly_, location_.c_str()));
+  rocksdb::Status Execute (Database& database) override {
+    return database.Open(options_, readOnly_, location_.c_str());
   }
 
-  leveldb::Options options_;
+  rocksdb::Options options_;
   const bool readOnly_;
   const std::string location_;
 };
@@ -918,8 +800,8 @@ struct CloseWorker final : public BaseWorker {
                napi_value callback)
     : BaseWorker(env, database, callback, "leveldown.db.close") {}
 
-  void DoExecute () override {
-    database_->CloseDatabase();
+  rocksdb::Status Execute (Database& database) override {
+    return database.db_->Close();
   }
 };
 
@@ -933,13 +815,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()) {
@@ -951,41 +826,15 @@ NAPI_METHOD(db_close) {
   return 0;
 }
 
-struct PutWorker final : public PriorityWorker {
-  PutWorker (napi_env env,
-             Database* database,
-             napi_value callback,
-             const std::string& key,
-             const std::string& value,
-             bool sync)
-    : PriorityWorker(env, database, callback, "rocks_level.db.put"),
-      key_(key), value_(value), sync_(sync) {
-  }
-
-  void DoExecute () override {
-    leveldb::WriteOptions options;
-    options.sync = sync_;
-    SetStatus(database_->Put(options, key_, value_));
-  }
-
-  const std::string key_;
-  const std::string value_;
-  const bool sync_;
-};
-
 NAPI_METHOD(db_put) {
-  NAPI_ARGV(5);
+  NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
   const auto key = ToString(env, argv[1]);
   const auto value = ToString(env, argv[2]);
-  const auto sync = BooleanProperty(env, argv[3], "sync", false);
-  const auto callback = argv[4];
-
-  auto worker = new PutWorker(env, database, callback, key, value, sync);
-  worker->Queue(env);
 
-  return 0;
+  rocksdb::WriteOptions options;
+  return ToError(env, database->db_->Put(options, key, value));
 }
 
 struct GetWorker final : public PriorityWorker {
@@ -996,16 +845,22 @@ struct GetWorker final : public PriorityWorker {
              const bool asBuffer,
              const bool fillCache)
     : PriorityWorker(env, database, callback, "rocks_level.db.get"),
-      key_(key), asBuffer_(asBuffer), fillCache_(fillCache) {
+      key_(key), asBuffer_(asBuffer), fillCache_(fillCache),
+      snapshot_(database_->db_->GetSnapshot(), [this](const rocksdb::Snapshot* ptr) {
+        database_->db_->ReleaseSnapshot(ptr);
+      }) {
   }
 
-  void DoExecute () override {
-    leveldb::ReadOptions options;
+  rocksdb::Status Execute (Database& database) override {
+    rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
-    SetStatus(database_->Get(options, key_, value_));
+    options.snapshot = snapshot_.get();
+    auto status = database.db_->Get(options, database.db_->DefaultColumnFamily(), key_, &value_);
+    snapshot_.reset();
+    return status;
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
+  void OnOk (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]);
@@ -1017,6 +872,7 @@ private:
   rocksdb::PinnableSlice value_;
   const bool asBuffer_;
   const bool fillCache_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 };
 
 NAPI_METHOD(db_get) {
@@ -1044,54 +900,42 @@ struct GetManyWorker final : public PriorityWorker {
                  const bool fillCache)
     : PriorityWorker(env, database, callback, "leveldown.get.many"),
       keys_(keys), valueAsBuffer_(valueAsBuffer), fillCache_(fillCache),
-      snapshot_(database->NewSnapshot()) {
+      snapshot_(database_->db_->GetSnapshot(), [this](const rocksdb::Snapshot* ptr) {
+        database_->db_->ReleaseSnapshot(ptr);
+      }) {
   }
 
-  ~GetManyWorker () {
-    if (snapshot_) {
-      database_->ReleaseSnapshot(snapshot_);
-      snapshot_ = nullptr;
-    }
-  }
-
-  void DoExecute () override {
-    cache_.reserve(keys_.size());
-
-    leveldb::ReadOptions options;
-    options.snapshot = snapshot_;
+  rocksdb::Status Execute (Database& database) override {
+    rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
-    
-    rocksdb::PinnableSlice value;
-
-    for (const auto& key: keys_) {
-      const auto status = database_->Get(options, key, value);
+    options.snapshot = snapshot_.get();
+  
+    status_ = database.db_->MultiGet(
+      options,
+      std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()),
+      &values_
+    );
+    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 OnOk (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);
       }
@@ -1106,10 +950,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_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 };
 
 NAPI_METHOD(db_get_many) {
@@ -1128,184 +973,65 @@ NAPI_METHOD(db_get_many) {
   return 0;
 }
 
-struct DelWorker final : public PriorityWorker {
-  DelWorker (napi_env env,
-             Database* database,
-             napi_value callback,
-             const std::string& key,
-             bool sync)
-    : PriorityWorker(env, database, callback, "rocks_level.db.del"),
-      key_(key), sync_(sync) {
-  }
-
-  void DoExecute () override {
-    leveldb::WriteOptions options;
-    options.sync = sync_;
-    SetStatus(database_->Del(options, key_));
-  }
-
-  const std::string key_;
-  const bool sync_;
-};
-
 NAPI_METHOD(db_del) {
-  NAPI_ARGV(4);
+  NAPI_ARGV(3);
   NAPI_DB_CONTEXT();
 
   const auto key = ToString(env, argv[1]);
-  const auto sync = BooleanProperty(env, argv[2], "sync", false);
-  const auto callback = argv[3];
-
-  auto worker = new DelWorker(env, database, callback, key, sync);
-  worker->Queue(env);
 
-  return 0;
+  rocksdb::WriteOptions options;
+  return ToError(env, database->db_->Delete(options, key));
 }
 
-struct ClearWorker final : public PriorityWorker {
-  ClearWorker (napi_env env,
-               Database* database,
-               napi_value callback,
-               const bool reverse,
-               const int limit,
-               const std::string* lt,
-               const std::string* lte,
-               const std::string* gt,
-               const std::string* gte)
-    : PriorityWorker(env, database, callback, "rocks_level.db.clear"),
-      iterator_(database, reverse, lt, lte, gt, gte, limit, false) {
-  }
-
-  void DoExecute () override {
-    iterator_.SeekToRange();
-
-    // TODO: add option
-    const uint32_t hwm = 16 * 1024;
-    leveldb::WriteBatch batch;
-
-    leveldb::WriteOptions options;
-    options.sync = false;
-
-    while (true) {
-      size_t bytesRead = 0;
-
-      while (bytesRead <= hwm && iterator_.Valid() && iterator_.Increment()) {
-        const auto key = iterator_.CurrentKey();
-        batch.Delete(key);
-        bytesRead += key.size();
-        iterator_.Next();
-      }
-
-      if (!SetStatus(iterator_.Status()) || bytesRead == 0) {
-        break;
-      }
-
-      if (!SetStatus(database_->WriteBatch(options, &batch))) {
-        break;
-      }
-
-      batch.Clear();
-    }
-
-    iterator_.Close();
-  }
-
-private:
-  BaseIterator iterator_;
-};
-
 NAPI_METHOD(db_clear) {
-  NAPI_ARGV(3);
+  NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  napi_value options = argv[1];
-  napi_value callback = argv[2];
-
-  const auto reverse = BooleanProperty(env, options, "reverse", false);
-  const auto limit = Int32Property(env, options, "limit", -1);
-
-  const auto lt = RangeOption(env, options, "lt");
-  const auto lte = RangeOption(env, options, "lte");
-  const auto gt = RangeOption(env, options, "gt");
-  const auto gte = RangeOption(env, options, "gte");
-
-  auto worker = new ClearWorker(env, database, callback, reverse, limit, lt, lte, gt, gte);
-  worker->Queue(env);
-
-  return 0;
-}
+  const auto reverse = BooleanProperty(env, argv[1], "reverse", false);
+  const auto limit = Int32Property(env, argv[1], "limit", -1);
 
-struct ApproximateSizeWorker final : public PriorityWorker {
-  ApproximateSizeWorker (napi_env env,
-                         Database* database,
-                         napi_value callback,
-                         const std::string& start,
-                         const std::string& end)
-    : PriorityWorker(env, database, callback, "rocks_level.db.approximate_size"),
-      start_(start), end_(end) {}
+  const auto lt = RangeOption(env, argv[1], "lt");
+  const auto lte = RangeOption(env, argv[1], "lte");
+  const auto gt = RangeOption(env, argv[1], "gt");
+  const auto gte = RangeOption(env, argv[1], "gte");
 
-  void DoExecute () override {
-    leveldb::Range range(start_, end_);
-    size_ = database_->ApproximateSize(&range);
-  }
-
-  void HandleOKCallback (napi_env env, napi_value callback) override {
-    napi_value argv[2];
-    napi_get_null(env, &argv[0]);
-    napi_create_int64(env, size_, &argv[1]);
-    CallFunction(env, callback, 2, argv);
-  }
+  BaseIterator it(database, reverse, lt, lte, gt, gte, limit, false);
 
-  std::string start_;
-  std::string end_;
-  uint64_t size_;
-};
+  it.SeekToRange();
 
-NAPI_METHOD(db_approximate_size) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
+  // TODO: add option
+  const uint32_t hwm = 16 * 1024;
 
-  const auto start = ToString(env, argv[1]);
-  const auto end = ToString(env, argv[2]);
-  const auto callback = argv[3];
+  rocksdb::WriteBatch batch;
+  rocksdb::WriteOptions options;
+  rocksdb::Status status;
+  
+  while (true) {
+    size_t bytesRead = 0;
 
-  auto worker  = new ApproximateSizeWorker(env, database, callback, start, end);
-  worker->Queue(env);
+    while (bytesRead <= hwm && it.Valid() && it.Increment()) {
+      const auto key = it.CurrentKey();
+      batch.Delete(key);
+      bytesRead += key.size();
+      it.Next();
+    }
 
-  return 0;
-}
+    status = it.Status();
+    if (!status.ok() || bytesRead == 0) {
+      break;
+    }
 
-struct CompactRangeWorker final : public PriorityWorker {
-  CompactRangeWorker (napi_env env,
-                      Database* database,
-                      napi_value callback,
-                      const std::string& start,
-                      const std::string& end)
-    : PriorityWorker(env, database, callback, "rocks_level.db.compact_range"),
-      start_(start), end_(end) {}
+    status = database->db_->Write(options, &batch);
+    if (!status.ok()) {
+      break;
+    }
 
-  void DoExecute () override {
-    leveldb::Slice start = start_;
-    leveldb::Slice end = end_;
-    database_->CompactRange(&start, &end);
+    batch.Clear();
   }
 
-  const std::string start_;
-  const std::string end_;
-};
-
-NAPI_METHOD(db_compact_range) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
-
-  const auto start = ToString(env, argv[1]);
-  const auto end = ToString(env, argv[2]);
-  const auto callback = argv[3];
-
-  auto worker  = new CompactRangeWorker(env, database, callback, start, end);
-  worker->Queue(env);
-
-  return 0;
+  it.Close();
+  
+  return ToError(env, status);
 }
 
 NAPI_METHOD(db_get_property) {
@@ -1315,7 +1041,7 @@ NAPI_METHOD(db_get_property) {
   const auto property = ToString(env, argv[1]);
 
   std::string value;
-  database->GetProperty(property, value);
+  database->db_->GetProperty(property, &value);
 
   napi_value result;
   napi_create_string_utf8(env, value.data(), value.size(), &result);
@@ -1323,62 +1049,6 @@ NAPI_METHOD(db_get_property) {
   return result;
 }
 
-struct DestroyWorker final : public BaseWorker {
-  DestroyWorker (napi_env env,
-                 const std::string& location,
-                 napi_value callback)
-    : BaseWorker(env, nullptr, callback, "rocks_level.destroy_db"),
-      location_(location) {}
-
-  ~DestroyWorker () {}
-
-  void DoExecute () override {
-    leveldb::Options options;
-    SetStatus(leveldb::DestroyDB(location_, options));
-  }
-
-  const std::string location_;
-};
-
-NAPI_METHOD(destroy_db) {
-  NAPI_ARGV(2);
-
-  const auto location = ToString(env, argv[0]);
-  const auto callback = argv[1];
-
-  auto worker = new DestroyWorker(env, location, callback);
-  worker->Queue(env);
-
-  return 0;
-}
-
-struct RepairWorker final : public BaseWorker {
-  RepairWorker (napi_env env,
-                const std::string& location,
-                napi_value callback)
-    : BaseWorker(env, nullptr, callback, "rocks_level.repair_db"),
-      location_(location) {}
-
-  void DoExecute () override {
-    leveldb::Options options;
-    SetStatus(leveldb::RepairDB(location_, options));
-  }
-
-  const std::string location_;
-};
-
-NAPI_METHOD(repair_db) {
-  NAPI_ARGV(2);
-
-  const auto location = ToString(env, argv[1]);
-  const auto callback = argv[1];
-
-  auto worker = new RepairWorker(env, location, callback);
-  worker->Queue(env);
-
-  return 0;
-}
-
 static void FinalizeIterator (napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<Iterator*>(data);
@@ -1409,9 +1079,7 @@ NAPI_METHOD(iterator_init) {
                                keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
   napi_value result;
 
-  NAPI_STATUS_THROWS(napi_create_external(env, iterator,
-                                          FinalizeIterator,
-                                          nullptr, &result));
+  NAPI_STATUS_THROWS(napi_create_external(env, iterator, FinalizeIterator, nullptr, &result));
 
   // Prevent GC of JS object before the iterator is closed (explicitly or on
   // db close) and keep track of non-closed iterators to end them on db close.
@@ -1424,10 +1092,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);
@@ -1442,41 +1106,28 @@ struct CloseIteratorWorker final : public BaseWorker {
     : BaseWorker(env, iterator->database_, callback, "leveldown.iterator.end"),
       iterator_(iterator) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute (Database& database) override {
     iterator_->Close();
+    return rocksdb::Status::OK();
   }
 
-  void DoFinally (napi_env env) override {
+  void Destroy (napi_env env) override {
     iterator_->Detach(env);
-    BaseWorker::DoFinally(env);
+    BaseWorker::Destroy(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;
 }
@@ -1488,63 +1139,82 @@ 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 (Database& database) 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());
+    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 OnOk (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) {
@@ -1557,99 +1227,55 @@ 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;
-  }
-
-  ~BatchWorker () {
-    delete batch_;
-  }
-
-  void DoExecute () override {
-    if (hasData_) {
-      SetStatus(database_->WriteBatch(options_, batch_));
-    }
-  }
-
-private:
-  leveldb::WriteOptions options_;
-  leveldb::WriteBatch* batch_;
-  const bool hasData_;
-};
-
 NAPI_METHOD(batch_do) {
-  NAPI_ARGV(4);
+  NAPI_ARGV(3);
   NAPI_DB_CONTEXT();
 
-  const auto array = argv[1];
-  const auto sync = BooleanProperty(env, argv[2], "sync", false);
-  const auto callback = argv[3];
+  const auto operations = argv[1];
 
-  uint32_t length;
-  napi_get_array_length(env, array, &length);
+  rocksdb::WriteBatch batch;
 
-  leveldb::WriteBatch* batch = new leveldb::WriteBatch();
-  bool hasData = false;
+  uint32_t length;
+  NAPI_STATUS_THROWS(napi_get_array_length(env, operations, &length));
 
   for (uint32_t i = 0; i < length; i++) {
     napi_value element;
-    napi_get_element(env, array, i, &element);
+    NAPI_STATUS_THROWS(napi_get_element(env, operations, i, &element));
 
     if (!IsObject(env, element)) continue;
 
-    std::string type = StringProperty(env, element, "type");
+    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;
+      const auto key = NapiSlice(env, GetProperty(env, element, "key"));
+
+      batch.Delete(key);
     } 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"));
+      const auto key = NapiSlice(env, GetProperty(env, element, "key"));
+      const auto value = NapiSlice(env, GetProperty(env, element, "value"));
 
-      batch->Put(key, value);
-      if (!hasData) hasData = true;
+      batch.Put(key, value);
     }
   }
 
-  auto worker = new BatchWorker(env, database, callback, batch, sync, hasData);
-  worker->Queue(env);
-
-  return 0;
+  rocksdb::WriteOptions options;
+  return ToError(env, database->db_->Write(options, &batch));
 }
 
 static void FinalizeBatch (napi_env env, void* data, void* hint) {
   if (data) {
-    delete reinterpret_cast<leveldb::WriteBatch*>(data);
+    delete reinterpret_cast<rocksdb::WriteBatch*>(data);
   }
 }
 
@@ -1657,12 +1283,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;
 }
 
@@ -1670,8 +1294,8 @@ NAPI_METHOD(batch_put) {
   NAPI_ARGV(3);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = ToString(env, argv[1]);
-  const auto value = ToString(env, argv[2]);
+  const auto key = NapiSlice(env, argv[1]);
+  const auto value = NapiSlice(env, argv[2]);
 
   batch->Put(key, value);
 
@@ -1682,7 +1306,7 @@ NAPI_METHOD(batch_del) {
   NAPI_ARGV(2);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = ToString(env, argv[1]);
+  const auto key = NapiSlice(env, argv[1]);
 
   batch->Delete(key);
 
@@ -1698,51 +1322,15 @@ NAPI_METHOD(batch_clear) {
   return 0;
 }
 
-struct BatchWriteWorker final : public PriorityWorker {
-  BatchWriteWorker (napi_env env,
-                    Database* database,
-                    napi_value batch,
-                    napi_value callback,
-                    const bool sync)
-    : PriorityWorker(env, database, callback, "leveldown.batch.write"),
-      sync_(sync) {
-
-    NAPI_STATUS_THROWS_VOID(napi_get_value_external(env, batch, reinterpret_cast<void**>(&batch_)));
-
-    // Prevent GC of batch object before we execute
-    NAPI_STATUS_THROWS_VOID(napi_create_reference(env, batch, 1, &batchRef_));
-  }
-
-  void DoExecute () override {
-    leveldb::WriteOptions options;
-    options.sync = sync_;
-    SetStatus(database_->WriteBatch(options, batch_));
-  }
-
-  void DoFinally (napi_env env) override {
-    napi_delete_reference(env, batchRef_);
-    PriorityWorker::DoFinally(env);
-  }
-
-private:
-  leveldb::WriteBatch* batch_;
-  const bool sync_;
-  napi_ref batchRef_;
-};
-
 NAPI_METHOD(batch_write) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto batch = argv[1];
-  const auto options = argv[2];
-  const auto sync = BooleanProperty(env, options, "sync", false);
-  const auto callback = argv[3];
-
-  auto worker = new BatchWriteWorker(env, database, batch, callback, sync);
-  worker->Queue(env);
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
-  return 0;
+  rocksdb::WriteOptions options;
+  return ToError(env, database->db_->Write(options, batch));
 }
 
 NAPI_INIT() {
@@ -1754,13 +1342,8 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_get_many);
   NAPI_EXPORT_FUNCTION(db_del);
   NAPI_EXPORT_FUNCTION(db_clear);
-  NAPI_EXPORT_FUNCTION(db_approximate_size);
-  NAPI_EXPORT_FUNCTION(db_compact_range);
   NAPI_EXPORT_FUNCTION(db_get_property);
 
-  NAPI_EXPORT_FUNCTION(destroy_db);
-  NAPI_EXPORT_FUNCTION(repair_db);
-
   NAPI_EXPORT_FUNCTION(iterator_init);
   NAPI_EXPORT_FUNCTION(iterator_seek);
   NAPI_EXPORT_FUNCTION(iterator_close);