@nxtedition/rocksdb 5.2.21 → 5.2.28

package/binding.cc

@@ -1,28 +1,27 @@
 #define NAPI_VERSION 8
 
+#include <assert.h>
 #include <napi-macros.h>
 #include <node_api.h>
-#include <assert.h>
 
-#include <rocksdb/db.h>
-#include <rocksdb/write_batch.h>
-#include <rocksdb/cache.h>
-#include <rocksdb/filter_policy.h>
 #include <rocksdb/cache.h>
 #include <rocksdb/comparator.h>
+#include <rocksdb/db.h>
 #include <rocksdb/env.h>
+#include <rocksdb/filter_policy.h>
 #include <rocksdb/options.h>
 #include <rocksdb/table.h>
+#include <rocksdb/write_batch.h>
 
-namespace leveldb = rocksdb;
-
-#include <set>
+#include <array>
 #include <memory>
+#include <optional>
+#include <set>
 #include <string>
 #include <vector>
 
 class NullLogger : public rocksdb::Logger {
-public:
+ public:
   using rocksdb::Logger::Logv;
   virtual void Logv(const char* format, va_list ap) override {}
   virtual size_t GetLogFileSize() const override { return 0; }
@@ -30,9 +29,8 @@ public:
 
 struct Database;
 struct Iterator;
-static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb);
 
-#define NAPI_DB_CONTEXT() \
+#define NAPI_DB_CONTEXT()       \
   Database* database = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
@@ -40,29 +38,29 @@ static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb);
   Iterator* iterator = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
-#define NAPI_BATCH_CONTEXT() \
+#define NAPI_BATCH_CONTEXT()            \
   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) {
+static bool IsString(napi_env env, napi_value value) {
   napi_valuetype type;
   napi_typeof(env, value, &type);
   return type == napi_string;
 }
 
-static bool IsBuffer (napi_env env, napi_value value) {
+static bool IsBuffer(napi_env env, napi_value value) {
   bool isBuffer;
   napi_is_buffer(env, value, &isBuffer);
   return isBuffer;
 }
 
-static bool IsObject (napi_env env, napi_value value) {
+static bool IsObject(napi_env env, napi_value value) {
   napi_valuetype type;
   napi_typeof(env, value, &type);
   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 +68,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 +78,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,12 +101,12 @@ 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;
 
   if (napi_get_named_property(env, obj, option.data(), &value) == napi_ok &&
-    napi_get_value_string_utf8(env, value, nullptr, 0, &size) == napi_ok) {
+      napi_get_value_string_utf8(env, value, nullptr, 0, &size) == napi_ok) {
     // Value is either "buffer" or "utf8" so we can tell them apart just by size
     return size == 6;
   }
@@ -117,8 +114,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 +125,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;
@@ -141,24 +136,27 @@ static int Int32Property (napi_env env, napi_value obj, const std::string& key,
   return defaultValue;
 }
 
-static std::string ToString (napi_env env, napi_value from, const std::string& defaultValue = "") {
+static std::string ToString(napi_env env, napi_value from, const std::string& defaultValue = "") {
   if (IsString(env, from)) {
     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;
     size_t length = 0;
-    napi_get_buffer_info(env, from, reinterpret_cast<void **>(&buf), &length);
+    napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length);
     return std::string(buf, length);
   }
 
   return defaultValue;
 }
 
-static std::string StringProperty (napi_env env, napi_value obj, const std::string& key, const std::string& defaultValue = "") {
+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)) {
@@ -169,59 +167,62 @@ static std::string StringProperty (napi_env env, napi_value obj, const std::stri
   return defaultValue;
 }
 
-static size_t StringOrBufferLength (napi_env env, napi_value value) {
+static size_t StringOrBufferLength(napi_env env, napi_value value) {
   size_t size = 0;
 
   if (IsString(env, value)) {
     napi_get_value_string_utf8(env, value, nullptr, 0, &size);
   } else if (IsBuffer(env, value)) {
     char* buf = nullptr;
-    napi_get_buffer_info(env, value, (void **)&buf, &size);
+    napi_get_buffer_info(env, value, (void**)&buf, &size);
   }
 
   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 ToString(env, value);
   }
 
-  return nullptr;
+  return {};
 }
 
-static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
-  uint32_t length;
-  std::vector<std::string> result;
+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);
+}
 
-  if (napi_get_array_length(env, arr, &length) == napi_ok) {
-    result.reserve(length);
+static napi_value ToError(napi_env env, const rocksdb::Status& status) {
+  if (status.ok()) {
+    return 0;
+  }
 
-    for (uint32_t i = 0; i < length; i++) {
-      napi_value element;
+  const auto msg = status.ToString();
 
-      if (napi_get_element(env, arr, i, &element) == napi_ok &&
-          StringOrBufferLength(env, element) > 0) {
-        result.push_back(ToString(env, element));
-      }
+  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 result;
-}
-
-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);
+  return CreateError(env, msg);
 }
 
 template <typename T>
-void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
+void Convert(napi_env env, const T& s, bool asBuffer, napi_value& result) {
   if (asBuffer) {
     napi_create_buffer_copy(env, s.size(), s.data(), nullptr, &result);
   } else {
@@ -229,132 +230,101 @@ 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)
-    : database_(database) {
+struct Worker {
+  Worker(napi_env env, Database* database, napi_value callback, 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_async_work(env, callback,
-                                              asyncResourceName,
-                                              BaseWorker::Execute,
-                                              BaseWorker::Complete,
-                                              this, &asyncWork_));
+    NAPI_STATUS_THROWS_VOID(napi_create_string_utf8(env, resourceName.data(), resourceName.size(), &asyncResourceName));
+    NAPI_STATUS_THROWS_VOID(napi_create_async_work(env, callback, asyncResourceName, Worker::Execute,
+                                                   Worker::Complete, this, &asyncWork_));
   }
 
-  virtual ~BaseWorker () {}
-
-  static void Execute (napi_env env, void* data) {
-    auto self = reinterpret_cast<BaseWorker*>(data);
+  virtual ~Worker() {}
 
-    // Don't pass env to DoExecute() because use of Node-API
-    // methods should generally be avoided in async work.
-    self->DoExecute();
+  static void Execute(napi_env env, void* data) {
+    auto self = reinterpret_cast<Worker*>(data);
+    self->status_ = self->Execute(*self->database_);
   }
 
-  bool SetStatus (const rocksdb::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);
+  static void Complete(napi_env env, napi_status status, void* data) {
+    auto self = reinterpret_cast<Worker*>(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_));
     }
-  }
 
-  virtual void HandleOKCallback (napi_env env, napi_value callback) {
-    napi_value argv;
-    napi_get_null(env, &argv);
-    CallFunction(env, callback, 1, &argv);
-  }
+    self->Destroy(env);
 
-  virtual void HandleErrorCallback (napi_env env, napi_value callback) {
-    napi_value argv;
+    napi_delete_reference(env, self->callbackRef_);
+    napi_delete_async_work(env, self->asyncWork_);
 
-    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);
-    }
+    delete self;
+  }
+
+  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 DoFinally (napi_env env) {
-    napi_delete_reference(env, callbackRef_);
-    napi_delete_async_work(env, asyncWork_);
+  virtual void OnError(napi_env env, napi_value callback, napi_value err) { CallFunction(env, callback, 1, &err); }
 
-    delete this;
-  }
+  virtual void Destroy(napi_env env) {}
 
-  void Queue (napi_env env) {
-    napi_queue_async_work(env, asyncWork_);
-  }
+  void Queue(napi_env env) { napi_queue_async_work(env, asyncWork_); }
 
   Database* database_;
 
-private:
+ private:
   napi_ref callbackRef_;
   napi_async_work asyncWork_;
   rocksdb::Status status_;
 };
 
