@nxtedition/rocksdb 11.0.4 → 11.0.6

package/binding.cc

@@ -307,12 +307,15 @@ struct BaseIterator : public Closable {
     }
 
     rocksdb::ReadOptions readOptions;
+
     if (upper_bound_) {
       readOptions.iterate_upper_bound = &*upper_bound_;
     }
+
     if (lower_bound_) {
       readOptions.iterate_lower_bound = &*lower_bound_;
     }
+
     readOptions.fill_cache = fillCache;
     readOptions.async_io = true;
     readOptions.adaptive_readahead = true;
@@ -329,9 +332,15 @@ struct BaseIterator : public Closable {
     database_->Attach(this);
   }
 
-  virtual ~BaseIterator() { assert(!iterator_); }
+  virtual ~BaseIterator() {
+    if (iterator_) {
+      database_->Detach(this);
+    }
+  }
 
   virtual void Seek(const rocksdb::Slice& target) {
+    assert(iterator_);
+
     if ((upper_bound_ && target.compare(*upper_bound_) >= 0) || (lower_bound_ && target.compare(*lower_bound_) < 0)) {
       // TODO (fix): Why is this required? Seek should handle it?
       // https://github.com/facebook/rocksdb/issues/9904
@@ -347,8 +356,10 @@ struct BaseIterator : public Closable {
   }
 
   virtual rocksdb::Status Close() override {
-    iterator_.reset();
-    database_->Detach(this);
+    if (iterator_) {
+      iterator_.reset();
+      database_->Detach(this);
+    }
     return rocksdb::Status::OK();
   }
 
@@ -632,7 +643,6 @@ NAPI_METHOD(db_get_location) {
   return result;
 }
 
-
 NAPI_METHOD(db_query) {
   NAPI_ARGV(2);
 
@@ -986,7 +996,7 @@ NAPI_METHOD(db_close) {
   return 0;
 }
 
-NAPI_METHOD(db_get_many) {
+NAPI_METHOD(db_get_many_sync) {
   NAPI_ARGV(3);
 
   Database* database;
@@ -1028,9 +1038,6 @@ NAPI_METHOD(db_get_many) {
   napi_value rows;
   NAPI_STATUS_THROWS(napi_create_array_with_length(env, count, &rows));
 
-  napi_value finished;
-  NAPI_STATUS_THROWS(napi_get_boolean(env, true, &finished));
-
   for (auto n = 0; n < count; n++) {
     napi_value row;
     if (statuses[n].IsNotFound()) {
@@ -1044,11 +1051,88 @@ NAPI_METHOD(db_get_many) {
     NAPI_STATUS_THROWS(napi_set_element(env, rows, n, row));
   }
 
-  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, "finished", finished));
-  return ret;
+  return rows;
+}
+
+NAPI_METHOD(db_get_many) {
+  NAPI_ARGV(4);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  uint32_t count;
+  NAPI_STATUS_THROWS(napi_get_array_length(env, argv[1], &count));
+
+  bool fillCache = true;
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "fillCache", fillCache));
+
+  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "column", column));
+
+  Encoding valueEncoding = Encoding::Buffer;
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "valueEncoding", valueEncoding));
+
+  int32_t highWaterMarkBytes = std::numeric_limits<int32_t>::max();
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "highWaterMarkBytes", highWaterMarkBytes));
+
+  auto callback = argv[3];
+
+  std::vector<rocksdb::PinnableSlice> keys{count};
+
+  for (uint32_t n = 0; n < count; n++) {
+    napi_value element;
+    NAPI_STATUS_THROWS(napi_get_element(env, argv[1], n, &element));
+    NAPI_STATUS_THROWS(GetValue(env, element, keys[n]));
+  }
+
+  struct State {
+    std::vector<rocksdb::Status> statuses;
+    std::vector<rocksdb::PinnableSlice> values;
+  };
+
+  runAsync<State>(
+      "leveldown.get_many", env, callback,
+      [=, keys = std::move(keys)](auto& state) {
+        std::vector<rocksdb::Slice> keys2{count};
+        for (uint32_t n = 0; n < count; n++) {
+          keys2[n] = keys[n];
+        }
+
+        rocksdb::ReadOptions readOptions;
+        readOptions.fill_cache = fillCache;
+        readOptions.async_io = true;
+        readOptions.optimize_multiget_for_io = true;
+        readOptions.value_size_soft_limit = highWaterMarkBytes;
+
+        state.statuses.resize(count);
+        state.values.resize(count);
+
+        database->db->MultiGet(readOptions, column, count, keys2.data(), state.values.data(), state.statuses.data());
+
+        return rocksdb::Status::OK();
+      },
+      [=](auto& state, auto env, auto& argv) {
+        argv.resize(2);
+
+        NAPI_STATUS_RETURN(napi_create_array_with_length(env, count, &argv[1]));
+
+        for (auto n = 0; n < count; n++) {
+          napi_value row;
+          if (state.statuses[n].IsNotFound()) {
+            NAPI_STATUS_RETURN(napi_get_undefined(env, &row));
+          } else if (state.statuses[n].IsAborted()) {
+            NAPI_STATUS_RETURN(napi_get_null(env, &row));
+          } else {
+            ROCKS_STATUS_RETURN_NAPI(state.statuses[n]);
+            NAPI_STATUS_RETURN(Convert(env, &state.values[n], valueEncoding, row));
+          }
+          NAPI_STATUS_RETURN(napi_set_element(env, argv[1], n, row));
+        }
+
+        return napi_ok;
+      });
+
+  return 0;
 }
 
 NAPI_METHOD(db_clear) {
@@ -1253,10 +1337,8 @@ NAPI_METHOD(batch_put) {
   rocksdb::Slice val;
   NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
-  const auto options = argv[3];
-
   rocksdb::ColumnFamilyHandle* column = nullptr;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
+  NAPI_STATUS_THROWS(GetProperty(env, argv[3], "column", column));
 
   if (column) {
     ROCKS_STATUS_THROWS_NAPI(batch->Put(column, key, val));
@@ -1276,10 +1358,8 @@ NAPI_METHOD(batch_del) {
   rocksdb::Slice key;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
-  const auto options = argv[2];
-
   rocksdb::ColumnFamilyHandle* column = nullptr;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "column", column));
 
   if (column) {
     ROCKS_STATUS_THROWS_NAPI(batch->Delete(column, key));
@@ -1302,10 +1382,8 @@ NAPI_METHOD(batch_merge) {
   rocksdb::Slice val;
   NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
-  const auto options = argv[3];
-
   rocksdb::ColumnFamilyHandle* column = nullptr;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
+  NAPI_STATUS_THROWS(GetProperty(env, argv[3], "column", column));
 
   if (column) {
     ROCKS_STATUS_THROWS_NAPI(batch->Merge(column, key, val));
@@ -1328,7 +1406,7 @@ NAPI_METHOD(batch_clear) {
 }
 
 NAPI_METHOD(batch_write) {
-  NAPI_ARGV(4);
+  NAPI_ARGV(3);
 
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
@@ -1336,14 +1414,11 @@ NAPI_METHOD(batch_write) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
-  auto options = argv[2];
-  auto callback = argv[3];
-
   bool sync = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "sync", sync));
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "sync", sync));
 
   bool lowPriority = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "lowPriority", lowPriority));
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "lowPriority", lowPriority));
 
   rocksdb::WriteOptions writeOptions;
   writeOptions.sync = sync;
