@nxtedition/rocksdb 7.0.7 → 7.0.10

package/binding.cc

@@ -6,12 +6,15 @@
 
 #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>
+#include <rocksdb/filter_policy.h>
 
 #include <array>
 #include <memory>
@@ -40,6 +43,14 @@ struct Updates;
     }                            \
   }
 
+#define ROCKS_STATUS_RETURN(call) \
+  {                               \
+    auto _status = (call);        \
+    if (!_status.ok()) {          \
+      return _status;             \
+    }                             \
+  }
+
 #define ROCKS_STATUS_THROWS(call)             \
   {                                           \
     auto _status = (call);                    \
@@ -187,6 +198,8 @@ static napi_value ToError(napi_env env, const rocksdb::Status& status) {
     return CreateError(env, "LEVEL_NOT_FOUND", msg);
   } else if (status.IsCorruption()) {
     return CreateError(env, "LEVEL_CORRUPTION", msg);
+  } else if (status.IsTryAgain()) {
+    return CreateError(env, "LEVEL_TRYAGAIN", msg);
   } else if (status.IsIOError()) {
     if (msg.find("IO error: lock ") != std::string::npos) {  // env_posix.cc
       return CreateError(env, "LEVEL_LOCKED", msg);
@@ -676,7 +689,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");
@@ -720,6 +733,20 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
     // 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);
 
   rocksdb::BlockBasedTableOptions tableOptions;
@@ -748,6 +775,13 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
     tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
   }
 
+  const auto filterPolicyOpt = StringProperty(env, options, "filterPolicy");
+  if (filterPolicyOpt) {
+    rocksdb::ConfigOptions configOptions;
+    ROCKS_STATUS_RETURN(
+        rocksdb::FilterPolicy::CreateFromString(configOptions, *filterPolicyOpt, &tableOptions.filter_policy));
+  }
+
   tableOptions.block_size = Uint32Property(env, options, "blockSize").value_or(4096);
   tableOptions.block_restart_interval = Uint32Property(env, options, "blockRestartInterval").value_or(16);
   tableOptions.format_version = 5;
@@ -756,7 +790,7 @@ 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) {
@@ -776,6 +810,7 @@ NAPI_METHOD(db_open) {
   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.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")
@@ -784,6 +819,12 @@ NAPI_METHOD(db_open) {
   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, 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;
+
+  // TODO (feat): dbOptions.listeners
 
   const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
   if (infoLogLevel.size() > 0) {
@@ -812,7 +853,7 @@ NAPI_METHOD(db_open) {
     dbOptions.info_log.reset(new NullLogger());
   }
 
-  NAPI_STATUS_THROWS(InitOptions(env, dbOptions, argv[2]));
+  ROCKS_STATUS_THROWS(InitOptions(env, dbOptions, argv[2]));
 
   std::vector<rocksdb::ColumnFamilyDescriptor> columnsFamilies;
 
@@ -837,7 +878,7 @@ NAPI_METHOD(db_open) {
       napi_value column;
       NAPI_STATUS_THROWS(napi_get_property(env, columns, key, &column));
 
-      NAPI_STATUS_THROWS(InitOptions(env, columnsFamilies[n].options, column));
+      ROCKS_STATUS_THROWS(InitOptions(env, columnsFamilies[n].options, column));
 
       NAPI_STATUS_THROWS(ToString(env, key, columnsFamilies[n].name));
     }
@@ -1112,22 +1153,30 @@ 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() {
+    if (snapshot_) {
+      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.adaptive_readahead = true;
+    readOptions.ignore_range_deletions = ignoreRangeDeletions_;
 
     std::vector<rocksdb::Slice> keys;
     keys.reserve(keys_.size());
@@ -1182,7 +1231,8 @@ 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) {
@@ -1206,11 +1256,13 @@ NAPI_METHOD(db_get_many) {
 
   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);
 
   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);
+  auto worker =
+      new GetManyWorker(env, database, column, std::move(keys), argv[3], asBuffer, fillCache, ignoreRangeDeletions);
   worker->Queue(env);
 
   return 0;
@@ -1421,7 +1473,7 @@ NAPI_METHOD(iterator_get_sequence) {
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_bigint_int64(env, seq, &result));
 
-  return 0;
+  return result;
 }
 
 struct NextWorker final : public Worker {

package/iterator.js

@@ -29,6 +29,10 @@ class Iterator extends AbstractIterator {
     this[kPosition] = 0
   }
 
+  get sequence () {
+    return binding.iterator_get_sequence(this[kContext])
+  }
+
   _seek (target) {
     if (target.length === 0) {
       throw new Error('cannot seek() to an empty target')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "7.0.7",
+  "version": "7.0.10",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",