@nxtedition/rocksdb 5.2.33 → 5.2.36

package/binding.cc

@@ -30,6 +30,23 @@ class NullLogger : public rocksdb::Logger {
 struct Database;
 struct Iterator;
 
+#define NAPI_STATUS_RETURN(call) \
+  {                              \
+    const auto status = (call);  \
+    if (status != napi_ok) {     \
+      return status;             \
+    }                            \
+  }
+
+#define NAPI_PENDING_EXCEPTION()                                 \
+  {                                                              \
+    bool result;                                                 \
+    NAPI_STATUS_THROWS(napi_is_exception_pending(env, &result)); \
+    if (result) {                                                \
+      return nullptr;                                            \
+    }                                                            \
+  }
+
 #define NAPI_DB_CONTEXT()       \
   Database* database = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
@@ -60,21 +77,15 @@ static bool IsObject(napi_env env, napi_value value) {
   return type == napi_object;
 }
 
-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;
-  napi_create_error(env, nullptr, msg, &error);
-  return error;
-}
-
-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);
+static napi_value CreateError(napi_env env, const std::optional<std::string_view>& code, const std::string_view& msg) {
+  napi_value codeValue = nullptr;
+  if (code) {
+    NAPI_STATUS_THROWS(napi_create_string_utf8(env, code->data(), code->size(), &codeValue));
+  }
   napi_value msgValue;
-  napi_create_string_utf8(env, msg.data(), msg.size(), &msgValue);
+  NAPI_STATUS_THROWS(napi_create_string_utf8(env, msg.data(), msg.size(), &msgValue));
   napi_value error;
-  napi_create_error(env, codeValue, msgValue, &error);
+  NAPI_STATUS_THROWS(napi_create_error(env, codeValue, msgValue, &error));
   return error;
 }
 
@@ -90,7 +101,7 @@ static napi_value GetProperty(napi_env env, napi_value obj, const std::string_vi
   return value;
 }
 
