@nxtedition/rocksdb 10.3.8 → 11.0.1

package/binding.cc

@@ -284,15 +284,11 @@ struct BaseIterator : public Closable {
                const std::optional<std::string>& gte,
                const int limit,
                const bool fillCache,
-               std::shared_ptr<const rocksdb::Snapshot> snapshot,
                bool tailing = false)
       : database_(database),
         column_(column),
-        snapshot_(snapshot),
         reverse_(reverse),
-        limit_(limit),
-        fillCache_(fillCache),
-        tailing_(tailing) {
+        limit_(limit) {
     if (lte) {
       upper_bound_ = rocksdb::PinnableSlice();
       *upper_bound_->GetSelf() = std::move(*lte) + '\0';
@@ -312,30 +308,33 @@ struct BaseIterator : public Closable {
       *lower_bound_->GetSelf() = std::move(*gt) + '\0';
       lower_bound_->PinSelf();
     }
-    database_->Attach(this);
-  }
-
-  virtual ~BaseIterator() { assert(!iterator_); }
-
-  bool DidSeek() const { return iterator_ != nullptr; }
 
-  void SeekToRange() {
-    if (!iterator_) {
-      Init();
+    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;
+    readOptions.tailing = tailing;
+
+    iterator_.reset(database_->db->NewIterator(readOptions, column_));
 
     if (reverse_) {
       iterator_->SeekToLast();
     } else {
       iterator_->SeekToFirst();
     }
+
+    database_->Attach(this);
   }
 
-  virtual void Seek(const rocksdb::Slice& target) {
-    if (!iterator_) {
-      Init();
-    }
+  virtual ~BaseIterator() { assert(!iterator_); }
 
+  virtual void Seek(const rocksdb::Slice& target) {
     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
@@ -351,7 +350,6 @@ struct BaseIterator : public Closable {
   }
 
   virtual rocksdb::Status Close() override {
-    snapshot_.reset();
     iterator_.reset();
     database_->Detach(this);
     return rocksdb::Status::OK();
@@ -393,25 +391,8 @@ struct BaseIterator : public Closable {
 
   Database* database_;
   rocksdb::ColumnFamilyHandle* column_;
-  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 
  private:
-  void Init() {
-    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.snapshot = snapshot_.get();
-    readOptions.async_io = true;
-    readOptions.adaptive_readahead = true;
-    readOptions.tailing = tailing_;
-
-    iterator_.reset(database_->db->NewIterator(readOptions, column_));
-  }
 
   int count_ = 0;
   std::optional<rocksdb::PinnableSlice> lower_bound_;
@@ -419,8 +400,6 @@ struct BaseIterator : public Closable {
   std::unique_ptr<rocksdb::Iterator> iterator_;
   const bool reverse_;
   const int limit_;
-  const bool fillCache_;
-  const bool tailing_;
 };
 
 struct Iterator final : public BaseIterator {
@@ -436,12 +415,15 @@ struct Iterator final : public BaseIterator {
            const std::optional<std::string>& gte,
            const bool fillCache,
            const size_t highWaterMarkBytes,
-           std::shared_ptr<const rocksdb::Snapshot> snapshot,
-           bool tailing = false)
-      : BaseIterator(database, column, reverse, lt, lte, gt, gte, limit, fillCache, snapshot, tailing),
+           bool tailing = false,
+           Encoding keyEncoding = Encoding::Invalid,
+           Encoding valueEncoding = Encoding::Invalid)
+      : BaseIterator(database, column, reverse, lt, lte, gt, gte, limit, fillCache, tailing),
         keys_(keys),
         values_(values),
-        highWaterMarkBytes_(highWaterMarkBytes) {}
+        highWaterMarkBytes_(highWaterMarkBytes),
+        keyEncoding_(keyEncoding),
+        valueEncoding_(valueEncoding) {}
 
   void Seek(const rocksdb::Slice& target) override {
     first_ = true;
@@ -452,6 +434,8 @@ struct Iterator final : public BaseIterator {
   const bool values_;
   const size_t highWaterMarkBytes_;
   bool first_ = true;
+  const Encoding keyEncoding_;
+  const Encoding valueEncoding_;
 };
 
 /**
@@ -698,64 +682,6 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   return napi_ok;
 }
 
-NAPI_METHOD(db_get_merge_operands) {
-  NAPI_ARGV(4);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  std::string key;
-  NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
-
-  const auto options = argv[2];
-
-  Encoding valueEncoding = Encoding::String;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
-
-  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
-  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
-
-  auto callback = argv[3];
-
-  runAsync<std::vector<rocksdb::PinnableSlice>>(
-      "leveldown.get.mergeOperands", env, callback,
-      [=, key = std::move(key)](auto& values) {
-        rocksdb::ReadOptions readOptions;
-
-        values.resize(16);  // TODO (fix): Make option
-
-        rocksdb::GetMergeOperandsOptions mergeOperandsOptions;
-        mergeOperandsOptions.expected_max_number_of_operands = values.size();
-
-        int size = 0;
-        const auto status =
-            database->db->GetMergeOperands(readOptions, column, key, values.data(), &mergeOperandsOptions, &size);
-
-        values.resize(size);
-
-        return status;
-      },
-      [=](auto& values, auto env, auto& argv) {
-        argv.resize(2);
-
-        NAPI_STATUS_RETURN(napi_create_array_with_length(env, values.size(), &argv[1]));
-
-        for (size_t idx = 0; idx < values.size(); idx++) {
-          napi_value element;
-          if (values[idx].GetSelf()) {
-            NAPI_STATUS_RETURN(Convert(env, &values[idx], valueEncoding, element));
-          } else {
-            NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
-          }
-          NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<uint32_t>(idx), element));
-        }
-
-        return napi_ok;
-      });
-
-  return 0;
-}
-
 NAPI_METHOD(db_get_identity) {
   NAPI_ARGV(1);
 
@@ -946,117 +872,6 @@ NAPI_METHOD(db_close) {
 }
 
 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));
-
-  const auto options = argv[2];
-
-  bool fillCache = true;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "fillCache", fillCache));
-
-  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
-  NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
-
-  bool takeSnapshot = true;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "snapshot", takeSnapshot));
-
-  auto callback = argv[3];
-
-  std::shared_ptr<const rocksdb::Snapshot> snapshot;
-  if (takeSnapshot) {
-    snapshot.reset(database->db->GetSnapshot(), [=](const auto ptr) { database->db->ReleaseSnapshot(ptr); });
-  }
-
-  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<uint8_t> data;
-    std::vector<int32_t> sizes;
-  };
-
-  runAsync<State>(
-      "leveldown.get.many", env, callback,
-      [=, keys = std::move(keys), snapshot = std::move(snapshot)](auto& state) {
-        rocksdb::ReadOptions readOptions;
-        readOptions.fill_cache = fillCache;
-        readOptions.snapshot = snapshot.get();
-        readOptions.async_io = true;
-        readOptions.optimize_multiget_for_io = true;
-
-        std::vector<rocksdb::Status> statuses{count};
-        std::vector<rocksdb::PinnableSlice> values{count};
-        std::vector<rocksdb::Slice> keys2{count};
-
-        for (auto n = 0; n < count; n++) {
-          keys2[n] = keys[n];
-        }
-
-        database->db->MultiGet(readOptions, column, count, keys2.data(), values.data(), statuses.data());
-
-        auto size = 0;
-        for (auto n = 0; n < count; n++) {
-          const auto valueSize = values[n].size();
-          size += valueSize & 0x7 ? (valueSize | 0x7) + 1 : valueSize;
-        }
-
-        state.data.reserve(size);
-
-        auto push = [&](rocksdb::Slice* slice){
-          if (slice) {
-            state.sizes.push_back(static_cast<int32_t>(slice->size()));
-            std::copy_n(slice->data(), slice->size(), std::back_inserter(state.data));
-
-            if (state.data.size() & 0x7) {
-              state.data.resize((state.data.size() | 0x7) + 1);
-            }
-          } else {
-            state.sizes.push_back(-1);
-          }
-        };
-
-        for (auto n = 0; n < count; n++) {
-          push(statuses[n].ok() ? &values[n] : nullptr);
-        }
-
-        return rocksdb::Status::OK();
-      },
-      [=](auto& state, auto env, auto& argv) {
-        argv.resize(3);
-
-        if (state.sizes.size() > 0) {
-          auto sizes = std::make_unique<std::vector<int32_t>>(std::move(state.sizes));
-          NAPI_STATUS_RETURN(napi_create_external_buffer(env, sizes->size() * 4, sizes->data(), Finalize<std::vector<int32_t>>, sizes.get(), &argv[1]));
-          sizes.release();
-        } else {
-          NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[1]));
-        }
-
-        if (state.data.size() > 0) {
-          auto data = std::make_unique<std::vector<uint8_t>>(std::move(state.data));
-          NAPI_STATUS_RETURN(napi_create_external_buffer(env, data->size(), data->data(), Finalize<std::vector<uint8_t>>, data.get(), &argv[2]));
-          data.release();
-        } else {
-          NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[2]));
-        }
-
-        return napi_ok;
-      });
-
-  return 0;
-}
-
-NAPI_METHOD(db_get_many_sync) {
   NAPI_ARGV(3);
 
   Database* database;
@@ -1071,7 +886,7 @@ NAPI_METHOD(db_get_many_sync) {
   rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
   NAPI_STATUS_THROWS(GetProperty(env, argv[2], "column", column));
 
-  Encoding valueEncoding = Encoding::String;
+  Encoding valueEncoding = Encoding::Buffer;
   NAPI_STATUS_THROWS(GetProperty(env, argv[2], "valueEncoding", valueEncoding));
 
   std::vector<rocksdb::Slice> keys{count};
@@ -1094,19 +909,25 @@ NAPI_METHOD(db_get_many_sync) {
   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].ok()) {
-      NAPI_STATUS_THROWS(Convert(env, &values[n], valueEncoding, row));
-    } else if (statuses[n].IsNotFound()) {
+    if (statuses[n].IsNotFound()) {
       NAPI_STATUS_THROWS(napi_get_undefined(env, &row));
     } else {
       ROCKS_STATUS_THROWS_NAPI(statuses[n]);
+      NAPI_STATUS_THROWS(Convert(env, &values[n], valueEncoding, row));
     }
     NAPI_STATUS_THROWS(napi_set_element(env, rows, n, row));
   }
 
-  return rows;
+  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;
 }
 
 NAPI_METHOD(db_clear) {
@@ -1169,11 +990,7 @@ NAPI_METHOD(db_clear) {
     // TODO (fix): Error handling.
     // TODO (fix): This should be async...
 
-    std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db->GetSnapshot(),
-                                                      [=](const auto ptr) { database->db->ReleaseSnapshot(ptr); });
-    BaseIterator it(database, column, reverse, lt, lte, gt, gte, limit, false, snapshot);
-
-    it.SeekToRange();
+    BaseIterator it(database, column, reverse, lt, lte, gt, gte, limit, false);
 
     rocksdb::WriteBatch batch;
     rocksdb::WriteOptions writeOptions;
@@ -1288,17 +1105,15 @@ NAPI_METHOD(iterator_init) {
   rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
   NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
-  bool takeSnapshot = !tailing;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "snapshot", takeSnapshot));
+  Encoding keyEncoding;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "keyEncoding", keyEncoding));
 
-  std::shared_ptr<const rocksdb::Snapshot> snapshot;
-  if (takeSnapshot) {
-    snapshot.reset(database->db->GetSnapshot(), [=](const auto ptr) { database->db->ReleaseSnapshot(ptr); });
-  }
+  Encoding valueEncoding;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
 
   auto iterator = std::unique_ptr<Iterator>(new Iterator(database, column, reverse, keys, values, limit, lt, lte, gt,
                                                          gte, fillCache, highWaterMarkBytes,
-                                                         snapshot, tailing));
+                                                         tailing, keyEncoding, valueEncoding));
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, iterator.get(), Finalize<Iterator>, iterator.get(), &result));
@@ -1333,7 +1148,7 @@ NAPI_METHOD(iterator_close) {
 }
 
 NAPI_METHOD(iterator_nextv) {
-  NAPI_ARGV(3);
+  NAPI_ARGV(2);
 
   Iterator* iterator;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
@@ -1341,102 +1156,71 @@ NAPI_METHOD(iterator_nextv) {
   uint32_t count;
   NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &count));
 
-  auto callback = argv[2];
-
-  struct State {
-    std::vector<uint8_t> data;
-    std::vector<int32_t> sizes;
-    bool finished = false;
-  };
-
-  runAsync<State>(
-      std::string("leveldown.iterator.next"), env, callback,
-      [=](auto& state) {
-        if (!iterator->DidSeek()) {
-          iterator->SeekToRange();
-        }
-
-        state.sizes.reserve(count * 2);
-        state.data.reserve(iterator->highWaterMarkBytes_);
+  napi_value finished;
+  NAPI_STATUS_THROWS(napi_get_boolean(env, false, &finished));
 
-        auto bytesRead = 0;
-
-        auto push = [&](const std::optional<rocksdb::Slice>& slice){
-          if (slice) {
-            state.sizes.push_back(static_cast<int32_t>(slice->size()));
-            std::copy_n(slice->data(), slice->size(), std::back_inserter(state.data));
-
-            if (state.data.size() & 0x7) {
-              state.data.resize((state.data.size() | 0x7) + 1);
-            }
-
-            bytesRead += slice->size();
-          } else {
-            state.sizes.push_back(-1);
-          }
-        };
-
-        while (true) {
-          if (!iterator->first_) {
-            iterator->Next();
-          } else {
-            iterator->first_ = false;
-          }
-
-          if (!iterator->Valid() || !iterator->Increment()) {
-            state.finished = true;
-            return iterator->Status();
-          }
+  napi_value rows;
+  NAPI_STATUS_THROWS(napi_create_array(env, &rows));
 
-          if (iterator->keys_ && iterator->values_) {
-            push(iterator->CurrentKey());
-            push(iterator->CurrentValue());
-          } else if (iterator->keys_) {
-            push(iterator->CurrentKey());
-            push(std::nullopt);
-          } else if (iterator->values_) {
-            push(std::nullopt);
-            push(iterator->CurrentValue());
-          }
+  size_t idx = 0;
+  size_t bytesRead = 0;
+  while (true) {
+    if (!iterator->first_) {
+      iterator->Next();
+    } else {
+      iterator->first_ = false;
+    }
 
-          if (bytesRead > iterator->highWaterMarkBytes_ || state.sizes.size() / 2 >= count) {
-            state.finished = false;
-            return rocksdb::Status::OK();
-          }
-        }
-      },
-      [=](auto& state, auto env, auto& argv) {
-        argv.resize(4);
-
-        if (state.sizes.size() > 0) {
-          auto sizes = std::make_unique<std::vector<int32_t>>(std::move(state.sizes));
-          NAPI_STATUS_RETURN(napi_create_external_buffer(env, sizes->size() * 4, sizes->data(), Finalize<std::vector<int32_t>>, sizes.get(), &argv[1]));
-          sizes.release();
-        } else {
-          NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[1]));
-        }
+    if (!iterator->Valid() || !iterator->Increment()) {
+      ROCKS_STATUS_THROWS_NAPI(iterator->Status());
+      NAPI_STATUS_THROWS(napi_get_boolean(env, true, &finished));
+      break;
+    }
 
-        if (state.data.size() > 0) {
-          auto data = std::make_unique<std::vector<uint8_t>>(std::move(state.data));
-          NAPI_STATUS_RETURN(napi_create_external_buffer(env, data->size(), data->data(), Finalize<std::vector<uint8_t>>, data.get(), &argv[2]));
-          data.release();
-        } else {
-          NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[2]));
-        }
+    napi_value key;
+    napi_value val;
+
+    if (iterator->keys_ && iterator->values_) {
+      const auto k = iterator->CurrentKey();
+      const auto v = iterator->CurrentValue();
+      NAPI_STATUS_THROWS(Convert(env, &k, iterator->keyEncoding_, key));
+      NAPI_STATUS_THROWS(Convert(env, &v, iterator->valueEncoding_, val));
+      bytesRead += k.size() + v.size();
+    } else if (iterator->keys_) {
+      const auto k = iterator->CurrentKey();
+      NAPI_STATUS_THROWS(Convert(env, &k, iterator->keyEncoding_, key));
+      NAPI_STATUS_THROWS(napi_get_undefined(env, &val));
+      bytesRead += k.size();
+    } else if (iterator->values_) {
+      const auto v = iterator->CurrentValue();
+      NAPI_STATUS_THROWS(napi_get_undefined(env, &key));
+      NAPI_STATUS_THROWS(Convert(env, &v, iterator->valueEncoding_, val));
+      bytesRead += v.size();
+    } else {
+      assert(false);
+    }
 
-        NAPI_STATUS_RETURN(napi_get_boolean(env, state.finished, &argv[3]));
+    NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, key));
+    NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, val));
 
-        return napi_ok;
-      });
+    if (bytesRead > iterator->highWaterMarkBytes_ || idx / 2 >= count) {
+      break;
+    }
+  }
 
-  return 0;
+  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;
 }
 
 NAPI_METHOD(batch_init) {
-  auto batch = new rocksdb::WriteBatch();
+  auto batch = std::make_unique<rocksdb::WriteBatch>();
 
   napi_value result;
-  NAPI_STATUS_THROWS(napi_create_external(env, batch, Finalize<rocksdb::WriteBatch>, batch, &result));
+  NAPI_STATUS_THROWS(napi_create_external(env, batch.get(), Finalize<rocksdb::WriteBatch>, batch.get(), &result));
+  batch.release();
 
   return result;
 }
@@ -1545,36 +1329,6 @@ NAPI_METHOD(batch_write) {
   bool lowPriority = false;
   NAPI_STATUS_THROWS(GetProperty(env, options, "lowPriority", lowPriority));
 
-  runAsync<int64_t>(
-      "leveldown.batch.write", env, callback,
-      [=](int64_t& seq) {
-        rocksdb::WriteOptions writeOptions;
-        writeOptions.sync = sync;
-        writeOptions.low_pri = lowPriority;
-        return database->db->Write(writeOptions, batch);
-      },
-      [=](int64_t& seq, auto env, auto& argv) { return napi_ok; });
-
-  return 0;
-}
-
-NAPI_METHOD(batch_write_sync) {
-  NAPI_ARGV(3);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
-
-  auto options = argv[2];
-
-  bool sync = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "sync", sync));
-
-  bool lowPriority = false;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "lowPriority", lowPriority));
-
   rocksdb::WriteOptions writeOptions;
   writeOptions.sync = sync;
   writeOptions.low_pri = lowPriority;
@@ -1640,11 +1394,9 @@ 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);
-  NAPI_EXPORT_FUNCTION(db_get_merge_operands);
 
   NAPI_EXPORT_FUNCTION(iterator_init);
   NAPI_EXPORT_FUNCTION(iterator_seek);
@@ -1656,7 +1408,6 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(batch_del);
   NAPI_EXPORT_FUNCTION(batch_clear);
   NAPI_EXPORT_FUNCTION(batch_write);
-  NAPI_EXPORT_FUNCTION(batch_write_sync);
   NAPI_EXPORT_FUNCTION(batch_merge);
   NAPI_EXPORT_FUNCTION(batch_count);
   NAPI_EXPORT_FUNCTION(batch_iterate);

package/chained-batch.js

@@ -5,7 +5,6 @@ const binding = require('./binding')
 const ModuleError = require('module-error')
 const { fromCallback } = require('catering')
 
-const kWrite = Symbol('write')
 const kBatchContext = Symbol('batchContext')
 const kDbContext = Symbol('dbContext')
 const kPromise = Symbol('promise')
@@ -13,10 +12,9 @@ const kPromise = Symbol('promise')
 const EMPTY = {}
 
 class ChainedBatch extends AbstractChainedBatch {
-  constructor (db, context, write) {
+  constructor (db, context) {
     super(db)
 
-    this[kWrite] = write
     this[kDbContext] = context
     this[kBatchContext] = binding.batch_init()
   }
@@ -59,16 +57,18 @@ class ChainedBatch extends AbstractChainedBatch {
   _write (options, callback) {
     callback = fromCallback(callback, kPromise)
 
-    // NOTE: `this` needs to be referenced until callback is called
-    this[kWrite](this, this[kBatchContext], options ?? EMPTY, (err) => {
-      callback(err, null, this)
-    })
+    try {
+      this._writeSync(options)
+      process.nextTick(callback, null)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }
 
   _writeSync (options) {
-    binding.batch_write_sync(this[kDbContext], this[kBatchContext], options ?? EMPTY)
+    binding.batch_write(this[kDbContext], this[kBatchContext], options ?? EMPTY)
   }
 
   _close (callback) {

package/index.js

@@ -8,7 +8,6 @@ const { ChainedBatch } = require('./chained-batch')
 const { Iterator } = require('./iterator')
 const fs = require('node:fs')
 const assert = require('node:assert')
-const { handleNextv, handleMany } = require('./util')
 
 const kContext = Symbol('context')
 const kColumns = Symbol('columns')
@@ -18,7 +17,7 @@ const kUnref = Symbol('unref')
 const kRefs = Symbol('refs')
 const kPendingClose = Symbol('pendingClose')
 
-const EMPTY = {}
+const kEmpty = {}
 
 class RocksLevel extends AbstractLevel {
   constructor (locationOrHandle, options) {
@@ -125,7 +124,7 @@ class RocksLevel extends AbstractLevel {
 
     try {
       const batch = this.batch()
-      batch.put(key, value, options ?? EMPTY)
+      batch.put(key, value, options ?? kEmpty)
       batch.write(callback)
     } catch (err) {
       process.nextTick(callback, err)
@@ -137,7 +136,7 @@ class RocksLevel extends AbstractLevel {
   _get (key, options, callback) {
     callback = fromCallback(callback, kPromise)
 
-    this._getMany([key], options ?? EMPTY, (err, val) => {
+    this._getMany([key], options ?? kEmpty, (err, val) => {
       if (err) {
         callback(err)
       } else if (val[0] === undefined) {
@@ -152,52 +151,27 @@ class RocksLevel extends AbstractLevel {
     return callback[kPromise]
   }
 
-  _getManySync (keys, options) {
-    return binding.db_get_many_sync(this[kContext], keys, options ?? EMPTY)
-  }
-
   _getMany (keys, options, callback) {
     callback = fromCallback(callback, kPromise)
 
     try {
-      this[kRef]()
-      binding.db_get_many(this[kContext], keys, options ?? EMPTY, (err, sizes, data) => {
-        if (err) {
-          callback(err)
-        } else {
-          let rows
-          try {
-            rows = handleMany(sizes, data, options ?? EMPTY)
-          } catch (err) {
-            callback(err)
-          }
-          callback(null, rows)
-        }
-        this[kUnref]()
-      })
+      // TODO (fix): highWaterMark and limit with async between...
+      process.nextTick(callback, null, this._getManySync(keys, options ?? kEmpty))
     } catch (err) {
       process.nextTick(callback, err)
-      this[kUnref]()
     }
 
     return callback[kPromise]
   }
 
-  _getMergeOperands (key, options, callback) {
-    callback = fromCallback(callback, kPromise)
-
-    try {
-      this[kRef]()
-      binding.db_get_merge_operands(this[kContext], key, options ?? EMPTY, (err, val) => {
-        callback(err, val)
-        this[kUnref]()
-      })
-    } catch (err) {
-      process.nextTick(callback, err)
-      this[kUnref]()
+  _getManySync (keys, options) {
+    if (keys.some(key => typeof key === 'string')) {
+      keys = keys.map(key => typeof key === 'string' ? Buffer.from(key) : key)
     }
 
-    return callback[kPromise]
+    const { rows, finished } = binding.db_get_many(this[kContext], keys, options ?? kEmpty)
+    assert(finished)
+    return rows
   }
 
   _del (key, options, callback) {
@@ -205,7 +179,7 @@ class RocksLevel extends AbstractLevel {
 
     try {
       const batch = this.batch()
-      batch.del(key, options ?? EMPTY)
+      batch.del(key, options ?? kEmpty)
       batch.write(callback)
     } catch (err) {
       process.nextTick(callback, err)
@@ -219,7 +193,7 @@ class RocksLevel extends AbstractLevel {
 
     try {
       // TODO (fix): Use batch + DeleteRange...
-      binding.db_clear(this[kContext], options ?? EMPTY)
+      binding.db_clear(this[kContext], options ?? kEmpty)
       process.nextTick(callback, null)
     } catch (err) {
       process.nextTick(callback, err)
@@ -229,17 +203,7 @@ class RocksLevel extends AbstractLevel {
   }
 
   _chainedBatch () {
-    return new ChainedBatch(this, this[kContext], (batch, context, options, callback) => {
-      try {
-        this[kRef]()
-        binding.batch_write(this[kContext], context, options, (err) => {
-          this[kUnref]()
-          callback(err)
-        })
-      } catch (err) {
-        process.nextTick(callback, err)
-      }
-    })
+    return new ChainedBatch(this, this[kContext])
   }
 
   _batch (operations, options, callback) {
@@ -261,7 +225,7 @@ class RocksLevel extends AbstractLevel {
   }
 
   _iterator (options) {
-    return new Iterator(this, this[kContext], options ?? EMPTY)
+    return new Iterator(this, this[kContext], options ?? kEmpty)
   }
 
   get identity () {
@@ -290,24 +254,22 @@ class RocksLevel extends AbstractLevel {
       })
     }
 
-    const context = binding.iterator_init(this[kContext], options ?? {})
+    // TOOD (perf): Merge into single call...
+    const context = binding.iterator_init(this[kContext], options ?? kEmpty)
     try {
-      this[kRef]()
-      return await new Promise((resolve, reject) => binding.iterator_nextv(context, options.limit, (err, sizes, buffer, finished) => {
-        handleNextv(err, sizes, buffer, finished, options, (err, rows, finished) => {
-          if (err) {
-            reject(err)
-          } else {
-            resolve({
-              rows,
-              finished
-            })
-          }
-        })
-      }))
+      return binding.iterator_nextv(context, options.limit)
+    } finally {
+      binding.iterator_close(context)
+    }
+  }
+
+  querySync (options) {
+    // TOOD (perf): Merge into single call...
+    const context = binding.iterator_init(this[kContext], options ?? kEmpty)
+    try {
+      return binding.iterator_nextv(context, options.limit)
     } finally {
       binding.iterator_close(context)
-      this[kUnref]()
     }
   }
 }

package/iterator.js

@@ -2,7 +2,6 @@
 
 const { fromCallback } = require('catering')
 const { AbstractIterator } = require('abstract-level')
-const { handleNextv } = require('./util')
 
 const binding = require('./binding')
 
@@ -12,29 +11,16 @@ const kCache = Symbol('cache')
 const kFinished = Symbol('finished')
 const kFirst = Symbol('first')
 const kPosition = Symbol('position')
-const kHandleNext = Symbol('handleNext')
-const kHandleNextv = Symbol('handleNextv')
-const kCallback = Symbol('callback')
-const kOptions = Symbol('options')
-const empty = []
-
-const registry = new FinalizationRegistry((context) => {
-  binding.iterator_close(context)
-})
+const kEmpty = []
 
 class Iterator extends AbstractIterator {
   constructor (db, context, options) {
     super(db, options)
 
     this[kContext] = binding.iterator_init(context, options)
-    registry.register(this, this[kContext], this[kContext])
 
-    this[kOptions] = { ...options }
-    this[kHandleNext] = this[kHandleNext].bind(this)
-    this[kHandleNextv] = this[kHandleNextv].bind(this)
-    this[kCallback] = null
     this[kFirst] = true
-    this[kCache] = empty
+    this[kCache] = kEmpty
     this[kFinished] = false
     this[kPosition] = 0
   }
@@ -45,7 +31,7 @@ class Iterator extends AbstractIterator {
     }
 
     this[kFirst] = true
-    this[kCache] = empty
+    this[kCache] = kEmpty
     this[kFinished] = false
     this[kPosition] = 0
 
@@ -60,35 +46,22 @@ class Iterator extends AbstractIterator {
     } else if (this[kFinished]) {
       process.nextTick(callback)
     } else {
-      this[kCallback] = callback
-
-      if (this[kFirst]) {
-        // It's common to only want one entry initially or after a seek()
-        this[kFirst] = false
-        binding.iterator_nextv(this[kContext], 1, this[kHandleNext])
-      } else {
-        // Limit the size of the cache to prevent starving the event loop
-        // while we're recursively calling process.nextTick().
-        binding.iterator_nextv(this[kContext], 1000, this[kHandleNext])
-      }
-    }
+      const size = this[kFirst] ? 1 : 1000
+      this[kFirst] = false
 
-    return this
-  }
+      try {
+        const { rows, finished } = binding.iterator_nextv(this[kContext], size)
+        this[kCache] = rows
+        this[kFinished] = finished
+        this[kPosition] = 0
 
-  [kHandleNext] (err, sizes, buffer, finished) {
-    handleNextv(err, sizes, buffer, finished, this[kOptions], (err, items, finished) => {
-      const callback = this[kCallback]
-      if (err) {
-        return callback(err)
+        setImmediate(() => this._next(callback))
+      } catch (err) {
+        process.nextTick(callback, err)
       }
+    }
 
-      this[kCache] = items
-      this[kFinished] = finished
-      this[kPosition] = 0
-
-      this._next(callback)
-    })
+    return this
   }
 
   _nextv (size, options, callback) {
@@ -97,38 +70,43 @@ class Iterator extends AbstractIterator {
     if (this[kFinished]) {
       process.nextTick(callback, null, [])
     } else {
-      this[kCallback] = callback
       this[kFirst] = false
-      binding.iterator_nextv(this[kContext], size, this[kHandleNextv])
-    }
 
-    return callback[kPromise]
-  }
+      setImmediate(() => {
+        try {
+          const { rows, finished } = binding.iterator_nextv(this[kContext], size)
 
-  [kHandleNextv] (err, sizes, buffer, finished) {
-    handleNextv(err, sizes, buffer, finished, this[kOptions], (err, items, finished) => {
-      const callback = this[kCallback]
-      if (err) {
-        return callback(err)
-      }
+          const entries = []
+          for (let n = 0; n < rows.length; n += 2) {
+            entries.push([rows[n + 0], rows[n + 1]])
+          }
 
-      this[kFinished] = finished
+          this[kFinished] = finished
 
-      const entries = []
-      for (let n = 0; n < items.length; n += 2) {
-        entries.push([items[n + 0], items[n + 1]])
-      }
+          callback(null, entries, finished)
+        } catch (err) {
+          callback(err)
+        }
+      })
+    }
 
-      callback(null, entries)
-    })
+    return callback[kPromise]
+  }
+
+  _nextvSync (size, options) {
+    this[kFirst] = false
+    return binding.iterator_nextv(this[kContext], size)
   }
 
   _close (callback) {
-    this[kCache] = empty
-    this[kCallback] = null
+    this[kCache] = kEmpty
 
-    registry.unregister(this[kContext])
-    process.nextTick(callback, binding.iterator_close(this[kContext]))
+    try {
+      binding.iterator_close(this[kContext])
+      process.nextTick(callback)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
   }
 
   _end (callback) {

package/package.json

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

package/util.h

@@ -263,23 +263,6 @@ static napi_status GetProperty(napi_env env,
   return GetValue(env, value, result);
 }
 
-// NOTE: napi_create_external_buffer is slow with finalizer...
-// template <typename T>
-// napi_status Convert(napi_env env, rocksdb::PinnableSlice* s, Encoding encoding, napi_value& result) {
-//   if (!s || !s->IsPinned()) {
-//     return napi_get_null(env, &result);
-//   } else if (encoding == Encoding::Buffer) {
-//     auto ptr = new rocksdb::PinnableSlice(std::move(*s));
-//     return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()),
-//                                        Finalize<rocksdb::PinnableSlice>, ptr, &result);
-//     return napi_create_buffer_copy(env, s->size(), s->data(), nullptr, &result);
-//   } else if (encoding == Encoding::String) {
-//     return napi_create_string_utf8(env, s->data(), s->size(), &result);
-//   } else {
-//     return napi_invalid_arg;
-//   }
-// }
-
 template <typename T>
 napi_status Convert(napi_env env, T&& s, Encoding encoding, napi_value& result) {
   if (!s) {