@nxtedition/rocksdb 7.0.21 → 7.0.22

package/binding.cc

@@ -133,8 +133,7 @@ static std::optional<int64_t> Int64Property(napi_env env, napi_value obj, const
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int64_t result;
-    bool lossless;
-    napi_get_value_bigint_int64(env, value, &result, &lossless);
+    napi_get_value_int64(env, value, &result);
     return result;
   }
 
@@ -538,7 +537,24 @@ struct Iterator final : public BaseIterator {
 };
 
 struct Updates {
-  Updates(Database* database, int64_t seqNumber) : database_(database), seqNumber_(seqNumber) {}
+  Updates(Database* database,
+          int64_t seqNumber,
+          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?
+      }
+    }
+  }
 
   void Close() { iterator_.reset(); }
 
@@ -557,6 +573,10 @@ struct Updates {
   Database* database_;
   int64_t seqNumber_;
   std::unique_ptr<rocksdb::TransactionLogIterator> iterator_;
+  bool keys_;
+  bool values_;
+  bool data_;
+  std::optional<uint32_t> column_family_id_;
 
  private:
   napi_ref ref_ = nullptr;
@@ -941,49 +961,33 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
 
     updates_->seqNumber_ = batch.sequence;
 
+    count_ = batch.writeBatchPtr->Count();
     cache_.reserve(batch.writeBatchPtr->Count() * 4);
 
     return batch.writeBatchPtr->Iterate(this);
   }
 
   napi_status OnOk(napi_env env, napi_value callback) override {
-    napi_value argv[3];
+    napi_value argv[4];
+
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
 
     if (cache_.empty()) {
       return CallFunction(env, callback, 1, argv);
     }
 
-    NAPI_STATUS_RETURN(napi_create_array_with_length(env, cache_.size() * 4, &argv[1]));
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, cache_.size(), &argv[1]));
     for (size_t idx = 0; idx < cache_.size(); idx++) {
-      napi_value op;
-      NAPI_STATUS_RETURN(Convert(env, std::get<0>(cache_[idx]), false, op));
-      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(idx * 4 + 0), op));
-
-      napi_value key;
-      NAPI_STATUS_RETURN(Convert(env, std::get<1>(cache_[idx]), false, key));
-      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(idx * 4 + 1), key));
-
       napi_value val;
-      NAPI_STATUS_RETURN(Convert(env, std::get<2>(cache_[idx]), false, val));
-      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(idx * 4 + 2), val));
-
-      auto column_family_id = std::get<3>(cache_[idx]);
-      auto columns = database_->columns_;
-      auto columnIt = std::find_if(columns.begin(), columns.end(),
-                                   [&](const auto& handle) { return handle->GetID() == column_family_id; });
-      napi_value column;
-      if (columnIt != columns.end()) {
-        NAPI_STATUS_RETURN(napi_create_external(env, *columnIt, nullptr, nullptr, &column));
-      } else {
-        NAPI_STATUS_RETURN(napi_get_null(env, &column));
-      }
-      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(idx * 4 + 3), column));
+      NAPI_STATUS_RETURN(Convert(env, cache_[idx], false, val));
+      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], idx, val));
     }
 
-    NAPI_STATUS_RETURN(napi_create_bigint_int64(env, updates_->seqNumber_, &argv[2]));
+    NAPI_STATUS_RETURN(napi_create_int64(env, updates_->seqNumber_, &argv[2]));
 
-    return CallFunction(env, callback, 3, argv);
+    NAPI_STATUS_RETURN(napi_create_int64(env, count_, &argv[3]));
+
+    return CallFunction(env, callback, 4, argv);
   }
 
   void Destroy(napi_env env) override {
@@ -991,28 +995,83 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
     Worker::Destroy(env);
   }
 
+  std::optional<std::string> GetColumnName(uint32_t column_family_id) {
+    if (column_family_id == 0) {
+      return "default";
+    }
+    auto columns = database_->columns_;
+    auto columnIt = std::find_if(columns.begin(), columns.end(),
+                                 [&](const auto& handle) { return handle->GetID() == column_family_id; });
+    return columnIt == columns.end() ? std::nullopt : std::optional<std::string>((*columnIt)->GetName());
+  }
+
   rocksdb::Status PutCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
-    cache_.emplace_back("put", key.ToStringView(), value.ToStringView(), column_family_id);
+    if (updates_->column_family_id_ && *updates_->column_family_id_ != 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));
     return rocksdb::Status::OK();
   }
 
   rocksdb::Status DeleteCF(uint32_t column_family_id, const rocksdb::Slice& key) override {
-    cache_.emplace_back("del", key.ToStringView(), std::nullopt, column_family_id);
+    if (updates_->column_family_id_ && *updates_->column_family_id_ != 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));
     return rocksdb::Status::OK();
   }
 
   rocksdb::Status MergeCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
-    cache_.emplace_back("merge", key.ToStringView(), value.ToStringView(), column_family_id);
+    if (updates_->column_family_id_ && *updates_->column_family_id_ != 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));
     return rocksdb::Status::OK();
   }
 
-  void LogData(const rocksdb::Slice& data) override { cache_.emplace_back("data", std::nullopt, data.ToStringView()); }
+  void LogData(const rocksdb::Slice& data) override {
+    if (updates_->data_) {
+      cache_.emplace_back("data");
+      cache_.emplace_back(std::nullopt);
+      cache_.emplace_back(data.ToStringView());
+      cache_.emplace_back(std::nullopt);
+    }
+  }
 
   bool Continue() override { return true; }
 
  private:
-  std::vector<std::tuple<std::optional<std::string>, std::optional<std::string>, std::optional<std::string>, uint32_t>>
-      cache_;
+  size_t count_;
+  std::vector<std::optional<std::string>> cache_;
   Updates* updates_;
 };
 
@@ -1023,8 +1082,12 @@ NAPI_METHOD(updates_init) {
   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");
 
-  auto updates = std::make_unique<Updates>(database, seqNumber);
+  auto updates = std::make_unique<Updates>(database, seqNumber, keys, values, data, column);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));

package/index.js

@@ -193,10 +193,7 @@ class RocksLevel extends AbstractLevel {
 
     class Updates {
       constructor (db, options) {
-        this.context = binding.updates_init(db[kContext], {
-          ...options,
-          since: BigInt(options.since || 0)
-        })
+        this.context = binding.updates_init(db[kContext], options)
         this.closed = false
         this.promise = null
         this.db = db
@@ -208,12 +205,12 @@ class RocksLevel extends AbstractLevel {
           return {}
         }
 
-        this.promise = new Promise(resolve => binding.updates_next(this.context, (err, rows, sequence) => {
+        this.promise = new Promise(resolve => binding.updates_next(this.context, (err, rows, sequence, count) => {
           this.promise = null
           if (err) {
             resolve(Promise.reject(err))
           } else {
-            resolve({ rows, sequence: Number(sequence) })
+            resolve({ rows, sequence, count })
           }
         }))
 

package/package.json

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