@nxtedition/rocksdb 7.0.31 → 7.0.34

package/binding.cc

@@ -544,7 +544,13 @@ struct Updates {
           bool values,
           bool data,
           const rocksdb::ColumnFamilyHandle* column)
-      : database_(database), seqNumber_(seqNumber), keys_(keys), values_(values), data_(data), column_(column) {}
+      : database_(database),
+        sequence_(seqNumber),
+        start_(seqNumber),
+        keys_(keys),
+        values_(values),
+        data_(data),
+        column_(column) {}
 
   void Close() { iterator_.reset(); }
 
@@ -561,7 +567,8 @@ struct Updates {
   }
 
   Database* database_;
-  int64_t seqNumber_;
+  int64_t sequence_;
+  int64_t start_;
   std::unique_ptr<rocksdb::TransactionLogIterator> iterator_;
   bool keys_;
   bool values_;
@@ -814,9 +821,8 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options dbOptions;
 
-  const auto parallelismValue = Uint32Property(env, argv[2], "parallelism")
-                                    .value_or(std::max<uint32_t>(1, std::thread::hardware_concurrency() / 2));
-  dbOptions.IncreaseParallelism(parallelismValue);
+  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, argv[2], "createIfMissing").value_or(true);
   dbOptions.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
@@ -824,8 +830,6 @@ 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.wal_compression = BooleanProperty(env, argv[2], "walCompression").value_or(false)
@@ -836,46 +840,6 @@ NAPI_METHOD(db_open) {
   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
 
   const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
@@ -939,7 +903,7 @@ NAPI_METHOD(db_open) {
   auto worker = new OpenWorker(env, database, argv[3], location, dbOptions, columnsFamilies);
   worker->Queue(env);
 
-  return ret;
+  return 0;
 }
 
 struct CloseWorker final : public Worker {
@@ -983,24 +947,23 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
   }
 
   rocksdb::Status Execute(Database& database) override {
-    rocksdb::TransactionLogIterator::ReadOptions options;
-
     if (!updates_->iterator_) {
-      const auto status = database_->db_->GetUpdatesSince(updates_->seqNumber_, &updates_->iterator_, options);
+      rocksdb::TransactionLogIterator::ReadOptions options;
+      const auto status = database_->db_->GetUpdatesSince(updates_->sequence_, &updates_->iterator_, options);
       if (!status.ok()) {
         return status;
       }
-    } else {
+    } else if (updates_->iterator_->Valid()) {
       updates_->iterator_->Next();
     }
 
-    if (!updates_->iterator_->Valid()) {
+    if (!updates_->iterator_->Valid() || !updates_->iterator_->status().ok()) {
       return updates_->iterator_->status();
     }
 
     auto batch = updates_->iterator_->GetBatch();
 
-    updates_->seqNumber_ = batch.sequence;
+    updates_->sequence_ = batch.sequence;
 
     count_ = batch.writeBatchPtr->Count();
     cache_.reserve(batch.writeBatchPtr->Count() * 4);
@@ -1009,7 +972,7 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
   }
 
   napi_status OnOk(napi_env env, napi_value callback) override {
-    napi_value argv[4];
+    napi_value argv[5];
 
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
 
@@ -1024,11 +987,13 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
       NAPI_STATUS_RETURN(napi_set_element(env, argv[1], idx, val));
     }
 
-    NAPI_STATUS_RETURN(napi_create_int64(env, updates_->seqNumber_, &argv[2]));
+    NAPI_STATUS_RETURN(napi_create_int64(env, updates_->sequence_, &argv[2]));
 
     NAPI_STATUS_RETURN(napi_create_int64(env, count_, &argv[3]));
 
-    return CallFunction(env, callback, 4, argv);
+    NAPI_STATUS_RETURN(napi_create_int64(env, updates_->start_, &argv[4]));
+
+    return CallFunction(env, callback, 5, argv);
   }
 
   void Destroy(napi_env env) override {
@@ -1169,6 +1134,7 @@ NAPI_METHOD(updates_init) {
   NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "data", &dataProperty));
   NAPI_STATUS_THROWS(napi_get_value_bool(env, dataProperty, &data));
 
+  // TODO (fix): Needs to support { column: null }
   rocksdb::ColumnFamilyHandle* column;
   NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column, false));
 

package/index.js

@@ -6,11 +6,11 @@ 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')
 const kLocation = Symbol('location')
-const kOptions = Symbol('options')
 
 class RocksLevel extends AbstractLevel {
   constructor (location, options, _) {
@@ -25,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,
@@ -44,10 +59,6 @@ class RocksLevel extends AbstractLevel {
     this[kColumns] = {}
   }
 
-  get options () {
-    return this[kOptions]
-  }
-
   get sequence () {
     return Number(binding.db_get_latest_sequence(this[kContext]))
   }
@@ -72,10 +83,10 @@ class RocksLevel extends AbstractLevel {
     if (options.createIfMissing) {
       fs.mkdir(this[kLocation], { recursive: true }, (err) => {
         if (err) return callback(err)
-        this[kOptions] = binding.db_open(this[kContext], this[kLocation], options, onOpen)
+        binding.db_open(this[kContext], this[kLocation], options, onOpen)
       })
     } else {
-      this[kOptions] = binding.db_open(this[kContext], this[kLocation], options, onOpen)
+      binding.db_open(this[kContext], this[kLocation], options, onOpen)
     }
   }
 
@@ -249,6 +260,15 @@ class RocksLevel extends AbstractLevel {
       throw new TypeError("'data' must be nully or a boolean")
     }
 
+    if (options.column !== undefined && typeof options.column !== 'object') {
+      throw new TypeError("'column' must be nully or a object")
+    }
+
+    // HACK: We don't properly check for nully column in binding.
+    if (!options.column) {
+      delete options.column
+    }
+
     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.31",
+  "version": "7.0.34",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",