@nxtedition/rocksdb 7.0.42 → 7.0.45

package/binding.cc

@@ -180,6 +180,7 @@ static napi_status ToString(napi_env env, napi_value from, rocksdb::PinnableSlic
       size_t length = 0;
       NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length));
 
+      // TODO (fix): Should extend life of "from". Or "to" should be a non-pinnable slice.
       to.PinSlice(rocksdb::Slice(buf, length), noop, nullptr, nullptr);
     } else {
       return napi_invalid_arg;
@@ -248,7 +249,7 @@ napi_status Convert(napi_env env, T&& s, bool asBuffer, napi_value& result) {
   if (!s) {
     return napi_get_null(env, &result);
   } else if (asBuffer) {
-    using Y = typename std::remove_pointer<typename std::decay<decltype(*s)>::type>::type;
+    using Y = typename std::decay<decltype(*s)>::type;
     auto ptr = new Y(std::move(*s));
     return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<Y>, ptr, &result);
   } else {
@@ -328,6 +329,13 @@ struct Worker {
   rocksdb::Status status_;
 };
 
+struct ColumnFamily {
+  napi_ref ref;
+  napi_value val;
+  rocksdb::ColumnFamilyHandle* handle;
+  rocksdb::ColumnFamilyDescriptor descriptor;
+};
+
 struct Database {
   void AttachIterator(napi_env env, Iterator* iterator) {
     iterators_.insert(iterator);
@@ -366,13 +374,228 @@ struct Database {
   Worker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
   std::set<Updates*> updates_;
-  std::vector<rocksdb::ColumnFamilyHandle*> columns_;
+  std::map<int32_t, ColumnFamily> columns_;
   napi_ref priorityRef_;
 
  private:
   uint32_t priorityWork_ = 0;
 };
 
+enum BatchOp { Empty, Put, Delete, Merge, Data };
+
+struct BatchEntry {
+  BatchOp op = BatchOp::Empty;
+  std::optional<std::string> key;
+  std::optional<std::string> val;
+  std::optional<ColumnFamily> column;
+};
+
+struct BatchIterator : public rocksdb::WriteBatch::Handler {
+  BatchIterator(Database* database,
+                bool keys = true,
+                bool values = true,
+                bool data = true,
+                const rocksdb::ColumnFamilyHandle* column = nullptr,
+                bool keyAsBuffer = false,
+                bool valueAsBuffer = false)
+      : database_(database),
+        keys_(keys),
+        values_(values),
+        data_(data),
+        column_(column),
+        keyAsBuffer_(keyAsBuffer),
+        valueAsBuffer_(valueAsBuffer) {}
+
+  napi_status Iterate(napi_env env, const rocksdb::WriteBatch& batch, napi_value* result) {
+    cache_.reserve(batch.Count());
+    batch.Iterate(this);  // TODO (fix): Error?
+
+    napi_value putStr;
+    NAPI_STATUS_RETURN(napi_create_string_utf8(env, "put", NAPI_AUTO_LENGTH, &putStr));
+
+    napi_value delStr;
+    NAPI_STATUS_RETURN(napi_create_string_utf8(env, "del", NAPI_AUTO_LENGTH, &delStr));
+
+    napi_value mergeStr;
+    NAPI_STATUS_RETURN(napi_create_string_utf8(env, "merge", NAPI_AUTO_LENGTH, &mergeStr));
+
+    napi_value dataStr;
+    NAPI_STATUS_RETURN(napi_create_string_utf8(env, "data", NAPI_AUTO_LENGTH, &dataStr));
+
+    napi_value nullVal;
+    NAPI_STATUS_RETURN(napi_get_null(env, &nullVal));
+
+    NAPI_STATUS_RETURN(napi_create_array_with_length(env, cache_.size() * 4, result));
+    for (size_t n = 0; n < cache_.size(); ++n) {
+      napi_value op;
+      if (cache_[n].op == BatchOp::Put) {
+        op = putStr;
+      } else if (cache_[n].op == BatchOp::Delete) {
+        op = delStr;
+      } else if (cache_[n].op == BatchOp::Merge) {
+        op = mergeStr;
+      } else if (cache_[n].op == BatchOp::Data) {
+        op = dataStr;
+      } else {
+        continue;
+      }
+
+      NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 0, op));
+
+      napi_value key;
+      NAPI_STATUS_RETURN(Convert(env, cache_[n].key, keyAsBuffer_, key));
+      NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 1, key));
+
+      napi_value val;
+      NAPI_STATUS_RETURN(Convert(env, cache_[n].val, valueAsBuffer_, val));
+      NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 2, val));
+
+      // TODO (fix)
+      // napi_value column = cache_[n].column ? cache_[n].column->val : nullVal;
+      NAPI_STATUS_RETURN(napi_set_element(env, *result, n * 4 + 3, nullVal));
+    }
+
+    return napi_ok;
+  }
+
+  rocksdb::Status PutCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
+    if (column_ && column_->GetID() != column_family_id) {
+      return rocksdb::Status::OK();
+    }
+
+    BatchEntry entry;
+
+    entry.op = BatchOp::Put;
+
+    if (keys_) {
+      entry.key = key.ToStringView();
+    }
+
+    if (values_) {
+      entry.val = value.ToStringView();
+    }
+
+    // if (database_ && database_->columns_.find(column_family_id) != database_->columns_.end()) {
+    //   entry.column = database_->columns_[column_family_id];
+    // }
+
+    cache_.push_back(entry);
+
+    return rocksdb::Status::OK();
+  }
+
+  rocksdb::Status DeleteCF(uint32_t column_family_id, const rocksdb::Slice& key) override {
+    if (column_ && column_->GetID() != column_family_id) {
+      return rocksdb::Status::OK();
+    }
+
+    BatchEntry entry;
+
+    entry.op = BatchOp::Delete;
+
+    if (keys_) {
+      entry.key = key.ToStringView();
+    }
+
+    // if (database_ && database_->columns_.find(column_family_id) != database_->columns_.end()) {
+    //   entry.column = database_->columns_[column_family_id];
+    // }
+
+    cache_.push_back(entry);
+
+    return rocksdb::Status::OK();
+  }
+
+  rocksdb::Status MergeCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
+    if (column_ && column_->GetID() != column_family_id) {
+      return rocksdb::Status::OK();
+    }
+
+    BatchEntry entry;
+
+    entry.op = BatchOp::Merge;
+
+    if (keys_) {
+      entry.key = key.ToStringView();
+    }
+
+    if (values_) {
+      entry.val = value.ToStringView();
+    }
+
+    // if (database_ && database_->columns_.find(column_family_id) != database_->columns_.end()) {
+    //   entry.column = database_->columns_[column_family_id];
+    // }
+
+    cache_.push_back(entry);
+
+    return rocksdb::Status::OK();
+  }
+
+  void LogData(const rocksdb::Slice& data) override {
+    if (!data_) {
+      return;
+    }
+
+    BatchEntry entry;
+
+    entry.op = BatchOp::Data;
+
+    entry.val = data.ToStringView();
+
+    cache_.push_back(entry);
+  }
+
+  bool Continue() override { return true; }
+
+ private:
+  Database* database_;
+  bool keys_;
+  bool values_;
+  bool data_;
+  const rocksdb::ColumnFamilyHandle* column_;
+  bool keyAsBuffer_;
+  bool valueAsBuffer_;
+  std::vector<BatchEntry> cache_;
+};
+
+struct Updates : public BatchIterator {
+  Updates(Database* database,
+          int64_t seqNumber,
+          bool keys,
+          bool values,
+          bool data,
+          const rocksdb::ColumnFamilyHandle* column,
+          bool keyAsBuffer,
+          bool valueAsBuffer)
+      : BatchIterator(database, keys, values, data, column, keyAsBuffer, valueAsBuffer),
+        database_(database),
+        sequence_(seqNumber),
+        start_(seqNumber) {}
+
+  void Close() { iterator_.reset(); }
+
+  void Attach(napi_env env, napi_value context) {
+    napi_create_reference(env, context, 1, &ref_);
+    database_->AttachUpdates(env, this);
+  }
+
+  void Detach(napi_env env) {
+    database_->DetachUpdates(env, this);
+    if (ref_) {
+      napi_delete_reference(env, ref_);
+    }
+  }
+
+  Database* database_;
+  int64_t sequence_;
+  int64_t start_;
+  std::unique_ptr<rocksdb::TransactionLogIterator> iterator_;
+
+ private:
+  napi_ref ref_ = nullptr;
+};
+
 struct BaseIterator {
   BaseIterator(Database* database,
                rocksdb::ColumnFamilyHandle* column,
@@ -561,53 +784,10 @@ struct Iterator final : public BaseIterator {
   napi_ref ref_ = nullptr;
 };
 
-struct Updates {
-  Updates(Database* database,
-          int64_t seqNumber,
-          bool keys,
-          bool values,
-          bool data,
-          const rocksdb::ColumnFamilyHandle* column)
-      : database_(database),
-        sequence_(seqNumber),
-        start_(seqNumber),
-        keys_(keys),
-        values_(values),
-        data_(data),
-        column_(column) {}
-
-  void Close() { iterator_.reset(); }
-
-  void Attach(napi_env env, napi_value context) {
-    napi_create_reference(env, context, 1, &ref_);
-    database_->AttachUpdates(env, this);
-  }
-
-  void Detach(napi_env env) {
-    database_->DetachUpdates(env, this);
-    if (ref_) {
-      napi_delete_reference(env, ref_);
-    }
-  }
-
-  Database* database_;
-  int64_t sequence_;
-  int64_t start_;
-  std::unique_ptr<rocksdb::TransactionLogIterator> iterator_;
-  bool keys_;
-  bool values_;
-  bool data_;
-  const rocksdb::ColumnFamilyHandle* column_;
-
- private:
-  napi_ref ref_ = nullptr;
-};
-
 static napi_status GetColumnFamily(Database* database,
                                    napi_env env,
                                    napi_value options,
-                                   rocksdb::ColumnFamilyHandle** column,
-                                   bool fallback = true) {
+                                   rocksdb::ColumnFamilyHandle** column) {
   bool hasColumn = false;
   NAPI_STATUS_RETURN(napi_has_named_property(env, options, "column", &hasColumn));
 
@@ -615,7 +795,7 @@ static napi_status GetColumnFamily(Database* database,
     napi_value value = nullptr;
     NAPI_STATUS_RETURN(napi_get_named_property(env, options, "column", &value));
     NAPI_STATUS_RETURN(napi_get_value_external(env, value, reinterpret_cast<void**>(column)));
-  } else if (fallback) {
+  } else if (database) {
     *column = database->db_->DefaultColumnFamily();
   } else {
     *column = nullptr;
@@ -640,18 +820,18 @@ static void env_cleanup_hook(void* arg) {
   // following code must be a safe noop if called before db_open() or after
   // db_close().
   if (database && database->db_) {
-    for (auto it : database->iterators_) {
+    for (auto& it : database->iterators_) {
       // TODO: does not do `napi_delete_reference`. Problem?
       it->Close();
     }
 
-    for (auto it : database->updates_) {
+    for (auto& it : database->updates_) {
       // TODO: does not do `napi_delete_reference`. Problem?
       it->Close();
     }
 
-    for (auto it : database->columns_) {
-      database->db_->DestroyColumnFamilyHandle(it);
+    for (auto& it : database->columns_) {
+      database->db_->DestroyColumnFamilyHandle(it.second.handle);
     }
 
     // Having closed the iterators (and released snapshots) we can safely close.
@@ -665,6 +845,9 @@ static void FinalizeDatabase(napi_env env, void* data, void* hint) {
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
     if (database->priorityRef_)
       napi_delete_reference(env, database->priorityRef_);
+    for (auto& it : database->columns_) {
+      napi_delete_reference(env, it.second.ref);
+    }
     delete database;
   }
 }
@@ -687,17 +870,16 @@ struct OpenWorker final : public Worker {
              napi_value callback,
              const std::string& location,
              const rocksdb::Options& options,
-             std::vector<rocksdb::ColumnFamilyDescriptor> column_families)
+             std::vector<rocksdb::ColumnFamilyDescriptor> descriptors)
       : Worker(env, database, callback, "leveldown.db.open"),
         options_(options),
         location_(location),
-        column_families_(std::move(column_families)) {}
+        descriptors_(std::move(descriptors)) {}
 
   rocksdb::Status Execute(Database& database) override {
     rocksdb::DB* db = nullptr;
-    const auto status = column_families_.empty()
-                            ? rocksdb::DB::Open(options_, location_, &db)
-                            : rocksdb::DB::Open(options_, location_, column_families_, &database.columns_, &db);
+    const auto status = descriptors_.empty() ? rocksdb::DB::Open(options_, location_, &db)
+                                             : rocksdb::DB::Open(options_, location_, descriptors_, &handles_, &db);
     database.db_.reset(db);
     return status;
   }
@@ -706,13 +888,19 @@ struct OpenWorker final : public Worker {
     napi_value argv[2];
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
 
-    const auto size = database_->columns_.size();
+    const auto size = handles_.size();
     NAPI_STATUS_RETURN(napi_create_object(env, &argv[1]));
 
     for (size_t n = 0; n < size; ++n) {
-      napi_value column;
-      NAPI_STATUS_RETURN(napi_create_external(env, database_->columns_[n], nullptr, nullptr, &column));
-      NAPI_STATUS_RETURN(napi_set_named_property(env, argv[1], column_families_[n].name.c_str(), column));
+      ColumnFamily column;
+      column.handle = handles_[n];
+      column.descriptor = descriptors_[n];
+      NAPI_STATUS_RETURN(napi_create_external(env, column.handle, nullptr, nullptr, &column.val));
+      NAPI_STATUS_RETURN(napi_create_reference(env, column.val, 1, &column.ref));
+
+      NAPI_STATUS_RETURN(napi_set_named_property(env, argv[1], descriptors_[n].name.c_str(), column.val));
+
+      database_->columns_[column.handle->GetID()] = column;
     }
 
     return CallFunction(env, callback, 2, argv);
@@ -720,7 +908,8 @@ struct OpenWorker final : public Worker {
 
   rocksdb::Options options_;
   const std::string location_;
-  std::vector<rocksdb::ColumnFamilyDescriptor> column_families_;
+  std::vector<rocksdb::ColumnFamilyDescriptor> descriptors_;
+  std::vector<rocksdb::ColumnFamilyHandle*> handles_;
 };
 
 template <typename T, typename U>
@@ -939,8 +1128,8 @@ struct CloseWorker final : public Worker {
       : Worker(env, database, callback, "leveldown.db.close") {}
 
   rocksdb::Status Execute(Database& database) override {
-    for (auto it : database.columns_) {
-      database.db_->DestroyColumnFamilyHandle(it);
+    for (auto& it : database.columns_) {
+      database.db_->DestroyColumnFamilyHandle(it.second.handle);
     }
 
     return database.db_->Close();
@@ -968,7 +1157,7 @@ NAPI_METHOD(db_close) {
   return 0;
 }
 
-struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Worker {
+struct UpdatesNextWorker final : public Worker {
   UpdatesNextWorker(napi_env env, Updates* updates, napi_value callback)
       : Worker(env, updates->database_, callback, "rocks_level.db.get"), updates_(updates) {
     database_->IncrementPriorityWork(env);
@@ -993,10 +1182,10 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
 
     updates_->sequence_ = batch.sequence;
 
-    count_ = batch.writeBatchPtr->Count();
-    cache_.reserve(batch.writeBatchPtr->Count() * 4);
+    batch_ = std::move(batch.writeBatchPtr);
+    count_ = batch_->Count();
 
-    return batch.writeBatchPtr->Iterate(this);
+    return rocksdb::Status::OK();
   }
 
   napi_status OnOk(napi_env env, napi_value callback) override {
@@ -1008,12 +1197,7 @@ struct UpdatesNextWorker final : public rocksdb::WriteBatch::Handler, public Wor
       return CallFunction(env, callback, 1, argv);
     }
 
-    NAPI_STATUS_RETURN(napi_create_array_with_length(env, cache_.size(), &argv[1]));
-    for (size_t idx = 0; idx < cache_.size(); idx++) {
-      napi_value val;
-      NAPI_STATUS_RETURN(Convert(env, cache_[idx], false, val));
-      NAPI_STATUS_RETURN(napi_set_element(env, argv[1], idx, val));
-    }
+    NAPI_STATUS_RETURN(updates_->Iterate(env, *batch_, &argv[1]));
 
     NAPI_STATUS_RETURN(napi_create_int64(env, updates_->sequence_, &argv[2]));
 
@@ -1029,110 +1213,9 @@ 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 {
-    if (updates_->column_ && updates_->column_->GetID() != 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);
-    }
-
-    if (!updates_->column_) {
-      cache_.emplace_back(GetColumnName(column_family_id));
-    } else {
-      cache_.emplace_back(std::nullopt);
-    }
-
-    return rocksdb::Status::OK();
-  }
-
-  rocksdb::Status DeleteCF(uint32_t column_family_id, const rocksdb::Slice& key) override {
-    if (updates_->column_ && updates_->column_->GetID() != 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);
-
-    if (!updates_->column_) {
-      cache_.emplace_back(GetColumnName(column_family_id));
-    } else {
-      cache_.emplace_back(std::nullopt);
-    }
-
-    return rocksdb::Status::OK();
-  }
-
-  rocksdb::Status MergeCF(uint32_t column_family_id, const rocksdb::Slice& key, const rocksdb::Slice& value) override {
-    if (updates_->column_ && updates_->column_->GetID() != column_family_id) {
-      return rocksdb::Status::OK();
-    }
-
-    cache_.emplace_back("merge");
-
-    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);
-    }
-
-    if (!updates_->column_) {
-      cache_.emplace_back(GetColumnName(column_family_id));
-    } else {
-      cache_.emplace_back(std::nullopt);
-    }
-
-    return rocksdb::Status::OK();
-  }
-
-  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:
   int64_t count_ = -1;
-  std::vector<std::optional<std::string>> cache_;
+  std::unique_ptr<rocksdb::WriteBatch> batch_;
   Updates* updates_;
 };
 
@@ -1162,11 +1245,13 @@ NAPI_METHOD(updates_init) {
   NAPI_STATUS_THROWS(napi_get_named_property(env, argv[1], "data", &dataProperty));
   NAPI_STATUS_THROWS(napi_get_value_bool(env, dataProperty, &data));
 
-  // TODO (fix): Needs to support { column: null }
+  const bool keyAsBuffer = EncodingIsBuffer(env, argv[1], "keyEncoding");
+  const bool valueAsBuffer = EncodingIsBuffer(env, argv[1], "valueEncoding");
+
   rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[1], &column, false));
+  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[1], &column));
 
-  auto updates = std::make_unique<Updates>(database, since, keys, values, data, column);
+  auto updates = std::make_unique<Updates>(database, since, keys, values, data, column, keyAsBuffer, valueAsBuffer);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));
@@ -1202,102 +1287,6 @@ NAPI_METHOD(updates_close) {
   return 0;
 }
 
-NAPI_METHOD(db_put) {
-  NAPI_ARGV(4);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
-
-  rocksdb::PinnableSlice val;
-  NAPI_STATUS_THROWS(ToString(env, argv[2], val));
-
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[3], &column));
-
-  rocksdb::WriteOptions writeOptions;
-  ROCKS_STATUS_THROWS(database->db_->Put(writeOptions, column, key, val));
-
-  return 0;
-}
-
-struct GetWorker final : public Worker {
-  GetWorker(napi_env env,
-            Database* database,
-            rocksdb::ColumnFamilyHandle* column,
-            napi_value callback,
-            const std::string& key,
-            const bool asBuffer,
-            const bool fillCache)
-      : Worker(env, database, callback, "rocks_level.db.get"),
-        column_(column),
-        key_(key),
-        asBuffer_(asBuffer),
-        fillCache_(fillCache),
-        snapshot_(database_->db_->GetSnapshot(),
-                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
-    database_->IncrementPriorityWork(env);
-  }
-
-  rocksdb::Status Execute(Database& database) override {
-    rocksdb::ReadOptions readOptions;
-    readOptions.fill_cache = fillCache_;
-    readOptions.snapshot = snapshot_.get();
-
-    auto status = database.db_->Get(readOptions, column_, key_, &value_);
-
-    key_.clear();
-    snapshot_ = nullptr;
-
-    return status;
-  }
-
-  napi_status OnOk(napi_env env, napi_value callback) override {
-    napi_value argv[2];
-    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
-
-    NAPI_STATUS_RETURN(Convert(env, &value_, asBuffer_, argv[1]));
-
-    return CallFunction(env, callback, 2, argv);
-  }
-
-  void Destroy(napi_env env) override {
-    database_->DecrementPriorityWork(env);
-    Worker::Destroy(env);
-  }
-
- private:
-  rocksdb::ColumnFamilyHandle* column_;
-  std::string key_;
-  rocksdb::PinnableSlice value_;
-  const bool asBuffer_;
-  const bool fillCache_;
-  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
-};
-
-NAPI_METHOD(db_get) {
-  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(ToString(env, argv[1], key));
-
-  const auto asBuffer = EncodingIsBuffer(env, argv[2], "valueEncoding");
-  const auto fillCache = BooleanProperty(env, argv[2], "fillCache").value_or(true);
-
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[2], &column));
-
-  auto worker = new GetWorker(env, database, column, argv[3], key, asBuffer, fillCache);
-  worker->Queue(env);
-
-  return 0;
-}
-
 struct GetManyWorker final : public Worker {
   GetManyWorker(napi_env env,
                 Database* database,
@@ -1420,24 +1409,6 @@ NAPI_METHOD(db_get_many) {
   return 0;
 }
 
-NAPI_METHOD(db_del) {
-  NAPI_ARGV(3);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
-  rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
-
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[2], &column));
-
-  rocksdb::WriteOptions writeOptions;
-  ROCKS_STATUS_THROWS(database->db_->Delete(writeOptions, column, key));
-
-  return 0;
-}
-
 NAPI_METHOD(db_clear) {
   NAPI_ARGV(2);
 
@@ -1806,11 +1777,6 @@ NAPI_METHOD(batch_do) {
 }
 
 NAPI_METHOD(batch_init) {
-  NAPI_ARGV(1);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
-
   auto batch = new rocksdb::WriteBatch();
 
   napi_value result;
@@ -1820,53 +1786,79 @@ NAPI_METHOD(batch_init) {
 }
 
 NAPI_METHOD(batch_put) {
-  NAPI_ARGV(5);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+  NAPI_ARGV(4);
 
   rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], (void**)(&batch)));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)(&batch)));
 
   rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[2], key));
