@nxtedition/rocksdb 5.2.26 → 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:
@@ -61,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;
@@ -69,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;
@@ -79,19 +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;
@@ -102,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;
 
@@ -115,7 +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;
@@ -126,7 +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;
@@ -142,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;
@@ -154,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, 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)) {
@@ -178,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) {
@@ -213,6 +215,32 @@ static napi_status CallFunction (napi_env env, napi_value callback, const int ar
   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) {
@@ -222,14 +250,39 @@ 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):
  *
  * - Execute (abstract, worker pool thread): main work
- * - Then (main thread): call JS callback on success
- * - Catch (main thread): call JS callback on error
- * - Finally (main thread): do cleanup regardless of success
+ * - 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 {
   BaseWorker (napi_env env,
@@ -253,7 +306,7 @@ struct BaseWorker {
 
   static void Execute (napi_env env, void* data) {
     auto self = reinterpret_cast<BaseWorker*>(data);
-    self->status_ = self->Execute();
+    self->status_ = self->Execute(*self->database_);
   }
 
   static void Complete (napi_env env, napi_status status, void* data) {
@@ -263,53 +316,32 @@ struct BaseWorker {
     napi_get_reference_value(env, self->callbackRef_, &callback);
 
     if (self->status_.ok()) {
-      self->Then(env, callback);
+      self->OnOk(env, callback);
     } else {
-      self->Catch(env, callback);
+      self->OnError(env, callback, ToError(env, self->status_));
     }
 
-    self->Finally(env);
+    self->Destroy(env);
+
+    napi_delete_reference(env, self->callbackRef_);
+    napi_delete_async_work(env, self->asyncWork_);
+
+    delete self;
   }
 
-  virtual rocksdb::Status Execute () = 0;
+  virtual rocksdb::Status Execute (Database& database) = 0;
 
-  virtual void Then (napi_env env, napi_value callback) {
+  virtual void OnOk (napi_env env, napi_value callback) {
     napi_value argv;
     napi_get_null(env, &argv);
     CallFunction(env, callback, 1, &argv);
   }
 
-  virtual void Catch (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 Finally (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) {
@@ -317,7 +349,6 @@ struct BaseWorker {
   }
 
   Database* database_;
-
 private:
   napi_ref callbackRef_;
   napi_async_work asyncWork_;
@@ -345,56 +376,6 @@ struct Database {
     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) {
     iterators_.insert(iterator);
     IncrementPriorityWork(env);
@@ -442,19 +423,19 @@ struct PriorityWorker : public BaseWorker {
 
   virtual ~PriorityWorker () {}
 
-  void Finally (napi_env env) override {
+  void Destroy (napi_env env) override {
     database_->DecrementPriorityWork(env);
-    BaseWorker::Finally(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),
@@ -462,10 +443,10 @@ struct BaseIterator {
       lte_(lte),
       gt_(gt),
       gte_(gte),
-      snapshot_(database->NewSnapshot(), [this](const rocksdb::Snapshot* ptr) {
-        database_->ReleaseSnapshot(ptr);
+      snapshot_(database_->db_->GetSnapshot(), [this](const rocksdb::Snapshot* ptr) {
+        database_->db_->ReleaseSnapshot(ptr);
       }),
-      iterator_(database->NewIterator([&]{
+      iterator_(database->db_->NewIterator([&]{
         rocksdb::ReadOptions options;
         if (lt_ && !lte_) {
           upper_bound_ = rocksdb::Slice(lt_->data(), lt_->size());
@@ -501,13 +482,7 @@ struct BaseIterator {
         iterator_->Next();
       }
     } else if (reverse_ && lte_) {
-      iterator_->Seek(*lte_);
-
-      if (!iterator_->Valid()) {
-        iterator_->SeekToLast();
-      } else if (iterator_->key().compare(*lte_) > 0) {
-        iterator_->Prev();
-      }
+      iterator_->SeekForPrev(*lte_);
     } else if (reverse_) {
       iterator_->SeekToLast();
     } else {
@@ -518,25 +493,16 @@ struct BaseIterator {
   void Seek (const std::string& target) {
     didSeek_ = true;
 
-    if (OutOfRange(target)) {
-      return SeekToEnd();
-    }
-
-    iterator_->Seek(target);
+    // TODO (fix): Only check for (gt && !gte) and lte.
+    // See, https://github.com/facebook/rocksdb/issues/9904.
 
-    if (iterator_->Valid()) {
-      const auto cmp = iterator_->key().compare(target);
-      if (reverse_ ? cmp > 0 : cmp < 0) {
-        Next();
-      }
+    if (OutOfRange(target)) {
+      SeekToLast();
+      Next();
+    } else if (reverse_) {
+      iterator_->SeekForPrev(target);
     } else {
-      SeekToFirst();
-      if (iterator_->Valid()) {
-        const auto cmp = iterator_->key().compare(target);
-        if (reverse_ ? cmp > 0 : cmp < 0) {
-          SeekToEnd();
-        }
-      }
+      iterator_->Seek(target);
     }
   }
 
@@ -580,11 +546,6 @@ struct BaseIterator {
     else iterator_->SeekToLast();
   }
 
-  void SeekToEnd () {
-    SeekToLast();
-    Next();
-  }
-
   rocksdb::Slice CurrentKey () const {
     return iterator_->key();
   }
@@ -616,10 +577,10 @@ struct BaseIterator {
   Database* database_;
 
 private:
-  const std::unique_ptr<const std::string> lt_;
-  const std::unique_ptr<const std::string> lte_;
-  const std::unique_ptr<const std::string> gt_;
-  const std::unique_ptr<const std::string> gte_;
+  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_;
@@ -636,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,
@@ -790,8 +751,8 @@ struct OpenWorker final : public PriorityWorker {
     );
   }
 
-  rocksdb::Status Execute () override {
-    return database_->Open(options_, readOnly_, location_.c_str());
+  rocksdb::Status Execute (Database& database) override {
+    return database.Open(options_, readOnly_, location_.c_str());
   }
 
   rocksdb::Options options_;
@@ -839,9 +800,8 @@ struct CloseWorker final : public BaseWorker {
                napi_value callback)
     : BaseWorker(env, database, callback, "leveldown.db.close") {}
 
-  rocksdb::Status Execute () override {
-    database_->CloseDatabase();
-    return rocksdb::Status::OK();
+  rocksdb::Status Execute (Database& database) override {
+    return database.db_->Close();
   }
 };
 
@@ -866,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) {
-  }
-
-  rocksdb::Status Execute () override {
-    rocksdb::WriteOptions options;
-    options.sync = sync_;
-    return 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 {
@@ -911,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);
+      }) {
   }
 
-  rocksdb::Status Execute () override {
+  rocksdb::Status Execute (Database& database) override {
     rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
-    return 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 Then (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]);
@@ -932,6 +872,7 @@ private:
   rocksdb::PinnableSlice value_;
   const bool asBuffer_;
   const bool fillCache_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 };
 
 NAPI_METHOD(db_get) {
@@ -959,28 +900,21 @@ 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;
-    }
-  }
-
-  rocksdb::Status Execute () override {
+  rocksdb::Status Execute (Database& database) override {
     rocksdb::ReadOptions options;
-    options.snapshot = snapshot_;
     options.fill_cache = fillCache_;
-    
-    status_ = database_->db_->MultiGet(
+    options.snapshot = snapshot_.get();
+  
+    status_ = database.db_->MultiGet(
       options,
       std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()),
       &values_
     );
-
-    database_->ReleaseSnapshot(snapshot_);
     snapshot_ = nullptr;
 
     for (auto status : status_) {
@@ -992,7 +926,7 @@ struct GetManyWorker final : public PriorityWorker {
     return rocksdb::Status::OK();
   }
 
-  void Then (napi_env env, napi_value callback) override {
+  void OnOk (napi_env env, napi_value callback) override {
     const auto size = values_.size();
 
     napi_value array;
@@ -1020,7 +954,7 @@ private:
   std::vector<rocksdb::Status> status_;
   const bool valueAsBuffer_;
   const bool fillCache_;
-  const rocksdb::Snapshot* snapshot_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 };
 
 NAPI_METHOD(db_get_many) {
@@ -1039,190 +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) {
-  }
-
-  rocksdb::Status Execute () override {
-    rocksdb::WriteOptions options;
-    options.sync = sync_;
-    return 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) {
-  }
-
-  rocksdb::Status Execute () override {
-    iterator_.SeekToRange();
-
-    // TODO: add option
-    const uint32_t hwm = 16 * 1024;
-
-    rocksdb::WriteBatch batch;
-    rocksdb::WriteOptions options;
-    rocksdb::Status status;
-    
-    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();
-      }
-
-      status = iterator_.Status();
-      if (!status.ok() || bytesRead == 0) {
-        break;
-      }
-
-      status = database_->WriteBatch(options, &batch);
-      if (!status.ok()) {
-        break;
-      }
-
-      batch.Clear();
-    }
-
-    iterator_.Close();
-
-    return status;
-  }
-
-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, argv[1], "reverse", false);
+  const auto limit = Int32Property(env, argv[1], "limit", -1);
 
-  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");
+  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);
+  BaseIterator it(database, reverse, lt, lte, gt, gte, limit, false);
 
-  return 0;
-}
+  it.SeekToRange();
 
-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) {}
-
-  rocksdb::Status Execute () override {
-    rocksdb::Range range(start_, end_);
-    size_ = database_->ApproximateSize(&range);
-    return rocksdb::Status::OK();
-  }
+  // TODO: add option
+  const uint32_t hwm = 16 * 1024;
 
-  void Then (napi_env env, napi_value callback) override {
-    napi_value argv[2];
-    napi_get_null(env, &argv[0]);
-    napi_create_int64(env, size_, &argv[1]);
-    CallFunction(env, callback, 2, argv);
-  }
-
-  std::string start_;
-  std::string end_;
-  uint64_t size_;
-};
-
-NAPI_METHOD(db_approximate_size) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
+  rocksdb::WriteBatch batch;
+  rocksdb::WriteOptions options;
+  rocksdb::Status status;
+  
+  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) {}
-
-  rocksdb::Status Execute () override {
-    rocksdb::Slice start = start_;
-    rocksdb::Slice end = end_;
-    database_->CompactRange(&start, &end);
-    return rocksdb::Status::OK();
+    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) {
@@ -1232,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);
@@ -1240,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 () {}
-
-  rocksdb::Status Execute () override {
-    rocksdb::Options options;
-    return 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) {}
-
-  rocksdb::Status Execute () override {
-    rocksdb::Options options;
-    return 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) {
   if (data) {
     delete reinterpret_cast<Iterator*>(data);
@@ -1326,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.
@@ -1355,14 +1106,14 @@ struct CloseIteratorWorker final : public BaseWorker {
     : BaseWorker(env, iterator->database_, callback, "leveldown.iterator.end"),
       iterator_(iterator) {}
 
-  rocksdb::Status Execute () override {
+  rocksdb::Status Execute (Database& database) override {
     iterator_->Close();
     return rocksdb::Status::OK();
   }
 
-  void Finally (napi_env env) override {
+  void Destroy (napi_env env) override {
     iterator_->Detach(env);
-    BaseWorker::Finally(env);
+    BaseWorker::Destroy(env);
   }
 
 private:
@@ -1390,7 +1141,7 @@ struct NextWorker final : public BaseWorker {
                  "leveldown.iterator.next"),
       iterator_(iterator), size_(size) {}
 
-  rocksdb::Status Execute () override {
+  rocksdb::Status Execute (Database& database) override {
     if (!iterator_->DidSeek()) {
       iterator_->SeekToRange();
     }
@@ -1398,7 +1149,6 @@ struct NextWorker final : public BaseWorker {
     // Limit the size of the cache to prevent starving the event loop
     // in JS-land while we're recursively calling process.nextTick().
 
-    finished_ = false;
     cache_.reserve(size_ * 2);
     size_t bytesRead = 0;
 
@@ -1435,7 +1185,7 @@ struct NextWorker final : public BaseWorker {
     return iterator_->Status();
   }
 
-  void Then (napi_env env, napi_value callback) override {
+  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);
@@ -1483,71 +1233,44 @@ 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));
-
-      if (!IsObject(env, element)) continue;
+NAPI_METHOD(batch_do) {
+  NAPI_ARGV(3);
+  NAPI_DB_CONTEXT();
 
-      const auto type = StringProperty(env, element, "type");
+  const auto operations = argv[1];
 
-      if (type == "del") {
-        if (!HasProperty(env, element, "key")) continue;
-        const auto key = ToString(env, GetProperty(env, element, "key"));
+  rocksdb::WriteBatch batch;
 
-        batch_.Delete(key);
-        if (!hasData_) hasData_ = true;
-      } else if (type == "put") {
-        if (!HasProperty(env, element, "key")) continue;
-        if (!HasProperty(env, element, "value")) continue;
+  uint32_t length;
+  NAPI_STATUS_THROWS(napi_get_array_length(env, operations, &length));
 
-        const auto key = ToString(env, GetProperty(env, element, "key"));
-        const auto value = ToString(env, GetProperty(env, element, "value"));
+  for (uint32_t i = 0; i < length; i++) {
+    napi_value element;
+    NAPI_STATUS_THROWS(napi_get_element(env, operations, i, &element));
 
-        batch_.Put(key, value);
-        if (!hasData_) hasData_ = true;
-      }
-    }
-  }
+    if (!IsObject(env, element)) continue;
 
-  rocksdb::Status Execute () override {
-    if (!hasData_) {
-      return rocksdb::Status::OK();
-    }
+    const auto type = StringProperty(env, element, "type");
 
-    rocksdb::WriteOptions options;
-    options.sync = sync_;
-    return database_->WriteBatch(options, &batch_);
-  }
+    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) {
@@ -1571,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);
 
@@ -1583,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);
 
@@ -1599,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_));
-  }
-
-  rocksdb::Status Execute () override {
-    rocksdb::WriteOptions options;
-    options.sync = sync_;
-    return database_->WriteBatch(options, batch_);
-  }
-
-  void Finally (napi_env env) override {
-    napi_delete_reference(env, batchRef_);
-    PriorityWorker::Finally(env);
-  }
-
-private:
-  rocksdb::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];
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
-  auto worker = new BatchWriteWorker(env, database, batch, callback, sync);
-  worker->Queue(env);
-
-  return 0;
+  rocksdb::WriteOptions options;
+  return ToError(env, database->db_->Write(options, batch));
 }
 
 NAPI_INIT() {
@@ -1655,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);