@nxtedition/rocksdb 6.0.3 → 7.0.0-alpha.3

package/binding.cc

@@ -30,6 +30,7 @@ class NullLogger : public rocksdb::Logger {
 
 struct Database;
 struct Iterator;
+struct Updates;
 
 #define NAPI_STATUS_RETURN(call) \
   {                              \
@@ -39,17 +40,14 @@ struct Iterator;
     }                            \
   }
 
-#define NAPI_DB_CONTEXT()       \
-  Database* database = nullptr; \
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
-
-#define NAPI_ITERATOR_CONTEXT() \
-  Iterator* iterator = nullptr; \
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
-
-#define NAPI_BATCH_CONTEXT()            \
-  rocksdb::WriteBatch* batch = nullptr; \
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&batch));
+#define ROCKS_STATUS_THROWS(call) \
+  {                              \
+    const auto status = (call);  \
+    if (!status.ok()) {     \
+      napi_throw(env, ToError(env, status)); \
+      return NULL; \
+    }                            \
+  }
 
 static bool IsString(napi_env env, napi_value value) {
   napi_valuetype type;
@@ -111,6 +109,20 @@ static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_vie
   return false;
 }
 
+template <typename T>
+static std::optional<T*> ExternalValueProperty(napi_env env, napi_value obj, const std::string_view& key) {
+  if (HasProperty(env, obj, key.data())) {
+    const auto value = GetProperty(env, obj, key.data());
+
+    T* result;
+    if (napi_get_value_external(env, value, reinterpret_cast<void**>(&result)) == napi_ok) {
+      return result;
+    }
+  }
+
+  return {};
+}
+
 static std::optional<uint32_t> Uint32Property(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
@@ -133,6 +145,18 @@ static std::optional<int> Int32Property(napi_env env, napi_value obj, const std:
   return {};
 }
 
+static std::optional<int64_t> Int64Property(napi_env env, napi_value obj, const std::string_view& key) {
+  if (HasProperty(env, obj, key.data())) {
+    const auto value = GetProperty(env, obj, key.data());
+    int64_t result;
+    bool lossless;
+    napi_get_value_bigint_int64(env, value, &result, &lossless);
+    return result;
+  }
+
+  return {};
+}
+
 static std::string ToString(napi_env env, napi_value from, const std::string& defaultValue = "") {
   if (IsString(env, from)) {
     size_t length = 0;
@@ -210,6 +234,18 @@ napi_status Convert(napi_env env, rocksdb::PinnableSlice&& s, bool asBuffer, nap
   }
 }
 
+napi_status Convert(napi_env env, std::optional<std::string>&& s, bool asBuffer, napi_value& result) {
+  if (!s) {
+    return napi_get_null(env, &result);
+  } else if (asBuffer) {
+    auto ptr = new std::string(std::move(*s));
+    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<std::string>, ptr,
+                                       &result);
+  } else {
+    return napi_create_string_utf8(env, s->data(), s->size(), &result);
+  }
+}
+
 struct NapiSlice : public rocksdb::Slice {
   std::unique_ptr<char[]> heap_;
   std::array<char, 128> stack_;
@@ -318,6 +354,16 @@ struct Database {
     DecrementPriorityWork(env);
   }
 
+  void AttachUpdates(napi_env env, Updates* update) {
+    updates_.insert(update);
+    IncrementPriorityWork(env);
+  }
+
+  void DetachUpdates(napi_env env, Updates* update) {
+    updates_.erase(update);
+    DecrementPriorityWork(env);
+  }
+
   void IncrementPriorityWork(napi_env env) { napi_reference_ref(env, priorityRef_, &priorityWork_); }
 
   void DecrementPriorityWork(napi_env env) {
@@ -334,6 +380,8 @@ struct Database {
   std::unique_ptr<rocksdb::DB> db_;
   Worker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
+  std::set<Updates*> updates_;
+  std::vector<rocksdb::ColumnFamilyHandle*> columns_;
   napi_ref priorityRef_;
 
  private:
@@ -342,16 +390,18 @@ struct Database {
 
 struct BaseIterator {
   BaseIterator(Database* database,
+               rocksdb::ColumnFamilyHandle* column,
                const bool reverse,
                const std::optional<std::string>& lt,
                const std::optional<std::string>& lte,
                const std::optional<std::string>& gt,
                const std::optional<std::string>& gte,
                const int limit,
-               const bool fillCache)
+               const bool fillCache,
+               std::shared_ptr<const rocksdb::Snapshot> snapshot)
       : database_(database),
-        snapshot_(database_->db_->GetSnapshot(),
-                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }),
+        column_(column),
+        snapshot_(snapshot),
         reverse_(reverse),
         limit_(limit),
         fillCache_(fillCache) {
@@ -434,6 +484,8 @@ struct BaseIterator {
   rocksdb::Status Status() const { return iterator_->status(); }
 
   Database* database_;
+  rocksdb::ColumnFamilyHandle* column_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 
  private:
   void Init() {
@@ -448,12 +500,11 @@ struct BaseIterator {
     options.snapshot = snapshot_.get();
     options.async_io = true;
 
-    iterator_.reset(database_->db_->NewIterator(options));
+    iterator_.reset(database_->db_->NewIterator(options, column_));
   }
 
   std::optional<rocksdb::PinnableSlice> lower_bound_;
   std::optional<rocksdb::PinnableSlice> upper_bound_;
-  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
   std::unique_ptr<rocksdb::Iterator> iterator_;
   const bool reverse_;
   const int limit_;
@@ -463,6 +514,7 @@ struct BaseIterator {
 
 struct Iterator final : public BaseIterator {
   Iterator(Database* database,
+           rocksdb::ColumnFamilyHandle* column,
            const bool reverse,
            const bool keys,
            const bool values,
@@ -474,8 +526,9 @@ struct Iterator final : public BaseIterator {
            const bool fillCache,
            const bool keyAsBuffer,
            const bool valueAsBuffer,
-           const uint32_t highWaterMarkBytes)
-      : BaseIterator(database, reverse, lt, lte, gt, gte, limit, fillCache),
+           const uint32_t highWaterMarkBytes,
+           std::shared_ptr<const rocksdb::Snapshot> snapshot)
+      : BaseIterator(database, column, reverse, lt, lte, gt, gte, limit, fillCache, snapshot),
         keys_(keys),
         values_(values),
         keyAsBuffer_(keyAsBuffer),
@@ -505,6 +558,39 @@ struct Iterator final : public BaseIterator {
   napi_ref ref_ = nullptr;
 };
 
+struct Updates {
+  Updates(Database* database, const bool keyAsBuffer, const bool valueAsBuffer, int64_t seqNumber)
+      : database_(database), keyAsBuffer_(keyAsBuffer), valueAsBuffer_(valueAsBuffer), seqNumber_(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_;
+  const bool keyAsBuffer_;
+  const bool valueAsBuffer_;
+  int64_t seqNumber_;
+  std::unique_ptr<rocksdb::TransactionLogIterator> iterator_;
+
+ private:
+  napi_ref ref_ = nullptr;
+};
+
+static rocksdb::ColumnFamilyHandle* GetColumnFamily(Database* database, napi_env env, napi_value options) {
+  auto column_opt = ExternalValueProperty<rocksdb::ColumnFamilyHandle>(env, options, "column");
+  return column_opt ? *column_opt : database->db_->DefaultColumnFamily();
+}
+
 /**
  * Hook for when the environment exits. This hook will be called after
  * already-scheduled napi_async_work items have finished, which gives us
@@ -521,11 +607,20 @@ 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_) {
-    // TODO: does not do `napi_delete_reference(env, iterator->ref_)`. Problem?
     for (auto it : database->iterators_) {
+      // TODO: does not do `napi_delete_reference`. Problem?
+      it->Close();
+    }
+
+    for (auto it : database->updates_) {
+      // TODO: does not do `napi_delete_reference`. Problem?
       it->Close();
     }
 
+    for (auto it : database->columns_) {
+      database->db_->DestroyColumnFamilyHandle(it);
+    }
+
     // Having closed the iterators (and released snapshots) we can safely close.
     database->db_->Close();
   }
@@ -558,55 +653,154 @@ struct OpenWorker final : public Worker {
              Database* database,
              napi_value callback,
              const std::string& location,
-             rocksdb::Options options,
-             const bool readOnly)
+             const rocksdb::Options& options,
+             std::vector<rocksdb::ColumnFamilyDescriptor> column_families)
       : Worker(env, database, callback, "leveldown.db.open"),
         options_(options),
-        readOnly_(readOnly),
-        location_(location) {}
+        location_(location),
+        column_families_(std::move(column_families)) {}
 
   rocksdb::Status Execute(Database& database) override {
     rocksdb::DB* db = nullptr;
-    const auto status = readOnly_ ? rocksdb::DB::OpenForReadOnly(options_, location_, &db)
-                                  : rocksdb::DB::Open(options_, location_, &db);
+    const auto status = column_families_.empty()
+      ? rocksdb::DB::Open(options_, location_, &db)
+      : rocksdb::DB::Open(options_, location_, column_families_, &database.columns_, &db);
     database.db_.reset(db);
     return status;
   }
 
+  napi_status OnOk(napi_env env, napi_value callback) override {    
+    const auto size = database_->columns_.size();
+    napi_value result;
+    NAPI_STATUS_RETURN(napi_create_object(env, &result));
+  
+    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, result, column_families_[n].name.c_str(), column));
+    }
+
+    napi_value argv[2];
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+    argv[1] = result;
+    return CallFunction(env, callback, 2, argv);
+  }
+
   rocksdb::Options options_;
-  const bool readOnly_;
   const std::string location_;
+  std::vector<rocksdb::ColumnFamilyDescriptor> column_families_;
 };
 
-NAPI_METHOD(db_open) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
-
-  rocksdb::Options options;
-
-  options.IncreaseParallelism(
-      Uint32Property(env, argv[2], "parallelism").value_or(std::thread::hardware_concurrency() / 2));
+napi_status InitOptions(napi_env env, auto& options, auto options2) {
+  const auto memtable_memory_budget = Uint32Property(env, options2, "memtableMemoryBudget").value_or(256 * 1024 * 1024);
+
+  const auto compaction = StringProperty(env, options2, "compaction").value_or("level");
+
+  if (compaction == "universal") {
+    options.write_buffer_size = static_cast<size_t>(memtable_memory_budget / 4);
+    // merge two memtables when flushing to L0
+    options.min_write_buffer_number_to_merge = 2;
+    // this means we'll use 50% extra memory in the worst case, but will reduce
+    // write stalls.
+    options.max_write_buffer_number = 6;
+    // universal style compaction
+    options.compaction_style = rocksdb::kCompactionStyleUniversal;
+    options.compaction_options_universal.compression_size_percent = 80;
+  } else {
+    // merge two memtables when flushing to L0
+    options.min_write_buffer_number_to_merge = 2;
+    // this means we'll use 50% extra memory in the worst case, but will reduce
+    // write stalls.
+    options.max_write_buffer_number = 6;
+    // start flushing L0->L1 as soon as possible. each file on level0 is
+    // (memtable_memory_budget / 2). This will flush level 0 when it's bigger than
+    // memtable_memory_budget.
+    options.level0_file_num_compaction_trigger = 2;
+    // doesn't really matter much, but we don't want to create too many files
+    options.target_file_size_base = memtable_memory_budget / 8;
+    // make Level1 size equal to Level0 size, so that L0->L1 compactions are fast
+    options.max_bytes_for_level_base = memtable_memory_budget;
+
+    // level style compaction
+    options.compaction_style = rocksdb::kCompactionStyleLevel;
+
+    // TODO (perf): only compress levels >= 2
+  }
 
-  const auto location = ToString(env, argv[1]);
-  options.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
-  options.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
-  options.compression = BooleanProperty(env, argv[2], "compression").value_or((true)) ? rocksdb::kZSTD
-                                                                                      : rocksdb::kNoCompression;
+  options.compression =
+      BooleanProperty(env, options2, "compression").value_or((true)) ? rocksdb::kZSTD : rocksdb::kNoCompression;
   if (options.compression == rocksdb::kZSTD) {
     options.compression_opts.max_dict_bytes = 16 * 1024;
     options.compression_opts.zstd_max_train_bytes = 16 * 1024 * 100;
     // options.compression_opts.parallel_threads
   }
 
-  options.use_adaptive_mutex = BooleanProperty(env, argv[2], "useAdaptiveMutex").value_or(true);
-  options.enable_pipelined_write = BooleanProperty(env, argv[2], "enablePipelinedWrite").value_or(true);
-  options.max_background_jobs =
-      Uint32Property(env, argv[2], "maxBackgroundJobs").value_or(std::thread::hardware_concurrency() / 4);
+  const auto cacheSize = Uint32Property(env, options2, "cacheSize").value_or(8 << 20);
+
+  rocksdb::BlockBasedTableOptions tableOptions;
+
+  if (cacheSize) {
+    tableOptions.block_cache = rocksdb::NewLRUCache(cacheSize);
+    tableOptions.cache_index_and_filter_blocks =
+        BooleanProperty(env, options2, "cacheIndexAndFilterBlocks").value_or(true);
+  } else {
+    tableOptions.no_block_cache = true;
+    tableOptions.cache_index_and_filter_blocks = false;
+  }
+
+  const auto optimize = StringProperty(env, options2, "optimize").value_or("");
+
+  if (optimize == "point-lookup") {
+    tableOptions.data_block_index_type = rocksdb::BlockBasedTableOptions::kDataBlockBinaryAndHash;
+    tableOptions.data_block_hash_table_util_ratio = 0.75;
+    tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10, 1));
+
+    options.memtable_prefix_bloom_size_ratio = 0.02;
+    options.memtable_whole_key_filtering = true;
+  } else if (optimize == "range-lookup") {
+    // TODO?
+  } else {
+    tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
+  }
+
+  tableOptions.block_size = Uint32Property(env, options2, "blockSize").value_or(4096);
+  tableOptions.block_restart_interval = Uint32Property(env, options2, "blockRestartInterval").value_or(16);
+  tableOptions.format_version = 5;
+  tableOptions.checksum = rocksdb::kXXH3;
+  tableOptions.optimize_filters_for_memory = BooleanProperty(env, options2, "optimizeFiltersForMemory").value_or(true);
+
+  options.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
+
+  return napi_ok;
+}
+
+NAPI_METHOD(db_open) {
+  NAPI_ARGV(4);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+
+  const auto location = ToString(env, argv[1]);
+  const auto options = argv[2];
+  const auto callback = argv[3];
+
+  rocksdb::Options dbOptions;
+
+  dbOptions.IncreaseParallelism(
+      Uint32Property(env, options, "parallelism").value_or(std::thread::hardware_concurrency() / 2));
 
-  // TODO: Consider direct IO (https://github.com/facebook/rocksdb/wiki/Direct-IO) once
-  // secondary compressed cache is stable.
+  dbOptions.create_if_missing = BooleanProperty(env, options, "createIfMissing").value_or(true);
+  dbOptions.error_if_exists = BooleanProperty(env, options, "errorIfExists").value_or(false);
+  dbOptions.avoid_unnecessary_blocking_io = true;
+  dbOptions.use_adaptive_mutex = BooleanProperty(env, options, "useAdaptiveMutex").value_or(true);
+  dbOptions.enable_pipelined_write = BooleanProperty(env, options, "enablePipelinedWrite").value_or(true);
+  dbOptions.max_background_jobs =
+      Uint32Property(env, options, "maxBackgroundJobs").value_or(std::thread::hardware_concurrency() / 4);
+  dbOptions.WAL_ttl_seconds = Uint32Property(env, options, "walTTL").value_or(0) / 1e3;
+  dbOptions.WAL_size_limit_MB = Uint32Property(env, options, "walSizeLimit").value_or(0) / 1e6;
+  dbOptions.create_missing_column_families = true;
 
-  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
+  const auto infoLogLevel = StringProperty(env, options, "infoLogLevel").value_or("");
   if (infoLogLevel.size() > 0) {
     rocksdb::InfoLogLevel lvl = {};
 
@@ -625,40 +819,43 @@ NAPI_METHOD(db_open) {
     else
       napi_throw_error(env, nullptr, "invalid log level");
 
-    options.info_log_level = lvl;
+    dbOptions.info_log_level = lvl;
   } else {
     // In some places RocksDB checks this option to see if it should prepare
     // debug information (ahead of logging), so set it to the highest level.
-    options.info_log_level = rocksdb::InfoLogLevel::HEADER_LEVEL;
-    options.info_log.reset(new NullLogger());
+    dbOptions.info_log_level = rocksdb::InfoLogLevel::HEADER_LEVEL;
+    dbOptions.info_log.reset(new NullLogger());
   }
 
-  const auto readOnly = BooleanProperty(env, argv[2], "readOnly").value_or(false);
-  const auto cacheSize = Uint32Property(env, argv[2], "cacheSize").value_or(8 << 20);
+  NAPI_STATUS_THROWS(InitOptions(env, dbOptions, options));
 
-  rocksdb::BlockBasedTableOptions tableOptions;
+  std::vector<rocksdb::ColumnFamilyDescriptor> column_families;
+  
+  if (HasProperty(env, options, "columns")) {
+    napi_value columns;
+    NAPI_STATUS_THROWS(napi_get_named_property(env, options, "columns", &columns));
 
-  if (cacheSize) {
-    tableOptions.block_cache = rocksdb::NewLRUCache(cacheSize);
-    tableOptions.cache_index_and_filter_blocks =
-        BooleanProperty(env, argv[2], "cacheIndexAndFilterBlocks").value_or(true);
-  } else {
-    tableOptions.no_block_cache = true;
-    tableOptions.cache_index_and_filter_blocks = false;
-  }
+    napi_value keys;
+    NAPI_STATUS_THROWS(napi_get_property_names(env, columns, &keys));
 
-  tableOptions.block_size = Uint32Property(env, argv[2], "blockSize").value_or(4096);
-  tableOptions.block_restart_interval = Uint32Property(env, argv[2], "blockRestartInterval").value_or(16);
-  tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
-  tableOptions.format_version = 5;
-  tableOptions.checksum = rocksdb::kXXH3;
-  tableOptions.optimize_filters_for_memory = BooleanProperty(env, argv[2], "optimizeFiltersForMemory").value_or(true);
+    uint32_t len;
+    NAPI_STATUS_THROWS(napi_get_array_length(env, keys, &len));
 
-  options.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));
+    for (uint32_t n = 0; n < len; ++n) {
+      napi_value key;
+      NAPI_STATUS_THROWS(napi_get_element(env, keys, n, &key));
+      
+      napi_value column;
+      NAPI_STATUS_THROWS(napi_get_property(env, columns, key, &column));
 
-  const auto callback = argv[3];
+      rocksdb::ColumnFamilyOptions columnOptions;
+      NAPI_STATUS_THROWS(InitOptions(env, columnOptions, column));
 
-  auto worker = new OpenWorker(env, database, callback, location, options, readOnly);
+      column_families.emplace_back(ToString(env, key), columnOptions);
+    }
+  }
+
+  auto worker = new OpenWorker(env, database, callback, location, dbOptions, column_families);
   worker->Queue(env);
 
   return 0;
@@ -668,7 +865,13 @@ struct CloseWorker final : public Worker {
   CloseWorker(napi_env env, Database* database, napi_value callback)
       : Worker(env, database, callback, "leveldown.db.close") {}
 
-  rocksdb::Status Execute(Database& database) override { return database.db_->Close(); }
+  rocksdb::Status Execute(Database& database) override { 
+    for (auto it : database.columns_) {
+      database.db_->DestroyColumnFamilyHandle(it);
+    }
+
+    return database.db_->Close(); 
+  }
 };
 
 napi_value noop_callback(napi_env env, napi_callback_info info) {
@@ -677,7 +880,9 @@ napi_value noop_callback(napi_env env, napi_callback_info info) {
 
 NAPI_METHOD(db_close) {
   NAPI_ARGV(2);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   const auto callback = argv[1];
 
@@ -692,9 +897,147 @@ NAPI_METHOD(db_close) {
   return 0;
 }
 
+struct UpdateNextWorker final : public rocksdb::WriteBatch::Handler, public Worker {
+  UpdateNextWorker(napi_env env, Updates* updates, napi_value callback)
+      : Worker(env, updates->database_, callback, "rocks_level.db.get"), updates_(updates) {
+    database_->IncrementPriorityWork(env);
+  }
+
+  rocksdb::Status Execute(Database& database) override {
+    rocksdb::TransactionLogIterator::ReadOptions options;
+
+    if (!updates_->iterator_) {
+      const auto status = database_->db_->GetUpdatesSince(updates_->seqNumber_, &updates_->iterator_, options);
+      if (!status.ok()) {
+        return status;
+      }
+    }
+
+    if (!updates_->iterator_->Valid()) {
+      return rocksdb::Status::OK();
+    }
+
+    auto batch = updates_->iterator_->GetBatch();
+
+    updates_->seqNumber_ = batch.sequence;
+
+    const auto status = batch.writeBatchPtr->Iterate(this);
+    if (!status.ok()) {
+      return status;
+    }
+
+    updates_->iterator_->Next();
+
+    return rocksdb::Status::OK();
+  }
+
+  napi_status OnOk(napi_env env, napi_value callback) override {
+    const auto size = cache_.size();
+    napi_value result;
+
+    if (cache_.size()) {
+      NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &result));
+
+      for (size_t idx = 0; idx < cache_.size(); idx += 2) {
+        napi_value key;
+        napi_value val;
+
+        NAPI_STATUS_RETURN(Convert(env, std::move(cache_[idx + 0]), updates_->keyAsBuffer_, key));
+        NAPI_STATUS_RETURN(Convert(env, std::move(cache_[idx + 1]), updates_->valueAsBuffer_, val));
+
+        NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 0), key));
+        NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 1), val));
+      }
+
+      cache_.clear();
+    } else {
+      NAPI_STATUS_RETURN(napi_get_null(env, &result));
+    }
+
+    napi_value argv[3];
+    NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
+    argv[1] = result;
+    NAPI_STATUS_RETURN(napi_create_bigint_int64(env, updates_->seqNumber_, &argv[2]));
+    return CallFunction(env, callback, 3, argv);
+  }
+
+  void Destroy(napi_env env) override {
+    database_->DecrementPriorityWork(env);
+    Worker::Destroy(env);
+  }
+
+  void Put(const rocksdb::Slice& key, const rocksdb::Slice& value) override {
+    cache_.emplace_back(key.ToString());
+    cache_.emplace_back(value.ToString());
+  }
+
+  void Delete(const rocksdb::Slice& key) override {
+    cache_.emplace_back(key.ToString());
+    cache_.emplace_back(std::nullopt);
+  }
+
+  bool Continue() override { return true; }
+
+ private:
+  std::vector<std::optional<std::string>> cache_;
+  Updates* updates_;
+};
+
+NAPI_METHOD(updates_init) {
+  NAPI_ARGV(2);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+
+  const auto options = argv[1];
+
+  const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
+  const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
+  const auto seqNumber = Int64Property(env, options, "since").value_or(database->db_->GetLatestSequenceNumber());
+
+  auto updates = std::make_unique<Updates>(database, keyAsBuffer, valueAsBuffer, seqNumber);
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_external(env, updates.get(), Finalize<Updates>, updates.get(), &result));
+
+  // Prevent GC of JS object before the iterator is closed (explicitly or on
+  // db close) and keep track of non-closed iterators to end them on db close.
+  updates.release()->Attach(env, result);
+
+  return result;
+}
+
+NAPI_METHOD(updates_next) {
+  NAPI_ARGV(2);
+
+  Updates* updates;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&updates));
+
+  const auto callback = argv[1];
+
+  auto worker = new UpdateNextWorker(env, updates, callback);
+  worker->Queue(env);
+
+  return 0;
+}
+
+NAPI_METHOD(updates_close) {
+  NAPI_ARGV(1);
+
+  Updates* updates;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&updates));
+
+  updates->Detach(env);
+  updates->Close();
+
+  return 0;
+}
+
 NAPI_METHOD(db_put) {
   NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   NapiSlice key;
   NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
@@ -702,18 +1045,20 @@ NAPI_METHOD(db_put) {
   NapiSlice val;
   NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], val));
 
-  rocksdb::WriteOptions options;
-  return ToError(env, database->db_->Put(options, key, val));
+  rocksdb::WriteOptions writeOptions;
+  return ToError(env, database->db_->Put(writeOptions, key, val));
 }
 
 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),
@@ -723,11 +1068,11 @@ struct GetWorker final : public Worker {
   }
 
   rocksdb::Status Execute(Database& database) override {
-    rocksdb::ReadOptions options;
-    options.fill_cache = fillCache_;
-    options.snapshot = snapshot_.get();
+    rocksdb::ReadOptions readOptions;
+    readOptions.fill_cache = fillCache_;
+    readOptions.snapshot = snapshot_.get();
 
-    auto status = database.db_->Get(options, database.db_->DefaultColumnFamily(), key_, &value_);
+    auto status = database.db_->Get(readOptions, column_, key_, &value_);
 
     key_.clear();
     snapshot_ = nullptr;
@@ -748,6 +1093,7 @@ struct GetWorker final : public Worker {
   }
 
  private:
+  rocksdb::ColumnFamilyHandle* column_;
   std::string key_;
   rocksdb::PinnableSlice value_;
   const bool asBuffer_;
@@ -757,15 +1103,18 @@ struct GetWorker final : public Worker {
 
 NAPI_METHOD(db_get) {
   NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   const auto key = ToString(env, argv[1]);
   const auto options = argv[2];
   const auto asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const auto fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
+  const auto column = GetColumnFamily(database, env, options);
   const auto callback = argv[3];
 
-  auto worker = new GetWorker(env, database, callback, key, asBuffer, fillCache);
+  auto worker = new GetWorker(env, database, column, callback, key, asBuffer, fillCache);
   worker->Queue(env);
 
   return 0;
@@ -774,24 +1123,25 @@ NAPI_METHOD(db_get) {
 struct GetManyWorker final : public Worker {
   GetManyWorker(napi_env env,
                 Database* database,
+                rocksdb::ColumnFamilyHandle* column,
                 std::vector<std::string> keys,
                 napi_value callback,
                 const bool valueAsBuffer,
                 const bool fillCache)
       : Worker(env, database, callback, "leveldown.get.many"),
+        column_(column),
         keys_(std::move(keys)),
         valueAsBuffer_(valueAsBuffer),
         fillCache_(fillCache),
-        snapshot_(database_->db_->GetSnapshot(),
-                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
+        snapshot_(database_->db_->GetSnapshot(), [=](const auto ptr) { database_->db_->ReleaseSnapshot(ptr); }) {
     database_->IncrementPriorityWork(env);
   }
 
   rocksdb::Status Execute(Database& database) override {
-    rocksdb::ReadOptions options;
-    options.fill_cache = fillCache_;
-    options.snapshot = snapshot_.get();
-    options.async_io = true;
+    rocksdb::ReadOptions readOptions;
+    readOptions.fill_cache = fillCache_;
+    readOptions.snapshot = snapshot_.get();
+    readOptions.async_io = true;
 
     const auto numKeys = keys_.size();
 
@@ -804,8 +1154,7 @@ struct GetManyWorker final : public Worker {
     statuses_.resize(numKeys);
     values_.resize(numKeys);
 
-    database.db_->MultiGet(options, database.db_->DefaultColumnFamily(), numKeys, keys.data(), values_.data(),
-                           statuses_.data());
+    database.db_->MultiGet(readOptions, column_, numKeys, keys.data(), values_.data(), statuses_.data());
 
     keys_.clear();
     snapshot_ = nullptr;
@@ -850,6 +1199,7 @@ struct GetManyWorker final : public Worker {
   }
 
  private:
+  rocksdb::ColumnFamilyHandle* column_;
   std::vector<std::string> keys_;
   std::vector<rocksdb::PinnableSlice> values_;
   std::vector<rocksdb::Status> statuses_;
@@ -860,7 +1210,9 @@ struct GetManyWorker final : public Worker {
 
 NAPI_METHOD(db_get_many) {
   NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   std::vector<std::string> keys;
   {
@@ -880,9 +1232,10 @@ NAPI_METHOD(db_get_many) {
   const auto options = argv[2];
   const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const bool fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
+  const auto column = GetColumnFamily(database, env, options);
   const auto callback = argv[3];
 
-  auto worker = new GetManyWorker(env, database, std::move(keys), callback, asBuffer, fillCache);
+  auto worker = new GetManyWorker(env, database, column, std::move(keys), callback, asBuffer, fillCache);
   worker->Queue(env);
 
   return 0;
@@ -890,27 +1243,36 @@ NAPI_METHOD(db_get_many) {
 
 NAPI_METHOD(db_del) {
   NAPI_ARGV(3);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   NapiSlice key;
   NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
 
-  rocksdb::WriteOptions options;
-  return ToError(env, database->db_->Delete(options, key));
+  const auto options = argv[2];
+  const auto column = GetColumnFamily(database, env, options);
+
+  rocksdb::WriteOptions writeOptions;
+  return ToError(env, database->db_->Delete(writeOptions, column, key));
 }
 
 NAPI_METHOD(db_clear) {
   NAPI_ARGV(2);
-  NAPI_DB_CONTEXT();
 
-  const auto reverse = BooleanProperty(env, argv[1], "reverse").value_or(false);
-  const auto limit = Int32Property(env, argv[1], "limit").value_or(-1);
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+
+  const auto options = argv[1];
+  const auto reverse = BooleanProperty(env, options, "reverse").value_or(false);
+  const auto limit = Int32Property(env, options, "limit").value_or(-1);
+
+  const auto lt = StringProperty(env, options, "lt");
+  const auto lte = StringProperty(env, options, "lte");
+  const auto gt = StringProperty(env, options, "gt");
+  const auto gte = StringProperty(env, options, "gte");
+  const auto column = GetColumnFamily(database, env, options);
 
-  const auto lt = StringProperty(env, argv[1], "lt");
-  const auto lte = StringProperty(env, argv[1], "lte");
-  const auto gt = StringProperty(env, argv[1], "gt");
-  const auto gte = StringProperty(env, argv[1], "gte");
-  
   if (!reverse && limit == -1 && (lte || lt)) {
     rocksdb::Slice begin;
     if (gte) {
@@ -932,13 +1294,15 @@ NAPI_METHOD(db_clear) {
       return ToError(env, rocksdb::Status::OK());
     }
 
-    rocksdb::WriteOptions options;
-    const auto status = database->db_->DeleteRange(options, database->db_->DefaultColumnFamily(), begin, end);
+    rocksdb::WriteOptions writeOptions;
+    const auto status = database->db_->DeleteRange(writeOptions, column, begin, end);
     return ToError(env, status);
   } else {
     // TODO (perf): Use DeleteRange.
 
-    BaseIterator it(database, reverse, lt, lte, gt, gte, limit, false);
+    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();
 
@@ -946,7 +1310,7 @@ NAPI_METHOD(db_clear) {
     const uint32_t hwm = 16 * 1024;
 
     rocksdb::WriteBatch batch;
-    rocksdb::WriteOptions options;
+    rocksdb::WriteOptions writeOptions;
     rocksdb::Status status;
 
     while (true) {
@@ -954,7 +1318,7 @@ NAPI_METHOD(db_clear) {
 
       while (bytesRead <= hwm && it.Valid() && it.Increment()) {
         const auto key = it.CurrentKey();
-        batch.Delete(key);
+        batch.Delete(column, key);
         bytesRead += key.size();
         it.Next();
       }
@@ -964,7 +1328,7 @@ NAPI_METHOD(db_clear) {
         break;
       }
 
-      status = database->db_->Write(options, &batch);
+      status = database->db_->Write(writeOptions, &batch);
       if (!status.ok()) {
         break;
       }
@@ -980,7 +1344,9 @@ NAPI_METHOD(db_clear) {
 
 NAPI_METHOD(db_get_property) {
   NAPI_ARGV(2);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   NapiSlice property;
   NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], property));
@@ -996,7 +1362,9 @@ NAPI_METHOD(db_get_property) {
 
 NAPI_METHOD(iterator_init) {
   NAPI_ARGV(2);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   const auto options = argv[1];
   const auto reverse = BooleanProperty(env, options, "reverse").value_or(false);
@@ -1013,8 +1381,13 @@ NAPI_METHOD(iterator_init) {
   const auto gt = StringProperty(env, options, "gt");
   const auto gte = StringProperty(env, options, "gte");
 
-  auto iterator = std::make_unique<Iterator>(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache,
-                                             keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
+  const auto column = GetColumnFamily(database, env, options);
+
+  std::shared_ptr<const rocksdb::Snapshot> snapshot(database->db_->GetSnapshot(),
+                                                    [=](const auto ptr) { database->db_->ReleaseSnapshot(ptr); });
+
+  auto iterator = std::make_unique<Iterator>(database, column, reverse, keys, values, limit, lt, lte, gt, gte,
+                                             fillCache, keyAsBuffer, valueAsBuffer, highWaterMarkBytes, snapshot);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, iterator.get(), Finalize<Iterator>, iterator.get(), &result));
@@ -1028,7 +1401,9 @@ NAPI_METHOD(iterator_init) {
 
 NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
-  NAPI_ITERATOR_CONTEXT();
+
+  Iterator* iterator;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
   NapiSlice target;
   NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], target));
@@ -1041,7 +1416,9 @@ NAPI_METHOD(iterator_seek) {
 
 NAPI_METHOD(iterator_close) {
   NAPI_ARGV(1);
-  NAPI_ITERATOR_CONTEXT();
+
+  Iterator* iterator;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
   iterator->Detach(env);
   iterator->Close();
@@ -1049,6 +1426,20 @@ NAPI_METHOD(iterator_close) {
   return 0;
 }
 
+NAPI_METHOD(iterator_get_sequence) {
+  NAPI_ARGV(1);
+
+  Iterator* iterator;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
+
+  const auto seq = iterator->snapshot_->GetSequenceNumber();
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_bigint_int64(env, seq, &result));
+
+  return 0;
+}
+
 struct NextWorker final : public Worker {
   NextWorker(napi_env env, Iterator* iterator, uint32_t size, napi_value callback)
       : Worker(env, iterator->database_, callback, "leveldown.iterator.next"), iterator_(iterator), size_(size) {}
@@ -1073,33 +1464,29 @@ struct NextWorker final : public Worker {
       if (iterator_->keys_ && iterator_->values_) {
         auto k = iterator_->CurrentKey();
         auto v = iterator_->CurrentValue();
-        cache_.push_back({});
-        cache_.back().PinSelf(k);
-        cache_.push_back({});
-        cache_.back().PinSelf(v);
         bytesRead += k.size() + v.size();
+        cache_.push_back(k.ToString());
+        cache_.push_back(v.ToString());
       } else if (iterator_->keys_) {
         auto k = iterator_->CurrentKey();
-        cache_.push_back({});
-        cache_.back().PinSelf(k);
-        cache_.push_back({});
-        // no value
         bytesRead += k.size();
+        cache_.push_back(k.ToString());
+        cache_.push_back(std::nullopt);
       } else if (iterator_->values_) {
         auto v = iterator_->CurrentValue();
-        cache_.push_back({});
-        // no key
-        cache_.push_back({});
-        cache_.back().PinSelf(v);
         bytesRead += v.size();
+        cache_.push_back(std::nullopt);
+        cache_.push_back(v.ToString());
       }
 
       if (bytesRead > iterator_->highWaterMarkBytes_ || cache_.size() / 2 >= size_) {
-        finished_ = true;
+        finished_ = false;
         return rocksdb::Status::OK();
       }
     }
 
+    finished_ = true;
+
     return iterator_->Status();
   }
 
@@ -1108,15 +1495,15 @@ struct NextWorker final : public Worker {
     napi_value result;
     NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &result));
 
-    for (size_t idx = 0; idx < cache_.size(); idx += 2) {
+    for (size_t n = 0; n < size; n += 2) {
       napi_value key;
       napi_value val;
 
-      NAPI_STATUS_RETURN(Convert(env, std::move(cache_[idx + 0]), iterator_->keyAsBuffer_, key));
-      NAPI_STATUS_RETURN(Convert(env, std::move(cache_[idx + 1]), iterator_->valueAsBuffer_, val));
+      NAPI_STATUS_RETURN(Convert(env, std::move(cache_[n + 0]), iterator_->keyAsBuffer_, key));
+      NAPI_STATUS_RETURN(Convert(env, std::move(cache_[n + 1]), iterator_->valueAsBuffer_, val));
 
-      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 0), key));
-      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(idx + 1), val));
+      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(n + 0), key));
+      NAPI_STATUS_RETURN(napi_set_element(env, result, static_cast<int>(n + 1), val));
     }
 
     cache_.clear();
@@ -1124,20 +1511,22 @@ struct NextWorker final : public Worker {
     napi_value argv[3];
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
     argv[1] = result;
-    NAPI_STATUS_RETURN(napi_get_boolean(env, !finished_, &argv[2]));
+    NAPI_STATUS_RETURN(napi_get_boolean(env, finished_, &argv[2]));
     return CallFunction(env, callback, 3, argv);
   }
 
  private:
-  std::vector<rocksdb::PinnableSlice> cache_;
+  std::vector<std::optional<std::string>> cache_;
   Iterator* iterator_ = nullptr;
   uint32_t size_ = 0;
-  bool finished_ = false;
+  bool finished_ = true;
 };
 
 NAPI_METHOD(iterator_nextv) {
   NAPI_ARGV(3);
-  NAPI_ITERATOR_CONTEXT();
+
+  Iterator* iterator;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
   uint32_t size;
   NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &size));
@@ -1152,9 +1541,12 @@ NAPI_METHOD(iterator_nextv) {
 
 NAPI_METHOD(batch_do) {
   NAPI_ARGV(3);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   const auto operations = argv[1];
+  const auto options = argv[2];
 
   rocksdb::WriteBatch batch;
 
@@ -1168,26 +1560,30 @@ NAPI_METHOD(batch_do) {
     NapiSlice type;
     NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "type"), type));
 
+    const auto column = GetColumnFamily(database, env, element);
+
     if (type == "del") {
       NapiSlice key;
       NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "key"), key));
-      batch.Delete(key);
+      batch.Delete(column, key);
     } else if (type == "put") {
       NapiSlice key;
       NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "key"), key));
       NapiSlice value;
       NAPI_STATUS_THROWS(ToNapiSlice(env, GetProperty(env, element, "value"), value));
-      batch.Put(key, value);
+      batch.Put(column, key, value);
     }
   }
 
-  rocksdb::WriteOptions options;
-  return ToError(env, database->db_->Write(options, &batch));
+  rocksdb::WriteOptions writeOptions;
+  return ToError(env, database->db_->Write(writeOptions, &batch));
 }
 
 NAPI_METHOD(batch_init) {
   NAPI_ARGV(1);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   auto batch = new rocksdb::WriteBatch();
 
@@ -1197,35 +1593,53 @@ NAPI_METHOD(batch_init) {
 }
 
 NAPI_METHOD(batch_put) {
-  NAPI_ARGV(3);
-  NAPI_BATCH_CONTEXT();
+  NAPI_ARGV(5);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], (void**)(&batch)));
 
   NapiSlice key;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], key));
 
   NapiSlice val;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], val));
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[3], val));
+
+  const auto options = argv[4];
+  const auto column = GetColumnFamily(database, env, options);
 
-  batch->Put(key, val);
+  batch->Put(column, key, val);
 
   return 0;
 }
 
 NAPI_METHOD(batch_del) {
-  NAPI_ARGV(2);
-  NAPI_BATCH_CONTEXT();
+  NAPI_ARGV(4);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
+
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
   NapiSlice key;
-  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[1], key));
+  NAPI_STATUS_THROWS(ToNapiSlice(env, argv[2], key));
 
-  batch->Delete(key);
+  const auto options = argv[3];
+  const auto column = GetColumnFamily(database, env, options);
+
+  batch->Delete(column, key);
 
   return 0;
 }
 
 NAPI_METHOD(batch_clear) {
-  NAPI_ARGV(1);
-  NAPI_BATCH_CONTEXT();
+  NAPI_ARGV(2);
+
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
   batch->Clear();
 
@@ -1234,13 +1648,15 @@ NAPI_METHOD(batch_clear) {
 
 NAPI_METHOD(batch_write) {
   NAPI_ARGV(3);
-  NAPI_DB_CONTEXT();
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::WriteOptions options;
-  return ToError(env, database->db_->Write(options, batch));
+  rocksdb::WriteOptions writeOptions;
+  return ToError(env, database->db_->Write(writeOptions, batch));
 }
 
 NAPI_INIT() {
@@ -1258,6 +1674,11 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(iterator_seek);
   NAPI_EXPORT_FUNCTION(iterator_close);
   NAPI_EXPORT_FUNCTION(iterator_nextv);
+  NAPI_EXPORT_FUNCTION(iterator_get_sequence);
+
+  NAPI_EXPORT_FUNCTION(updates_init);
+  NAPI_EXPORT_FUNCTION(updates_close);
+  NAPI_EXPORT_FUNCTION(updates_next);
 
   NAPI_EXPORT_FUNCTION(batch_do);
   NAPI_EXPORT_FUNCTION(batch_init);