+  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
 
   rocksdb::PinnableSlice val;
-  NAPI_STATUS_THROWS(ToString(env, argv[3], val));
+  NAPI_STATUS_THROWS(ToString(env, argv[2], val));
 
   rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[4], &column));
+  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[3], &column));
 
-  ROCKS_STATUS_THROWS(batch->Put(column, key, val));
+  if (column) {
+    ROCKS_STATUS_THROWS(batch->Put(column, key, val));
+  } else {
+    ROCKS_STATUS_THROWS(batch->Put(key, val));
+  }
 
   return 0;
 }
 
 NAPI_METHOD(batch_del) {
-  NAPI_ARGV(4);
+  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[0], reinterpret_cast<void**>(&batch)));
+
+  rocksdb::PinnableSlice key;
+  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
+
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[2], &column));
+
+  if (column) {
+    ROCKS_STATUS_THROWS(batch->Delete(column, key));
+  } else {
+    ROCKS_STATUS_THROWS(batch->Delete(key));
+  }
+
+  return 0;
+}
+
+NAPI_METHOD(batch_merge) {
+  NAPI_ARGV(4);
 
   rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)(&batch)));
 
   rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[2], key));
+  NAPI_STATUS_THROWS(ToString(env, argv[1], key));
+
+  rocksdb::PinnableSlice val;
+  NAPI_STATUS_THROWS(ToString(env, argv[2], val));
 
   rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[3], &column));
