@nxtedition/rocksdb 6.0.1 → 7.0.0-alpha.1

package/binding.cc

@@ -30,6 +30,8 @@ class NullLogger : public rocksdb::Logger {
 
 struct Database;
 struct Iterator;
+struct Updates;
+struct Snapshot;
 
 #define NAPI_STATUS_RETURN(call) \
   {                              \
@@ -47,6 +49,10 @@ struct Iterator;
   Iterator* iterator = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
+#define NAPI_UPDATES_CONTEXT() \
+  Updates* updates = nullptr;  \
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&updates));
+
 #define NAPI_BATCH_CONTEXT()            \
   rocksdb::WriteBatch* batch = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&batch));
@@ -133,6 +139,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;
@@ -200,22 +218,25 @@ static void Finalize(napi_env env, void* data, void* hint) {
   }
 }
 
-napi_status Convert(napi_env env, std::string s, bool asBuffer, napi_value& result) {
+napi_status Convert(napi_env env, rocksdb::PinnableSlice&& s, bool asBuffer, napi_value& result) {
   if (asBuffer) {
-    auto ptr = new std::string(std::move(s));
-    return napi_create_external_buffer(env, ptr->size(), ptr->data(), Finalize<std::string>, ptr, &result);
+    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);
   } else {
     return napi_create_string_utf8(env, s.data(), s.size(), &result);
   }
 }
 
-napi_status Convert(napi_env env, rocksdb::PinnableSlice s, bool asBuffer, napi_value& result) {
-  if (asBuffer) {
-    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);
+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);
+    return napi_create_string_utf8(env, s->data(), s->size(), &result);
   }
 }
 
@@ -327,6 +348,26 @@ struct Database {
     DecrementPriorityWork(env);
   }
 
