@nxtedition/rocksdb 5.2.37 → 5.2.40

package/binding.cc

@@ -18,6 +18,7 @@
 #include <optional>
 #include <set>
 #include <string>
+#include <thread>
 #include <vector>
 
 class NullLogger : public rocksdb::Logger {
@@ -38,15 +39,6 @@ struct Iterator;
     }                            \
   }
 
-#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));
@@ -71,12 +63,6 @@ static bool IsBuffer(napi_env env, napi_value value) {
   return isBuffer;
 }
 
-static bool IsObject(napi_env env, napi_value value) {
-  napi_valuetype type;
-  napi_typeof(env, value, &type);
-  return type == napi_object;
-}
-
 static napi_value CreateError(napi_env env, const std::optional<std::string_view>& code, const std::string_view& msg) {
   napi_value codeValue = nullptr;
   if (code) {
@@ -226,38 +212,39 @@ napi_status Convert(napi_env env, std::string s, bool asBuffer, napi_value& resu
 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);
+    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);
   }
 }
 
 struct NapiSlice : public rocksdb::Slice {
-  NapiSlice(napi_env env, napi_value from) {
-    if (IsString(env, from)) {
-      NAPI_STATUS_THROWS_VOID(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_STATUS_THROWS_VOID(napi_get_value_string_utf8(env, from, data, size_ + 1, &size_));
-      data_ = data;
-    } else if (IsBuffer(env, from)) {
-      void* data;
-      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, 1024> stack_;
+  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):
@@ -587,7 +574,7 @@ struct OpenWorker final : public Worker {
         location_(location) {}
 
   rocksdb::Status Execute(Database& database) override {
-    rocksdb::DB* db;
+    rocksdb::DB* db = nullptr;
     const auto status = readOnly_ ? rocksdb::DB::OpenForReadOnly(options_, location_, &db)
                                   : rocksdb::DB::Open(options_, location_, &db);
     database.db_.reset(db);
@@ -605,7 +592,8 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options options;
 
-  options.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism").value_or(4));
+  options.IncreaseParallelism(
+      Uint32Property(env, argv[2], "parallelism").value_or(std::thread::hardware_concurrency() / 2));
 
   const auto location = ToString(env, argv[1]);
   options.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
@@ -613,6 +601,12 @@ NAPI_METHOD(db_open) {
   options.compression = BooleanProperty(env, argv[2], "compression").value_or((true)) ? rocksdb::kSnappyCompression
                                                                                       : rocksdb::kNoCompression;
   options.use_adaptive_mutex = true;
+  options.enable_pipelined_write = true;
+  options.max_background_jobs =
+      Uint32Property(env, argv[2], "maxBackgroundJobs").value_or(std::thread::hardware_concurrency() / 4);
+
+  // TODO: Consider direct IO (https://github.com/facebook/rocksdb/wiki/Direct-IO) once
+  // secondary compressed cache is stable.
 
   const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
   if (infoLogLevel.size() > 0) {
@@ -648,22 +642,24 @@ NAPI_METHOD(db_open) {
 
   if (cacheSize) {
     tableOptions.block_cache = rocksdb::NewLRUCache(cacheSize);
+    tableOptions.cache_index_and_filter_blocks =
+        BooleanProperty(env, argv[2], "cacheIndexAndFilterBlocks").value_or(true);
   } else {
     tableOptions.no_block_cache = true;
+    tableOptions.cache_index_and_filter_blocks = false;
   }
 
   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.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
   tableOptions.format_version = 5;
-  tableOptions.checksum = rocksdb::kxxHash64;
+  tableOptions.checksum = rocksdb::kXXH3;
+  tableOptions.optimize_filters_for_memory = BooleanProperty(env, argv[2], "optimizeFiltersForMemory").value_or(true);
 
   options.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
 
   const auto callback = argv[3];
 
-  NAPI_PENDING_EXCEPTION();
-
   auto worker = new OpenWorker(env, database, callback, location, options, readOnly);
   worker->Queue(env);
 
@@ -702,10 +698,11 @@ NAPI_METHOD(db_put) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-  const auto val = NapiSlice(env, argv[2]);
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice val;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], val));
 
   rocksdb::WriteOptions options;
   return ToError(env, database->db_->Put(options, key, val));
@@ -770,8 +767,6 @@ NAPI_METHOD(db_get) {
   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);
 
@@ -781,12 +776,12 @@ NAPI_METHOD(db_get) {
 struct GetManyWorker final : public Worker {
   GetManyWorker(napi_env env,
                 Database* database,
-                const std::vector<std::string>& keys,
+                std::vector<std::string> keys,
                 napi_value callback,
                 const bool valueAsBuffer,
                 const bool fillCache)
       : Worker(env, database, callback, "leveldown.get.many"),
-        keys_(keys),
+        keys_(std::move(keys)),
         valueAsBuffer_(valueAsBuffer),
         fillCache_(fillCache),
         snapshot_(database_->db_->GetSnapshot(),
@@ -888,9 +883,7 @@ NAPI_METHOD(db_get_many) {
   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);
+  auto worker = new GetManyWorker(env, database, std::move(keys), callback, asBuffer, fillCache);
   worker->Queue(env);
 
   return 0;
@@ -900,9 +893,8 @@ NAPI_METHOD(db_del) {
   NAPI_ARGV(3);
   NAPI_DB_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
   rocksdb::WriteOptions options;
   return ToError(env, database->db_->Delete(options, key));
@@ -965,9 +957,8 @@ NAPI_METHOD(db_get_property) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  const auto property = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice property;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], property));
 
   std::string value;
   database->db_->GetProperty(property, &value);
@@ -1014,9 +1005,8 @@ NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  const auto target = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice target;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], target));
 
   iterator->first_ = true;
   iterator->Seek(target);
@@ -1144,23 +1134,18 @@ NAPI_METHOD(batch_do) {
     napi_value element;
     NAPI_STATUS_THROWS(napi_get_element(env, operations, i, &element));
 
-    if (!IsObject(env, element))
-      continue;
-
-    const auto type = StringProperty(env, element, "type");
+    NapiSlice type;
+    NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "type"), type));
 
     if (type == "del") {
-      const auto key = NapiSlice(env, GetProperty(env, element, "key"));
-
-      NAPI_PENDING_EXCEPTION();
-
+      NapiSlice key;
+      NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "key"), key));
       batch.Delete(key);
     } else if (type == "put") {
-      const auto key = NapiSlice(env, GetProperty(env, element, "key"));
-      const auto value = NapiSlice(env, GetProperty(env, element, "value"));
-
-      NAPI_PENDING_EXCEPTION();
-
+      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(key, value);
     }
   }
@@ -1184,10 +1169,11 @@ NAPI_METHOD(batch_put) {
   NAPI_ARGV(3);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-  const auto val = NapiSlice(env, argv[2]);
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice val;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], val));
 
   batch->Put(key, val);
 
@@ -1198,9 +1184,8 @@ NAPI_METHOD(batch_del) {
   NAPI_ARGV(2);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = NapiSlice(env, argv[1]);
-
-  NAPI_PENDING_EXCEPTION();
+  NapiSlice key;
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
   batch->Delete(key);