+  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[3], &column));
 
-  ROCKS_STATUS_THROWS(batch->Delete(column, key));
+  if (column) {
+    ROCKS_STATUS_THROWS(batch->Merge(column, key, val));
+  } else {
+    ROCKS_STATUS_THROWS(batch->Merge(key, val));
+  }
 
   return 0;
 }
 
 NAPI_METHOD(batch_clear) {
-  NAPI_ARGV(2);
+  NAPI_ARGV(1);
 
   rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
   batch->Clear();
 
@@ -1889,53 +1881,65 @@ NAPI_METHOD(batch_write) {
 }
 
 NAPI_METHOD(batch_put_log_data) {
-  NAPI_ARGV(4);
-
-  Database* database;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+  NAPI_ARGV(3);
 
   rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
   rocksdb::PinnableSlice logData;
-  NAPI_STATUS_THROWS(ToString(env, argv[2], logData));
+  NAPI_STATUS_THROWS(ToString(env, argv[1], logData));
 
   ROCKS_STATUS_THROWS(batch->PutLogData(logData));
 
   return 0;
 }
 
-NAPI_METHOD(batch_merge) {
-  NAPI_ARGV(5);
+NAPI_METHOD(batch_count) {
+  NAPI_ARGV(1);
+
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_int64(env, batch->Count(), &result));
+
+  return result;
+}
+
+NAPI_METHOD(batch_iterate) {
+  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], (void**)(&batch)));
-
-  rocksdb::PinnableSlice key;
-  NAPI_STATUS_THROWS(ToString(env, argv[2], key));
-
-  rocksdb::PinnableSlice val;
-  NAPI_STATUS_THROWS(ToString(env, argv[3], val));
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::ColumnFamilyHandle* column;
-  NAPI_STATUS_THROWS(GetColumnFamily(database, env, argv[4], &column));
+  napi_value keysProperty;
+  bool keys;
+  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "keys", &keysProperty));
+  NAPI_STATUS_THROWS(napi_get_value_bool(env, keysProperty, &keys));
 