-static bool BooleanProperty(napi_env env, napi_value obj, const std::string_view& key, bool defaultValue) {
+static std::optional<bool> BooleanProperty(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     bool result;
@@ -98,7 +109,7 @@ static bool BooleanProperty(napi_env env, napi_value obj, const std::string_view
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
 static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_view& option) {
@@ -114,7 +125,7 @@ static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_vie
   return false;
 }
 
-static uint32_t Uint32Property(napi_env env, napi_value obj, const std::string_view& key, uint32_t defaultValue) {
+static std::optional<uint32_t> Uint32Property(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
@@ -122,10 +133,10 @@ static uint32_t Uint32Property(napi_env env, napi_value obj, const std::string_v
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
-static int Int32Property(napi_env env, napi_value obj, const std::string_view& key, int defaultValue) {
+static std::optional<int> Int32Property(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int result;
@@ -133,7 +144,7 @@ static int Int32Property(napi_env env, napi_value obj, const std::string_view& k
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
 static std::string ToString(napi_env env, napi_value from, const std::string& defaultValue = "") {
@@ -153,42 +164,19 @@ static std::string ToString(napi_env env, napi_value from, const std::string& de
   return 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)) {
-      return ToString(env, value);
-    }
-  }
-
-  return defaultValue;
-}
-
-static std::optional<std::string> RangeOption(napi_env env, napi_value opts, const std::string_view& name) {
+static std::optional<std::string> StringProperty(napi_env env, napi_value opts, const std::string_view& name) {
   if (HasProperty(env, opts, name)) {
     const auto value = GetProperty(env, opts, name);
     return ToString(env, value);
   }
-
   return {};
 }
 
 static napi_status CallFunction(napi_env env, napi_value callback, const int argc, napi_value* argv) {
-  napi_status status;
   napi_value global;
 
-  status = napi_get_global(env, &global);
-  if (status != napi_ok) {
-    return status;
-  }
-
-  status = napi_call_function(env, global, callback, argc, argv, nullptr);
-  if (status != napi_ok) {
-    return status;
-  }
+  NAPI_STATUS_RETURN(napi_get_global(env, &global));
+  NAPI_STATUS_RETURN(napi_call_function(env, global, callback, argc, argv, nullptr));
 
   return napi_ok;
 }
@@ -201,28 +189,45 @@ static napi_value ToError(napi_env env, const rocksdb::Status& status) {
   const auto msg = status.ToString();
 
   if (status.IsNotFound()) {
-    return CreateCodeError(env, "LEVEL_NOT_FOUND", msg);
+    return CreateError(env, "LEVEL_NOT_FOUND", msg);
   } else if (status.IsCorruption()) {
-    return CreateCodeError(env, "LEVEL_CORRUPTION", msg);
+    return CreateError(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);
+      return CreateError(env, "LEVEL_LOCKED", msg);
     } else if (msg.find("IO error: LockFile ") != std::string::npos) {  // env_win.cc
-      return CreateCodeError(env, "LEVEL_LOCKED", msg);
+      return CreateError(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);
+      return CreateError(env, "LEVEL_LOCKED", msg);
     } else {
-      return CreateCodeError(env, "LEVEL_IO_ERROR", msg);
+      return CreateError(env, "LEVEL_IO_ERROR", msg);
     }
   }
 
-  return CreateError(env, msg);
+  return CreateError(env, {}, msg);
 }
 
 template <typename T>
-napi_status Convert(napi_env env, const T& s, bool asBuffer, napi_value& result) {
+static void Finalize(napi_env env, void* data, void* hint) {
+  if (hint) {
+    delete reinterpret_cast<T*>(hint);
+  }
+}
+
+napi_status Convert(napi_env env, std::string s, bool asBuffer, napi_value& result) {
+  if (asBuffer) {
+    auto ptr = new std::string(std::move(s));
+    return napi_create_external_buffer(env, ptr->size(), ptr->data(), Finalize<std::string>, ptr, &result);
+  } else {
+    return napi_create_string_utf8(env, s.data(), s.size(), &result);
+  }
+}
+
+napi_status Convert(napi_env env, rocksdb::PinnableSlice s, bool asBuffer, napi_value& result) {
   if (asBuffer) {
-    return napi_create_buffer_copy(env, s.size(), s.data(), nullptr, &result);
+    auto ptr = new rocksdb::PinnableSlice(std::move(s));
+    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<std::string>, ptr,
+                                       &result);
   } else {
     return napi_create_string_utf8(env, s.data(), s.size(), &result);
   }
@@ -231,7 +236,7 @@ napi_status 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_);
+      NAPI_STATUS_THROWS_VOID(napi_get_value_string_utf8(env, from, nullptr, 0, &size_));
       char* data;
       if (size_ + 1 < stack_.size()) {
         data = stack_.data();
@@ -240,17 +245,17 @@ struct NapiSlice : public rocksdb::Slice {
         data = heap_.get();
       }
       data[size_] = 0;
-      napi_get_value_string_utf8(env, from, data, size_ + 1, &size_);
+      NAPI_STATUS_THROWS_VOID(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_);
+      NAPI_STATUS_THROWS_VOID(napi_get_buffer_info(env, from, &data, &size_));
       data_ = static_cast<char*>(data);
     }
   }
 
   std::unique_ptr<char[]> heap_;
-  std::array<char, 8192> stack_;
+  std::array<char, 1024> stack_;
 };
 
 /**
@@ -263,13 +268,12 @@ struct NapiSlice : public rocksdb::Slice {
  * - Destroy (main thread): do cleanup regardless of success
  */
 struct Worker {
-  Worker(napi_env env, Database* database, napi_value callback, const std::string& resourceName)
-      : database_(database) {
+  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.data(), resourceName.size(), &asyncResourceName));
-    NAPI_STATUS_THROWS_VOID(napi_create_async_work(env, callback, asyncResourceName, Worker::Execute,
-                                                   Worker::Complete, this, &asyncWork_));
+    NAPI_STATUS_THROWS_VOID(
+        napi_create_async_work(env, callback, asyncResourceName, Worker::Execute, Worker::Complete, this, &asyncWork_));
   }
 
   virtual ~Worker() {}
@@ -282,6 +286,8 @@ struct Worker {
   static void Complete(napi_env env, napi_status status, void* data) {
     auto self = reinterpret_cast<Worker*>(data);
 
+    // TODO (fix): napi status handling...
+
     napi_value callback;
     napi_get_reference_value(env, self->callbackRef_, &callback);
 
@@ -301,13 +307,15 @@ struct Worker {
 
   virtual rocksdb::Status Execute(Database& database) = 0;
 
-  virtual void OnOk(napi_env env, napi_value callback) {
+  virtual napi_status OnOk(napi_env env, napi_value callback) {
     napi_value argv;
-    napi_get_null(env, &argv);
-    CallFunction(env, callback, 1, &argv);
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv));
+    return CallFunction(env, callback, 1, &argv);
   }
 
-  virtual void OnError(napi_env env, napi_value callback, napi_value err) { CallFunction(env, callback, 1, &err); }
+  virtual napi_status OnError(napi_env env, napi_value callback, napi_value err) {
+    return CallFunction(env, callback, 1, &err);
+  }
 
   virtual void Destroy(napi_env env) {}
 
@@ -322,20 +330,6 @@ struct Worker {
 };
 
 struct Database {
-  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);
-      db_.reset(db);
-      return status;
-    } else {
-      rocksdb::DB* db = nullptr;
-      const auto status = rocksdb::DB::Open(options, location, &db);
-      db_.reset(db);
-      return status;
-    }
-  }
-
   void AttachIterator(napi_env env, Iterator* iterator) {
     iterators_.insert(iterator);
     IncrementPriorityWork(env);
@@ -346,10 +340,10 @@ struct Database {
     DecrementPriorityWork(env);
   }
 
-  void IncrementPriorityWork(napi_env env) { napi_reference_ref(env, prioritRef_, &priorityWork_); }
+  void IncrementPriorityWork(napi_env env) { napi_reference_ref(env, priorityRef_, &priorityWork_); }
 
   void DecrementPriorityWork(napi_env env) {
-    napi_reference_unref(env, prioritRef_, &priorityWork_);
+    napi_reference_unref(env, priorityRef_, &priorityWork_);
 
     if (priorityWork_ == 0 && pendingCloseWorker_) {
       pendingCloseWorker_->Queue(env);
@@ -362,7 +356,7 @@ struct Database {
   std::unique_ptr<rocksdb::DB> db_;
   Worker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
-  napi_ref prioritRef_;
+  napi_ref priorityRef_;
 
  private:
   uint32_t priorityWork_ = 0;
@@ -378,33 +372,40 @@ struct BaseIterator {
                const int limit,
                const bool fillCache)
       : 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) {}
+        limit_(limit),
+        fillCache_(fillCache) {
+    if (lte) {
+      upper_bound_ = rocksdb::PinnableSlice();
+      *upper_bound_->GetSelf() = std::move(*lte) + '\0';
+      upper_bound_->PinSelf();
+    } else if (lt) {
+      upper_bound_ = rocksdb::PinnableSlice();
+      *upper_bound_->GetSelf() = std::move(*lt);
+      upper_bound_->PinSelf();
+    }
+
+    if (gte) {
+      lower_bound_ = rocksdb::PinnableSlice();
+      *lower_bound_->GetSelf() = std::move(*gte);
+      lower_bound_->PinSelf();
+    } else if (gt) {
+      lower_bound_ = rocksdb::PinnableSlice();
+      *lower_bound_->GetSelf() = std::move(*gt) + '\0';
+      lower_bound_->PinSelf();
+    }
+  }
 
   virtual ~BaseIterator() { assert(!iterator_); }
 
-  bool DidSeek() const { return didSeek_; }
+  bool DidSeek() const { return iterator_ != nullptr; }
 
   void SeekToRange() {
-    didSeek_ = true;
+    if (!iterator_) {
+      Init();
+    }
 
     if (reverse_) {
       iterator_->SeekToLast();
@@ -413,10 +414,12 @@ struct BaseIterator {
     }
   }
 
-  void Seek(const std::string& target) {
-    didSeek_ = true;
+  void Seek(const rocksdb::Slice& target) {
+    if (!iterator_) {
+      Init();
+    }
 
-    if ((lt_ && target.compare(*lt_) >= 0) || (gte_ && target.compare(*gte_) < 0)) {
+    if ((upper_bound_ && target.compare(*upper_bound_) >= 0) || (lower_bound_ && target.compare(*lower_bound_) < 0)) {
       // TODO (fix): Why is this required? Seek should handle it?
       // https://github.com/facebook/rocksdb/issues/9904
       iterator_->SeekToLast();
@@ -455,16 +458,28 @@ struct BaseIterator {
   Database* database_;
 
  private:
-  const std::optional<std::string> lt_;
-  const std::optional<std::string> gte_;
-  rocksdb::Slice lower_bound_;
-  rocksdb::Slice upper_bound_;
+  void Init() {
+    rocksdb::ReadOptions options;
+    if (upper_bound_) {
+      options.iterate_upper_bound = &*upper_bound_;
+    }
+    if (lower_bound_) {
+      options.iterate_lower_bound = &*lower_bound_;
+    }
+    options.fill_cache = fillCache_;
+    options.snapshot = snapshot_.get();
+
+    iterator_.reset(database_->db_->NewIterator(options));
+  }
+
+  std::optional<rocksdb::PinnableSlice> lower_bound_;
+  std::optional<rocksdb::PinnableSlice> upper_bound_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
   std::unique_ptr<rocksdb::Iterator> iterator_;
-  bool didSeek_ = false;
   const bool reverse_;
   const int limit_;
   int count_ = 0;
+  const bool fillCache_;
 };
 
 struct Iterator final : public BaseIterator {
@@ -486,9 +501,7 @@ struct Iterator final : public BaseIterator {
         values_(values),
         keyAsBuffer_(keyAsBuffer),
         valueAsBuffer_(valueAsBuffer),
-        highWaterMarkBytes_(highWaterMarkBytes),
-        first_(true),
-        ref_(nullptr) {}
+        highWaterMarkBytes_(highWaterMarkBytes) {}
 
   void Attach(napi_env env, napi_value context) {
     napi_create_reference(env, context, 1, &ref_);
@@ -507,10 +520,10 @@ struct Iterator final : public BaseIterator {
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
   const uint32_t highWaterMarkBytes_;
-  bool first_;
+  bool first_ = true;
 
  private:
-  napi_ref ref_;
+  napi_ref ref_ = nullptr;
 };
 
 /**
@@ -543,8 +556,8 @@ 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->prioritRef_)
-      napi_delete_reference(env, database->prioritRef_);
+    if (database->priorityRef_)
+      napi_delete_reference(env, database->priorityRef_);
     delete database;
   }
 }
@@ -556,7 +569,7 @@ NAPI_METHOD(db_init) {
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, database, FinalizeDatabase, nullptr, &result));
 
-  NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->prioritRef_));
+  NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->priorityRef_));
 
   return result;
 }
@@ -566,71 +579,21 @@ struct OpenWorker final : public Worker {
              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,
+             rocksdb::Options options,
              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_.write_buffer_size = writeBufferSize;
-    options_.max_open_files = maxOpenFiles;
-    options_.max_log_file_size = maxFileSize;
-    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");
-
-      options_.info_log_level = lvl;
-    } else {
-      // In some places RocksDB checks this option to see if it should prepare
-      // debug information (ahead of logging), so set it to the highest level.
-      options_.info_log_level = rocksdb::InfoLogLevel::HEADER_LEVEL;
-      options_.info_log.reset(new NullLogger());
-    }
-
-    rocksdb::BlockBasedTableOptions tableOptions;
-
-    if (cacheSize) {
-      tableOptions.block_cache = rocksdb::NewLRUCache(cacheSize);
-    } else {
-      tableOptions.no_block_cache = true;
-    }
-
-    tableOptions.block_size = blockSize;
-    tableOptions.block_restart_interval = blockRestartInterval;
-    tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
-    tableOptions.format_version = 5;
-    tableOptions.checksum = rocksdb::kxxHash64;
+      : Worker(env, database, callback, "leveldown.db.open"),
+        options_(options),
+        readOnly_(readOnly),
+        location_(location) {}
 
-    options_.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
+  rocksdb::Status Execute(Database& database) override {
+    rocksdb::DB* db;
+    const auto status = readOnly_ ? rocksdb::DB::OpenForReadOnly(options_, location_, &db)
+                                  : rocksdb::DB::Open(options_, location_, &db);
+    database.db_.reset(db);
+    return status;
   }
 
-  rocksdb::Status Execute(Database& database) override { return database.Open(options_, readOnly_, location_.c_str()); }
-
   rocksdb::Options options_;
   const bool readOnly_;
   const std::string location_;
@@ -640,27 +603,68 @@ NAPI_METHOD(db_open) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
+  rocksdb::Options options;
+
+  options.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism").value_or(4));
+
   const auto location = ToString(env, argv[1]);
-  const auto options = argv[2];
-  const auto createIfMissing = BooleanProperty(env, options, "createIfMissing", true);
-  const auto errorIfExists = BooleanProperty(env, options, "errorIfExists", false);
-  const auto compression = BooleanProperty(env, options, "compression", true);
-  const auto readOnly = BooleanProperty(env, options, "readOnly", false);
+  options.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
+  options.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
+  options.compression = BooleanProperty(env, argv[2], "compression").value_or((true)) ? rocksdb::kSnappyCompression
+                                                                                      : rocksdb::kNoCompression;
+  options.use_adaptive_mutex = true;
+
+  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
+  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");
 
-  const auto infoLogLevel = StringProperty(env, options, "infoLogLevel");
+    options.info_log_level = lvl;
+  } else {
+    // In some places RocksDB checks this option to see if it should prepare
+    // debug information (ahead of logging), so set it to the highest level.
+    options.info_log_level = rocksdb::InfoLogLevel::HEADER_LEVEL;
+    options.info_log.reset(new NullLogger());
+  }
 
-  const auto cacheSize = Uint32Property(env, options, "cacheSize", 8 << 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 maxFileSize = Uint32Property(env, options, "maxFileSize", 2 << 20);
+  const auto readOnly = BooleanProperty(env, argv[2], "readOnly").value_or(false);
+  const auto cacheSize = Uint32Property(env, argv[2], "cacheSize").value_or(8 << 20);
+
+  rocksdb::BlockBasedTableOptions tableOptions;
+
+  if (cacheSize) {
+    tableOptions.block_cache = rocksdb::NewLRUCache(cacheSize);
+  } else {
+    tableOptions.no_block_cache = true;
+  }
+
+  tableOptions.block_size = Uint32Property(env, argv[2], "blockSize").value_or(4096);
+  tableOptions.block_restart_interval = Uint32Property(env, argv[2], "blockRestartInterval").value_or(16);
+  tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
+  tableOptions.format_version = 5;
+  tableOptions.checksum = rocksdb::kxxHash64;
+
+  options.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
 
   const auto callback = argv[3];
 
-  auto worker =
-      new OpenWorker(env, database, callback, location, createIfMissing, errorIfExists, compression, writeBufferSize,
-                     blockSize, maxOpenFiles, blockRestartInterval, maxFileSize, cacheSize, infoLogLevel, readOnly);
+  NAPI_PENDING_EXCEPTION();
+
+  auto worker = new OpenWorker(env, database, callback, location, options, readOnly);
   worker->Queue(env);
 
   return 0;
@@ -698,11 +702,13 @@ NAPI_METHOD(db_put) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto key = ToString(env, argv[1]);
-  const auto value = ToString(env, argv[2]);
+  const auto key = NapiSlice(env, argv[1]);
+  const auto val = NapiSlice(env, argv[2]);
+
+  NAPI_PENDING_EXCEPTION();
 
   rocksdb::WriteOptions options;
-  return ToError(env, database->db_->Put(options, key, value));
+  return ToError(env, database->db_->Put(options, key, val));
 }
 
 struct GetWorker final : public Worker {
@@ -726,17 +732,19 @@ struct GetWorker final : public Worker {
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
 
-    auto status = database.db_->Get(options, database.db_->DefaultColumnFamily(), key_, &value_);
+    auto status = database.db_->Get(options, key_, &value_);
+
+    key_.clear();
     snapshot_ = nullptr;
 
     return status;
   }
 
-  void OnOk(napi_env env, napi_value callback) override {
+  napi_status 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);
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+    NAPI_STATUS_RETURN(Convert(env, std::move(value_), asBuffer_, argv[1]));
+    return CallFunction(env, callback, 2, argv);
   }
 
   void Destroy(napi_env env) override {
@@ -745,8 +753,8 @@ struct GetWorker final : public Worker {
   }
 
  private:
-  const std::string key_;
-  rocksdb::PinnableSlice value_;
+  std::string key_;
+  std::string value_;
   const bool asBuffer_;
   const bool fillCache_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
@@ -759,9 +767,11 @@ NAPI_METHOD(db_get) {
   const auto key = ToString(env, argv[1]);
   const auto options = argv[2];
   const auto asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const auto fillCache = BooleanProperty(env, options, "fillCache", true);
+  const auto fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
   const auto callback = argv[3];
 
+  NAPI_PENDING_EXCEPTION();
+
   auto worker = new GetWorker(env, database, callback, key, asBuffer, fillCache);
   worker->Queue(env);
 
@@ -789,10 +799,24 @@ struct GetManyWorker final : public Worker {
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
 
-    status_ = database.db_->MultiGet(options, std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()), &values_);
+    const auto numKeys = keys_.size();
+
+    std::vector<rocksdb::Slice> keys;
+    keys.reserve(keys_.size());
+    for (const auto& key : keys_) {
+      keys.emplace_back(key);
+    }
+
+    statuses_.resize(numKeys);
+    values_.resize(numKeys);
+
+    database.db_->MultiGet(options, database.db_->DefaultColumnFamily(), numKeys, keys.data(), values_.data(),
+                           statuses_.data());
+
+    keys_.clear();
     snapshot_ = nullptr;
 
-    for (auto status : status_) {
+    for (auto status : statuses_) {
       if (!status.ok() && !status.IsNotFound()) {
         return status;
       }
@@ -801,26 +825,29 @@ struct GetManyWorker final : public Worker {
     return rocksdb::Status::OK();
   }
 
-  void OnOk(napi_env env, napi_value callback) override {
+  napi_status OnOk(napi_env env, napi_value callback) override {
     const auto size = values_.size();
 
     napi_value array;
-    napi_create_array_with_length(env, size, &array);
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &array));
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
-      if (status_[idx].ok()) {
-        Convert(env, values_[idx], valueAsBuffer_, element);
+      if (statuses_[idx].ok()) {
+        NAPI_STATUS_RETURN(Convert(env, std::move(values_[idx]), valueAsBuffer_, element));
       } else {
-        napi_get_undefined(env, &element);
+        NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
       }
-      napi_set_element(env, array, static_cast<uint32_t>(idx), element);
+      NAPI_STATUS_RETURN(napi_set_element(env, array, static_cast<uint32_t>(idx), element));
     }
 
+    values_.clear();
+    statuses_.clear();
+
     napi_value argv[2];
-    napi_get_null(env, &argv[0]);
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
     argv[1] = array;
-    CallFunction(env, callback, 2, argv);
+    return CallFunction(env, callback, 2, argv);
   }
 
   void Destroy(napi_env env) override {
@@ -829,9 +856,9 @@ struct GetManyWorker final : public Worker {
   }
 
  private:
-  const std::vector<std::string> keys_;
-  std::vector<std::string> values_;
-  std::vector<rocksdb::Status> status_;
+  std::vector<std::string> keys_;
+  std::vector<rocksdb::PinnableSlice> values_;
+  std::vector<rocksdb::Status> statuses_;
   const bool valueAsBuffer_;
   const bool fillCache_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
@@ -858,9 +885,11 @@ NAPI_METHOD(db_get_many) {
 
   const auto options = argv[2];
   const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const bool fillCache = BooleanProperty(env, options, "fillCache", true);
+  const bool fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
   const auto callback = argv[3];
 
+  NAPI_PENDING_EXCEPTION();
+
   auto worker = new GetManyWorker(env, database, keys, callback, asBuffer, fillCache);
   worker->Queue(env);
 
@@ -871,7 +900,9 @@ NAPI_METHOD(db_del) {
   NAPI_ARGV(3);
   NAPI_DB_CONTEXT();
 
-  const auto key = ToString(env, argv[1]);
+  const auto key = NapiSlice(env, argv[1]);
+
+  NAPI_PENDING_EXCEPTION();
 
   rocksdb::WriteOptions options;
   return ToError(env, database->db_->Delete(options, key));
@@ -881,13 +912,13 @@ NAPI_METHOD(db_clear) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  const auto reverse = BooleanProperty(env, argv[1], "reverse", false);
-  const auto limit = Int32Property(env, argv[1], "limit", -1);
+  const auto reverse = BooleanProperty(env, argv[1], "reverse").value_or(false);
+  const auto limit = Int32Property(env, argv[1], "limit").value_or(-1);
 
-  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");
+  const auto lt = StringProperty(env, argv[1], "lt");
+  const auto lte = StringProperty(env, argv[1], "lte");
+  const auto gt = StringProperty(env, argv[1], "gt");
+  const auto gte = StringProperty(env, argv[1], "gte");
 
   // TODO (perf): Use DeleteRange.
 
@@ -934,51 +965,47 @@ NAPI_METHOD(db_get_property) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  const auto property = ToString(env, argv[1]);
+  const auto property = NapiSlice(env, argv[1]);
+
+  NAPI_PENDING_EXCEPTION();
 
   std::string value;
   database->db_->GetProperty(property, &value);
 
   napi_value result;
-  napi_create_string_utf8(env, value.data(), value.size(), &result);
+  NAPI_STATUS_THROWS(napi_create_string_utf8(env, value.data(), value.size(), &result));
 
   return result;
 }
 
-static void FinalizeIterator(napi_env env, void* data, void* hint) {
-  if (data) {
-    delete reinterpret_cast<Iterator*>(data);
-  }
-}
-
 NAPI_METHOD(iterator_init) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
   const auto options = argv[1];
-  const auto reverse = BooleanProperty(env, options, "reverse", false);
-  const auto keys = BooleanProperty(env, options, "keys", true);
-  const auto values = BooleanProperty(env, options, "values", true);
-  const auto fillCache = BooleanProperty(env, options, "fillCache", false);
+  const auto reverse = BooleanProperty(env, options, "reverse").value_or(false);
+  const auto keys = BooleanProperty(env, options, "keys").value_or(true);
+  const auto values = BooleanProperty(env, options, "values").value_or(true);
+  const auto fillCache = BooleanProperty(env, options, "fillCache").value_or(false);
   const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
   const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const auto limit = Int32Property(env, options, "limit", -1);
-  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes", 16 * 1024);
+  const auto limit = Int32Property(env, options, "limit").value_or(-1);
+  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes").value_or(16 * 1024);
 
-  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 = StringProperty(env, options, "lt");
+  const auto lte = StringProperty(env, options, "lte");
+  const auto gt = StringProperty(env, options, "gt");
+  const auto gte = StringProperty(env, options, "gte");
 
-  auto iterator = new Iterator(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache, keyAsBuffer,
-                               valueAsBuffer, highWaterMarkBytes);
-  napi_value result;
+  auto iterator = std::make_unique<Iterator>(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache,
+                                             keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
 
-  NAPI_STATUS_THROWS(napi_create_external(env, iterator, FinalizeIterator, nullptr, &result));
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_external(env, iterator.get(), Finalize<Iterator>, iterator.get(), &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.
-  iterator->Attach(env, result);
+  iterator.release()->Attach(env, result);
 
   return result;
 }
@@ -987,39 +1014,22 @@ NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  const auto target = ToString(env, argv[1]);
+  const auto target = NapiSlice(env, argv[1]);
+
+  NAPI_PENDING_EXCEPTION();
+
   iterator->first_ = true;
   iterator->Seek(target);
 
   return 0;
 }
 
-struct CloseIteratorWorker final : public Worker {
-  CloseIteratorWorker(napi_env env, Iterator* iterator, napi_value callback)
-      : Worker(env, iterator->database_, callback, "leveldown.iterator.end"), iterator_(iterator) {}
-
-  rocksdb::Status Execute(Database& database) override {
-    iterator_->Close();
-    return rocksdb::Status::OK();
-  }
-
-  void Destroy(napi_env env) override {
-    iterator_->Detach(env);
-    Worker::Destroy(env);
-  }
-
- private:
-  Iterator* iterator_;
-};
-
 NAPI_METHOD(iterator_close) {
-  NAPI_ARGV(2);
+  NAPI_ARGV(1);
   NAPI_ITERATOR_CONTEXT();
 
-  const auto callback = argv[1];
-
-  auto worker = new CloseIteratorWorker(env, iterator, callback);
-  worker->Queue(env);
+  iterator->Detach(env);
+  iterator->Close();
 
   return 0;
 }
@@ -1033,9 +1043,6 @@ struct NextWorker final : public Worker {
       iterator_->SeekToRange();
     }
 
-    // Limit the size of the cache to prevent starving the event loop
-    // in JS-land while we're recursively calling process.nextTick().
-
     cache_.reserve(size_ * 2);
     size_t bytesRead = 0;
 
@@ -1075,29 +1082,29 @@ struct NextWorker final : public Worker {
     return iterator_->Status();
   }
 
-  void OnOk(napi_env env, napi_value callback) override {
+  napi_status OnOk(napi_env env, napi_value callback) override {
     const auto size = cache_.size();
     napi_value result;
-    napi_create_array_with_length(env, size, &result);
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &result));
 
     for (size_t idx = 0; idx < cache_.size(); idx += 2) {
       napi_value key;
       napi_value val;
 
-      Convert(env, cache_[idx + 0], iterator_->keyAsBuffer_, key);
-      Convert(env, cache_[idx + 1], iterator_->valueAsBuffer_, val);
+      NAPI_STATUS_RETURN(Convert(env, std::move(cache_[idx + 0]), iterator_->keyAsBuffer_, key));
+      NAPI_STATUS_RETURN(Convert(env, std::move(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);
+      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 0), key));
+      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 1), val));
     }
 
     cache_.clear();
 
     napi_value argv[3];
-    napi_get_null(env, &argv[0]);
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
     argv[1] = result;
-    napi_get_boolean(env, !finished_, &argv[2]);
-    CallFunction(env, callback, 3, argv);
+    NAPI_STATUS_RETURN(napi_get_boolean(env, !finished_, &argv[2]));
+    return CallFunction(env, callback, 3, argv);
   }
 
  private:
@@ -1113,8 +1120,6 @@ NAPI_METHOD(iterator_nextv) {
 
   uint32_t size;
   NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &size));
-  if (size == 0)
-    size = 1;
 
   const auto callback = argv[2];
 
@@ -1150,6 +1155,8 @@ NAPI_METHOD(batch_do) {
 
       const auto key = NapiSlice(env, GetProperty(env, element, "key"));
 
+      NAPI_PENDING_EXCEPTION();
+
       batch.Delete(key);
     } else if (type == "put") {
       if (!HasProperty(env, element, "key"))
@@ -1160,6 +1167,8 @@ NAPI_METHOD(batch_do) {
       const auto key = NapiSlice(env, GetProperty(env, element, "key"));
       const auto value = NapiSlice(env, GetProperty(env, element, "value"));
 
+      NAPI_PENDING_EXCEPTION();
+
       batch.Put(key, value);
     }
   }
@@ -1168,12 +1177,6 @@ NAPI_METHOD(batch_do) {
   return ToError(env, database->db_->Write(options, &batch));
 }
 
-static void FinalizeBatch(napi_env env, void* data, void* hint) {
-  if (data) {
-    delete reinterpret_cast<rocksdb::WriteBatch*>(data);
-  }
-}
-
 NAPI_METHOD(batch_init) {
   NAPI_ARGV(1);
   NAPI_DB_CONTEXT();
@@ -1181,7 +1184,7 @@ NAPI_METHOD(batch_init) {
   auto batch = new rocksdb::WriteBatch();
 
   napi_value result;
-  NAPI_STATUS_THROWS(napi_create_external(env, batch, FinalizeBatch, nullptr, &result));
+  NAPI_STATUS_THROWS(napi_create_external(env, batch, Finalize<rocksdb::WriteBatch>, batch, &result));
   return result;
 }
 
@@ -1190,9 +1193,11 @@ NAPI_METHOD(batch_put) {
   NAPI_BATCH_CONTEXT();
 
   const auto key = NapiSlice(env, argv[1]);
-  const auto value = NapiSlice(env, argv[2]);
+  const auto val = NapiSlice(env, argv[2]);
 
-  batch->Put(key, value);
+  NAPI_PENDING_EXCEPTION();
+
+  batch->Put(key, val);
 
   return 0;
 }
@@ -1203,6 +1208,8 @@ NAPI_METHOD(batch_del) {
 
   const auto key = NapiSlice(env, argv[1]);
 
+  NAPI_PENDING_EXCEPTION();
+
   batch->Delete(key);
 
   return 0;