+  void AttachSnapshot(napi_env env, Snapshot* snapshot) {
+    snapshots_.insert(snapshot);
+    IncrementPriorityWork(env);
+  }
+
+  void DetachSnapshot(napi_env env, Snapshot* snapshot) {
+    snapshots_.erase(snapshot);
+    DecrementPriorityWork(env);
+  }
+
+  void AttachUpdates(napi_env env, Updates* updates) {
+    updates_.insert(updates);
+    IncrementPriorityWork(env);
+  }
+
+  void DetachUpdates(napi_env env, Updates* updates) {
+    updates_.erase(updates);
+    DecrementPriorityWork(env);
+  }
+
   void IncrementPriorityWork(napi_env env) { napi_reference_ref(env, priorityRef_, &priorityWork_); }
 
   void DecrementPriorityWork(napi_env env) {
@@ -343,12 +384,42 @@ struct Database {
   std::unique_ptr<rocksdb::DB> db_;
   Worker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
+  std::set<Snapshot*> snapshots_;
+  std::set<Updates*> updates_;
   napi_ref priorityRef_;
 
  private:
   uint32_t priorityWork_ = 0;
 };
 
+struct Snapshot {
+  Snapshot(Database* database)
+      : snapshot_(database->db_->GetSnapshot(), [=](auto ptr) { database->db_->ReleaseSnapshot(ptr); }),
+        database_(database) {}
+
+  void Close() { snapshot_.reset(); }
+
+  void Attach(napi_env env, napi_value context) {
+    napi_create_reference(env, context, 1, &ref_);
+    database_->AttachSnapshot(env, this);
+  }
+
+  void Detach(napi_env env) {
+    database_->DetachSnapshot(env, this);
+    if (ref_) {
+      napi_delete_reference(env, ref_);
+    }
+  }
+
+  int64_t GetSequenceNumber() const { return snapshot_->GetSequenceNumber(); }
+
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
+
+ private:
+  Database* database_;
+  napi_ref ref_ = nullptr;
+};
+
 struct BaseIterator {
   BaseIterator(Database* database,
                const bool reverse,
@@ -357,13 +428,9 @@ struct BaseIterator {
                const std::optional<std::string>& gt,
                const std::optional<std::string>& gte,
                const int limit,
-               const bool fillCache)
-      : database_(database),
-        snapshot_(database_->db_->GetSnapshot(),
-                  [this](const rocksdb::Snapshot* ptr) { database_->db_->ReleaseSnapshot(ptr); }),
-        reverse_(reverse),
-        limit_(limit),
-        fillCache_(fillCache) {
+               const bool fillCache,
+               std::shared_ptr<const rocksdb::Snapshot> snapshot)
+      : database_(database), snapshot_(snapshot), reverse_(reverse), limit_(limit), fillCache_(fillCache) {
     if (lte) {
       upper_bound_ = rocksdb::PinnableSlice();
       *upper_bound_->GetSelf() = std::move(*lte) + '\0';
@@ -443,6 +510,7 @@ struct BaseIterator {
   rocksdb::Status Status() const { return iterator_->status(); }
 
   Database* database_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
 
  private:
   void Init() {
@@ -455,13 +523,13 @@ struct BaseIterator {
     }
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
+    options.async_io = true;
 
     iterator_.reset(database_->db_->NewIterator(options));
   }
 
   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_;
@@ -482,8 +550,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, reverse, lt, lte, gt, gte, limit, fillCache, snapshot),
         keys_(keys),
         values_(values),
         keyAsBuffer_(keyAsBuffer),
@@ -513,6 +582,34 @@ 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;
+};
+
 /**
  * Hook for when the environment exits. This hook will be called after
  * already-scheduled napi_async_work items have finished, which gives us
@@ -529,8 +626,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_) {
-    // 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->snapshots_) {
+      // 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();
     }
 
@@ -595,11 +702,48 @@ NAPI_METHOD(db_open) {
   options.IncreaseParallelism(
       Uint32Property(env, argv[2], "parallelism").value_or(std::thread::hardware_concurrency() / 2));
 
+  options.avoid_unnecessary_blocking_io = true;
+
+  const auto memtable_memory_budget = Uint32Property(env, argv[2], "memtableMemoryBudget").value_or(256 * 1024 * 1024);
+
+  const auto compaction = StringProperty(env, argv[2], "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, argv[2], "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;
@@ -611,6 +755,9 @@ NAPI_METHOD(db_open) {
   options.max_background_jobs =
       Uint32Property(env, argv[2], "maxBackgroundJobs").value_or(std::thread::hardware_concurrency() / 4);
 
+  options.WAL_ttl_seconds = Uint32Property(env, argv[2], "walTTL").value_or(0) / 1e3;
+  options.WAL_size_limit_MB = Uint32Property(env, argv[2], "walSizeLimit").value_or(0) / 1e6;
+
   // TODO: Consider direct IO (https://github.com/facebook/rocksdb/wiki/Direct-IO) once
   // secondary compressed cache is stable.
 
@@ -655,9 +802,21 @@ NAPI_METHOD(db_open) {
     tableOptions.cache_index_and_filter_blocks = false;
   }
 
+  const auto optimize = StringProperty(env, argv[2], "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));
+
+    options.memtable_prefix_bloom_size_ratio = 0.02;
+    options.memtable_whole_key_filtering = true;
+  } else {
+    tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10));
+  }
+
   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);
@@ -700,6 +859,136 @@ 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);
+  NAPI_DB_CONTEXT();
+
+  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);
+  NAPI_UPDATES_CONTEXT();
+
+  const auto callback = argv[1];
+
+  auto worker = new UpdateNextWorker(env, updates, callback);
+  worker->Queue(env);
+
+  return 0;
+}
+
+NAPI_METHOD(updates_close) {
+  NAPI_ARGV(1);
+  NAPI_UPDATES_CONTEXT();
+
+  updates->Detach(env);
+  updates->Close();
+
+  return 0;
+}
+
 NAPI_METHOD(db_put) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
@@ -735,7 +1024,7 @@ struct GetWorker final : public Worker {
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
 
-    auto status = database.db_->Get(options, key_, &value_);
+    auto status = database.db_->Get(options, database.db_->DefaultColumnFamily(), key_, &value_);
 
     key_.clear();
     snapshot_ = nullptr;
@@ -757,7 +1046,7 @@ struct GetWorker final : public Worker {
 
  private:
   std::string key_;
-  std::string value_;
+  rocksdb::PinnableSlice value_;
   const bool asBuffer_;
   const bool fillCache_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
@@ -790,8 +1079,7 @@ struct GetManyWorker final : public Worker {
         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);
   }
 
@@ -799,6 +1087,7 @@ struct GetManyWorker final : public Worker {
     rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
+    options.async_io = true;
 
     const auto numKeys = keys_.size();
 
@@ -917,7 +1206,7 @@ NAPI_METHOD(db_clear) {
   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) {
@@ -945,7 +1234,8 @@ NAPI_METHOD(db_clear) {
   } else {
     // TODO (perf): Use DeleteRange.
 
-    BaseIterator it(database, reverse, lt, lte, gt, gte, limit, false);
+    Snapshot snapshot(database);
+    BaseIterator it(database, reverse, lt, lte, gt, gte, limit, false, snapshot.snapshot_);
 
     it.SeekToRange();
 
@@ -1001,6 +1291,18 @@ NAPI_METHOD(db_get_property) {
   return result;
 }
 
+NAPI_METHOD(db_get_latest_sequence_number) {
+  NAPI_ARGV(1);
+  NAPI_DB_CONTEXT();
+
+  const auto seq = database->db_->GetLatestSequenceNumber();
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_bigint_int64(env, seq, &result));
+
+  return result;
+}
+
 NAPI_METHOD(iterator_init) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
@@ -1020,8 +1322,20 @@ NAPI_METHOD(iterator_init) {
   const auto gt = StringProperty(env, options, "gt");
   const auto gte = StringProperty(env, options, "gte");
 
+  std::shared_ptr<const rocksdb::Snapshot> snapshotRaw;
+
+  if (HasProperty(env, options, "snapshot")) {
+    const auto property = GetProperty(env, options, "snapshot");
+    Snapshot* snapshot;
+    NAPI_STATUS_THROWS(napi_get_value_external(env, property, reinterpret_cast<void**>(&snapshot)));
+    snapshotRaw = snapshot->snapshot_;
+  } else {
+    Snapshot snapshot(database);
+    snapshotRaw = snapshot.snapshot_;
+  }
+
   auto iterator = std::make_unique<Iterator>(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache,
-                                             keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
+                                             keyAsBuffer, valueAsBuffer, highWaterMarkBytes, std::move(snapshotRaw));
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, iterator.get(), Finalize<Iterator>, iterator.get(), &result));
@@ -1056,6 +1370,18 @@ NAPI_METHOD(iterator_close) {
   return 0;
 }
 
+NAPI_METHOD(iterator_get_sequence) {
+  NAPI_ARGV(1);
+  NAPI_ITERATOR_CONTEXT();
+
+  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) {}
@@ -1080,27 +1406,29 @@ struct NextWorker final : public Worker {
       if (iterator_->keys_ && iterator_->values_) {
         auto k = iterator_->CurrentKey();
         auto v = iterator_->CurrentValue();
-        cache_.emplace_back(k.data(), k.size());
-        cache_.emplace_back(v.data(), v.size());
         bytesRead += k.size() + v.size();
+        cache_.push_back(k.ToString());
+        cache_.push_back(v.ToString());
       } else if (iterator_->keys_) {
         auto k = iterator_->CurrentKey();
-        cache_.emplace_back(k.data(), k.size());
-        cache_.push_back({});
         bytesRead += k.size();
+        cache_.push_back(k.ToString());
+        cache_.push_back(std::nullopt);
       } else if (iterator_->values_) {
         auto v = iterator_->CurrentValue();
-        cache_.push_back({});
-        cache_.emplace_back(v.data(), v.size());
         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();
   }
 
@@ -1125,15 +1453,15 @@ 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<std::string> 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) {
@@ -1244,10 +1572,54 @@ NAPI_METHOD(batch_write) {
   return ToError(env, database->db_->Write(options, batch));
 }
 
+NAPI_METHOD(snapshot_init) {
+  NAPI_ARGV(1);
+  NAPI_DB_CONTEXT();
+
+  auto snapshot = std::make_unique<Snapshot>(database);
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_external(env, snapshot.get(), Finalize<Snapshot>, snapshot.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.
+  snapshot.release()->Attach(env, result);
+
+  return result;
+}
+
+NAPI_METHOD(snapshot_get_sequence_number) {
+  NAPI_ARGV(3);
+  NAPI_DB_CONTEXT();
+
+  Snapshot* snapshot;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&snapshot)));
+
+  const auto seq = snapshot->GetSequenceNumber();
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_bigint_int64(env, seq, &result));
+
+  return result;
+}
+
+NAPI_METHOD(snapshot_close) {
+  NAPI_ARGV(2);
+  NAPI_DB_CONTEXT();
+
+  Snapshot* snapshot;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&snapshot)));
+
+  snapshot->Close();
+
+  return 0;
+}
+
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
   NAPI_EXPORT_FUNCTION(db_close);
+  NAPI_EXPORT_FUNCTION(db_get_latest_sequence_number);
   NAPI_EXPORT_FUNCTION(db_put);
   NAPI_EXPORT_FUNCTION(db_get);
   NAPI_EXPORT_FUNCTION(db_get_many);
@@ -1259,6 +1631,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);
@@ -1266,4 +1643,8 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(batch_del);
   NAPI_EXPORT_FUNCTION(batch_clear);
   NAPI_EXPORT_FUNCTION(batch_write);
+
+  NAPI_EXPORT_FUNCTION(snapshot_init);
+  NAPI_EXPORT_FUNCTION(snapshot_get_sequence_number);
+  NAPI_EXPORT_FUNCTION(snapshot_close);
 }