-  ROCKS_STATUS_THROWS(batch->Merge(column, key, val));
+  napi_value valuesProperty;
+  bool values;
+  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "values", &valuesProperty));
+  NAPI_STATUS_THROWS(napi_get_value_bool(env, valuesProperty, &values));
 
-  return 0;
-}
+  napi_value dataProperty;
+  bool data;
+  NAPI_STATUS_THROWS(napi_get_named_property(env, argv[2], "data", &dataProperty));
+  NAPI_STATUS_THROWS(napi_get_value_bool(env, dataProperty, &data));
 
-NAPI_METHOD(batch_count) {
-  NAPI_ARGV(2);
+  const bool keyAsBuffer = EncodingIsBuffer(env, argv[1], "keyEncoding");
+  const bool valueAsBuffer = EncodingIsBuffer(env, argv[1], "valueEncoding");
 
-  rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
+  rocksdb::ColumnFamilyHandle* column;
+  NAPI_STATUS_THROWS(GetColumnFamily(nullptr, env, argv[2], &column));
 
   napi_value result;
-  NAPI_STATUS_THROWS(napi_create_int64(env, batch->Count(), &result));
+  BatchIterator iterator(nullptr, keys, values, data, column, keyAsBuffer, valueAsBuffer);
+
+  NAPI_STATUS_THROWS(iterator.Iterate(env, *batch, &result));
 
   return result;
 }
