@nxtedition/rocksdb 11.0.5 → 11.0.7

package/binding.cc

@@ -643,7 +643,6 @@ NAPI_METHOD(db_get_location) {
   return result;
 }
 
-
 NAPI_METHOD(db_query) {
   NAPI_ARGV(2);
 
@@ -997,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;
@@ -1039,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()) {
@@ -1055,11 +1051,89 @@ 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];
+
+  struct State {
+    std::vector<rocksdb::Status> statuses;
+    std::vector<rocksdb::PinnableSlice> values;
+    std::vector<rocksdb::PinnableSlice> keys;
+  } state;
+
+  state.keys.resize(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, state.keys[n]));
+  }
+
+  runAsync(std::move(state),
+      "leveldown.get_many", env, callback,
+      [=](auto& state) {
+        rocksdb::ReadOptions readOptions;
+        readOptions.fill_cache = fillCache;
+        readOptions.async_io = true;
+        readOptions.optimize_multiget_for_io = true;
+        readOptions.value_size_soft_limit = highWaterMarkBytes;
+
+        std::vector<rocksdb::Slice> keys{count};
+        for (uint32_t n = 0; n < count; n++) {
+          keys[n] = state.keys[n];
+        }
+
+        state.statuses.resize(count);
+        state.values.resize(count);
+
+        database->db->MultiGet(readOptions, column, count, keys.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) {
@@ -1264,10 +1338,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));
@@ -1287,10 +1359,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));
@@ -1313,10 +1383,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));
@@ -1339,7 +1407,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)));
@@ -1347,14 +1415,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;
@@ -1421,6 +1486,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/chained-batch.js

@@ -72,6 +72,7 @@ class ChainedBatch extends AbstractChainedBatch {
   }
 
   _close (callback) {
+    binding.batch_clear(this[kBatchContext])
     process.nextTick(callback)
   }
 

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.5",
+  "version": "11.0.7",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",