@nxtedition/rocksdb 7.0.5 → 7.0.8

package/binding.cc

@@ -6,10 +6,12 @@
 
 #include <rocksdb/cache.h>
 #include <rocksdb/comparator.h>
+#include <rocksdb/convenience.h>
 #include <rocksdb/db.h>
 #include <rocksdb/env.h>
 #include <rocksdb/filter_policy.h>
 #include <rocksdb/options.h>
+#include <rocksdb/slice_transform.h>
 #include <rocksdb/table.h>
 #include <rocksdb/write_batch.h>
 
@@ -34,32 +36,28 @@ struct Updates;
 
 #define NAPI_STATUS_RETURN(call) \
   {                              \
-    const auto status = (call);  \
-    if (status != napi_ok) {     \
-      return status;             \
+    auto _status = (call);       \
+    if (_status != napi_ok) {    \
+      return _status;            \
     }                            \
   }
 
-#define ROCKS_STATUS_THROWS(call)            \
-  {                                          \
-    const auto status = (call);              \
-    if (!status.ok()) {                      \
-      napi_throw(env, ToError(env, status)); \
-      return NULL;                           \
-    }                                        \
+#define ROCKS_STATUS_RETURN(call) \
+  {                               \
+    auto _status = (call);        \
+    if (!_status.ok()) {          \
+      return _status;             \
+    }                             \
   }
 
-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) {
-  bool isBuffer;
-  napi_is_buffer(env, value, &isBuffer);
-  return isBuffer;
-}
+#define ROCKS_STATUS_THROWS(call)             \
+  {                                           \
+    auto _status = (call);                    \
+    if (!_status.ok()) {                      \
+      napi_throw(env, ToError(env, _status)); \
+      return NULL;                            \
+    }                                         \
+  }
 
 static napi_value CreateError(napi_env env, const std::optional<std::string_view>& code, const std::string_view& msg) {
   napi_value codeValue = nullptr;
@@ -109,20 +107,6 @@ static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_vie
   return false;
 }
 
-template <typename T>
-static std::optional<T*> ExternalValueProperty(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());
-
-    T* result;
-    if (napi_get_value_external(env, value, reinterpret_cast<void**>(&result)) == napi_ok) {
-      return result;
-    }
-  }
-
-  return {};
-}
-
 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());
@@ -157,27 +141,38 @@ static std::optional<int64_t> Int64Property(napi_env env, napi_value obj, const
   return {};
 }
 
-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);
-    return value;
-  } else if (IsBuffer(env, from)) {
-    char* buf = nullptr;
+static napi_status ToString(napi_env env, napi_value from, std::string& to) {
+  napi_valuetype type;
+  NAPI_STATUS_RETURN(napi_typeof(env, from, &type));
+
+  if (type == napi_string) {
     size_t length = 0;
-    napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length);
-    return std::string(buf, length);
+    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, nullptr, 0, &length));
+    to.resize(length, '\0');
+    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, &to[0], length + 1, &length));
+  } else {
+    bool isBuffer;
+    NAPI_STATUS_RETURN(napi_is_buffer(env, from, &isBuffer));
+
+    if (isBuffer) {
+      char* buf = nullptr;
+      size_t length = 0;
+      NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length));
+      to.assign(buf, length);
+    } else {
+      return napi_invalid_arg;
+    }
   }
 
-  return defaultValue;
+  return napi_ok;
 }
 
 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);
+    const auto property = GetProperty(env, opts, name);
+    std::string value;
+    ToString(env, property, value);
+    return value;
   }
   return {};
 }
@@ -224,54 +219,17 @@ static void Finalize(napi_env env, void* data, void* hint) {
   }
 }
 
-napi_status Convert(napi_env env, rocksdb::PinnableSlice& s, bool asBuffer, napi_value& result) {
-  if (asBuffer) {
-    auto ptr = new rocksdb::PinnableSlice(std::move(s));
-    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()),
-                                       Finalize<rocksdb::PinnableSlice>, ptr, &result);
-  } else {
-    return napi_create_string_utf8(env, s.data(), s.size(), &result);
-  }
-}
-
-napi_status Convert(napi_env env, std::optional<std::string>& s, bool asBuffer, napi_value& result) {
+template <typename T>
+napi_status Convert(napi_env env, T&& s, bool asBuffer, napi_value& result) {
   if (!s) {
     return napi_get_null(env, &result);
   } else if (asBuffer) {
-    auto ptr = new std::string(std::move(*s));
-    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<std::string>, ptr,
-                                       &result);
+    return napi_create_buffer_copy(env, s->size(), s->data(), NULL, &result);
   } else {
     return napi_create_string_utf8(env, s->data(), s->size(), &result);
   }
 }
 