@@ -2020,10 +2024,7 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
   NAPI_EXPORT_FUNCTION(db_close);
-  NAPI_EXPORT_FUNCTION(db_put);
-  NAPI_EXPORT_FUNCTION(db_get);
   NAPI_EXPORT_FUNCTION(db_get_many);
-  NAPI_EXPORT_FUNCTION(db_del);
   NAPI_EXPORT_FUNCTION(db_clear);
   NAPI_EXPORT_FUNCTION(db_get_property);
   NAPI_EXPORT_FUNCTION(db_get_latest_sequence);
@@ -2051,4 +2052,5 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(batch_put_log_data);
   NAPI_EXPORT_FUNCTION(batch_merge);
   NAPI_EXPORT_FUNCTION(batch_count);
+  NAPI_EXPORT_FUNCTION(batch_iterate);
 }

package/chained-batch.js

@@ -2,55 +2,104 @@
 
 const { AbstractChainedBatch } = require('abstract-level')
 const binding = require('./binding')
+const ModuleError = require('module-error')
+const kWrite = Symbol('write')
+const kBatchContext = Symbol('batchContext')
+const kDbContext = Symbol('dbContext')
 
-const kDbContext = Symbol('db')
-const kBatchContext = Symbol('context')
+const NOOP = () => {}
+const EMPTY = {}
 
 class ChainedBatch extends AbstractChainedBatch {
-  constructor (db, context) {
+  constructor (db, context, write) {
     super(db)
 
+    this[kWrite] = write
     this[kDbContext] = context
-    this[kBatchContext] = binding.batch_init(this[kDbContext])
+    this[kBatchContext] = binding.batch_init()
   }
 
   _put (key, value, options) {
-    binding.batch_put(this[kDbContext], this[kBatchContext], key, value, options)
+    if (key === null || key === undefined) {
+      throw new ModuleError('Key cannot be null or undefined', {
+        code: 'LEVEL_INVALID_KEY'
+      })
+    }
+
+    if (value === null || value === undefined) {
+      throw new ModuleError('value cannot be null or undefined', {
+        code: 'LEVEL_INVALID_VALUE'
+      })
+    }
+
+    binding.batch_put(this[kBatchContext], key, value, options ?? EMPTY)
   }
 
   _del (key, options) {
-    binding.batch_del(this[kDbContext], this[kBatchContext], key, options)
+    if (key === null || key === undefined) {
+      throw new ModuleError('Key cannot be null or undefined', {
+        code: 'LEVEL_INVALID_KEY'
+      })
+    }
+
+    binding.batch_del(this[kBatchContext], key, options ?? EMPTY)
   }
 
   _clear () {
-    binding.batch_clear(this[kDbContext], this[kBatchContext])
+    binding.batch_clear(this[kBatchContext])
   }
 
   _write (options, callback) {
-    try {
-      binding.batch_write(this[kDbContext], this[kBatchContext], options)
-      process.nextTick(callback, null)
-    } catch (err) {
-      process.nextTick(callback, err)
-    }
+    this[kWrite](this, this[kBatchContext], options ?? EMPTY, callback ?? NOOP)
   }
 
   _close (callback) {
     process.nextTick(callback)
   }
 
-  putLogData (data, options) {
-    // TODO (fix): Check if open...
-    binding.batch_put_log_data(this[kDbContext], this[kBatchContext], data, options)
+  get length () {
+    return binding.batch_count(this[kBatchContext])
+  }
+
+  _putLogData (value, options) {
+    if (value === null || value === undefined) {
+      throw new ModuleError('value cannot be null or undefined', {
+        code: 'LEVEL_INVALID_VALUE'
+      })
+    }
+
+    binding.batch_put_log_data(this[kBatchContext], value, options ?? EMPTY)
   }
 
-  merge (key, value, options = {}) {
-    // TODO (fix): Check if open...
-    binding.batch_merge(this[kDbContext], this[kBatchContext], key, value, options)
+  _merge (key, value, options) {
+    if (key === null || key === undefined) {
+      throw new ModuleError('Key cannot be null or undefined', {
+        code: 'LEVEL_INVALID_KEY'
+      })
+    }
+
+    if (value === null || value === undefined) {
+      throw new ModuleError('value cannot be null or undefined', {
+        code: 'LEVEL_INVALID_VALUE'
+      })
+    }
+
+    binding.batch_merge(this[kBatchContext], key, value, options ?? EMPTY)
   }
 
-  get count () {
-    return binding.batch_count(this[kDbContext], this[kBatchContext])
+  * [Symbol.iterator] () {
+    const rows = binding.batch_iterate(this[kDbContext], this[kBatchContext], {
+      keys: true,
+      values: true,
+      data: true
+    })
+    for (let n = 0; n < rows.length; n += 4) {
+      yield {
+        type: rows[n + 0],
+        key: rows[n + 1],
+        value: rows[n + 2]
+      }
+    }
   }
 }
 

package/index.js

@@ -96,25 +96,41 @@ class RocksLevel extends AbstractLevel {
 
   _put (key, value, options, callback) {
     try {
-      binding.db_put(this[kContext], key, value, options)
-      process.nextTick(callback, null)
+      const batch = this.batch()
+      batch.put(key, value, options)
+      batch.write(callback)
     } catch (err) {
       process.nextTick(callback, err)
     }
   }
 
   _get (key, options, callback) {
-    binding.db_get(this[kContext], key, options, callback)
+    this._getMany([key], options, (err, val) => {
+      if (err) {
+        callback(err)
+      } else if (val[0] === undefined) {
+        callback(Object.assign(new Error('not found'), {
+          code: 'LEVEL_NOT_FOUND'
+        }))
+      } else {
+        callback(null, val[0])
+      }
+    })
   }
 
   _getMany (keys, options, callback) {
-    binding.db_get_many(this[kContext], keys, options, callback)
+    try {
+      binding.db_get_many(this[kContext], keys, options, callback)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
   }
 
   _del (key, options, callback) {
     try {
-      binding.db_del(this[kContext], key, options)
-      process.nextTick(callback, null)
+      const batch = this.batch()
+      batch.del(key, options)
+      batch.write(callback)
     } catch (err) {
       process.nextTick(callback, err)
     }
@@ -122,6 +138,7 @@ class RocksLevel extends AbstractLevel {
 
   _clear (options, callback) {
     try {
+      // TODO (fix): Use batch + DeleteRange...
       binding.db_clear(this[kContext], options)
       process.nextTick(callback, null)
     } catch (err) {
@@ -130,7 +147,16 @@ class RocksLevel extends AbstractLevel {
   }
 
   _chainedBatch () {
-    return new ChainedBatch(this, this[kContext])
+    return new ChainedBatch(this, this[kContext], (batch, context, options, callback) => {
+      try {
+        const seq = this.sequence
+        binding.batch_write(this[kContext], context, options)
+        this.emit('write', batch, seq + 1)
+        process.nextTick(callback, null)
+      } catch (err) {
+        process.nextTick(callback, err)
+      }
+    })
   }
 
   _batch (operations, options, callback) {

package/max_rev_operator.h

@@ -1,17 +1,15 @@
 #pragma once
 
-#include <memory.h>
-
 int compareRev(const rocksdb::Slice& a, const rocksdb::Slice& b) {
-  auto indexA = 0;
-  auto indexB = 0;
+  auto indexA = 0UL;
+  auto indexB = 0UL;
   const auto endA = a.size();
   const auto endB = b.size();
 
   // Compare the revision number
   auto result = 0;
   const auto end = std::min(endA, endB);
-  while (indexA < end) {
+  while (indexA < end && indexB < end) {
     const auto ac = a[indexA++];
     const auto bc = b[indexB++];
 
@@ -45,8 +43,6 @@ int compareRev(const rocksdb::Slice& a, const rocksdb::Slice& b) {
   return endA - endB;
 }
 
-// Merge operator that picks the maximum operand, Comparison is based on
-// Slice::compare
 class MaxRevOperator : public rocksdb::MergeOperator {
  public:
   bool FullMergeV2(const MergeOperationInput& merge_in,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "7.0.42",
+  "version": "7.0.45",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "abstract-level": "^1.0.2",
-    "module-error": "^1.0.1",
+    "module-error": "^1.0.2",
     "napi-macros": "~2.0.0",
     "node-gyp-build": "^4.3.0"
   },