-/**
- * Owns the LevelDB storage, cache, filter policy and iterators.
- */
 struct Database {
-  Database ()
-    : pendingCloseWorker_(nullptr),
-      ref_(nullptr),
-      priorityWork_(0) {}
-
-  rocksdb::Status Open (const rocksdb::Options& options,
-                        const bool readOnly,
-                        const char* location) {
+  rocksdb::Status Open(const rocksdb::Options& options, const bool readOnly, const char* location) {
     if (readOnly) {
       rocksdb::DB* db = nullptr;
       const auto status = rocksdb::DB::OpenForReadOnly(options, location, &db);
@@ -368,76 +338,20 @@ struct Database {
     }
   }
 
-  void CloseDatabase () {
-    db_.reset();
-  }
-
-  rocksdb::Status Put (const rocksdb::WriteOptions& options,
-                       const std::string& key,
-                       const std::string& value) {
-    return db_->Put(options, db_->DefaultColumnFamily(), key, value);
-  }
-
-  rocksdb::Status Get (const rocksdb::ReadOptions& options,
-                       const std::string& key,
-                       rocksdb::PinnableSlice& value) {
-    return db_->Get(options, db_->DefaultColumnFamily(), key, &value);
-  }
-
-  rocksdb::Status Del (const rocksdb::WriteOptions& options,
-                       const std::string& key) {
-    return db_->Delete(options, db_->DefaultColumnFamily(), key);
-  }
-
-  rocksdb::Status WriteBatch (const rocksdb::WriteOptions& options,
-                              rocksdb::WriteBatch* batch) {
-    return db_->Write(options, batch);
-  }
-
-  uint64_t ApproximateSize (const rocksdb::Range* range) {
-    uint64_t size = 0;
-    db_->GetApproximateSizes(range, 1, &size);
-    return size;
-  }
-
-  void CompactRange (const rocksdb::Slice* start,
-                     const rocksdb::Slice* end) {
-    rocksdb::CompactRangeOptions options;
-    db_->CompactRange(options, start, end);
-  }
-
-  void GetProperty (const std::string& property, std::string& value) {
-    db_->GetProperty(property, &value);
-  }
-
-  const rocksdb::Snapshot* NewSnapshot () {
-    return db_->GetSnapshot();
-  }
-
-  rocksdb::Iterator* NewIterator (const rocksdb::ReadOptions& options) {
-    return db_->NewIterator(options);
-  }
-
-  void ReleaseSnapshot (const rocksdb::Snapshot* snapshot) {
-    return db_->ReleaseSnapshot(snapshot);
-  }
-
-  void AttachIterator (napi_env env, Iterator* iterator) {
+  void AttachIterator(napi_env env, Iterator* iterator) {
     iterators_.insert(iterator);
     IncrementPriorityWork(env);
   }
 
-  void DetachIterator (napi_env env, Iterator* iterator) {
+  void DetachIterator(napi_env env, Iterator* iterator) {
     iterators_.erase(iterator);
     DecrementPriorityWork(env);
   }
 
-  void IncrementPriorityWork (napi_env env) {
-    napi_reference_ref(env, ref_, &priorityWork_);
-  }
+  void IncrementPriorityWork(napi_env env) { napi_reference_ref(env, prioritRef_, &priorityWork_); }
 
-  void DecrementPriorityWork (napi_env env) {
-    napi_reference_unref(env, ref_, &priorityWork_);
+  void DecrementPriorityWork(napi_env env) {
+    napi_reference_unref(env, prioritRef_, &priorityWork_);
 
     if (priorityWork_ == 0 && pendingCloseWorker_) {
       pendingCloseWorker_->Queue(env);
@@ -445,290 +359,149 @@ struct Database {
     }
   }
 
-  bool HasPriorityWork () const {
-    return priorityWork_ > 0;
-  }
+  bool HasPriorityWork() const { return priorityWork_ > 0; }
 
   std::unique_ptr<rocksdb::DB> db_;
-  BaseWorker* pendingCloseWorker_;
+  Worker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
-  napi_ref ref_;
+  napi_ref prioritRef_;
 
-private:
-  uint32_t priorityWork_;
-};
-
-/**
- * Base worker class for doing async work that defers closing the database.
- */
-struct PriorityWorker : public BaseWorker {
-  PriorityWorker (napi_env env, Database* database, napi_value callback, const char* resourceName)
-    : BaseWorker(env, database, callback, resourceName) {
-      database_->IncrementPriorityWork(env);
-  }
-
-  virtual ~PriorityWorker () {}
-
-  void DoFinally (napi_env env) override {
-    database_->DecrementPriorityWork(env);
-    BaseWorker::DoFinally(env);
-  }
+ private:
+  uint32_t priorityWork_ = 0;
 };
 
 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([&]{
-        rocksdb::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) {
-  }
-
-  virtual ~BaseIterator () {
-    assert(!dbIterator_);
-
-    delete lt_;
-    delete lte_;
-    delete gt_;
-    delete gte_;
-  }
-
-  bool DidSeek () const {
-    return didSeek_;
-  }
-
-  /**
-   * Seek to the first relevant key based on range options.
-   */
-  void SeekToRange () {
+      : database_(database),
+        lt_(!lte ? lt : *lte + '\0'),
+        gte_(gte ? gte : (gt ? std::optional<std::string>(*gt + '\0') : std::nullopt)),
+        snapshot_(database_->db_->GetSnapshot(),
+                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }),
+        iterator_(database->db_->NewIterator([&] {
+          rocksdb::ReadOptions options;
+          if (lt_) {
+            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(!iterator_); }
+
+  bool DidSeek() const { return didSeek_; }
+
+  void SeekToRange() {
     didSeek_ = true;
 
-    if (!reverse_ && gte_) {
-      dbIterator_->Seek(*gte_);
-    } else if (!reverse_ && gt_) {
-      dbIterator_->Seek(*gt_);
-
-      if (dbIterator_->Valid() && dbIterator_->key().compare(*gt_) == 0) {
-        dbIterator_->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();
-      }
-    } else if (reverse_) {
-      dbIterator_->SeekToLast();
+    if (reverse_) {
+      iterator_->SeekToLast();
     } else {
-      dbIterator_->SeekToFirst();
+      iterator_->SeekToFirst();
     }
   }
 
-  /**
-   * Seek manually (during iteration).
-   */
-  void Seek (const std::string& target) {
+  void Seek(const std::string& target) {
     didSeek_ = true;
 
-    if (OutOfRange(target)) {
-      return SeekToEnd();
-    }
-
-    dbIterator_->Seek(target);
-
-    if (dbIterator_->Valid()) {
-      const auto cmp = dbIterator_->key().compare(target);
-      if (reverse_ ? cmp > 0 : cmp < 0) {
-        Next();
+    if ((lt_ && target.compare(*lt_) >= 0) || (gte_ && target.compare(*gte_) < 0)) {
+      // TODO (fix): Why is this required? Seek should handle it?
+      // https://github.com/facebook/rocksdb/issues/9904
+      iterator_->SeekToLast();
+      if (iterator_->Valid()) {
+        iterator_->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();
-        }
-      }
-    }
-  }
-
-  void Close () {
-    if (dbIterator_) {
-      delete dbIterator_;
-      dbIterator_ = nullptr;
-      database_->ReleaseSnapshot(snapshot_);
+      iterator_->Seek(target);
     }
   }
 
-  bool Valid () const {
-    return dbIterator_->Valid() && !OutOfRange(dbIterator_->key());
-  }
-
-  bool Increment () {
-    return limit_ < 0 || ++count_ <= limit_;
-  }
-
-  void Next () {
-    if (reverse_) dbIterator_->Prev();
-    else dbIterator_->Next();
+  void Close() {
+    snapshot_.reset();
+    iterator_.reset();
   }
 
-  void SeekToFirst () {
-    if (reverse_) dbIterator_->SeekToLast();
-    else dbIterator_->SeekToFirst();
-  }
-
-  void SeekToLast () {
-    if (reverse_) dbIterator_->SeekToFirst();
-    else dbIterator_->SeekToLast();
-  }
-
-  void SeekToEnd () {
-    SeekToLast();
-    Next();
-  }
-
-  rocksdb::Slice CurrentKey () const {
-    return dbIterator_->key();
-  }
+  bool Valid() const { return iterator_->Valid(); }
 
-  rocksdb::Slice CurrentValue () const {
-    return dbIterator_->value();
-  }
+  bool Increment() { return limit_ < 0 || ++count_ <= limit_; }
 
-  rocksdb::Status Status () const {
-    return dbIterator_->status();
+  void Next() {
+    if (reverse_)
+      iterator_->Prev();
+    else
+      iterator_->Next();
   }
 
-  bool OutOfRange (const rocksdb::Slice& target) const {
-    if (lte_) {
-      if (target.compare(*lte_) > 0) return true;
-    } else if (lt_) {
-      if (target.compare(*lt_) >= 0) return true;
-    }
+  rocksdb::Slice CurrentKey() const { return iterator_->key(); }
 
-    if (gte_) {
-      if (target.compare(*gte_) < 0) return true;
-    } else if (gt_) {
-      if (target.compare(*gt_) <= 0) return true;
-    }
+  rocksdb::Slice CurrentValue() const { return iterator_->value(); }
 
-    return false;
-  }
+  rocksdb::Status Status() const { return iterator_->status(); }
 
   Database* database_;
 
-private:
-  const rocksdb::Snapshot* snapshot_;
-  rocksdb::Iterator* dbIterator_;
-  bool didSeek_;
+ private:
+  const std::optional<std::string> lt_;
+  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 {
-  Iterator (Database* database,
-            const bool reverse,
-            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 bool fillCache,
-            const bool keyAsBuffer,
-            const bool valueAsBuffer,
-            const uint32_t highWaterMarkBytes)
-    : BaseIterator(database, reverse, lt, lte, gt, gte, limit, fillCache),
-      keys_(keys),
-      values_(values),
-      keyAsBuffer_(keyAsBuffer),
-      valueAsBuffer_(valueAsBuffer),
-      highWaterMarkBytes_(highWaterMarkBytes),
-      first_(true),
-      ref_(nullptr) {
-  }
-
-  void Attach (napi_env env, napi_value context) {
+  Iterator(Database* database,
+           const bool reverse,
+           const bool keys,
+           const bool values,
+           const int limit,
+           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,
+           const uint32_t highWaterMarkBytes)
+      : BaseIterator(database, reverse, lt, lte, gt, gte, limit, fillCache),
+        keys_(keys),
+        values_(values),
+        keyAsBuffer_(keyAsBuffer),
+        valueAsBuffer_(valueAsBuffer),
+        highWaterMarkBytes_(highWaterMarkBytes),
+        first_(true),
+        ref_(nullptr) {}
+
+  void Attach(napi_env env, napi_value context) {
     napi_create_reference(env, context, 1, &ref_);
     database_->AttachIterator(env, this);
   }
 
-  void Detach (napi_env env) {
+  void Detach(napi_env env) {
     database_->DetachIterator(env, this);
-    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;
-      }
+    if (ref_) {
+      napi_delete_reference(env, ref_);
     }
-
-    return false;
   }
 
   const bool keys_;
@@ -737,9 +510,8 @@ struct Iterator final : public BaseIterator {
   const bool valueAsBuffer_;
   const uint32_t highWaterMarkBytes_;
   bool first_;
-  std::vector<std::string> cache_;
 
-private:
+ private:
   napi_ref ref_;
 };
 
@@ -748,15 +520,16 @@ private:
  * already-scheduled napi_async_work items have finished, which gives us
  * the guarantee that no db operations will be in-flight at this time.
  */
-static void env_cleanup_hook (void* arg) {
+static void env_cleanup_hook(void* 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
-  // closing their db) made during the lifetime of the environment. That's different
-  // from an environment being torn down (like the main process or a worker thread)
-  // where it's our responsibility to clean up. Note also, the following code must
-  // be a safe noop if called before db_open() or after db_close().
+  // 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 closing their db) made during the lifetime of the environment. That's
+  // different from an environment being torn down (like the main process or a
+  // worker thread) where it's our responsibility to clean up. Note also, the
+  // following code must be a safe noop if called before db_open() or after
+  // db_close().
   if (database && database->db_) {
     // TODO: does not do `napi_delete_reference(env, iterator->ref_)`. Problem?
     for (auto it : database->iterators_) {
@@ -764,15 +537,16 @@ static void env_cleanup_hook (void* arg) {
     }
 
     // Having closed the iterators (and released snapshots) we can safely close.
-    database->CloseDatabase();
+    database->db_->Close();
   }
 }
 
-static void FinalizeDatabase (napi_env env, void* data, void* hint) {
+static void FinalizeDatabase(napi_env env, void* data, void* hint) {
   if (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;
   }
 }
@@ -782,55 +556,55 @@ NAPI_METHOD(db_init) {
   napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
 
   napi_value result;
-  NAPI_STATUS_THROWS(napi_create_external(env, database,
-                                          FinalizeDatabase,
-                                          nullptr, &result));
+  NAPI_STATUS_THROWS(napi_create_external(env, database, 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;
 }
 
-struct OpenWorker final : public PriorityWorker {
-  OpenWorker (napi_env env,
-              Database* database,
-              napi_value callback,
-              const std::string& location,
-              const bool createIfMissing,
-              const bool errorIfExists,
-              const bool compression,
-              const uint32_t writeBufferSize,
-              const uint32_t blockSize,
-              const uint32_t maxOpenFiles,
-              const uint32_t blockRestartInterval,
-              const uint32_t maxFileSize,
-              const uint32_t cacheSize,
-              const std::string& infoLogLevel,
-              const bool readOnly)
-    : PriorityWorker(env, database, callback, "leveldown.db.open"),
-      readOnly_(readOnly),
-      location_(location) {
+struct OpenWorker final : public Worker {
+  OpenWorker(napi_env env,
+             Database* database,
+             napi_value callback,
+             const std::string& location,
+             const bool createIfMissing,
+             const bool errorIfExists,
+             const bool compression,
+             const uint32_t writeBufferSize,
+             const uint32_t blockSize,
+             const uint32_t maxOpenFiles,
+             const uint32_t blockRestartInterval,
+             const uint32_t maxFileSize,
+             const uint32_t cacheSize,
+             const std::string& infoLogLevel,
+             const bool readOnly)
+      : Worker(env, database, callback, "leveldown.db.open"), readOnly_(readOnly), location_(location) {
     options_.create_if_missing = createIfMissing;
     options_.error_if_exists = errorIfExists;
-    options_.compression = compression
-      ? rocksdb::kSnappyCompression
-      : rocksdb::kNoCompression;
+    options_.compression = compression ? 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 = {};
 
-      if (infoLogLevel == "debug") lvl = rocksdb::InfoLogLevel::DEBUG_LEVEL;
-      else if (infoLogLevel == "info") lvl = rocksdb::InfoLogLevel::INFO_LEVEL;
-      else if (infoLogLevel == "warn") lvl = rocksdb::InfoLogLevel::WARN_LEVEL;
-      else if (infoLogLevel == "error") lvl = rocksdb::InfoLogLevel::ERROR_LEVEL;
-      else if (infoLogLevel == "fatal") lvl = rocksdb::InfoLogLevel::FATAL_LEVEL;
-      else if (infoLogLevel == "header") lvl = rocksdb::InfoLogLevel::HEADER_LEVEL;
-      else napi_throw_error(env, nullptr, "invalid log level");
+      if (infoLogLevel == "debug")
+        lvl = rocksdb::InfoLogLevel::DEBUG_LEVEL;
+      else if (infoLogLevel == "info")
+        lvl = rocksdb::InfoLogLevel::INFO_LEVEL;
+      else if (infoLogLevel == "warn")
+        lvl = rocksdb::InfoLogLevel::WARN_LEVEL;
+      else if (infoLogLevel == "error")
+        lvl = rocksdb::InfoLogLevel::ERROR_LEVEL;
+      else if (infoLogLevel == "fatal")
+        lvl = rocksdb::InfoLogLevel::FATAL_LEVEL;
+      else if (infoLogLevel == "header")
+        lvl = rocksdb::InfoLogLevel::HEADER_LEVEL;
+      else
+        napi_throw_error(env, nullptr, "invalid log level");
 
       options_.info_log_level = lvl;
     } else {
@@ -854,14 +628,10 @@ struct OpenWorker final : public PriorityWorker {
     tableOptions.format_version = 5;
     tableOptions.checksum = rocksdb::kxxHash64;
 
-    options_.table_factory.reset(
-      rocksdb::NewBlockBasedTableFactory(tableOptions)
-    );
+    options_.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
   }
 
-  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()); }
 
   rocksdb::Options options_;
   const bool readOnly_;
@@ -882,38 +652,30 @@ NAPI_METHOD(db_open) {
   const auto infoLogLevel = StringProperty(env, options, "infoLogLevel");
 
   const auto cacheSize = Uint32Property(env, options, "cacheSize", 8 << 20);
-  const auto writeBufferSize = Uint32Property(env, options , "writeBufferSize" , 4 << 20);
+  const auto writeBufferSize = Uint32Property(env, options, "writeBufferSize", 4 << 20);
   const auto blockSize = Uint32Property(env, options, "blockSize", 4096);
   const auto maxOpenFiles = Uint32Property(env, options, "maxOpenFiles", 1000);
-  const auto blockRestartInterval = Uint32Property(env, options,
-                                                 "blockRestartInterval", 16);
+  const auto blockRestartInterval = Uint32Property(env, options, "blockRestartInterval", 16);
   const auto maxFileSize = Uint32Property(env, options, "maxFileSize", 2 << 20);
 
   const auto callback = argv[3];
 
-  auto worker = new OpenWorker(env, database, callback, location,
-                               createIfMissing, errorIfExists,
-                               compression, writeBufferSize, blockSize,
-                               maxOpenFiles, blockRestartInterval,
-                               maxFileSize, cacheSize,
-                               infoLogLevel, readOnly);
+  auto worker =
+      new OpenWorker(env, database, callback, location, createIfMissing, errorIfExists, compression, writeBufferSize,
+                     blockSize, maxOpenFiles, blockRestartInterval, maxFileSize, cacheSize, infoLogLevel, readOnly);
   worker->Queue(env);
 
   return 0;
 }
 
-struct CloseWorker final : public BaseWorker {
-  CloseWorker (napi_env env,
-               Database* database,
-               napi_value callback)
-    : BaseWorker(env, database, callback, "leveldown.db.close") {}
+struct CloseWorker final : public Worker {
+  CloseWorker(napi_env env, Database* database, napi_value callback)
+      : Worker(env, database, callback, "leveldown.db.close") {}
 
-  void DoExecute () override {
-    database_->CloseDatabase();
-  }
+  rocksdb::Status Execute(Database& database) override { return database.db_->Close(); }
 };
 
-napi_value noop_callback (napi_env env, napi_callback_info info) {
+napi_value noop_callback(napi_env env, napi_callback_info info) {
   return 0;
 }
 
@@ -934,72 +696,62 @@ 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 {
-    rocksdb::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 {
-  GetWorker (napi_env env,
-             Database* database,
-             napi_value callback,
-             const std::string& key,
-             const bool asBuffer,
-             const bool fillCache)
-    : PriorityWorker(env, database, callback, "rocks_level.db.get"),
-      key_(key), asBuffer_(asBuffer), fillCache_(fillCache) {
-  }
-
-  void DoExecute () override {
+struct GetWorker final : public Worker {
+  GetWorker(napi_env env,
+            Database* database,
+            napi_value callback,
+            const std::string& key,
+            const bool asBuffer,
+            const bool fillCache)
+      : Worker(env, database, callback, "rocks_level.db.get"),
+        key_(key),
+        asBuffer_(asBuffer),
+        fillCache_(fillCache),
+        snapshot_(database_->db_->GetSnapshot(),
+                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
+    database_->IncrementPriorityWork(env);
+  }
+
+  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_ = nullptr;
+
+    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]);
     CallFunction(env, callback, 2, argv);
   }
 
-private:
+  void Destroy(napi_env env) override {
+    database_->DecrementPriorityWork(env);
+    Worker::Destroy(env);
+  }
+
+ private:
   const std::string key_;
   rocksdb::PinnableSlice value_;
   const bool asBuffer_;
   const bool fillCache_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 };
 
 NAPI_METHOD(db_get) {
@@ -1018,63 +770,49 @@ NAPI_METHOD(db_get) {
   return 0;
 }
 
-struct GetManyWorker final : public PriorityWorker {
-  GetManyWorker (napi_env env,
-                 Database* database,
-                 const std::vector<std::string>& keys,
-                 napi_value callback,
-                 const bool valueAsBuffer,
-                 const bool fillCache)
-    : PriorityWorker(env, database, callback, "leveldown.get.many"),
-      keys_(keys), valueAsBuffer_(valueAsBuffer), fillCache_(fillCache),
-      snapshot_(database->NewSnapshot()) {
-  }
-
-  ~GetManyWorker () {
-    if (snapshot_) {
-      database_->ReleaseSnapshot(snapshot_);
-      snapshot_ = nullptr;
-    }
-  }
-
-  void DoExecute () override {
-    cache_.reserve(keys_.size());
-
+struct GetManyWorker final : public Worker {
+  GetManyWorker(napi_env env,
+                Database* database,
+                const std::vector<std::string>& keys,
+                napi_value callback,
+                const bool valueAsBuffer,
+                const bool fillCache)
+      : Worker(env, database, callback, "leveldown.get.many"),
+        keys_(keys),
+        valueAsBuffer_(valueAsBuffer),
+        fillCache_(fillCache),
+        snapshot_(database_->db_->GetSnapshot(),
+                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
+    database_->IncrementPriorityWork(env);
+  }
+
+  rocksdb::Status Execute(Database& database) override {
     rocksdb::ReadOptions options;
-    options.snapshot = snapshot_;
     options.fill_cache = fillCache_;
-    
-    rocksdb::PinnableSlice value;
+    options.snapshot = snapshot_.get();
 
-    for (const auto& key: keys_) {
-      const auto status = database_->Get(options, key, value);
+    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);
       }
@@ -1087,19 +825,39 @@ struct GetManyWorker final : public PriorityWorker {
     CallFunction(env, callback, 2, argv);
   }
 
-private:
+  void Destroy(napi_env env) override {
+    database_->DecrementPriorityWork(env);
+    Worker::Destroy(env);
+  }
+
+ 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 rocksdb::Snapshot* snapshot_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 };
 
 NAPI_METHOD(db_get_many) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto keys = KeyArray(env, argv[1]);
+  std::vector<std::string> keys;
+  {
+    uint32_t length;
+    NAPI_STATUS_THROWS(napi_get_array_length(env, argv[1], &length));
+
+    keys.reserve(length);
+
+    for (uint32_t i = 0; i < length; i++) {
+      napi_value element;
+
+      NAPI_STATUS_THROWS(napi_get_element(env, argv[1], i, &element));
+      keys.push_back(ToString(env, element));
+    }
+  }
+
   const auto options = argv[2];
   const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const bool fillCache = BooleanProperty(env, options, "fillCache", true);
@@ -1111,183 +869,67 @@ 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 {
-    rocksdb::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;
-
-    rocksdb::WriteBatch batch;
-    rocksdb::WriteOptions options;
-
-    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 reverse = BooleanProperty(env, argv[1], "reverse", false);
+  const auto limit = Int32Property(env, argv[1], "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");
+  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");
 
-  auto worker = new ClearWorker(env, database, callback, reverse, limit, lt, lte, gt, gte);
-  worker->Queue(env);
+  // TODO (perf): Use DeleteRange.
 
-  return 0;
-}
+  BaseIterator it(database, reverse, lt, lte, gt, gte, limit, false);
 
-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) {}
-
-  void DoExecute () override {
-    rocksdb::Range range(start_, end_);
-    size_ = database_->ApproximateSize(&range);
-  }
+  it.SeekToRange();
 
-  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);
-  }
+  // TODO: add option
+  const uint32_t hwm = 16 * 1024;
 
-  std::string start_;
-  std::string end_;
-  uint64_t size_;
-};
+  rocksdb::WriteBatch batch;
+  rocksdb::WriteOptions options;
+  rocksdb::Status status;
 
-NAPI_METHOD(db_approximate_size) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
+  while (true) {
+    size_t bytesRead = 0;
 
-  const auto start = ToString(env, argv[1]);
-  const auto end = ToString(env, argv[2]);
-  const auto callback = argv[3];
+    while (bytesRead <= hwm && it.Valid() && it.Increment()) {
+      const auto key = it.CurrentKey();
+      batch.Delete(key);
+      bytesRead += key.size();
+      it.Next();
+    }
 
-  auto worker  = new ApproximateSizeWorker(env, database, callback, start, end);
-  worker->Queue(env);
+    status = it.Status();
+    if (!status.ok() || bytesRead == 0) {
+      break;
+    }
 
-  return 0;
-}
+    status = database->db_->Write(options, &batch);
+    if (!status.ok()) {
+      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) {}
-
-  void DoExecute () override {
-    rocksdb::Slice start = start_;
-    rocksdb::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();
+  it.Close();
 
-  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;
+  return ToError(env, status);
 }
 
 NAPI_METHOD(db_get_property) {
@@ -1297,7 +939,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);
@@ -1305,63 +947,7 @@ 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 {
-    rocksdb::Options options;
-    SetStatus(rocksdb::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 {
-    rocksdb::Options options;
-    SetStatus(rocksdb::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) {
+static void FinalizeIterator(napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<Iterator*>(data);
   }
@@ -1386,14 +972,11 @@ NAPI_METHOD(iterator_init) {
   const auto gt = RangeOption(env, options, "gt");
   const auto gte = RangeOption(env, options, "gte");
 
-  auto iterator = new Iterator(database, reverse, keys,
-                               values, limit, lt, lte, gt, gte, fillCache,
-                               keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
+  auto iterator = new Iterator(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache, 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.
@@ -1413,23 +996,21 @@ NAPI_METHOD(iterator_seek) {
   return 0;
 }
 
-struct CloseIteratorWorker final : public BaseWorker {
-  CloseIteratorWorker (napi_env env,
-                       Iterator* iterator,
-                       napi_value callback)
-    : BaseWorker(env, iterator->database_, callback, "leveldown.iterator.end"),
-      iterator_(iterator) {}
+struct CloseIteratorWorker final : public Worker {
+  CloseIteratorWorker(napi_env env, Iterator* iterator, napi_value callback)
+      : Worker(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);
+    Worker::Destroy(env);
   }
 
-private:
+ private:
   Iterator* iterator_;
 };
 
@@ -1445,62 +1026,87 @@ NAPI_METHOD(iterator_close) {
   return 0;
 }
 
-struct NextWorker final : public BaseWorker {
-  NextWorker (napi_env env,
-              Iterator* iterator,
-              uint32_t size,
-              napi_value callback)
-    : BaseWorker(env, iterator->database_, callback,
-                 "leveldown.iterator.next"),
-      iterator_(iterator), size_(size), ok_() {}
+struct NextWorker final : public Worker {
+  NextWorker(napi_env env, Iterator* iterator, uint32_t size, napi_value callback)
+      : Worker(env, iterator->database_, callback, "leveldown.iterator.next"), 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 {
-    BaseWorker::DoFinally(env);
-  }
-
-private:
-  Iterator* iterator_;
-  uint32_t size_;
-  bool ok_;
+ private:
+  std::vector<std::string> cache_;
+  Iterator* iterator_ = nullptr;
+  uint32_t size_ = 0;
+  bool finished_ = false;
 };
 
 NAPI_METHOD(iterator_nextv) {
@@ -1509,7 +1115,8 @@ NAPI_METHOD(iterator_nextv) {
 
   uint32_t size;
   NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &size));
-  if (size == 0) size = 1;
+  if (size == 0)
+    size = 1;
 
   const auto callback = argv[2];
 
@@ -1519,74 +1126,51 @@ NAPI_METHOD(iterator_nextv) {
   return 0;
 }
 
-struct BatchWorker final : public PriorityWorker {
-  BatchWorker (napi_env env,
-               Database* database,
-               napi_value callback,
-               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));
+NAPI_METHOD(batch_do) {
+  NAPI_ARGV(3);
+  NAPI_DB_CONTEXT();
 
-      if (!IsObject(env, element)) continue;
+  const auto operations = argv[1];
 
-      const auto type = StringProperty(env, element, "type");
+  rocksdb::WriteBatch batch;
 
-      if (type == "del") {
-        if (!HasProperty(env, element, "key")) continue;
-        const auto key = ToString(env, GetProperty(env, element, "key"));
+  uint32_t length;
+  NAPI_STATUS_THROWS(napi_get_array_length(env, operations, &length));
 
-        batch_.Delete(key);
-        if (!hasData_) hasData_ = true;
-      } else if (type == "put") {
-        if (!HasProperty(env, element, "key")) continue;
-        if (!HasProperty(env, element, "value")) continue;
+  for (uint32_t i = 0; i < length; i++) {
+    napi_value element;
+    NAPI_STATUS_THROWS(napi_get_element(env, operations, i, &element));
 
-        const auto key = ToString(env, GetProperty(env, element, "key"));
-        const auto value = ToString(env, GetProperty(env, element, "value"));
+    if (!IsObject(env, element))
+      continue;
 
-        batch_.Put(key, value);
-        if (!hasData_) hasData_ = true;
-      }
-    }
-  }
+    const auto type = StringProperty(env, element, "type");
 
-  void DoExecute () override {
-    if (hasData_) {
-      rocksdb::WriteOptions options;
-      options.sync = sync_;
-      SetStatus(database_->WriteBatch(options, &batch_));
-    } else {
-      SetStatus(rocksdb::Status::OK());
-    }
-  }
+    if (type == "del") {
+      if (!HasProperty(env, element, "key"))
+        continue;
 
-private:
-  rocksdb::WriteBatch batch_;
-  const bool sync_;
-  bool hasData_;
-};
+      const auto key = NapiSlice(env, GetProperty(env, element, "key"));
 
-NAPI_METHOD(batch_do) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
+      batch.Delete(key);
+    } else if (type == "put") {
+      if (!HasProperty(env, element, "key"))
+        continue;
+      if (!HasProperty(env, element, "value"))
+        continue;
 
-  const auto array = argv[1];
-  const auto sync = BooleanProperty(env, argv[2], "sync", false);
-  const auto callback = argv[3];
+      const auto key = NapiSlice(env, GetProperty(env, element, "key"));
+      const auto value = NapiSlice(env, GetProperty(env, element, "value"));
 
-  auto worker = new BatchWorker(env, database, callback, array, sync);
-  worker->Queue(env);
+      batch.Put(key, value);
+    }
+  }
 
-  return 0;
+  rocksdb::WriteOptions options;
+  return ToError(env, database->db_->Write(options, &batch));
 }
 
-static void FinalizeBatch (napi_env env, void* data, void* hint) {
+static void FinalizeBatch(napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<rocksdb::WriteBatch*>(data);
   }
@@ -1607,8 +1191,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);
 
@@ -1619,7 +1203,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);
 
@@ -1635,51 +1219,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 {
-    rocksdb::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:
-  rocksdb::WriteBatch* batch_;
-  const bool sync_;
-  napi_ref batchRef_;
-};
-
 NAPI_METHOD(batch_write) {
-  NAPI_ARGV(4);
+  NAPI_ARGV(3);
   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() {
@@ -1691,13 +1239,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);