-struct NapiSlice : public rocksdb::Slice {
-  std::unique_ptr<char[]> heap_;
-  std::array<char, 128> stack_;
-};
-
-napi_status ToNapiSlice(napi_env env, napi_value from, NapiSlice& slice) {
-  if (IsString(env, from)) {
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, nullptr, 0, &slice.size_));
-    char* data;
-    if (slice.size_ + 1 < slice.stack_.size()) {
-      data = slice.stack_.data();
-    } else {
-      slice.heap_.reset(new char[slice.size_ + 1]);
-      data = slice.heap_.get();
-    }
-    data[slice.size_] = 0;
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, data, slice.size_ + 1, &slice.size_));
-    slice.data_ = data;
-  } else if (IsBuffer(env, from)) {
-    void* data;
-    NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, &data, &slice.size_));
-    slice.data_ = static_cast<char*>(data);
-  }
-  return napi_ok;
-}
-
 /**
  * Base worker class. Handles the async work. Derived classes can override the
  * following virtual methods (listed in the order in which they're called):
@@ -322,9 +280,10 @@ struct Worker {
   virtual rocksdb::Status Execute(Database& database) = 0;
 
   virtual napi_status OnOk(napi_env env, napi_value callback) {
-    napi_value argv;
-    NAPI_STATUS_RETURN(napi_get_null(env, &argv));
-    return CallFunction(env, callback, 1, &argv);
+    napi_value argv[1];
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+
+    return CallFunction(env, callback, 1, &argv[0]);
   }
 
   virtual napi_status OnError(napi_env env, napi_value callback, napi_value err) {
@@ -466,22 +425,39 @@ struct BaseIterator {
     iterator_.reset();
   }
 
-  bool Valid() const { return iterator_->Valid(); }
+  bool Valid() const {
+    assert(iterator_);
+    return iterator_->Valid();
+  }
 
-  bool Increment() { return limit_ < 0 || ++count_ <= limit_; }
+  bool Increment() {
+    assert(iterator_);
+    return limit_ < 0 || ++count_ <= limit_;
+  }
 
   void Next() {
+    assert(iterator_);
+
     if (reverse_)
       iterator_->Prev();
     else
       iterator_->Next();
   }
 
-  rocksdb::Slice CurrentKey() const { return iterator_->key(); }
+  rocksdb::Slice CurrentKey() const {
+    assert(iterator_);
+    return iterator_->key();
+  }
 
-  rocksdb::Slice CurrentValue() const { return iterator_->value(); }
+  rocksdb::Slice CurrentValue() const {
+    assert(iterator_);
+    return iterator_->value();
+  }
 
-  rocksdb::Status Status() const { return iterator_->status(); }
+  rocksdb::Status Status() const {
+    assert(iterator_);
+    return iterator_->status();
+  }
 
   Database* database_;
   rocksdb::ColumnFamilyHandle* column_;
@@ -489,26 +465,27 @@ struct BaseIterator {
 
  private:
   void Init() {
-    rocksdb::ReadOptions options;
+    rocksdb::ReadOptions readOptions;
     if (upper_bound_) {
-      options.iterate_upper_bound = &*upper_bound_;
+      readOptions.iterate_upper_bound = &*upper_bound_;
     }
     if (lower_bound_) {
-      options.iterate_lower_bound = &*lower_bound_;
+      readOptions.iterate_lower_bound = &*lower_bound_;
     }
-    options.fill_cache = fillCache_;
-    options.snapshot = snapshot_.get();
-    options.async_io = true;
+    readOptions.fill_cache = fillCache_;
+    readOptions.snapshot = snapshot_.get();
+    readOptions.async_io = true;
+    readOptions.adaptive_readahead = true;
 
-    iterator_.reset(database_->db_->NewIterator(options, column_));
+    iterator_.reset(database_->db_->NewIterator(readOptions, column_));
   }
 
+  int count_ = 0;
   std::optional<rocksdb::PinnableSlice> lower_bound_;
   std::optional<rocksdb::PinnableSlice> upper_bound_;
   std::unique_ptr<rocksdb::Iterator> iterator_;
   const bool reverse_;
   const int limit_;
-  int count_ = 0;
   const bool fillCache_;
 };
 
@@ -526,7 +503,7 @@ struct Iterator final : public BaseIterator {
            const bool fillCache,
            const bool keyAsBuffer,
            const bool valueAsBuffer,
-           const int32_t highWaterMarkBytes,
+           const size_t highWaterMarkBytes,
            std::shared_ptr<const rocksdb::Snapshot> snapshot)
       : BaseIterator(database, column, reverse, lt, lte, gt, gte, limit, fillCache, snapshot),
         keys_(keys),
@@ -551,7 +528,7 @@ struct Iterator final : public BaseIterator {
   const bool values_;
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
-  const int32_t highWaterMarkBytes_;
+  const size_t highWaterMarkBytes_;
   bool first_ = true;
 
  private:
@@ -559,8 +536,12 @@ struct Iterator final : public BaseIterator {
 };
 
 struct Updates {
-  Updates(Database* database, const bool keyAsBuffer, const bool valueAsBuffer, int64_t seqNumber)
-      : database_(database), keyAsBuffer_(keyAsBuffer), valueAsBuffer_(valueAsBuffer), seqNumber_(seqNumber) {}
+  Updates(Database* database, bool values, bool keyAsBuffer, bool valueAsBuffer, int64_t seqNumber)
+      : database_(database),
+        values_(values),
+        keyAsBuffer_(keyAsBuffer),
+        valueAsBuffer_(valueAsBuffer),
+        seqNumber_(seqNumber) {}
 
   void Close() { iterator_.reset(); }
 
@@ -577,6 +558,7 @@ struct Updates {
   }
 
   Database* database_;
+  const bool values_;
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
   int64_t seqNumber_;
@@ -586,9 +568,22 @@ struct Updates {
   napi_ref ref_ = nullptr;
 };
 
-static rocksdb::ColumnFamilyHandle* GetColumnFamily(Database* database, napi_env env, napi_value options) {
-  auto column_opt = ExternalValueProperty<rocksdb::ColumnFamilyHandle>(env, options, "column");
-  return column_opt ? *column_opt : database->db_->DefaultColumnFamily();
+static napi_status GetColumnFamily(Database* database,
+                                   napi_env env,
+                                   napi_value options,
+                                   rocksdb::ColumnFamilyHandle** column) {
+  bool hasColumn = false;
+  NAPI_STATUS_RETURN(napi_has_named_property(env, options, "column", &hasColumn));
+
+  if (hasColumn) {
+    napi_value value = nullptr;
+    NAPI_STATUS_RETURN(napi_get_named_property(env, options, "column", &value));
+    NAPI_STATUS_RETURN(napi_get_value_external(env, value, reinterpret_cast<void**>(column)));
+  } else {
+    *column = database->db_->DefaultColumnFamily();
+  }
+
+  return napi_ok;
 }
 
 /**
@@ -670,19 +665,18 @@ struct OpenWorker final : public Worker {
   }
 
   napi_status OnOk(napi_env env, napi_value callback) override {
+    napi_value argv[2];
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+
     const auto size = database_->columns_.size();
-    napi_value result;
-    NAPI_STATUS_RETURN(napi_create_object(env, &result));
+    NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
 
     for (size_t n = 0; n < size; ++n) {
       napi_value column;
       NAPI_STATUS_RETURN(napi_create_external(env, database_->columns_[n], nullptr, nullptr, &column));
-      NAPI_STATUS_RETURN(napi_set_named_property(env, result, column_families_[n].name.c_str(), column));
+      NAPI_STATUS_RETURN(napi_set_named_property(env, argv[1], column_families_[n].name.c_str(), column));
     }
 
-    napi_value argv[2];
-    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-    argv[1] = result;
     return CallFunction(env, callback, 2, argv);
   }
 
@@ -692,7 +686,7 @@ struct OpenWorker final : public Worker {
 };
 
 template <typename T, typename U>
-napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
+rocksdb::Status InitOptions(napi_env env, T& columnOptions, const U& options) {
   const auto memtable_memory_budget = Uint32Property(env, options, "memtableMemoryBudget").value_or(256 * 1024 * 1024);
 
   const auto compaction = StringProperty(env, options, "compaction").value_or("level");
@@ -733,7 +727,21 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   if (columnOptions.compression == rocksdb::kZSTD) {
     columnOptions.compression_opts.max_dict_bytes = 16 * 1024;
     columnOptions.compression_opts.zstd_max_train_bytes = 16 * 1024 * 100;
-    // columnOptions.compression_opts.parallel_threads
+    // TODO (perf): compression_opts.parallel_threads
+  }
+
+  const auto prefixExtractorOpt = StringProperty(env, options, "prefixExtractor");
+  if (prefixExtractorOpt) {
+    rocksdb::ConfigOptions configOptions;
+    ROCKS_STATUS_RETURN(
+        rocksdb::SliceTransform::CreateFromString(configOptions, *prefixExtractorOpt, &columnOptions.prefix_extractor));
+  }
+
+  const auto comparatorOpt = StringProperty(env, options, "comparator");
+  if (comparatorOpt) {
+    rocksdb::ConfigOptions configOptions;
+    ROCKS_STATUS_RETURN(
+        rocksdb::Comparator::CreateFromString(configOptions, *comparatorOpt, &columnOptions.comparator));
   }
 
   const auto cacheSize = Uint32Property(env, options, "cacheSize").value_or(8 << 20);
@@ -772,37 +780,43 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
 
   columnOptions.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
 
-  return napi_ok;
+  return rocksdb::Status::OK();
 }
 
 NAPI_METHOD(db_open) {
   NAPI_ARGV(4);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto location = ToString(env, argv[1]);
-  const auto options = argv[2];
-  const auto callback = argv[3];
+  std::string location;
+  NAPI_STATUS_THROWS(ToString(env, argv[1], location));
 
   rocksdb::Options dbOptions;
 
-  dbOptions.IncreaseParallelism(Uint32Property(env, options, "parallelism")
+  dbOptions.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism")
                                     .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2)));
 
-  dbOptions.create_if_missing = BooleanProperty(env, options, "createIfMissing").value_or(true);
-  dbOptions.error_if_exists = BooleanProperty(env, options, "errorIfExists").value_or(false);
+  dbOptions.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
+  dbOptions.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
   dbOptions.avoid_unnecessary_blocking_io = true;
-  dbOptions.use_adaptive_mutex = true;
-  dbOptions.enable_pipelined_write = false;
-  dbOptions.max_background_jobs = Uint32Property(env, options, "maxBackgroundJobs")
+  dbOptions.write_dbid_to_manifest = true;
+  dbOptions.use_adaptive_mutex = true;       // We don't have soo many threads in the libuv thread pool...
+  dbOptions.enable_pipelined_write = false;  // We only write in the main thread...
+  dbOptions.max_background_jobs = Uint32Property(env, argv[2], "maxBackgroundJobs")
                                       .value_or(std::max<uint32_t>(2, std::thread::hardware_concurrency() / 8));
-  dbOptions.WAL_ttl_seconds = Uint32Property(env, options, "walTTL").value_or(0) / 1e3;
-  dbOptions.WAL_size_limit_MB = Uint32Property(env, options, "walSizeLimit").value_or(0) / 1e6;
+  dbOptions.WAL_ttl_seconds = Uint32Property(env, argv[2], "walTTL").value_or(0) / 1e3;
+  dbOptions.WAL_size_limit_MB = Uint32Property(env, argv[2], "walSizeLimit").value_or(0) / 1e6;
   dbOptions.create_missing_column_families = true;
-  dbOptions.unordered_write = BooleanProperty(env, options, "unorderedWrite").value_or(false);
+  dbOptions.unordered_write = BooleanProperty(env, argv[2], "unorderedWrite").value_or(false);
+  dbOptions.fail_if_options_file_error = true;
+  dbOptions.wal_compression = BooleanProperty(env, argv[2], "walCompression").value_or(false)
+                                  ? rocksdb::CompressionType::kZSTD
+                                  : rocksdb::CompressionType::kNoCompression;
 
-  const auto infoLogLevel = StringProperty(env, options, "infoLogLevel").value_or("");
+  // TODO (feat): dbOptions.listeners
+
+  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
   if (infoLogLevel.size() > 0) {
     rocksdb::InfoLogLevel lvl = {};
 
@@ -829,13 +843,16 @@ NAPI_METHOD(db_open) {
     dbOptions.info_log.reset(new NullLogger());
   }
 
-  NAPI_STATUS_THROWS(InitOptions(env, dbOptions, options));
+  ROCKS_STATUS_THROWS(InitOptions(env, dbOptions, argv[2]));
+
+  std::vector<rocksdb::ColumnFamilyDescriptor> columnsFamilies;
 
-  std::vector<rocksdb::ColumnFamilyDescriptor> column_families;
+  bool hasColumns;
+  NAPI_STATUS_THROWS(napi_has_named_property(env, argv[2], "columns", &hasColumns));
 
-  if (HasProperty(env, options, "columns")) {
+  if (hasColumns) {
     napi_value columns;
-    NAPI_STATUS_THROWS(napi_get_named_property(env, options, "columns", &columns));
+    NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "columns", &columns));
 
     napi_value keys;
     NAPI_STATUS_THROWS(napi_get_property_names(env, columns, &keys));
@@ -843,6 +860,7 @@ NAPI_METHOD(db_open) {
     uint32_t len;
     NAPI_STATUS_THROWS(napi_get_array_length(env, keys, &len));
 
+    columnsFamilies.resize(len);
     for (uint32_t n = 0; n < len; ++n) {
       napi_value key;
       NAPI_STATUS_THROWS(napi_get_element(env, keys, n, &key));
@@ -850,14 +868,13 @@ NAPI_METHOD(db_open) {
       napi_value column;
       NAPI_STATUS_THROWS(napi_get_property(env, columns, key, &column));
 
-      rocksdb::ColumnFamilyOptions columnOptions;
-      NAPI_STATUS_THROWS(InitOptions(env, columnOptions, column));
+      ROCKS_STATUS_THROWS(InitOptions(env, columnsFamilies[n].options, column));
 
-      column_families.emplace_back(ToString(env, key), columnOptions);
+      NAPI_STATUS_THROWS(ToString(env, key, columnsFamilies[n].name));
     }
   }
 
-  auto worker = new OpenWorker(env, database, callback, location, dbOptions, column_families);
+  auto worker = new OpenWorker(env, database, argv[3], location, dbOptions, columnsFamilies);
   worker->Queue(env);
 
   return 0;
@@ -884,11 +901,9 @@ NAPI_METHOD(db_close) {
   NAPI_ARGV(2);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto callback = argv[1];
-
-  auto worker = new CloseWorker(env, database, callback);
+  auto worker = new CloseWorker(env, database, argv[1]);
 
   if (!database->HasPriorityWork()) {
     worker->Queue(env);
@@ -899,8 +914,8 @@ NAPI_METHOD(db_close) {
   return 0;
 }
 
-struct UpdateNextWorker final : public rocksdb::WriteBatch::Handler, public Worker {
-  UpdateNextWorker(napi_env env, Updates* updates, napi_value callback)
+struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Worker {
+  UpdatesNextWorker(napi_env env, Updates* updates, napi_value callback)
       : Worker(env, updates->database_, callback, "rocks_level.db.get"), updates_(updates) {
     database_->IncrementPriorityWork(env);
   }
@@ -913,53 +928,45 @@ struct UpdateNextWorker final : public rocksdb::WriteBatch::Handler, public Work
       if (!status.ok()) {
         return status;
       }
+    } else {
+      updates_->iterator_->Next();
     }
 
     if (!updates_->iterator_->Valid()) {
-      return rocksdb::Status::OK();
+      return updates_->iterator_->status();
     }
 
     auto batch = updates_->iterator_->GetBatch();
 
     updates_->seqNumber_ = batch.sequence;
 
-    const auto status = batch.writeBatchPtr->Iterate(this);
-    if (!status.ok()) {
-      return status;
-    }
-
-    updates_->iterator_->Next();
+    cache_.reserve(batch.writeBatchPtr->Count() * 2);
 
-    return rocksdb::Status::OK();
+    return batch.writeBatchPtr->Iterate(this);
   }
 
   napi_status OnOk(napi_env env, napi_value callback) override {
-    const auto size = cache_.size();
-    napi_value result;
-
-    if (cache_.size()) {
-      NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &result));
+    napi_value argv[3];
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
 
-      for (size_t idx = 0; idx < cache_.size(); idx += 2) {
-        napi_value key;
-        napi_value val;
+    if (cache_.empty()) {
+      return CallFunction(env, callback, 1, argv);
+    }
 
-        NAPI_STATUS_RETURN(Convert(env, cache_[idx + 0], updates_->keyAsBuffer_, key));
-        NAPI_STATUS_RETURN(Convert(env, cache_[idx + 1], updates_->valueAsBuffer_, val));
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, cache_.size(), &argv[1]));
 
-        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));
-      }
+    for (size_t idx = 0; idx < cache_.size(); idx += 2) {
+      napi_value key;
+      NAPI_STATUS_RETURN(Convert(env, cache_[idx + 0], updates_->keyAsBuffer_, key));
+      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(idx + 0), key));
 
-      cache_.clear();
-    } else {
-      NAPI_STATUS_RETURN(napi_get_null(env, &result));
+      napi_value val;
+      NAPI_STATUS_RETURN(Convert(env, cache_[idx + 1], updates_->valueAsBuffer_, val));
+      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(idx + 1), val));
     }
 
-    napi_value argv[3];
-    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-    argv[1] = result;
     NAPI_STATUS_RETURN(napi_create_bigint_int64(env, updates_->seqNumber_, &argv[2]));
+
     return CallFunction(env, callback, 3, argv);
   }
 
@@ -970,7 +977,11 @@ struct UpdateNextWorker final : public rocksdb::WriteBatch::Handler, public Work
 
   void Put(const rocksdb::Slice& key, const rocksdb::Slice& value) override {
     cache_.emplace_back(key.ToString());
-    cache_.emplace_back(value.ToString());
+    if (updates_->values_) {
+      cache_.emplace_back(value.ToString());
+    } else {
+      cache_.emplace_back(std::nullopt);
+    }
   }
 
   void Delete(const rocksdb::Slice& key) override {
@@ -989,15 +1000,14 @@ NAPI_METHOD(updates_init) {
   NAPI_ARGV(2);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto options = argv[1];
-
-  const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
-  const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const auto seqNumber = Int64Property(env, options, "since").value_or(database->db_->GetLatestSequenceNumber());
+  const auto values = BooleanProperty(env, argv[1], "values").value_or(true);
+  const bool keyAsBuffer = EncodingIsBuffer(env, argv[1], "keyEncoding");
+  const bool valueAsBuffer = EncodingIsBuffer(env, argv[1], "valueEncoding");
+  const auto seqNumber = Int64Property(env, argv[1], "since").value_or(database->db_->GetLatestSequenceNumber());
 
-  auto updates = std::make_unique<Updates>(database, keyAsBuffer, valueAsBuffer, seqNumber);
+  auto updates = std::make_unique<Updates>(database, values, keyAsBuffer, valueAsBuffer, seqNumber);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));
@@ -1015,9 +1025,7 @@ NAPI_METHOD(updates_next) {
   Updates* updates;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&updates));
 
-  const auto callback = argv[1];
-
-  auto worker = new UpdateNextWorker(env, updates, callback);
+  auto worker = new UpdatesNextWorker(env, updates, argv[1]);
   worker->Queue(env);
 
   return 0;
@@ -1039,16 +1047,18 @@ NAPI_METHOD(db_put) {
   NAPI_ARGV(4);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  NapiSlice key;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
+  std::string key;
+  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
 
-  NapiSlice val;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], val));
+  std::string val;
+  NAPI_STATUS_THROWS(ToString(env, argv[2], val));
 
   rocksdb::WriteOptions writeOptions;
-  return ToError(env, database->db_->Put(writeOptions, key, val));
+  ROCKS_STATUS_THROWS(database->db_->Put(writeOptions, key, val));
+
+  return 0;
 }
 
 struct GetWorker final : public Worker {
@@ -1085,7 +1095,9 @@ struct GetWorker final : public Worker {
   napi_status OnOk(napi_env env, napi_value callback) override {
     napi_value argv[2];
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-    NAPI_STATUS_RETURN(Convert(env, value_, asBuffer_, argv[1]));
+
+    NAPI_STATUS_RETURN(Convert(env, &value_, asBuffer_, argv[1]));
+
     return CallFunction(env, callback, 2, argv);
   }
 
@@ -1107,16 +1119,18 @@ NAPI_METHOD(db_get) {
   NAPI_ARGV(4);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  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").value_or(true);
-  const auto column = GetColumnFamily(database, env, options);
-  const auto callback = argv[3];
+  std::string key;
+  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
 
-  auto worker = new GetWorker(env, database, column, callback, key, asBuffer, fillCache);
+  const auto asBuffer = EncodingIsBuffer(env, argv[2], "valueEncoding");
+  const auto fillCache = BooleanProperty(env, argv[2], "fillCache").value_or(true);
+
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[2], &column));
+
+  auto worker = new GetWorker(env, database, column, argv[3], key, asBuffer, fillCache);
   worker->Queue(env);
 
   return 0;
@@ -1129,21 +1143,26 @@ struct GetManyWorker final : public Worker {
                 std::vector<std::string> keys,
                 napi_value callback,
                 const bool valueAsBuffer,
-                const bool fillCache)
+                const bool fillCache,
+                const bool ignoreRangeDeletions)
       : Worker(env, database, callback, "leveldown.get.many"),
         column_(column),
         keys_(std::move(keys)),
         valueAsBuffer_(valueAsBuffer),
         fillCache_(fillCache),
-        snapshot_(database_->db_->GetSnapshot(), [=](const auto ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
+        ignoreRangeDeletions_(ignoreRangeDeletions),
+        snapshot_(database_->db_->GetSnapshot()) {
     database_->IncrementPriorityWork(env);
   }
 
+  ~GetManyWorker() { database_->db_->ReleaseSnapshot(snapshot_); }
+
   rocksdb::Status Execute(Database& database) override {
     rocksdb::ReadOptions readOptions;
     readOptions.fill_cache = fillCache_;
-    readOptions.snapshot = snapshot_.get();
+    readOptions.snapshot = snapshot_;
     readOptions.async_io = true;
+    readOptions.ignore_range_deletions = ignoreRangeDeletions_;
 
     std::vector<rocksdb::Slice> keys;
     keys.reserve(keys_.size());
@@ -1154,12 +1173,7 @@ struct GetManyWorker final : public Worker {
     statuses_.resize(keys.size());
     values_.resize(keys.size());
 
-    // database.db_->MultiGet(readOptions, column_, keys.size(), keys.data(), values_.data(), statuses_.data());
-
-    // TODO (fix): Use MultiGet once https://github.com/facebook/rocksdb/issues/10186 is resolved.
-    for (auto n = 0; n < keys.size(); ++n) {
-      statuses_[n] = database.db_->Get(readOptions, column_, keys[n], &values_[n]);
-    }
+    database.db_->MultiGet(readOptions, column_, keys.size(), keys.data(), values_.data(), statuses_.data());
 
     for (const auto& status : statuses_) {
       if (!status.ok() && !status.IsNotFound()) {
@@ -1171,24 +1185,23 @@ struct GetManyWorker final : public Worker {
   }
 
   napi_status OnOk(napi_env env, napi_value callback) override {
+    napi_value argv[2];
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+
     const auto size = values_.size();
 
-    napi_value array;
-    NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &array));
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &argv[1]));
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
       if (statuses_[idx].ok()) {
-        NAPI_STATUS_RETURN(Convert(env, values_[idx], valueAsBuffer_, element));
+        NAPI_STATUS_RETURN(Convert(env, &values_[idx], valueAsBuffer_, element));
       } else {
         NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
       }
-      NAPI_STATUS_RETURN(napi_set_element(env, array, static_cast<uint32_t>(idx), element));
+      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<uint32_t>(idx), element));
     }
 
-    napi_value argv[2];
-    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-    argv[1] = array;
     return CallFunction(env, callback, 2, argv);
   }
 
@@ -1204,37 +1217,38 @@ struct GetManyWorker final : public Worker {
   std::vector<rocksdb::Status> statuses_;
   const bool valueAsBuffer_;
   const bool fillCache_;
-  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
+  const bool ignoreRangeDeletions_;
+  const rocksdb::Snapshot* snapshot_;
 };
 
 NAPI_METHOD(db_get_many) {
   NAPI_ARGV(4);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   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++) {
+    keys.resize(length);
+    for (uint32_t n = 0; n < length; n++) {
       napi_value element;
-
-      NAPI_STATUS_THROWS(napi_get_element(env, argv[1], i, &element));
-      keys.push_back(ToString(env, element));
+      NAPI_STATUS_THROWS(napi_get_element(env, argv[1], n, &element));
+      NAPI_STATUS_THROWS(ToString(env, element, keys[n]));
     }
   }
 
-  const auto options = argv[2];
-  const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const bool fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
-  const auto column = GetColumnFamily(database, env, options);
-  const auto callback = argv[3];
+  const bool asBuffer = EncodingIsBuffer(env, argv[2], "valueEncoding");
+  const bool fillCache = BooleanProperty(env, argv[2], "fillCache").value_or(true);
+  const bool ignoreRangeDeletions = BooleanProperty(env, argv[2], "ignoreRangeDeletions").value_or(false);
 
-  auto worker = new GetManyWorker(env, database, column, std::move(keys), callback, asBuffer, fillCache);
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[2], &column));
+
+  auto worker =
+      new GetManyWorker(env, database, column, std::move(keys), argv[3], asBuffer, fillCache, ignoreRangeDeletions);
   worker->Queue(env);
 
   return 0;
@@ -1244,60 +1258,67 @@ NAPI_METHOD(db_del) {
   NAPI_ARGV(3);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  NapiSlice key;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
+  std::string key;
+  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
 
-  const auto options = argv[2];
-  const auto column = GetColumnFamily(database, env, options);
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[2], &column));
 
   rocksdb::WriteOptions writeOptions;
-  return ToError(env, database->db_->Delete(writeOptions, column, key));
+  ROCKS_STATUS_THROWS(database->db_->Delete(writeOptions, column, key));
+
+  return 0;
 }
 
 NAPI_METHOD(db_clear) {
   NAPI_ARGV(2);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto options = argv[1];
-  const auto reverse = BooleanProperty(env, options, "reverse").value_or(false);
-  const auto limit = Int32Property(env, options, "limit").value_or(-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 = 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");
-  const auto column = GetColumnFamily(database, env, options);
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column));
 
-  if (!reverse && limit == -1 && (lte || lt)) {
-    rocksdb::Slice begin;
+  auto lt = StringProperty(env, argv[1], "lt");
+  auto lte = StringProperty(env, argv[1], "lte");
+  auto gt = StringProperty(env, argv[1], "gt");
+  auto gte = StringProperty(env, argv[1], "gte");
+
+  if (limit == -1) {
+    rocksdb::PinnableSlice begin;
     if (gte) {
-      begin = *gte;
+      *begin.GetSelf() = std::move(*gte);
     } else if (gt) {
-      begin = *gt + '\0';
+      *begin.GetSelf() = std::move(*gt) + '\0';
     }
+    begin.PinSelf();
 
-    rocksdb::Slice end;
+    rocksdb::PinnableSlice end;
     if (lte) {
-      end = *lte + '\0';
+      *end.GetSelf() = std::move(*lte) + '\0';
     } else if (lt) {
-      end = *lt;
+      *end.GetSelf() = std::move(*lt);
     } else {
-      assert(false);
+      // HACK: Assume no key that starts with 0xFF is larger than 1MiB.
+      end.GetSelf()->resize(1e6);
+      memset(end.GetSelf()->data(), 255, end.GetSelf()->size());
     }
+    end.PinSelf();
 
-    if (begin.compare(end) > 0) {
-      return ToError(env, rocksdb::Status::OK());
+    if (begin.compare(end) < 0) {
+      rocksdb::WriteOptions writeOptions;
+      ROCKS_STATUS_THROWS(database->db_->DeleteRange(writeOptions, column, begin, end));
     }
 
-    rocksdb::WriteOptions writeOptions;
-    const auto status = database->db_->DeleteRange(writeOptions, column, begin, end);
-    return ToError(env, status);
+    return 0;
   } else {
-    // TODO (perf): Use DeleteRange.
+    // TODO (fix): Error handling.
+    // TODO (fix): This should be async...
 
     std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db_->GetSnapshot(),
                                                       [=](const auto ptr) { database->db_->ReleaseSnapshot(ptr); });
@@ -1305,9 +1326,6 @@ NAPI_METHOD(db_clear) {
 
     it.SeekToRange();
 
-    // TODO: add option
-    const uint32_t hwm = 16 * 1024;
-
     rocksdb::WriteBatch batch;
     rocksdb::WriteOptions writeOptions;
     rocksdb::Status status;
@@ -1315,7 +1333,7 @@ NAPI_METHOD(db_clear) {
     while (true) {
       size_t bytesRead = 0;
 
-      while (bytesRead <= hwm && it.Valid() && it.Increment()) {
+      while (bytesRead <= 16 * 1024 && it.Valid() && it.Increment()) {
         const auto key = it.CurrentKey();
         batch.Delete(column, key);
         bytesRead += key.size();
@@ -1337,7 +1355,11 @@ NAPI_METHOD(db_clear) {
 
     it.Close();
 
-    return ToError(env, status);
+    if (!status.ok()) {
+      ROCKS_STATUS_THROWS(status);
+    }
+
+    return 0;
   }
 }
 
@@ -1345,10 +1367,10 @@ NAPI_METHOD(db_get_property) {
   NAPI_ARGV(2);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  NapiSlice property;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], property));
+  std::string property;
+  NAPI_STATUS_THROWS(ToString(env, argv[1], property));
 
   std::string value;
   database->db_->GetProperty(property, &value);
@@ -1363,7 +1385,7 @@ NAPI_METHOD(iterator_init) {
   NAPI_ARGV(2);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   const auto options = argv[1];
   const auto reverse = BooleanProperty(env, options, "reverse").value_or(false);
@@ -1373,14 +1395,15 @@ NAPI_METHOD(iterator_init) {
   const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
   const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const auto limit = Int32Property(env, options, "limit").value_or(-1);
-  const auto highWaterMarkBytes = Int32Property(env, options, "highWaterMarkBytes").value_or(16 * 1024);
+  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes").value_or(64 * 1024);
 
   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");
 
-  const auto column = GetColumnFamily(database, env, options);
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, options, &column));
 
   std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db_->GetSnapshot(),
                                                     [=](const auto ptr) { database->db_->ReleaseSnapshot(ptr); });
@@ -1402,13 +1425,13 @@ NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
 
   Iterator* iterator;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
-  NapiSlice target;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], target));
+  std::string target;
+  NAPI_STATUS_THROWS(ToString(env, argv[1], target));
 
   iterator->first_ = true;
-  iterator->Seek(target);
+  iterator->Seek(target);  // TODO: Does seek causing blocking IO?
 
   return 0;
 }
@@ -1417,7 +1440,7 @@ NAPI_METHOD(iterator_close) {
   NAPI_ARGV(1);
 
   Iterator* iterator;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
   iterator->Detach(env);
   iterator->Close();
@@ -1429,7 +1452,7 @@ NAPI_METHOD(iterator_get_sequence) {
   NAPI_ARGV(1);
 
   Iterator* iterator;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
   const auto seq = iterator->snapshot_->GetSequenceNumber();
 
@@ -1478,8 +1501,7 @@ struct NextWorker final : public Worker {
         cache_.push_back(v.ToString());
       }
 
-      if ((iterator_->highWaterMarkBytes_ != -1 && bytesRead > static_cast<size_t>(iterator_->highWaterMarkBytes_)) ||
-          cache_.size() / 2 >= size_) {
+      if (bytesRead > iterator_->highWaterMarkBytes_ || cache_.size() / 2 >= size_) {
         finished_ = false;
         return rocksdb::Status::OK();
       }
@@ -1491,27 +1513,24 @@ struct NextWorker final : public Worker {
   }
 
   napi_status OnOk(napi_env env, napi_value callback) override {
-    const auto size = cache_.size();
-    napi_value result;
-    NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &result));
+    napi_value argv[3];
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, cache_.size(), &argv[1]));
 
-    for (size_t n = 0; n < size; n += 2) {
+    for (size_t n = 0; n < cache_.size(); n += 2) {
       napi_value key;
       napi_value val;
 
       NAPI_STATUS_RETURN(Convert(env, cache_[n + 0], iterator_->keyAsBuffer_, key));
       NAPI_STATUS_RETURN(Convert(env, cache_[n + 1], iterator_->valueAsBuffer_, val));
 
-      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(n + 0), key));
-      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(n + 1), val));
+      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(n + 0), key));
+      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(n + 1), val));
     }
 
-    cache_.clear();
-
-    napi_value argv[3];
-    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-    argv[1] = result;
     NAPI_STATUS_RETURN(napi_get_boolean(env, finished_, &argv[2]));
+
     return CallFunction(env, callback, 3, argv);
   }
 
@@ -1526,14 +1545,12 @@ NAPI_METHOD(iterator_nextv) {
   NAPI_ARGV(3);
 
   Iterator* iterator;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
   uint32_t size;
   NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &size));
 
-  const auto callback = argv[2];
-
-  auto worker = new NextWorker(env, iterator, size, callback);
+  auto worker = new NextWorker(env, iterator, size, argv[2]);
   worker->Queue(env);
 
   return 0;
@@ -1543,51 +1560,66 @@ NAPI_METHOD(batch_do) {
   NAPI_ARGV(3);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
-
-  const auto operations = argv[1];
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   rocksdb::WriteBatch batch;
 
+  std::string type;
+  std::string key;
+  std::string value;
+
   uint32_t length;
-  NAPI_STATUS_THROWS(napi_get_array_length(env, operations, &length));
+  NAPI_STATUS_THROWS(napi_get_array_length(env, argv[1], &length));
 
   for (uint32_t i = 0; i < length; i++) {
     napi_value element;
-    NAPI_STATUS_THROWS(napi_get_element(env, operations, i, &element));
+    NAPI_STATUS_THROWS(napi_get_element(env, argv[1], i, &element));
 
-    NapiSlice type;
-    NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "type"), type));
+    napi_value typeProperty;
+    NAPI_STATUS_THROWS(napi_get_named_property(env, element, "type", &typeProperty));
+    NAPI_STATUS_THROWS(ToString(env, typeProperty, type));
 
-    const auto column = GetColumnFamily(database, env, element);
+    rocksdb::ColumnFamilyHandle* column;
+    NAPI_STATUS_THROWS(GetColumnFamily(database, env, element, &column));
 
     if (type == "del") {
-      NapiSlice key;
-      NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "key"), key));
-      batch.Delete(column, key);
+      napi_value keyProperty;
+      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "key", &keyProperty));
+      NAPI_STATUS_THROWS(ToString(env, keyProperty, key));
+
+      ROCKS_STATUS_THROWS(batch.Delete(column, key));
     } else if (type == "put") {
-      NapiSlice key;
-      NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "key"), key));
-      NapiSlice value;
-      NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "value"), value));
-      batch.Put(column, key, value);
+      napi_value keyProperty;
+      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "key", &keyProperty));
+      NAPI_STATUS_THROWS(ToString(env, keyProperty, key));
+
+      napi_value valueProperty;
+      NAPI_STATUS_THROWS(napi_get_named_property(env, element, "value", &valueProperty));
+      NAPI_STATUS_THROWS(ToString(env, valueProperty, value));
+
+      ROCKS_STATUS_THROWS(batch.Put(column, key, value));
+    } else {
+      ROCKS_STATUS_THROWS(rocksdb::Status::InvalidArgument());
     }
   }
 
   rocksdb::WriteOptions writeOptions;
-  return ToError(env, database->db_->Write(writeOptions, &batch));
+  ROCKS_STATUS_THROWS(database->db_->Write(writeOptions, &batch));
+
+  return 0;
 }
 
 NAPI_METHOD(batch_init) {
   NAPI_ARGV(1);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   auto batch = new rocksdb::WriteBatch();
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, batch, Finalize<rocksdb::WriteBatch>, batch, &result));
+
   return result;
 }
 
@@ -1595,21 +1627,21 @@ NAPI_METHOD(batch_put) {
   NAPI_ARGV(5);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], (void**)(&batch)));
 
-  NapiSlice key;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], key));
+  std::string key;
+  NAPI_STATUS_THROWS(ToString(env, argv[2], key));
 
-  NapiSlice val;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[3], val));
+  std::string val;
+  NAPI_STATUS_THROWS(ToString(env, argv[3], val));
 
-  const auto options = argv[4];
-  const auto column = GetColumnFamily(database, env, options);
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[4], &column));
 
-  batch->Put(column, key, val);
+  ROCKS_STATUS_THROWS(batch->Put(column, key, val));
 
   return 0;
 }
@@ -1618,18 +1650,18 @@ NAPI_METHOD(batch_del) {
   NAPI_ARGV(4);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
-  NapiSlice key;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], key));
+  std::string key;
+  NAPI_STATUS_THROWS(ToString(env, argv[2], key));
 
-  const auto options = argv[3];
-  const auto column = GetColumnFamily(database, env, options);
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[3], &column));
 
-  batch->Delete(column, key);
+  ROCKS_STATUS_THROWS(batch->Delete(column, key));
 
   return 0;
 }
@@ -1649,13 +1681,15 @@ NAPI_METHOD(batch_write) {
   NAPI_ARGV(3);
 
   Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
   rocksdb::WriteOptions writeOptions;
-  return ToError(env, database->db_->Write(writeOptions, batch));
+  ROCKS_STATUS_THROWS(database->db_->Write(writeOptions, batch));
+
+  return 0;
 }
 
 NAPI_INIT() {