@nxtedition/rocksdb 7.0.28 → 7.0.31

package/binding.cc

@@ -10,11 +10,11 @@
 #include <rocksdb/db.h>
 #include <rocksdb/env.h>
 #include <rocksdb/filter_policy.h>
+#include <rocksdb/merge_operator.h>
 #include <rocksdb/options.h>
 #include <rocksdb/slice_transform.h>
 #include <rocksdb/table.h>
 #include <rocksdb/write_batch.h>
-#include <rocksdb/merge_operator.h>
 
 #include <array>
 #include <memory>
@@ -543,19 +543,8 @@ struct Updates {
           bool keys,
           bool values,
           bool data,
-          const std::optional<std::string>& column)
-      : database_(database), seqNumber_(seqNumber), keys_(keys), values_(values), data_(data) {
-    if (column) {
-      auto columns = database->columns_;
-      auto columnIt = std::find_if(columns.begin(), columns.end(),
-                                   [&](const auto& handle) { return handle->GetName() == *column; });
-      if (columnIt != columns.end()) {
-        column_family_id_ = (*columnIt)->GetID();
-      } else {
-        // TODO: Throw?
-      }
-    }
-  }
+          const rocksdb::ColumnFamilyHandle* column)
+      : database_(database), seqNumber_(seqNumber), keys_(keys), values_(values), data_(data), column_(column) {}
 
   void Close() { iterator_.reset(); }
 
@@ -577,7 +566,7 @@ struct Updates {
   bool keys_;
   bool values_;
   bool data_;
-  std::optional<uint32_t> column_family_id_;
+  const rocksdb::ColumnFamilyHandle* column_;
 
  private:
   napi_ref ref_ = nullptr;
@@ -586,7 +575,8 @@ struct Updates {
 static napi_status GetColumnFamily(Database* database,
                                    napi_env env,
                                    napi_value options,
-                                   rocksdb::ColumnFamilyHandle** column) {
+                                   rocksdb::ColumnFamilyHandle** column,
+                                   bool fallback = true) {
   bool hasColumn = false;
   NAPI_STATUS_RETURN(napi_has_named_property(env, options, "column", &hasColumn));
 
@@ -594,8 +584,10 @@ static napi_status GetColumnFamily(Database* database,
     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 {
+  } else if (fallback) {
     *column = database->db_->DefaultColumnFamily();
+  } else {
+    *column = nullptr;
   }
 
   return napi_ok;
@@ -822,8 +814,9 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options dbOptions;
 
-  dbOptions.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism")
-                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2)));
+  const auto parallelismValue = Uint32Property(env, argv[2], "parallelism")
+                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2));
+  dbOptions.IncreaseParallelism(parallelismValue);
 
   dbOptions.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
   dbOptions.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
@@ -835,12 +828,53 @@ NAPI_METHOD(db_open) {
                                       .value_or(std::max<uint32_t>(2, std::thread::hardware_concurrency() / 8));
   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, 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;
+  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.manual_wal_flush = BooleanProperty(env, argv[2], "manualWalFlush").value_or(false);
+
+  napi_value ret;
+  NAPI_STATUS_THROWS(napi_create_object(env, &ret));
+  {
+    napi_value parallelism;
+    NAPI_STATUS_THROWS(napi_create_int64(env, parallelismValue, &parallelism));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "parallelism", parallelism));
+
+    napi_value createIfMissing;
+    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.create_if_missing, &createIfMissing));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "createIfMissing", createIfMissing));
+
+    napi_value errorIfExists;
+    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.error_if_exists, &errorIfExists));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "errorIfExists", errorIfExists));
+
+    napi_value maxBackgroundJobs;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.max_background_jobs, &maxBackgroundJobs));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "maxBackgroundJobs", maxBackgroundJobs));
+
+    napi_value walTTL;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.WAL_ttl_seconds * 1e3, &walTTL));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walTTL", walTTL));
+
+    napi_value walSizeLimit;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.WAL_size_limit_MB * 1e6, &walSizeLimit));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walSizeLimit", walSizeLimit));
+
+    napi_value walCompression;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.wal_compression, &walCompression));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "walCompression", walCompression));
+
+    napi_value unorderedWrite;
+    NAPI_STATUS_THROWS(napi_get_boolean(env, dbOptions.error_if_exists, &unorderedWrite));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "unorderedWrite", unorderedWrite));
+
+    napi_value manualWalFlush;
+    NAPI_STATUS_THROWS(napi_create_int64(env, dbOptions.manual_wal_flush, &manualWalFlush));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "manualWalFlush", manualWalFlush));
+  }
 
   // TODO (feat): dbOptions.listeners
 
@@ -905,7 +939,7 @@ NAPI_METHOD(db_open) {
   auto worker = new OpenWorker(env, database, argv[3], location, dbOptions, columnsFamilies);
   worker->Queue(env);
 
-  return 0;
+  return ret;
 }
 
 struct CloseWorker final : public Worker {
@@ -1013,57 +1047,82 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
   }
 
   rocksdb::Status PutCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
-    if (updates_->column_family_id_ && *updates_->column_family_id_ != column_family_id) {
+    if (updates_->column_ && updates_->column_->GetID() != column_family_id) {
       return rocksdb::Status::OK();
     }
+
     cache_.emplace_back("put");
+
     if (updates_->keys_) {
       cache_.emplace_back(key.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
+
     if (updates_->values_) {
       cache_.emplace_back(value.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
-    cache_.emplace_back(GetColumnName(column_family_id));
+
+    if (!updates_->column_) {
+      cache_.emplace_back(GetColumnName(column_family_id));
+    } else {
+      cache_.emplace_back(std::nullopt);
+    }
+
     return rocksdb::Status::OK();
   }
 
   rocksdb::Status DeleteCF(uint32_t column_family_id, const rocksdb::Slice& key) override {
-    if (updates_->column_family_id_ && *updates_->column_family_id_ != column_family_id) {
+    if (updates_->column_ && updates_->column_->GetID() != column_family_id) {
       return rocksdb::Status::OK();
     }
+
     cache_.emplace_back("del");
+
     if (updates_->keys_) {
       cache_.emplace_back(key.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
+
     cache_.emplace_back(std::nullopt);
-    cache_.emplace_back(GetColumnName(column_family_id));
+
+    if (!updates_->column_) {
+      cache_.emplace_back(GetColumnName(column_family_id));
+    } else {
+      cache_.emplace_back(std::nullopt);
+    }
+
     return rocksdb::Status::OK();
   }
 
   rocksdb::Status MergeCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
-    if (updates_->column_family_id_ && *updates_->column_family_id_ != column_family_id) {
+    if (updates_->column_ && updates_->column_->GetID() != column_family_id) {
       return rocksdb::Status::OK();
     }
+
     cache_.emplace_back("put");
+
     if (updates_->keys_) {
       cache_.emplace_back(key.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
+
     if (updates_->values_) {
       cache_.emplace_back(value.ToStringView());
     } else {
       cache_.emplace_back(std::nullopt);
     }
-    if (!updates_->column_family_id_) {
+
+    if (!updates_->column_) {
       cache_.emplace_back(GetColumnName(column_family_id));
+    } else {
+      cache_.emplace_back(std::nullopt);
     }
+
     return rocksdb::Status::OK();
   }
 
@@ -1090,13 +1149,30 @@ NAPI_METHOD(updates_init) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  const auto seqNumber = Int64Property(env, argv[1], "since").value_or(database->db_->GetLatestSequenceNumber());
-  const auto keys = BooleanProperty(env, argv[1], "keys").value_or(true);
-  const auto values = BooleanProperty(env, argv[1], "values").value_or(true);
-  const auto data = BooleanProperty(env, argv[1], "data").value_or(true);
-  const auto column = StringProperty(env, argv[1], "column");
+  napi_value sinceProperty;
+  int64_t since;
+  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "since", &sinceProperty));
+  NAPI_STATUS_THROWS(napi_get_value_int64(env, sinceProperty, &since));
+
+  napi_value keysProperty;
+  bool keys;
+  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "keys", &keysProperty));
+  NAPI_STATUS_THROWS(napi_get_value_bool(env, keysProperty, &keys));
+
+  napi_value valuesProperty;
+  bool values;
+  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "values", &valuesProperty));
+  NAPI_STATUS_THROWS(napi_get_value_bool(env, valuesProperty, &values));
+
+  napi_value dataProperty;
+  bool data;
+  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "data", &dataProperty));
+  NAPI_STATUS_THROWS(napi_get_value_bool(env, dataProperty, &data));
 
-  auto updates = std::make_unique<Updates>(database, seqNumber, keys, values, data, column);
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column, false));
+
+  auto updates = std::make_unique<Updates>(database, since, keys, values, data, column);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));
@@ -1858,6 +1934,81 @@ NAPI_METHOD(batch_merge) {
   return 0;
 }
 
+NAPI_METHOD(db_flush_wal) {
+  NAPI_ARGV(2);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  const auto flush = BooleanProperty(env, argv[1], "flush").value_or(false);
+
+  ROCKS_STATUS_THROWS(database->db_->FlushWAL(flush));
+
+  return 0;
+}
+
+napi_status FromLogFile(napi_env env, const auto& file, napi_value* obj) {
+  NAPI_STATUS_RETURN(napi_create_object(env, obj));
+
+  napi_value pathName;
+  NAPI_STATUS_RETURN(napi_create_string_utf8(env, file->PathName().c_str(), NAPI_AUTO_LENGTH, &pathName));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "pathName", pathName));
+
+  napi_value logNumber;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->LogNumber(), &logNumber));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "logNumber", logNumber));
+
+  napi_value type;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->Type(), &type));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "type", type));
+
+  napi_value startSequence;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->StartSequence(), &startSequence));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "startSequence", startSequence));
+
+  napi_value sizeFileBytes;
+  NAPI_STATUS_RETURN(napi_create_int64(env, file->SizeFileBytes(), &sizeFileBytes));
+  NAPI_STATUS_RETURN(napi_set_named_property(env, *obj, "sizeFileBytes", sizeFileBytes));
+
+  return napi_ok;
+}
+
+NAPI_METHOD(db_get_sorted_wal_files) {
+  NAPI_ARGV(1);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  rocksdb::VectorLogPtr files;
+  ROCKS_STATUS_THROWS(database->db_->GetSortedWalFiles(files));
+
+  napi_value ret;
+  NAPI_STATUS_THROWS(napi_create_array_with_length(env, files.size(), &ret));
+
+  for (size_t n = 0; n < files.size(); ++n) {
+    napi_value obj;
+    NAPI_STATUS_THROWS(FromLogFile(env, files[n], &obj));
+    NAPI_STATUS_THROWS(napi_set_element(env, ret, n, obj));
+  }
+
+  return ret;
+}
+
+NAPI_METHOD(db_get_current_wal_file) {
+  NAPI_ARGV(1);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  std::unique_ptr<rocksdb::LogFile> file;
+  ROCKS_STATUS_THROWS(database->db_->GetCurrentWalFile(&file));
+
+  napi_value ret;
+  NAPI_STATUS_THROWS(FromLogFile(env, file, &ret));
+
+  return ret;
+}
+
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
@@ -1880,6 +2031,10 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(updates_close);
   NAPI_EXPORT_FUNCTION(updates_next);
 
+  NAPI_EXPORT_FUNCTION(db_flush_wal);
+  NAPI_EXPORT_FUNCTION(db_get_sorted_wal_files);
+  NAPI_EXPORT_FUNCTION(db_get_current_wal_file);
+
   NAPI_EXPORT_FUNCTION(batch_do);
   NAPI_EXPORT_FUNCTION(batch_init);
   NAPI_EXPORT_FUNCTION(batch_put);

package/index.js

@@ -10,6 +10,7 @@ const { Iterator } = require('./iterator')
 const kContext = Symbol('context')
 const kColumns = Symbol('columns')
 const kLocation = Symbol('location')
+const kOptions = Symbol('options')
 
 class RocksLevel extends AbstractLevel {
   constructor (location, options, _) {
@@ -43,6 +44,10 @@ class RocksLevel extends AbstractLevel {
     this[kColumns] = {}
   }
 
+  get options () {
+    return this[kOptions]
+  }
+
   get sequence () {
     return Number(binding.db_get_latest_sequence(this[kContext]))
   }
@@ -67,10 +72,10 @@ class RocksLevel extends AbstractLevel {
     if (options.createIfMissing) {
       fs.mkdir(this[kLocation], { recursive: true }, (err) => {
         if (err) return callback(err)
-        binding.db_open(this[kContext], this[kLocation], options, onOpen)
+        this[kOptions] = binding.db_open(this[kContext], this[kLocation], options, onOpen)
       })
     } else {
-      binding.db_open(this[kContext], this[kLocation], options, onOpen)
+      this[kOptions] = binding.db_open(this[kContext], this[kLocation], options, onOpen)
     }
   }
 
@@ -145,6 +150,36 @@ class RocksLevel extends AbstractLevel {
     return binding.db_get_property(this[kContext], property)
   }
 
+  async getCurrentWALFile () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    return binding.db_get_current_wal_file(this[kContext])
+  }
+
+  async getSortedWALFiles () {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    return binding.db_get_sorted_wal_files(this[kContext])
+  }
+
+  async flushWAL (options) {
+    if (this.status !== 'open') {
+      throw new ModuleError('Database is not open', {
+        code: 'LEVEL_DATABASE_NOT_OPEN'
+      })
+    }
+
+    binding.db_flush_wal(this[kContext], options)
+  }
+
   async query (options) {
     if (this.status !== 'open') {
       throw new ModuleError('Database is not open', {
@@ -191,6 +226,29 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
+    options = {
+      since: options?.since ?? 0,
+      keys: options?.keys ?? true,
+      values: options?.values ?? true,
+      data: options?.data ?? true
+    }
+
+    if (typeof options.since !== 'number') {
+      throw new TypeError("'since' must be nully or a number")
+    }
+
+    if (typeof options.keys !== 'boolean') {
+      throw new TypeError("'keys' must be nully or a boolean")
+    }
+
+    if (typeof options.values !== 'boolean') {
+      throw new TypeError("'values' must be nully or a boolean")
+    }
+
+    if (typeof options.data !== 'boolean') {
+      throw new TypeError("'data' must be nully or a boolean")
+    }
+
     class Updates {
       constructor (db, options) {
         this.context = binding.updates_init(db[kContext], options)

package/package.json

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