@nxtedition/rocksdb 13.4.4 → 13.5.1

package/binding.cc

@@ -38,6 +38,7 @@ class NullLogger : public rocksdb::Logger {
 
 struct Database;
 class Iterator;
+class Updates;
 
 struct ColumnFamily {
   rocksdb::ColumnFamilyHandle* handle;
@@ -1120,6 +1121,8 @@ NAPI_METHOD(db_open) {
     NAPI_STATUS_THROWS(GetProperty(env, options, "parallelism", parallelism));
     dbOptions.IncreaseParallelism(parallelism);
 
+    NAPI_STATUS_THROWS(GetProperty(env, options, "walDir", dbOptions.wal_dir));
+
     uint32_t walTTL = 0;
     NAPI_STATUS_THROWS(GetProperty(env, options, "walTTL", walTTL));
     dbOptions.WAL_ttl_seconds = walTTL / 1e3;
@@ -1725,6 +1728,20 @@ NAPI_METHOD(batch_put) {
   return 0;
 }
 
+NAPI_METHOD(batch_put_log_data) {
+  NAPI_ARGV(3);
+
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
+
+  rocksdb::Slice blob;
+  NAPI_STATUS_THROWS(GetValue(env, argv[1], blob));
+
+  ROCKS_STATUS_THROWS_NAPI(batch->PutLogData(blob));
+
+  return 0;
+}
+
 NAPI_METHOD(batch_del) {
   NAPI_ARGV(3);
 
@@ -1853,6 +1870,142 @@ NAPI_METHOD(batch_iterate) {
   return result;
 }
 
+struct Updates : public BatchIterator, public Closable {
+  Updates(Database* database,
+          const int64_t since,
+          const bool keys,
+          const bool values,
+          const bool data,
+          const rocksdb::ColumnFamilyHandle* column,
+          const Encoding keyEncoding,
+          const Encoding valueEncoding)
+      : BatchIterator(database, keys, values, data, column, keyEncoding, valueEncoding),
+        database_(database),
+        start_(since) {
+    database_->Attach(this);
+  }
+
+  virtual ~Updates() {
+    if (iterator_) {
+      database_->Detach(this);
+    }
+  }
+
+  rocksdb::Status Close() override {
+    if (iterator_) {
+      iterator_.reset();
+      database_->Detach(this);
+    }
+    return rocksdb::Status::OK();
+  }
+
+  Database* database_;
+  int64_t start_;
+  std::unique_ptr<rocksdb::TransactionLogIterator> iterator_;
+
+ private:
+  napi_ref ref_ = nullptr;
+};
+
+NAPI_METHOD(updates_init) {
+  NAPI_ARGV(2);
+
+  try {
+    Database* database;
+    NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+    const auto options = argv[1];
+
+    int64_t since = 0;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "since", since));
+
+    bool keys = true;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "keys", keys));
+
+    bool values = true;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "values", values));
+
+    bool data = true;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "data", data));
+
+    Encoding keyEncoding = Encoding::String;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
+
+    Encoding valueEncoding = Encoding::String;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
+
+    rocksdb::ColumnFamilyHandle* column = nullptr;
+    NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
+
+    napi_value result;
+    auto updates =
+      std::unique_ptr<Updates>(new Updates(database, since, keys, values, data, column, keyEncoding, valueEncoding));
+
+    NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));
+    updates.release();
+
+    return result;
+  } catch (const std::exception& e) {
+    napi_throw_error(env, nullptr, e.what());
+    return nullptr;
+  }
+}
+
+NAPI_METHOD(updates_next) {
+  NAPI_ARGV(2);
+
+  try {
+    Updates* updates;
+    NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&updates)));
+
+    if (!updates->iterator_) {
+      rocksdb::TransactionLogIterator::ReadOptions options;
+      ROCKS_STATUS_THROWS_NAPI(updates->database_->db->GetUpdatesSince(updates->start_, &updates->iterator_, options));
+    }
+
+    ROCKS_STATUS_THROWS_NAPI(updates->iterator_->status());
+
+    if (!updates->iterator_->Valid()) {
+      return 0;
+    }
+
+    auto batchResult = updates->iterator_->GetBatch();
+
+    napi_value rows;
+    napi_value sequence;
+
+    NAPI_STATUS_THROWS(updates->Iterate(env, *batchResult.writeBatchPtr, &rows));
+    NAPI_STATUS_THROWS(napi_create_int64(env, batchResult.sequence, &sequence));
+
+    ROCKS_STATUS_THROWS_NAPI(updates->iterator_->status());
+    updates->iterator_->Next();
+
+    napi_value ret;
+    NAPI_STATUS_THROWS(napi_create_object(env, &ret));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "rows", rows));
+    NAPI_STATUS_THROWS(napi_set_named_property(env, ret, "seq", sequence));
+    return ret;
+  } catch (const std::exception& e) {
+    napi_throw_error(env, nullptr, e.what());
+    return nullptr;
+  }
+}
+
+NAPI_METHOD(updates_close) {
+  NAPI_ARGV(1);
+
+  try {
+    Updates* updates;
+    NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&updates)));
+
+    ROCKS_STATUS_THROWS_NAPI(updates->Close());
+    return 0;
+  } catch (const std::exception& e) {
+    napi_throw_error(env, nullptr, e.what());
+    return nullptr;
+  }
+}
+
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
@@ -1873,8 +2026,13 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(iterator_nextv);
   NAPI_EXPORT_FUNCTION(iterator_nextv_sync);
 
+  NAPI_EXPORT_FUNCTION(updates_init);
+  NAPI_EXPORT_FUNCTION(updates_close);
+  NAPI_EXPORT_FUNCTION(updates_next);
+
   NAPI_EXPORT_FUNCTION(batch_init);
   NAPI_EXPORT_FUNCTION(batch_put);
+  NAPI_EXPORT_FUNCTION(batch_put_log_data);
   NAPI_EXPORT_FUNCTION(batch_del);
   NAPI_EXPORT_FUNCTION(batch_clear);
   NAPI_EXPORT_FUNCTION(batch_write);

package/chained-batch.js

@@ -41,6 +41,20 @@ class ChainedBatch extends AbstractChainedBatch {
     binding.batch_put(this[kBatchContext], key, value, options ?? EMPTY)
   }
 
+  _putLogData (blob) {
+    assert(this[kBatchContext])
+
+    if (blob === null || blob === undefined) {
+      throw new ModuleError('Blob cannot be null or undefined', {
+        code: 'LEVEL_INVALID_KEY'
+      })
+    }
+
+    blob = typeof blob === 'string' ? Buffer.from(blob) : blob
+
+    binding.batch_put_log_data(this[kBatchContext], blob)
+  }
+
   _del (key, options) {
     assert(this[kBatchContext])
 

package/index.js

@@ -269,6 +269,21 @@ class RocksLevel extends AbstractLevel {
 
     return binding.db_query(this[kContext], options ?? kEmpty)
   }
+
+  async * updates (options) {
+    const handle = binding.updates_init(this[kContext], options)
+    try {
+      while (true) {
+        const value = binding.updates_next(handle)
+        if (!value) {
+          break
+        }
+        yield value
+      }
+    } finally {
+      binding.updates_close(handle)
+    }
+  }
 }
 
 exports.RocksLevel = RocksLevel

package/package.json

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