@@ -1410,6 +1485,7 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_get_location);
   NAPI_EXPORT_FUNCTION(db_close);
   NAPI_EXPORT_FUNCTION(db_get_many);
+  NAPI_EXPORT_FUNCTION(db_get_many_sync);
   NAPI_EXPORT_FUNCTION(db_clear);
   NAPI_EXPORT_FUNCTION(db_get_property);
   NAPI_EXPORT_FUNCTION(db_get_latest_sequence);

package/index.js

@@ -152,11 +152,14 @@ class RocksLevel extends AbstractLevel {
   }
 
   _getMany (keys, options, callback) {
+    if (keys.some(key => typeof key === 'string')) {
+      keys = keys.map(key => typeof key === 'string' ? Buffer.from(key) : key)
+    }
+
     callback = fromCallback(callback, kPromise)
 
     try {
-      // TODO (fix): highWaterMark and limit with async between...
-      process.nextTick(callback, null, this._getManySync(keys, options ?? kEmpty))
+      binding.db_get_many(this[kContext], keys, options ?? kEmpty, callback)
     } catch (err) {
       process.nextTick(callback, err)
     }
@@ -169,9 +172,7 @@ class RocksLevel extends AbstractLevel {
       keys = keys.map(key => typeof key === 'string' ? Buffer.from(key) : key)
     }
 
-    const { rows, finished } = binding.db_get_many(this[kContext], keys, options ?? kEmpty)
-    assert(finished)
-    return rows
+    return binding.db_get_many_sync(this[kContext], keys, options ?? kEmpty)
   }
 
   _del (key, options, callback) {

package/package.json

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