@nxtedition/rocksdb 5.2.21 → 5.2.26

package/binding.cc

@@ -30,7 +30,6 @@ public:
 
 struct Database;
 struct Iterator;
-static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb);
 
 #define NAPI_DB_CONTEXT() \
   Database* database = nullptr; \
@@ -92,8 +91,7 @@ static napi_value GetProperty (napi_env env, napi_value obj, const std::string&
   return value;
 }
 
-static bool BooleanProperty (napi_env env, napi_value obj, const std::string& key,
-                             bool defaultValue) {
+static bool BooleanProperty (napi_env env, napi_value obj, const std::string& key, bool defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     bool result;
@@ -117,8 +115,7 @@ static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string& o
   return false;
 }
 
-static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string& key,
-                                uint32_t defaultValue) {
+static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string& key, uint32_t defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
@@ -129,8 +126,7 @@ static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string&
   return defaultValue;
 }
 
-static int Int32Property (napi_env env, napi_value obj, const std::string& key,
-                          int defaultValue) {
+static int Int32Property (napi_env env, napi_value obj, const std::string& key, int defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int result;
@@ -211,10 +207,7 @@ static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
   return result;
 }
 
-static napi_status CallFunction (napi_env env,
-                                 napi_value callback,
-                                 const int argc,
-                                 napi_value* argv) {
+static napi_status CallFunction (napi_env env, napi_value callback, const int argc, napi_value* argv) {
   napi_value global;
   napi_get_global(env, &global);
   return napi_call_function(env, global, callback, argc, argv, nullptr);
@@ -233,72 +226,60 @@ void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
  * Base worker class. Handles the async work. Derived classes can override the
  * following virtual methods (listed in the order in which they're called):
  *
- * - DoExecute (abstract, worker pool thread): main work
- * - HandleOKCallback (main thread): call JS callback on success
- * - HandleErrorCallback (main thread): call JS callback on error
- * - DoFinally (main thread): do cleanup regardless of success
+ * - Execute (abstract, worker pool thread): main work
+ * - Then (main thread): call JS callback on success
+ * - Catch (main thread): call JS callback on error
+ * - Finally (main thread): do cleanup regardless of success
  */
 struct BaseWorker {
-  // Note: storing env is discouraged as we'd end up using it in unsafe places.
   BaseWorker (napi_env env,
               Database* database,
               napi_value callback,
-              const char* resourceName)
+              const std::string& resourceName)
     : database_(database) {
     NAPI_STATUS_THROWS_VOID(napi_create_reference(env, callback, 1, &callbackRef_));
     napi_value asyncResourceName;
-    NAPI_STATUS_THROWS_VOID(napi_create_string_utf8(env, resourceName,
-                                               NAPI_AUTO_LENGTH,
-                                               &asyncResourceName));
+    NAPI_STATUS_THROWS_VOID(napi_create_string_utf8(env, resourceName.data(),
+                                                    NAPI_AUTO_LENGTH,
+                                                    &asyncResourceName));
     NAPI_STATUS_THROWS_VOID(napi_create_async_work(env, callback,
-                                              asyncResourceName,
-                                              BaseWorker::Execute,
-                                              BaseWorker::Complete,
-                                              this, &asyncWork_));
+                                                   asyncResourceName,
+                                                   BaseWorker::Execute,
+                                                   BaseWorker::Complete,
+                                                   this, &asyncWork_));
   }
 
   virtual ~BaseWorker () {}
 
   static void Execute (napi_env env, void* data) {
     auto self = reinterpret_cast<BaseWorker*>(data);
-
-    // Don't pass env to DoExecute() because use of Node-API
-    // methods should generally be avoided in async work.
-    self->DoExecute();
-  }
-
-  bool SetStatus (const rocksdb::Status& status) {
-    status_ = status;
-    return status.ok();
+    self->status_ = self->Execute();
   }
 
-  virtual void DoExecute () = 0;
-
   static void Complete (napi_env env, napi_status status, void* data) {
     auto self = reinterpret_cast<BaseWorker*>(data);
 
-    self->DoComplete(env);
-    self->DoFinally(env);
-  }
-
-  void DoComplete (napi_env env) {
     napi_value callback;
-    napi_get_reference_value(env, callbackRef_, &callback);
+    napi_get_reference_value(env, self->callbackRef_, &callback);
 
-    if (status_.ok()) {
-      HandleOKCallback(env, callback);
+    if (self->status_.ok()) {
+      self->Then(env, callback);
     } else {
-      HandleErrorCallback(env, callback);
+      self->Catch(env, callback);
     }
+
+    self->Finally(env);
   }
 
-  virtual void HandleOKCallback (napi_env env, napi_value callback) {
+  virtual rocksdb::Status Execute () = 0;
+
+  virtual void Then (napi_env env, napi_value callback) {
     napi_value argv;
     napi_get_null(env, &argv);
     CallFunction(env, callback, 1, &argv);
   }
 
-  virtual void HandleErrorCallback (napi_env env, napi_value callback) {
+  virtual void Catch (napi_env env, napi_value callback) {
     napi_value argv;
 
     const auto msg = status_.ToString();
@@ -324,7 +305,7 @@ struct BaseWorker {
     CallFunction(env, callback, 1, &argv);
   }
 
-  virtual void DoFinally (napi_env env) {
+  virtual void Finally (napi_env env) {
     napi_delete_reference(env, callbackRef_);
     napi_delete_async_work(env, asyncWork_);
 
@@ -343,15 +324,7 @@ private:
   rocksdb::Status status_;
 };
 
-/**
- * Owns the LevelDB storage, cache, filter policy and iterators.
- */
 struct Database {
-  Database ()
-    : pendingCloseWorker_(nullptr),
-      ref_(nullptr),
-      priorityWork_(0) {}
-
   rocksdb::Status Open (const rocksdb::Options& options,
                         const bool readOnly,
                         const char* location) {
@@ -433,11 +406,11 @@ struct Database {
   }
 
   void IncrementPriorityWork (napi_env env) {
-    napi_reference_ref(env, ref_, &priorityWork_);
+    napi_reference_ref(env, prioritRef_, &priorityWork_);
   }
 
   void DecrementPriorityWork (napi_env env) {
-    napi_reference_unref(env, ref_, &priorityWork_);
+    napi_reference_unref(env, prioritRef_, &priorityWork_);
 
     if (priorityWork_ == 0 && pendingCloseWorker_) {
       pendingCloseWorker_->Queue(env);
@@ -452,10 +425,10 @@ struct Database {
   std::unique_ptr<rocksdb::DB> db_;
   BaseWorker* pendingCloseWorker_;
   std::set<Iterator*> iterators_;
-  napi_ref ref_;
+  napi_ref prioritRef_;
 
 private:
-  uint32_t priorityWork_;
+  uint32_t priorityWork_ = 0;
 };
 
 /**
@@ -464,14 +437,14 @@ private:
 struct PriorityWorker : public BaseWorker {
   PriorityWorker (napi_env env, Database* database, napi_value callback, const char* resourceName)
     : BaseWorker(env, database, callback, resourceName) {
-      database_->IncrementPriorityWork(env);
+    database_->IncrementPriorityWork(env);
   }
 
   virtual ~PriorityWorker () {}
 
-  void DoFinally (napi_env env) override {
+  void Finally (napi_env env) override {
     database_->DecrementPriorityWork(env);
-    BaseWorker::DoFinally(env);
+    BaseWorker::Finally(env);
   }
 };
 
@@ -485,77 +458,63 @@ struct BaseIterator {
                const int limit,
                const bool fillCache)
     : database_(database),
-      snapshot_(database->NewSnapshot()),
-      dbIterator_(database->NewIterator([&]{
+      lt_(lt),
+      lte_(lte),
+      gt_(gt),
+      gte_(gte),
+      snapshot_(database->NewSnapshot(), [this](const rocksdb::Snapshot* ptr) {
+        database_->ReleaseSnapshot(ptr);
+      }),
+      iterator_(database->NewIterator([&]{
         rocksdb::ReadOptions options;
+        if (lt_ && !lte_) {
+          upper_bound_ = rocksdb::Slice(lt_->data(), lt_->size());
+          options.iterate_upper_bound = &upper_bound_;
+        }
+        if (gte_) {
+          lower_bound_ = rocksdb::Slice(gte_->data(), gte_->size());
+          options.iterate_lower_bound = &lower_bound_;
+        }
         options.fill_cache = fillCache;
-        options.verify_checksums = false;
-        options.snapshot = snapshot_;
+        options.snapshot = snapshot_.get();
         return options;
       }())),
-      didSeek_(false),
       reverse_(reverse),
-      lt_(lt),
-      lte_(lte),
-      gt_(gt),
-      gte_(gte),
-      limit_(limit),
-      count_(0) {
+      limit_(limit) {
   }
 
   virtual ~BaseIterator () {
-    assert(!dbIterator_);
-
-    delete lt_;
-    delete lte_;
-    delete gt_;
-    delete gte_;
+    assert(!iterator_);
   }
 
   bool DidSeek () const {
     return didSeek_;
   }
 
-  /**
-   * Seek to the first relevant key based on range options.
-   */
   void SeekToRange () {
     didSeek_ = true;
 
-    if (!reverse_ && gte_) {
-      dbIterator_->Seek(*gte_);
-    } else if (!reverse_ && gt_) {
-      dbIterator_->Seek(*gt_);
+    if (!reverse_ && gt_ && !gte_) {
+      iterator_->Seek(*gt_);
 
-      if (dbIterator_->Valid() && dbIterator_->key().compare(*gt_) == 0) {
-        dbIterator_->Next();
+      if (iterator_->Valid() && iterator_->key().compare(*gt_) == 0) {
+        iterator_->Next();
       }
     } else if (reverse_ && lte_) {
-      dbIterator_->Seek(*lte_);
-
-      if (!dbIterator_->Valid()) {
-        dbIterator_->SeekToLast();
-      } else if (dbIterator_->key().compare(*lte_) > 0) {
-        dbIterator_->Prev();
-      }
-    } else if (reverse_ && lt_) {
-      dbIterator_->Seek(*lt_);
+      iterator_->Seek(*lte_);
 
-      if (!dbIterator_->Valid()) {
-        dbIterator_->SeekToLast();
-      } else if (dbIterator_->key().compare(*lt_) >= 0) {
-        dbIterator_->Prev();
+      if (!iterator_->Valid()) {
+        iterator_->SeekToLast();
+      } else if (iterator_->key().compare(*lte_) > 0) {
+        iterator_->Prev();
       }
     } else if (reverse_) {
-      dbIterator_->SeekToLast();
+      iterator_->SeekToLast();
     } else {
-      dbIterator_->SeekToFirst();
+      iterator_->SeekToFirst();
     }
   }
 
-  /**
-   * Seek manually (during iteration).
-   */
   void Seek (const std::string& target) {
     didSeek_ = true;
 
@@ -563,17 +522,17 @@ struct BaseIterator {
       return SeekToEnd();
     }
 
-    dbIterator_->Seek(target);
+    iterator_->Seek(target);
 
-    if (dbIterator_->Valid()) {
-      const auto cmp = dbIterator_->key().compare(target);
+    if (iterator_->Valid()) {
+      const auto cmp = iterator_->key().compare(target);
       if (reverse_ ? cmp > 0 : cmp < 0) {
         Next();
       }
     } else {
       SeekToFirst();
-      if (dbIterator_->Valid()) {
-        const auto cmp = dbIterator_->key().compare(target);
+      if (iterator_->Valid()) {
+        const auto cmp = iterator_->key().compare(target);
         if (reverse_ ? cmp > 0 : cmp < 0) {
           SeekToEnd();
         }
@@ -582,15 +541,24 @@ struct BaseIterator {
   }
 
   void Close () {
-    if (dbIterator_) {
-      delete dbIterator_;
-      dbIterator_ = nullptr;
-      database_->ReleaseSnapshot(snapshot_);
-    }
+    snapshot_.reset();
+    iterator_.reset();
   }
 
   bool Valid () const {
-    return dbIterator_->Valid() && !OutOfRange(dbIterator_->key());
+    if (!iterator_->Valid()) {
+      return false;
+    }
+
+    if (lte_ && iterator_->key().compare(*lte_) > 0) {
+      return false;
+    }
+
+    if (!gte_ && gt_ && iterator_->key().compare(*gt_) <= 0) {
+      return false;
+    }
+
+    return true;
   }
 
   bool Increment () {
@@ -598,18 +566,18 @@ struct BaseIterator {
   }
 
   void Next () {
-    if (reverse_) dbIterator_->Prev();
-    else dbIterator_->Next();
+    if (reverse_) iterator_->Prev();
+    else iterator_->Next();
   }
 
   void SeekToFirst () {
-    if (reverse_) dbIterator_->SeekToLast();
-    else dbIterator_->SeekToFirst();
+    if (reverse_) iterator_->SeekToLast();
+    else iterator_->SeekToFirst();
   }
 
   void SeekToLast () {
-    if (reverse_) dbIterator_->SeekToFirst();
-    else dbIterator_->SeekToLast();
+    if (reverse_) iterator_->SeekToFirst();
+    else iterator_->SeekToLast();
   }
 
   void SeekToEnd () {
@@ -618,15 +586,15 @@ struct BaseIterator {
   }
 
   rocksdb::Slice CurrentKey () const {
-    return dbIterator_->key();
+    return iterator_->key();
   }
 
   rocksdb::Slice CurrentValue () const {
-    return dbIterator_->value();
+    return iterator_->value();
   }
 
   rocksdb::Status Status () const {
-    return dbIterator_->status();
+    return iterator_->status();
   }
 
   bool OutOfRange (const rocksdb::Slice& target) const {
@@ -648,16 +616,18 @@ struct BaseIterator {
   Database* database_;
 
 private:
-  const rocksdb::Snapshot* snapshot_;
-  rocksdb::Iterator* dbIterator_;
-  bool didSeek_;
+  const std::unique_ptr<const std::string> lt_;
+  const std::unique_ptr<const std::string> lte_;
+  const std::unique_ptr<const std::string> gt_;
+  const std::unique_ptr<const std::string> gte_;
+  rocksdb::Slice lower_bound_;
+  rocksdb::Slice upper_bound_;
+  std::shared_ptr<const rocksdb::Snapshot> snapshot_;
+  std::unique_ptr<rocksdb::Iterator> iterator_;
+  bool didSeek_ = false;
   const bool reverse_;
-  const std::string* lt_;
-  const std::string* lte_;
-  const std::string* gt_;
-  const std::string* gte_;
   const int limit_;
-  int count_;
+  int count_ = 0;
 };
 
 struct Iterator final : public BaseIterator {
@@ -694,50 +664,12 @@ struct Iterator final : public BaseIterator {
     if (ref_) napi_delete_reference(env, ref_);
   }
 
-  bool ReadMany (uint32_t size) {
-    cache_.clear();
-    cache_.reserve(size * 2);
-    size_t bytesRead = 0;
-
-    while (true) {
-      if (!first_) Next();
-      else first_ = false;
-
-      if (!Valid() || !Increment()) break;
-    
-      if (keys_ && values_) {
-        auto k = CurrentKey();
-        auto v = CurrentValue();
-        cache_.emplace_back(k.data(), k.size());
-        cache_.emplace_back(v.data(), v.size());
-        bytesRead += k.size() + v.size();
-      } else if (keys_) {
-        auto k = CurrentKey();
-        cache_.emplace_back(k.data(), k.size());
-        cache_.push_back({});
-        bytesRead += k.size();
-      } else if (values_) {
-        auto v = CurrentValue();
-        cache_.push_back({});
-        cache_.emplace_back(v.data(), v.size());
-        bytesRead += v.size();
-      }
-
-      if (bytesRead > highWaterMarkBytes_ || cache_.size() / 2 >= size) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
   const bool keys_;
   const bool values_;
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
   const uint32_t highWaterMarkBytes_;
   bool first_;
-  std::vector<std::string> cache_;
 
 private:
   napi_ref ref_;
@@ -772,7 +704,7 @@ static void FinalizeDatabase (napi_env env, void* data, void* hint) {
   if (data) {
     auto database = reinterpret_cast<Database*>(data);
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
-    if (database->ref_) napi_delete_reference(env, database->ref_);
+    if (database->prioritRef_) napi_delete_reference(env, database->prioritRef_);
     delete database;
   }
 }
@@ -786,8 +718,7 @@ NAPI_METHOD(db_init) {
                                           FinalizeDatabase,
                                           nullptr, &result));
 
-  // Reference counter to prevent GC of database while priority workers are active
-  NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->ref_));
+  NAPI_STATUS_THROWS(napi_create_reference(env, result, 0, &database->prioritRef_));
 
   return result;
 }
@@ -819,7 +750,7 @@ struct OpenWorker final : public PriorityWorker {
     options_.write_buffer_size = writeBufferSize;
     options_.max_open_files = maxOpenFiles;
     options_.max_log_file_size = maxFileSize;
-    options_.paranoid_checks = false;
+    options_.use_adaptive_mutex = true;
 
     if (infoLogLevel.size() > 0) {
       rocksdb::InfoLogLevel lvl = {};
@@ -859,8 +790,8 @@ struct OpenWorker final : public PriorityWorker {
     );
   }
 
-  void DoExecute () override {
-    SetStatus(database_->Open(options_, readOnly_, location_.c_str()));
+  rocksdb::Status Execute () override {
+    return database_->Open(options_, readOnly_, location_.c_str());
   }
 
   rocksdb::Options options_;
@@ -908,8 +839,9 @@ struct CloseWorker final : public BaseWorker {
                napi_value callback)
     : BaseWorker(env, database, callback, "leveldown.db.close") {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     database_->CloseDatabase();
+    return rocksdb::Status::OK();
   }
 };
 
@@ -945,10 +877,10 @@ struct PutWorker final : public PriorityWorker {
       key_(key), value_(value), sync_(sync) {
   }
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::WriteOptions options;
     options.sync = sync_;
-    SetStatus(database_->Put(options, key_, value_));
+    return database_->Put(options, key_, value_);
   }
 
   const std::string key_;
@@ -982,13 +914,13 @@ struct GetWorker final : public PriorityWorker {
       key_(key), asBuffer_(asBuffer), fillCache_(fillCache) {
   }
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::ReadOptions options;
     options.fill_cache = fillCache_;
-    SetStatus(database_->Get(options, key_, value_));
+    return database_->Get(options, key_, value_);
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
+  void Then (napi_env env, napi_value callback) override {
     napi_value argv[2];
     napi_get_null(env, &argv[0]);
     Convert(env, std::move(value_), asBuffer_, argv[1]);
@@ -1037,44 +969,39 @@ struct GetManyWorker final : public PriorityWorker {
     }
   }
 
-  void DoExecute () override {
-    cache_.reserve(keys_.size());
-
+  rocksdb::Status Execute () override {
     rocksdb::ReadOptions options;
     options.snapshot = snapshot_;
     options.fill_cache = fillCache_;
     
-    rocksdb::PinnableSlice value;
+    status_ = database_->db_->MultiGet(
+      options,
+      std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()),
+      &values_
+    );
 
-    for (const auto& key: keys_) {
-      const auto status = database_->Get(options, key, value);
+    database_->ReleaseSnapshot(snapshot_);
+    snapshot_ = nullptr;
 
-      if (status.ok()) {
-        cache_.emplace_back(std::move(value));
-      } else if (status.IsNotFound()) {
-        cache_.emplace_back(nullptr);
-      } else {
-        SetStatus(status);
-        break;
+    for (auto status : status_) {
+      if (!status.ok() && !status.IsNotFound()) {
+        return status;
       }
-
-      value.Reset();
     }
 
-    database_->ReleaseSnapshot(snapshot_);
-    snapshot_ = nullptr;
+    return rocksdb::Status::OK();
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
-    const auto size = cache_.size();
+  void Then (napi_env env, napi_value callback) override {
+    const auto size = values_.size();
 
     napi_value array;
     napi_create_array_with_length(env, size, &array);
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
-      if (cache_[idx].GetSelf() != nullptr) {
-        Convert(env, cache_[idx], valueAsBuffer_, element);
+      if (status_[idx].ok()) {
+        Convert(env, values_[idx], valueAsBuffer_, element);
       } else {
         napi_get_undefined(env, &element);
       }
@@ -1089,8 +1016,9 @@ struct GetManyWorker final : public PriorityWorker {
 
 private:
   const std::vector<std::string> keys_;
+  std::vector<std::string> values_;
+  std::vector<rocksdb::Status> status_;
   const bool valueAsBuffer_;
-  std::vector<rocksdb::PinnableSlice> cache_;
   const bool fillCache_;
   const rocksdb::Snapshot* snapshot_;
 };
@@ -1121,10 +1049,10 @@ struct DelWorker final : public PriorityWorker {
       key_(key), sync_(sync) {
   }
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::WriteOptions options;
     options.sync = sync_;
-    SetStatus(database_->Del(options, key_));
+    return database_->Del(options, key_);
   }
 
   const std::string key_;
@@ -1159,7 +1087,7 @@ struct ClearWorker final : public PriorityWorker {
       iterator_(database, reverse, lt, lte, gt, gte, limit, false) {
   }
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     iterator_.SeekToRange();
 
     // TODO: add option
@@ -1167,7 +1095,8 @@ struct ClearWorker final : public PriorityWorker {
 
     rocksdb::WriteBatch batch;
     rocksdb::WriteOptions options;
-
+    rocksdb::Status status;
+    
     while (true) {
       size_t bytesRead = 0;
 
@@ -1178,11 +1107,13 @@ struct ClearWorker final : public PriorityWorker {
         iterator_.Next();
       }
 
-      if (!SetStatus(iterator_.Status()) || bytesRead == 0) {
+      status = iterator_.Status();
+      if (!status.ok() || bytesRead == 0) {
         break;
       }
 
-      if (!SetStatus(database_->WriteBatch(options, &batch))) {
+      status = database_->WriteBatch(options, &batch);
+      if (!status.ok()) {
         break;
       }
 
@@ -1190,6 +1121,8 @@ struct ClearWorker final : public PriorityWorker {
     }
 
     iterator_.Close();
+
+    return status;
   }
 
 private:
@@ -1226,12 +1159,13 @@ struct ApproximateSizeWorker final : public PriorityWorker {
     : PriorityWorker(env, database, callback, "rocks_level.db.approximate_size"),
       start_(start), end_(end) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::Range range(start_, end_);
     size_ = database_->ApproximateSize(&range);
+    return rocksdb::Status::OK();
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
+  void Then (napi_env env, napi_value callback) override {
     napi_value argv[2];
     napi_get_null(env, &argv[0]);
     napi_create_int64(env, size_, &argv[1]);
@@ -1266,10 +1200,11 @@ struct CompactRangeWorker final : public PriorityWorker {
     : PriorityWorker(env, database, callback, "rocks_level.db.compact_range"),
       start_(start), end_(end) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::Slice start = start_;
     rocksdb::Slice end = end_;
     database_->CompactRange(&start, &end);
+    return rocksdb::Status::OK();
   }
 
   const std::string start_;
@@ -1314,9 +1249,9 @@ struct DestroyWorker final : public BaseWorker {
 
   ~DestroyWorker () {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::Options options;
-    SetStatus(rocksdb::DestroyDB(location_, options));
+    return rocksdb::DestroyDB(location_, options);
   }
 
   const std::string location_;
@@ -1341,9 +1276,9 @@ struct RepairWorker final : public BaseWorker {
     : BaseWorker(env, nullptr, callback, "rocks_level.repair_db"),
       location_(location) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::Options options;
-    SetStatus(rocksdb::RepairDB(location_, options));
+    return rocksdb::RepairDB(location_, options);
   }
 
   const std::string location_;
@@ -1420,13 +1355,14 @@ struct CloseIteratorWorker final : public BaseWorker {
     : BaseWorker(env, iterator->database_, callback, "leveldown.iterator.end"),
       iterator_(iterator) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     iterator_->Close();
+    return rocksdb::Status::OK();
   }
 
-  void DoFinally (napi_env env) override {
+  void Finally (napi_env env) override {
     iterator_->Detach(env);
-    BaseWorker::DoFinally(env);
+    BaseWorker::Finally(env);
   }
 
 private:
@@ -1452,55 +1388,83 @@ struct NextWorker final : public BaseWorker {
               napi_value callback)
     : BaseWorker(env, iterator->database_, callback,
                  "leveldown.iterator.next"),
-      iterator_(iterator), size_(size), ok_() {}
+      iterator_(iterator), size_(size) {}
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     if (!iterator_->DidSeek()) {
       iterator_->SeekToRange();
     }
 
     // Limit the size of the cache to prevent starving the event loop
     // in JS-land while we're recursively calling process.nextTick().
-    ok_ = iterator_->ReadMany(size_);
 
-    if (!ok_) {
-      SetStatus(iterator_->Status());
+    finished_ = false;
+    cache_.reserve(size_ * 2);
+    size_t bytesRead = 0;
+
+    while (true) {
+      if (!iterator_->first_) iterator_->Next();
+      else iterator_->first_ = false;
+
+      if (!iterator_->Valid() || !iterator_->Increment()) break;
+    
+      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();
+      } else if (iterator_->keys_) {
+        auto k = iterator_->CurrentKey();
+        cache_.emplace_back(k.data(), k.size());
+        cache_.push_back({});
+        bytesRead += k.size();
+      } else if (iterator_->values_) {
+        auto v = iterator_->CurrentValue();
+        cache_.push_back({});
+        cache_.emplace_back(v.data(), v.size());
+        bytesRead += v.size();
+      }
+
+      if (bytesRead > iterator_->highWaterMarkBytes_ || cache_.size() / 2 >= size_) {
+        finished_ = true;
+        return rocksdb::Status::OK();
+      }
     }
+
+    return iterator_->Status();
   }
 
-  void HandleOKCallback (napi_env env, napi_value callback) override {
-    const auto size = iterator_->cache_.size();
+  void Then (napi_env env, napi_value callback) override {
+    const auto size = cache_.size();
     napi_value result;
     napi_create_array_with_length(env, size, &result);
 
-    for (size_t idx = 0; idx < iterator_->cache_.size(); idx += 2) {
+    for (size_t idx = 0; idx < cache_.size(); idx += 2) {
       napi_value key;
       napi_value val;
 
-      Convert(env, iterator_->cache_[idx + 0], iterator_->keyAsBuffer_, key);
-      Convert(env, iterator_->cache_[idx + 1], iterator_->valueAsBuffer_, val);
+      Convert(env, cache_[idx + 0], iterator_->keyAsBuffer_, key);
+      Convert(env, cache_[idx + 1], iterator_->valueAsBuffer_, val);
 
       napi_set_element(env, result, static_cast<int>(idx + 0), key);
       napi_set_element(env, result, static_cast<int>(idx + 1), val);
     }
 
-    iterator_->cache_.clear();
+    cache_.clear();
 
     napi_value argv[3];
     napi_get_null(env, &argv[0]);
     argv[1] = result;
-    napi_get_boolean(env, !ok_, &argv[2]);
+    napi_get_boolean(env, !finished_, &argv[2]);
     CallFunction(env, callback, 3, argv);
   }
 
-  void DoFinally (napi_env env) override {
-    BaseWorker::DoFinally(env);
-  }
-
 private:
-  Iterator* iterator_;
-  uint32_t size_;
-  bool ok_;
+  std::vector<std::string> cache_;
+  Iterator* iterator_ = nullptr;
+  uint32_t size_ = 0;
+  bool finished_ = false;
 };
 
 NAPI_METHOD(iterator_nextv) {
@@ -1556,14 +1520,14 @@ struct BatchWorker final : public PriorityWorker {
     }
   }
 
-  void DoExecute () override {
-    if (hasData_) {
-      rocksdb::WriteOptions options;
-      options.sync = sync_;
-      SetStatus(database_->WriteBatch(options, &batch_));
-    } else {
-      SetStatus(rocksdb::Status::OK());
+  rocksdb::Status Execute () override {
+    if (!hasData_) {
+      return rocksdb::Status::OK();
     }
+
+    rocksdb::WriteOptions options;
+    options.sync = sync_;
+    return database_->WriteBatch(options, &batch_);
   }
 
 private:
@@ -1650,15 +1614,15 @@ struct BatchWriteWorker final : public PriorityWorker {
     NAPI_STATUS_THROWS_VOID(napi_create_reference(env, batch, 1, &batchRef_));
   }
 
-  void DoExecute () override {
+  rocksdb::Status Execute () override {
     rocksdb::WriteOptions options;
     options.sync = sync_;
-    SetStatus(database_->WriteBatch(options, batch_));
+    return database_->WriteBatch(options, batch_);
   }
 
-  void DoFinally (napi_env env) override {
+  void Finally (napi_env env) override {
     napi_delete_reference(env, batchRef_);
-    PriorityWorker::DoFinally(env);
+    PriorityWorker::Finally(env);
   }
 
 private: