@nxtedition/rocksdb 7.0.29 → 7.0.32

package/binding.cc

@@ -823,16 +823,14 @@ NAPI_METHOD(db_open) {
   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, 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);
 
   // TODO (feat): dbOptions.listeners
@@ -1108,15 +1106,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);
+  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));
 
   rocksdb::ColumnFamilyHandle* column;
   NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column, false));
 
-  auto updates = std::make_unique<Updates>(database, seqNumber, keys, values, data, column);
+  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));
@@ -1891,6 +1904,68 @@ NAPI_METHOD(db_flush_wal) {
   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);
@@ -1914,6 +1989,8 @@ NAPI_INIT() {
   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);

package/index.js

@@ -6,6 +6,7 @@ const fs = require('fs')
 const binding = require('./binding')
 const { ChainedBatch } = require('./chained-batch')
 const { Iterator } = require('./iterator')
+const os = require('os')
 
 const kContext = Symbol('context')
 const kColumns = Symbol('columns')
@@ -24,6 +25,21 @@ class RocksLevel extends AbstractLevel {
       throw new TypeError("The first argument 'location' must be a non-empty string")
     }
 
+    options = {
+      ...options, // TODO (fix): Other defaults...
+      parallelism: options?.parallelism ?? Math.max(1, os.cpus().length / 2),
+      createIfMissing: options?.createIfMissing ?? true,
+      errorIfExists: options?.errorIfExists ?? false,
+      walTTL: options?.walTTL ?? 0,
+      walSizeLimit: options?.walSizeLimit ?? 0,
+      walCompression: options?.walCompression ?? false,
+      unorderedWrite: options?.unorderedWrite ?? false,
+      manualWalFlush: options?.manualWalFlush ?? false,
+      infoLogLevel: options?.infoLogLevel ?? ''
+    }
+
+    // TODO (fix): Check options.
+
     super({
       encodings: {
         buffer: true,
@@ -145,7 +161,33 @@ 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)
   }
 
@@ -195,6 +237,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.29",
+  "version": "7.0.32",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",