@nxtedition/rocksdb 5.2.1 → 5.2.10

package/binding.cc

@@ -1,4 +1,4 @@
-#define NAPI_VERSION 3
+#define NAPI_VERSION 8
 
 #include <napi-macros.h>
 #include <node_api.h>
@@ -16,7 +16,11 @@
 
 namespace leveldb = rocksdb;
 
-#include <map>
+#include <set>
+#include <optional>
+#include <memory>
+#include <string>
+#include <string_view>
 #include <vector>
 
 class NullLogger : public rocksdb::Logger {
@@ -26,255 +30,182 @@ public:
   virtual size_t GetLogFileSize() const override { return 0; }
 };
 
-/**
- * Forward declarations.
- */
 struct Database;
 struct Iterator;
-static void iterator_end_do (napi_env env, Iterator* iterator, napi_value cb);
-
-/**
- * Macros.
- */
+static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb);
 
 #define NAPI_DB_CONTEXT() \
-  Database* database = NULL; \
+  Database* database = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&database));
 
 #define NAPI_ITERATOR_CONTEXT() \
-  Iterator* iterator = NULL; \
+  Iterator* iterator = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&iterator));
 
 #define NAPI_BATCH_CONTEXT() \
-  Batch* batch = NULL; \
+  leveldb::WriteBatch* batch = nullptr; \
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)&batch));
 
-#define NAPI_RETURN_UNDEFINED() \
-  return 0;
-
-#define NAPI_UTF8_NEW(name, val)                \
-  size_t name##_size = 0;                                               \
-  NAPI_STATUS_THROWS(napi_get_value_string_utf8(env, val, NULL, 0, &name##_size)) \
-  char* name = new char[name##_size + 1];                               \
-  NAPI_STATUS_THROWS(napi_get_value_string_utf8(env, val, name, name##_size + 1, &name##_size)) \
-  name[name##_size] = '\0';
-
-#define NAPI_ARGV_UTF8_NEW(name, i) \
-  NAPI_UTF8_NEW(name, argv[i])
-
-#define LD_STRING_OR_BUFFER_TO_COPY(env, from, to)                      \
-  char* to##Ch_ = 0;                                                    \
-  size_t to##Sz_ = 0;                                                   \
-  if (IsString(env, from)) {                                            \
-    napi_get_value_string_utf8(env, from, NULL, 0, &to##Sz_);           \
-    to##Ch_ = new char[to##Sz_ + 1];                                    \
-    napi_get_value_string_utf8(env, from, to##Ch_, to##Sz_ + 1, &to##Sz_); \
-    to##Ch_[to##Sz_] = '\0';                                            \
-  } else if (IsBuffer(env, from)) {                                     \
-    char* buf = 0;                                                      \
-    napi_get_buffer_info(env, from, (void **)&buf, &to##Sz_);           \
-    to##Ch_ = new char[to##Sz_];                                        \
-    memcpy(to##Ch_, buf, to##Sz_);                                      \
-  }
-
-/*********************************************************************
- * Helpers.
- ********************************************************************/
-
-/**
- * Returns true if 'value' is a string.
- */
 static bool IsString (napi_env env, napi_value value) {
   napi_valuetype type;
   napi_typeof(env, value, &type);
   return type == napi_string;
 }
 
-/**
- * Returns true if 'value' is a buffer.
- */
 static bool IsBuffer (napi_env env, napi_value value) {
   bool isBuffer;
   napi_is_buffer(env, value, &isBuffer);
   return isBuffer;
 }
 
-/**
- * Returns true if 'value' is an object.
- */
 static bool IsObject (napi_env env, napi_value value) {
   napi_valuetype type;
   napi_typeof(env, value, &type);
   return type == napi_object;
 }
 
-/**
- * Create an error object.
- */
-static napi_value CreateError (napi_env env, const char* str) {
+static napi_value CreateError (napi_env env, const std::string_view& str) {
   napi_value msg;
-  napi_create_string_utf8(env, str, strlen(str), &msg);
+  napi_create_string_utf8(env, str.data(), str.size(), &msg);
   napi_value error;
-  napi_create_error(env, NULL, msg, &error);
+  napi_create_error(env, nullptr, msg, &error);
   return error;
 }
 
-/**
- * Returns true if 'obj' has a property 'key'.
- */
-static bool HasProperty (napi_env env, napi_value obj, const char* key) {
+static napi_value CreateCodeError (napi_env env, const std::string_view& code, const std::string_view& msg) {
+  napi_value codeValue;
+  napi_create_string_utf8(env, code.data(), code.size(), &codeValue);
+  napi_value msgValue;
+  napi_create_string_utf8(env, msg.data(), msg.size(), &msgValue);
+  napi_value error;
+  napi_create_error(env, codeValue, msgValue, &error);
+  return error;
+}
+
+static bool HasProperty (napi_env env, napi_value obj, const std::string_view& key) {
   bool has = false;
-  napi_has_named_property(env, obj, key, &has);
+  napi_has_named_property(env, obj, key.data(), &has);
   return has;
 }
 
-/**
- * Returns a property in napi_value form.
- */
-static napi_value GetProperty (napi_env env, napi_value obj, const char* key) {
+static napi_value GetProperty (napi_env env, napi_value obj, const std::string_view& key) {
   napi_value value;
-  napi_get_named_property(env, obj, key, &value);
+  napi_get_named_property(env, obj, key.data(), &value);
   return value;
 }
 
-/**
- * Returns a boolean property 'key' from 'obj'.
- * Returns 'DEFAULT' if the property doesn't exist.
- */
-static bool BooleanProperty (napi_env env, napi_value obj, const char* key,
-                             bool DEFAULT) {
-  if (HasProperty(env, obj, key)) {
-    napi_value value = GetProperty(env, obj, key);
+static bool BooleanProperty (napi_env env, napi_value obj, const std::string_view& key,
+                             bool defaultValue) {
+  if (HasProperty(env, obj, key.data())) {
+    const auto value = GetProperty(env, obj, key.data());
     bool result;
     napi_get_value_bool(env, value, &result);
     return result;
   }
 
-  return DEFAULT;
+  return defaultValue;
 }
 
-/**
- * Returns a uint32 property 'key' from 'obj'.
- * Returns 'DEFAULT' if the property doesn't exist.
- */
-static uint32_t Uint32Property (napi_env env, napi_value obj, const char* key,
-                                uint32_t DEFAULT) {
-  if (HasProperty(env, obj, key)) {
-    napi_value value = GetProperty(env, obj, key);
+static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string_view& option) {
+  napi_value value;
+  size_t size;
+
+  if (napi_get_named_property(env, obj, option.data(), &value) == napi_ok &&
+    napi_get_value_string_utf8(env, value, NULL, 0, &size) == napi_ok) {
+    // Value is either "buffer" or "utf8" so we can tell them apart just by size
+    return size == 6;
+  }
+
+  return false;
+}
+
+static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string_view& key,
+                                uint32_t defaultValue) {
+  if (HasProperty(env, obj, key.data())) {
+    const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
     napi_get_value_uint32(env, value, &result);
     return result;
   }
 
-  return DEFAULT;
+  return defaultValue;
 }
 
-/**
- * Returns a int32 property 'key' from 'obj'.
- * Returns 'DEFAULT' if the property doesn't exist.
- */
-static int Int32Property (napi_env env, napi_value obj, const char* key,
-                          int DEFAULT) {
-  if (HasProperty(env, obj, key)) {
-    napi_value value = GetProperty(env, obj, key);
+static int Int32Property (napi_env env, napi_value obj, const std::string_view& key,
+                          int defaultValue) {
+  if (HasProperty(env, obj, key.data())) {
+    const auto value = GetProperty(env, obj, key.data());
     int result;
     napi_get_value_int32(env, value, &result);
     return result;
   }
 
-  return DEFAULT;
+  return defaultValue;
 }
 
-/**
- * Returns a string property 'key' from 'obj'.
- * Returns empty string if the property doesn't exist.
- */
-static std::string StringProperty (napi_env env, napi_value obj, const char* key) {
+static std::optional<std::string> ToString (napi_env env, napi_value from) {
+  if (IsString(env, from)) {
+    size_t length = 0;
+    napi_get_value_string_utf8(env, from, nullptr, 0, &length);
+    std::string value(length, '\0');
+    napi_get_value_string_utf8( env, from, &value[0], value.length() + 1, &length);
+    return value;
+  } else if (IsBuffer(env, from)) {
+    char* buf = nullptr;
+    size_t length = 0;
+    napi_get_buffer_info(env, from, reinterpret_cast<void **>(&buf), &length);
+    return std::string(buf, length);
+  }
+
+  return {};
+}
+
+static std::string StringProperty (napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key)) {
     napi_value value = GetProperty(env, obj, key);
     if (IsString(env, value)) {
-      size_t size = 0;
-      napi_get_value_string_utf8(env, value, NULL, 0, &size);
-
-      char* buf = new char[size + 1];
-      napi_get_value_string_utf8(env, value, buf, size + 1, &size);
-      buf[size] = '\0';
-
-      std::string result = buf;
-      delete [] buf;
-      return result;
+      return ToString(env, value).value_or(std::string());
     }
   }
 
   return "";
 }
 
-static void DisposeSliceBuffer (leveldb::Slice slice) {
-  if (!slice.empty()) delete [] slice.data();
-}
-
-/**
- * Convert a napi_value to a leveldb::Slice.
- */
-static leveldb::Slice ToSlice (napi_env env, napi_value from) {
-  LD_STRING_OR_BUFFER_TO_COPY(env, from, to);
-  return leveldb::Slice(toCh_, toSz_);
-}
-
-/**
- * Returns length of string or buffer
- */
 static size_t StringOrBufferLength (napi_env env, napi_value value) {
   size_t size = 0;
 
   if (IsString(env, value)) {
-    napi_get_value_string_utf8(env, value, NULL, 0, &size);
+    napi_get_value_string_utf8(env, value, nullptr, 0, &size);
   } else if (IsBuffer(env, value)) {
-    char* buf;
+    char* buf = nullptr;
     napi_get_buffer_info(env, value, (void **)&buf, &size);
   }
 
   return size;
 }
 
-/**
- * Takes a Buffer or string property 'name' from 'opts'.
- * Returns null if the property does not exist or is zero-length.
- */
-static std::string* RangeOption (napi_env env, napi_value opts, const char* name) {
+static std::optional<std::string> RangeOption (napi_env env, napi_value opts, const std::string& name) {
   if (HasProperty(env, opts, name)) {
-    napi_value value = GetProperty(env, opts, name);
-
-    if (StringOrBufferLength(env, value) > 0) {
-      LD_STRING_OR_BUFFER_TO_COPY(env, value, to);
-      std::string* result = new std::string(toCh_, toSz_);
-      delete [] toCh_;
-      return result;
-    }
+    const auto value = GetProperty(env, opts, name);
+    return ToString(env, value);
   }
 
-  return NULL;
+  return {};
 }
 
-/**
- * Converts an array containing Buffer or string keys to a vector.
- * Empty elements are skipped.
- */
-static std::vector<std::string>* KeyArray (napi_env env, napi_value arr) {
+static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
   uint32_t length;
-  std::vector<std::string>* result = new std::vector<std::string>();
+  std::vector<std::string> result;
 
   if (napi_get_array_length(env, arr, &length) == napi_ok) {
-    result->reserve(length);
+    result.reserve(length);
 
     for (uint32_t i = 0; i < length; i++) {
       napi_value element;
 
       if (napi_get_element(env, arr, i, &element) == napi_ok &&
           StringOrBufferLength(env, element) > 0) {
-        LD_STRING_OR_BUFFER_TO_COPY(env, element, to);
-        result->emplace_back(toCh_, toSz_);
-        delete [] toCh_;
+        result.push_back(ToString(env, element).value_or(std::string()));
       }
     }
   }
@@ -282,75 +213,34 @@ static std::vector<std::string>* KeyArray (napi_env env, napi_value arr) {
   return result;
 }
 
-/**
- * Calls a function.
- */
 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, NULL);
+  return napi_call_function(env, global, callback, argc, argv, nullptr);
 }
 
-/**
- * Whether to yield entries, keys or values.
- */
-enum Mode {
-  entries,
-  keys,
-  values
-};
-
-/**
- * Helper struct for caching and converting a key-value pair to napi_values.
- */
-struct Entry {
-  Entry (const leveldb::Slice* key, const leveldb::Slice* value) {
-    key_ = key != NULL ? new std::string(key->data(), key->size()) : NULL;
-    value_ = value != NULL ? new std::string(value->data(), value->size()) : NULL;
-  }
-
-  ~Entry () {
-    if (key_ != NULL) delete key_;
-    if (value_ != NULL) delete value_;
-  }
-
-  // Not used yet.
-  void ConvertXX (napi_env env, Mode mode, bool keyAsBuffer, bool valueAsBuffer, napi_value* result) {
-    if (mode == Mode::entries) {
-      napi_create_array_with_length(env, 2, result);
-
-      napi_value valueElement;
-      napi_value keyElement;
-
-      Convert(env, key_, keyAsBuffer, &keyElement);
-      Convert(env, value_, valueAsBuffer, &valueElement);
-
-      napi_set_element(env, *result, 0, keyElement);
-      napi_set_element(env, *result, 1, valueElement);
-    } else if (mode == Mode::keys) {
-      Convert(env, key_, keyAsBuffer, result);
-    } else {
-      Convert(env, value_, valueAsBuffer, result);
-    }
+template <typename T>
+void Convert (napi_env env, const std::optional<T>& s, bool asBuffer, napi_value& result) {
+  if (!s) {
+    napi_get_undefined(env, &result);
+  } else if (asBuffer) {
+    napi_create_buffer_copy(env, s->size(), s->data(), nullptr, &result);
+  } else {
+    napi_create_string_utf8(env, s->data(), s->size(), &result);
   }
+}
 
-  static void Convert (napi_env env, const std::string* s, bool asBuffer, napi_value* result) {
-    if (s == NULL) {
-      napi_get_undefined(env, result);
-    } else if (asBuffer) {
-      napi_create_buffer_copy(env, s->size(), s->data(), NULL, result);
-    } else {
-      napi_create_string_utf8(env, s->data(), s->size(), result);
-    }
+template <typename T>
+void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
+  if (asBuffer) {
+    napi_create_buffer_copy(env, s.size(), s.data(), nullptr, &result);
+  } else {
+    napi_create_string_utf8(env, s.data(), s.size(), &result);
   }
-
-private:
-  std::string* key_;
-  std::string* value_;
-};
+}
 
 /**
  * Base worker class. Handles the async work. Derived classes can override the
@@ -367,7 +257,7 @@ struct BaseWorker {
               Database* database,
               napi_value callback,
               const char* resourceName)
-    : database_(database), errMsg_(NULL) {
+    : 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,
@@ -380,38 +270,25 @@ struct BaseWorker {
                                               this, &asyncWork_));
   }
 
-  virtual ~BaseWorker () {
-    delete [] errMsg_;
-  }
+  virtual ~BaseWorker () {}
 
   static void Execute (napi_env env, void* data) {
-    BaseWorker* self = (BaseWorker*)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 (leveldb::Status status) {
+  bool SetStatus (const leveldb::Status& status) {
     status_ = status;
-    if (!status.ok()) {
-      SetErrorMessage(status.ToString().c_str());
-      return false;
-    }
-    return true;
-  }
-
-  void SetErrorMessage(const char *msg) {
-    delete [] errMsg_;
-    size_t size = strlen(msg) + 1;
-    errMsg_ = new char[size];
-    memcpy(errMsg_, msg, size);
+    return status.ok();
   }
 
   virtual void DoExecute () = 0;
 
   static void Complete (napi_env env, napi_status status, void* data) {
-    BaseWorker* self = (BaseWorker*)data;
+    auto self = reinterpret_cast<BaseWorker*>(data);
 
     self->DoComplete(env);
     self->DoFinally(env);
@@ -435,7 +312,28 @@ struct BaseWorker {
   }
 
   virtual void HandleErrorCallback (napi_env env, napi_value callback) {
-    napi_value argv = CreateError(env, errMsg_);
+    napi_value argv;
+
+    const auto msg = status_.ToString();
+
+    if (status_.IsNotFound()) {
+      argv = CreateCodeError(env, "LEVEL_NOT_FOUND", msg);
+    } else if (status_.IsCorruption()) {
+      argv = CreateCodeError(env, "LEVEL_CORRUPTION", msg);
+    } else if (status_.IsIOError()) {
+      if (msg.find("IO error: lock ") != std::string::npos) { // env_posix.cc
+        argv = CreateCodeError(env, "LEVEL_LOCKED", msg);
+      } else if (msg.find("IO error: LockFile ") != std::string::npos) { // env_win.cc
+        argv = CreateCodeError(env, "LEVEL_LOCKED", msg);
+      } else if (msg.find("IO error: While lock file") != std::string::npos) { // env_mac.cc
+        argv = CreateCodeError(env, "LEVEL_LOCKED", msg);
+      } else {
+        argv = CreateCodeError(env, "LEVEL_IO_ERROR", msg);
+      }
+    } else {
+      argv = CreateError(env, msg);
+    }
+
     CallFunction(env, callback, 1, &argv);
   }
 
@@ -456,7 +354,6 @@ private:
   napi_ref callbackRef_;
   napi_async_work asyncWork_;
   leveldb::Status status_;
-  char *errMsg_;
 };
 
 /**
@@ -464,49 +361,45 @@ private:
  */
 struct Database {
   Database ()
-    : db_(NULL),
-      currentIteratorId_(0),
-      pendingCloseWorker_(NULL),
-      ref_(NULL),
+    : pendingCloseWorker_(nullptr),
+      ref_(nullptr),
       priorityWork_(0) {}
 
-  ~Database () {
-    if (db_ != NULL) {
-      delete db_;
-      db_ = NULL;
-    }
-  }
-
   leveldb::Status Open (const leveldb::Options& options,
-                        bool readOnly,
+                        const bool readOnly,
                         const char* location) {
     if (readOnly) {
-      return rocksdb::DB::OpenForReadOnly(options, location, &db_);
+      leveldb::DB* db = nullptr;
+      const auto status = rocksdb::DB::OpenForReadOnly(options, location, &db);
+      db_.reset(db);
+      return status;
     } else {
-      return leveldb::DB::Open(options, location, &db_);
+      leveldb::DB* db = nullptr;
+      const auto status = leveldb::DB::Open(options, location, &db);
+      db_.reset(db);
+      return status;
     }
   }
 
   void CloseDatabase () {
-    delete db_;
-    db_ = NULL;
+    db_.reset();
   }
 
   leveldb::Status Put (const leveldb::WriteOptions& options,
-                       leveldb::Slice key,
-                       leveldb::Slice value) {
-    return db_->Put(options, key, value);
+                       const std::string& key,
+                       const std::string& value) {
+    return db_->Put(options, db_->DefaultColumnFamily(), key, value);
   }
 
   leveldb::Status Get (const leveldb::ReadOptions& options,
-                       leveldb::Slice key,
-                       std::string& value) {
-    return db_->Get(options, key, &value);
+                       const std::string& key,
+                       rocksdb::PinnableSlice& value) {
+    return db_->Get(options, db_->DefaultColumnFamily(), key, &value);
   }
 
   leveldb::Status Del (const leveldb::WriteOptions& options,
-                       leveldb::Slice key) {
-    return db_->Delete(options, key);
+                       const std::string& key) {
+    return db_->Delete(options, db_->DefaultColumnFamily(), key);
   }
 
   leveldb::Status WriteBatch (const leveldb::WriteOptions& options,
@@ -514,41 +407,29 @@ struct Database {
     return db_->Write(options, batch);
   }
 
-  uint64_t ApproximateSize (const leveldb::Range* range) {
-    uint64_t size = 0;
-    db_->GetApproximateSizes(range, 1, &size);
-    return size;
-  }
-
-  void CompactRange (const leveldb::Slice* start,
-                     const leveldb::Slice* end) {
-    rocksdb::CompactRangeOptions options;
-    db_->CompactRange(options, start, end);
-  }
-
-  void GetProperty (const leveldb::Slice& property, std::string* value) {
-    db_->GetProperty(property, value);
+  void GetProperty (const std::string& property, std::string& value) {
+    db_->GetProperty(property, &value);
   }
 
   const leveldb::Snapshot* NewSnapshot () {
     return db_->GetSnapshot();
   }
 
-  leveldb::Iterator* NewIterator (leveldb::ReadOptions* options) {
-    return db_->NewIterator(*options);
+  leveldb::Iterator* NewIterator (const leveldb::ReadOptions& options) {
+    return db_->NewIterator(options);
   }
 
   void ReleaseSnapshot (const leveldb::Snapshot* snapshot) {
     return db_->ReleaseSnapshot(snapshot);
   }
 
-  void AttachIterator (napi_env env, uint32_t id, Iterator* iterator) {
-    iterators_[id] = iterator;
+  void AttachIterator (napi_env env, Iterator* iterator) {
+    iterators_.insert(iterator);
     IncrementPriorityWork(env);
   }
 
-  void DetachIterator (napi_env env, uint32_t id) {
-    iterators_.erase(id);
+  void DetachIterator (napi_env env, Iterator* iterator) {
+    iterators_.erase(iterator);
     DecrementPriorityWork(env);
   }
 
@@ -559,9 +440,9 @@ struct Database {
   void DecrementPriorityWork (napi_env env) {
     napi_reference_unref(env, ref_, &priorityWork_);
 
-    if (priorityWork_ == 0 && pendingCloseWorker_ != NULL) {
+    if (priorityWork_ == 0 && pendingCloseWorker_) {
       pendingCloseWorker_->Queue(env);
-      pendingCloseWorker_ = NULL;
+      pendingCloseWorker_ = nullptr;
     }
   }
 
@@ -569,10 +450,9 @@ struct Database {
     return priorityWork_ > 0;
   }
 
-  leveldb::DB* db_;
-  uint32_t currentIteratorId_;
-  BaseWorker *pendingCloseWorker_;
-  std::map< uint32_t, Iterator * > iterators_;
+  std::unique_ptr<leveldb::DB> db_;
+  BaseWorker* pendingCloseWorker_;
+  std::set<Iterator*> iterators_;
   napi_ref ref_;
 
 private:
@@ -596,20 +476,24 @@ struct PriorityWorker : public BaseWorker {
   }
 };
 
-/**
- * Owns a leveldb iterator.
- */
 struct BaseIterator {
   BaseIterator(Database* database,
                const bool reverse,
-               std::string* lt,
-               std::string* lte,
-               std::string* gt,
-               std::string* gte,
+               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)
     : database_(database),
-      hasEnded_(false),
+      snapshot_(database->NewSnapshot()),
+      dbIterator_(database->NewIterator([&]{
+        leveldb::ReadOptions options;
+        options.fill_cache = fillCache;
+        options.verify_checksums = false;
+        options.snapshot = snapshot_;
+        return options;
+      }())),
       didSeek_(false),
       reverse_(reverse),
       lt_(lt),
@@ -618,22 +502,10 @@ struct BaseIterator {
       gte_(gte),
       limit_(limit),
       count_(0) {
-    options_ = new leveldb::ReadOptions();
-    options_->fill_cache = fillCache;
-    options_->verify_checksums = false;
-    options_->snapshot = database->NewSnapshot();
-    dbIterator_ = database_->NewIterator(options_);
   }
 
   virtual ~BaseIterator () {
-    assert(hasEnded_);
-
-    if (lt_ != NULL) delete lt_;
-    if (gt_ != NULL) delete gt_;
-    if (lte_ != NULL) delete lte_;
-    if (gte_ != NULL) delete gte_;
-
-    delete options_;
+    assert(!dbIterator_);
   }
 
   bool DidSeek () const {
@@ -646,15 +518,15 @@ struct BaseIterator {
   void SeekToRange () {
     didSeek_ = true;
 
-    if (!reverse_ && gte_ != NULL) {
+    if (!reverse_ && gte_) {
       dbIterator_->Seek(*gte_);
-    } else if (!reverse_ && gt_ != NULL) {
+    } else if (!reverse_ && gt_) {
       dbIterator_->Seek(*gt_);
 
       if (dbIterator_->Valid() && dbIterator_->key().compare(*gt_) == 0) {
         dbIterator_->Next();
       }
-    } else if (reverse_ && lte_ != NULL) {
+    } else if (reverse_ && lte_) {
       dbIterator_->Seek(*lte_);
 
       if (!dbIterator_->Valid()) {
@@ -662,7 +534,7 @@ struct BaseIterator {
       } else if (dbIterator_->key().compare(*lte_) > 0) {
         dbIterator_->Prev();
       }
-    } else if (reverse_ && lt_ != NULL) {
+    } else if (reverse_ && lt_) {
       dbIterator_->Seek(*lt_);
 
       if (!dbIterator_->Valid()) {
@@ -680,7 +552,7 @@ struct BaseIterator {
   /**
    * Seek manually (during iteration).
    */
-  void Seek (leveldb::Slice& target) {
+  void Seek (const std::string& target) {
     didSeek_ = true;
 
     if (OutOfRange(target)) {
@@ -690,14 +562,14 @@ struct BaseIterator {
     dbIterator_->Seek(target);
 
     if (dbIterator_->Valid()) {
-      int cmp = dbIterator_->key().compare(target);
+      const auto cmp = dbIterator_->key().compare(target);
       if (reverse_ ? cmp > 0 : cmp < 0) {
         Next();
       }
     } else {
       SeekToFirst();
       if (dbIterator_->Valid()) {
-        int cmp = dbIterator_->key().compare(target);
+        const auto cmp = dbIterator_->key().compare(target);
         if (reverse_ ? cmp > 0 : cmp < 0) {
           SeekToEnd();
         }
@@ -705,12 +577,11 @@ struct BaseIterator {
     }
   }
 
-  void End () {
-    if (!hasEnded_) {
-      hasEnded_ = true;
+  void Close () {
+    if (dbIterator_) {
       delete dbIterator_;
-      dbIterator_ = NULL;
-      database_->ReleaseSnapshot(options_->snapshot);
+      dbIterator_ = nullptr;
+      database_->ReleaseSnapshot(snapshot_);
     }
   }
 
@@ -755,108 +626,103 @@ struct BaseIterator {
   }
 
   bool OutOfRange (const leveldb::Slice& target) const {
-    // TODO: benchmark to see if this is worth it
-    // if (upperBoundOnly && !reverse_) {
-    //   return ((lt_  != NULL && target.compare(*lt_) >= 0) ||
-    //           (lte_ != NULL && target.compare(*lte_) > 0));
-    // }
+    if (lte_) {
+      if (target.compare(*lte_) > 0) return true;
+    } else if (lt_) {
+      if (target.compare(*lt_) >= 0) return true;
+    }
+
+    if (gte_) {
+      if (target.compare(*gte_) < 0) return true;
+    } else if (gt_) {
+      if (target.compare(*gt_) <= 0) return true;
+    }
 
-    return ((lt_  != NULL && target.compare(*lt_) >= 0) ||
-            (lte_ != NULL && target.compare(*lte_) > 0) ||
-            (gt_  != NULL && target.compare(*gt_) <= 0) ||
-            (gte_ != NULL && target.compare(*gte_) < 0));
+    return false;
   }
 
   Database* database_;
-  bool hasEnded_;
 
 private:
+  const leveldb::Snapshot* snapshot_;
   leveldb::Iterator* dbIterator_;
   bool didSeek_;
   const bool reverse_;
-  std::string* lt_;
-  std::string* lte_;
-  std::string* gt_;
-  std::string* gte_;
+  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_;
   int count_;
-  leveldb::ReadOptions* options_;
 };
 
-/**
- * Extends BaseIterator for reading it from JS land.
- */
 struct Iterator final : public BaseIterator {
   Iterator (Database* database,
-            const uint32_t id,
             const bool reverse,
             const bool keys,
             const bool values,
             const int limit,
-            std::string* lt,
-            std::string* lte,
-            std::string* gt,
-            std::string* gte,
+            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 bool fillCache,
             const bool keyAsBuffer,
             const bool valueAsBuffer,
-            const uint32_t highWaterMark)
+            const uint32_t highWaterMarkBytes)
     : BaseIterator(database, reverse, lt, lte, gt, gte, limit, fillCache),
-      id_(id),
       keys_(keys),
       values_(values),
       keyAsBuffer_(keyAsBuffer),
       valueAsBuffer_(valueAsBuffer),
-      highWaterMark_(highWaterMark),
-      landed_(false),
+      highWaterMarkBytes_(highWaterMarkBytes),
+      first_(true),
       nexting_(false),
-      isEnding_(false),
-      endWorker_(NULL),
-      ref_(NULL) {
+      isClosing_(false),
+      closeWorker_(nullptr),
+      ref_(nullptr) {
   }
 
-  ~Iterator () {}
-
   void Attach (napi_env env, napi_value context) {
     napi_create_reference(env, context, 1, &ref_);
-    database_->AttachIterator(env, id_, this);
+    database_->AttachIterator(env, this);
   }
 
   void Detach (napi_env env) {
-    database_->DetachIterator(env, id_);
-    if (ref_ != NULL) napi_delete_reference(env, ref_);
+    database_->DetachIterator(env, this);
+    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 (landed_) Next();
-      if (!Valid() || !Increment()) break;
-
-      if (keys_) {
-        leveldb::Slice slice = CurrentKey();
-        cache_.emplace_back(slice.data(), slice.size());
-        bytesRead += slice.size();
-      } else {
-        cache_.emplace_back("");
-      }
-
-      if (values_) {
-        leveldb::Slice slice = CurrentValue();
-        cache_.emplace_back(slice.data(), slice.size());
-        bytesRead += slice.size();
-      } else {
-        cache_.emplace_back("");
-      }
+      if (!first_) Next();
+      else first_ = false;
 
-      if (!landed_) {
-        landed_ = true;
-        return true;
+      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 > highWaterMark_ || cache_.size() >= size * 2) {
+      if (bytesRead > highWaterMarkBytes_ || cache_.size() / 2 >= size) {
         return true;
       }
     }
@@ -864,16 +730,15 @@ struct Iterator final : public BaseIterator {
     return false;
   }
 
-  const uint32_t id_;
   const bool keys_;
   const bool values_;
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
-  const uint32_t highWaterMark_;
-  bool landed_;
+  const uint32_t highWaterMarkBytes_;
+  bool first_;
   bool nexting_;
-  bool isEnding_;
-  BaseWorker* endWorker_;
+  bool isClosing_;
+  BaseWorker* closeWorker_;
   std::vector<std::string> cache_;
 
 private:
@@ -886,7 +751,7 @@ private:
  * the guarantee that no db operations will be in-flight at this time.
  */
 static void env_cleanup_hook (void* arg) {
-  Database* database = (Database*)arg;
+  Database* database = reinterpret_cast<Database*>(arg);
 
   // Do everything that db_close() does but synchronously. We're expecting that GC
   // did not (yet) collect the database because that would be a user mistake (not
@@ -894,35 +759,26 @@ static void env_cleanup_hook (void* arg) {
   // from an environment being torn down (like the main process or a worker thread)
   // where it's our responsibility to clean up. Note also, the following code must
   // be a safe noop if called before db_open() or after db_close().
-  if (database && database->db_ != NULL) {
-    std::map<uint32_t, Iterator*> iterators = database->iterators_;
-    std::map<uint32_t, Iterator*>::iterator it;
-
+  if (database && database->db_) {
     // TODO: does not do `napi_delete_reference(env, iterator->ref_)`. Problem?
-    for (it = iterators.begin(); it != iterators.end(); ++it) {
-      it->second->End();
+    for (auto it : database->iterators_) {
+      it->Close();
     }
 
-    // Having ended the iterators (and released snapshots) we can safely close.
+    // Having closed the iterators (and released snapshots) we can safely close.
     database->CloseDatabase();
   }
 }
 
-/**
- * Runs when a Database is garbage collected.
- */
 static void FinalizeDatabase (napi_env env, void* data, void* hint) {
   if (data) {
     Database* database = (Database*)data;
     napi_remove_env_cleanup_hook(env, env_cleanup_hook, database);
-    if (database->ref_ != NULL) napi_delete_reference(env, database->ref_);
+    if (database->ref_) napi_delete_reference(env, database->ref_);
     delete database;
   }
 }
 
-/**
- * Returns a context object for a database.
- */
 NAPI_METHOD(db_init) {
   Database* database = new Database();
   napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
@@ -930,7 +786,7 @@ NAPI_METHOD(db_init) {
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, database,
                                           FinalizeDatabase,
-                                          NULL, &result));
+                                          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_));
@@ -972,7 +828,7 @@ struct OpenWorker final : public BaseWorker {
     options_.paranoid_checks = false;
 
     if (infoLogLevel.size() > 0) {
-      rocksdb::InfoLogLevel lvl;
+      rocksdb::InfoLogLevel lvl = {};
 
       if (infoLogLevel == "debug") lvl = rocksdb::InfoLogLevel::DEBUG_LEVEL;
       else if (infoLogLevel == "info") lvl = rocksdb::InfoLogLevel::INFO_LEVEL;
@@ -980,7 +836,7 @@ struct OpenWorker final : public BaseWorker {
       else if (infoLogLevel == "error") lvl = rocksdb::InfoLogLevel::ERROR_LEVEL;
       else if (infoLogLevel == "fatal") lvl = rocksdb::InfoLogLevel::FATAL_LEVEL;
       else if (infoLogLevel == "header") lvl = rocksdb::InfoLogLevel::HEADER_LEVEL;
-      else napi_throw_error(env, NULL, "invalid log level");
+      else napi_throw_error(env, nullptr, "invalid log level");
 
       options_.info_log_level = lvl;
     } else {
@@ -1007,65 +863,55 @@ struct OpenWorker final : public BaseWorker {
     );
   }
 
-  ~OpenWorker () {}
-
   void DoExecute () override {
     SetStatus(database_->Open(options_, readOnly_, location_.c_str()));
   }
 
   leveldb::Options options_;
-  bool readOnly_;
-  std::string location_;
+  const bool readOnly_;
+  const std::string location_;
 };
 
-/**
- * Open a database.
- */
 NAPI_METHOD(db_open) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
-  NAPI_ARGV_UTF8_NEW(location, 1);
 
-  napi_value options = argv[2];
-  const bool createIfMissing = BooleanProperty(env, options, "createIfMissing", true);
-  const bool errorIfExists = BooleanProperty(env, options, "errorIfExists", false);
-  const bool compression = BooleanProperty(env, options, "compression", true);
-  bool readOnly = BooleanProperty(env, options, "readOnly", false);
+  const auto location = ToString(env, argv[1]).value_or(std::string());
+  const auto options = argv[2];
+  const auto createIfMissing = BooleanProperty(env, options, "createIfMissing", true);
+  const auto errorIfExists = BooleanProperty(env, options, "errorIfExists", false);
+  const auto compression = BooleanProperty(env, options, "compression", true);
+  const auto readOnly = BooleanProperty(env, options, "readOnly", false);
 
-  const std::string infoLogLevel = StringProperty(env, options, "infoLogLevel");
+  const auto infoLogLevel = StringProperty(env, options, "infoLogLevel");
 
-  const uint32_t cacheSize = Uint32Property(env, options, "cacheSize", 8 << 20);
-  const uint32_t writeBufferSize = Uint32Property(env, options , "writeBufferSize" , 4 << 20);
-  const uint32_t blockSize = Uint32Property(env, options, "blockSize", 4096);
-  const uint32_t maxOpenFiles = Uint32Property(env, options, "maxOpenFiles", 1000);
-  const uint32_t blockRestartInterval = Uint32Property(env, options,
+  const auto cacheSize = Uint32Property(env, options, "cacheSize", 8 << 20);
+  const auto writeBufferSize = Uint32Property(env, options , "writeBufferSize" , 4 << 20);
+  const auto blockSize = Uint32Property(env, options, "blockSize", 4096);
+  const auto maxOpenFiles = Uint32Property(env, options, "maxOpenFiles", 1000);
+  const auto blockRestartInterval = Uint32Property(env, options,
                                                  "blockRestartInterval", 16);
-  const uint32_t maxFileSize = Uint32Property(env, options, "maxFileSize", 2 << 20);
-
-  napi_value callback = argv[3];
-  OpenWorker* worker = new OpenWorker(env, database, callback, location,
-                                      createIfMissing, errorIfExists,
-                                      compression, writeBufferSize, blockSize,
-                                      maxOpenFiles, blockRestartInterval,
-                                      maxFileSize, cacheSize,
-                                      infoLogLevel, readOnly);
+  const auto maxFileSize = Uint32Property(env, options, "maxFileSize", 2 << 20);
+
+  const auto callback = argv[3];
+
+  auto worker = new OpenWorker(env, database, callback, location,
+                               createIfMissing, errorIfExists,
+                               compression, writeBufferSize, blockSize,
+                               maxOpenFiles, blockRestartInterval,
+                               maxFileSize, cacheSize,
+                               infoLogLevel, readOnly);
   worker->Queue(env);
-  delete [] location;
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for closing a database
- */
 struct CloseWorker final : public BaseWorker {
   CloseWorker (napi_env env,
                Database* database,
                napi_value callback)
     : BaseWorker(env, database, callback, "leveldown.db.close") {}
 
-  ~CloseWorker () {}
-
   void DoExecute () override {
     database_->CloseDatabase();
   }
@@ -1075,197 +921,172 @@ napi_value noop_callback (napi_env env, napi_callback_info info) {
   return 0;
 }
 
-/**
- * Close a database.
- */
 NAPI_METHOD(db_close) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  napi_value callback = argv[1];
-  CloseWorker* worker = new CloseWorker(env, database, callback);
-
-  if (!database->HasPriorityWork()) {
-    worker->Queue(env);
-    NAPI_RETURN_UNDEFINED();
-  }
-
-  database->pendingCloseWorker_ = worker;
+  const auto callback = argv[1];
 
   napi_value noop;
-  napi_create_function(env, NULL, 0, noop_callback, NULL, &noop);
+  napi_create_function(env, nullptr, 0, noop_callback, nullptr, &noop);
 
-  std::map<uint32_t, Iterator*> iterators = database->iterators_;
-  std::map<uint32_t, Iterator*>::iterator it;
+  for (auto it : database->iterators_) {
+    iterator_do_close(env, it, noop);
+  }
+  
+  auto worker = new CloseWorker(env, database, callback);
 
-  for (it = iterators.begin(); it != iterators.end(); ++it) {
-    iterator_end_do(env, it->second, noop);
+  if (!database->HasPriorityWork()) {
+    worker->Queue(env);
+  } else {
+    database->pendingCloseWorker_ = worker;
   }
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for putting key/value to the database
- */
 struct PutWorker final : public PriorityWorker {
   PutWorker (napi_env env,
              Database* database,
              napi_value callback,
-             leveldb::Slice key,
-             leveldb::Slice value,
+             const std::string& key,
+             const std::string& value,
              bool sync)
-    : PriorityWorker(env, database, callback, "leveldown.db.put"),
-      key_(key), value_(value) {
-    options_.sync = sync;
-  }
-
-  ~PutWorker () {
-    DisposeSliceBuffer(key_);
-    DisposeSliceBuffer(value_);
+    : PriorityWorker(env, database, callback, "classic_level.db.put"),
+      key_(key), value_(value), sync_(sync) {
   }
 
   void DoExecute () override {
-    SetStatus(database_->Put(options_, key_, value_));
+    leveldb::WriteOptions options;
+    options.sync = sync_;
+    SetStatus(database_->Put(options, key_, value_));
   }
 
-  leveldb::WriteOptions options_;
-  leveldb::Slice key_;
-  leveldb::Slice value_;
+  const std::string key_;
+  const std::string value_;
+  const bool sync_;
 };
 
-/**
- * Puts a key and a value to a database.
- */
 NAPI_METHOD(db_put) {
   NAPI_ARGV(5);
   NAPI_DB_CONTEXT();
 
-  leveldb::Slice key = ToSlice(env, argv[1]);
-  leveldb::Slice value = ToSlice(env, argv[2]);
-  bool sync = BooleanProperty(env, argv[3], "sync", false);
-  napi_value callback = argv[4];
+  const auto key = ToString(env, argv[1]).value_or(std::string());
+  const auto value = ToString(env, argv[2]).value_or(std::string());
+  const auto sync = BooleanProperty(env, argv[3], "sync", false);
+  const auto callback = argv[4];
 
-  PutWorker* worker = new PutWorker(env, database, callback, key, value, sync);
+  auto worker = new PutWorker(env, database, callback, key, value, sync);
   worker->Queue(env);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for getting a value from a database.
- */
 struct GetWorker final : public PriorityWorker {
   GetWorker (napi_env env,
              Database* database,
              napi_value callback,
-             leveldb::Slice key,
+             const std::string& key,
              const bool asBuffer,
              const bool fillCache)
-    : PriorityWorker(env, database, callback, "leveldown.db.get"),
-      key_(key),
-      asBuffer_(asBuffer) {
-    options_.fill_cache = fillCache;
-  }
-
-  ~GetWorker () {
-    DisposeSliceBuffer(key_);
+    : PriorityWorker(env, database, callback, "classic_level.db.get"),
+      key_(key), asBuffer_(asBuffer), fillCache_(fillCache) {
   }
 
   void DoExecute () override {
-    SetStatus(database_->Get(options_, key_, value_));
+    leveldb::ReadOptions options;
+    options.fill_cache = fillCache_;
+    SetStatus(database_->Get(options, key_, value_));
   }
 
   void HandleOKCallback (napi_env env, napi_value callback) override {
     napi_value argv[2];
     napi_get_null(env, &argv[0]);
-    Entry::Convert(env, &value_, asBuffer_, &argv[1]);
+    Convert(env, std::move(value_), asBuffer_, argv[1]);
     CallFunction(env, callback, 2, argv);
   }
 
 private:
-  leveldb::ReadOptions options_;
-  leveldb::Slice key_;
-  std::string value_;
+  const std::string key_;
+  rocksdb::PinnableSlice value_;
   const bool asBuffer_;
+  const bool fillCache_;
 };
 
-/**
- * Gets a value from a database.
- */
 NAPI_METHOD(db_get) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  leveldb::Slice key = ToSlice(env, argv[1]);
-  napi_value options = argv[2];
-  const bool asBuffer = BooleanProperty(env, options, "asBuffer", true);
-  const bool fillCache = BooleanProperty(env, options, "fillCache", true);
-  napi_value callback = argv[3];
+  const auto key = ToString(env, argv[1]).value_or(std::string());
+  const auto options = argv[2];
+  const auto asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
+  const auto fillCache = BooleanProperty(env, options, "fillCache", true);
+  const auto callback = argv[3];
 
-  GetWorker* worker = new GetWorker(env, database, callback, key, asBuffer,
-                                    fillCache);
+  auto worker = new GetWorker(env, database, callback, key, asBuffer, fillCache);
   worker->Queue(env);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for getting many values.
- */
+
 struct GetManyWorker final : public PriorityWorker {
   GetManyWorker (napi_env env,
                  Database* database,
-                 const std::vector<std::string>* keys,
+                 const std::vector<std::string>& keys,
                  napi_value callback,
                  const bool valueAsBuffer,
                  const bool fillCache)
     : PriorityWorker(env, database, callback, "leveldown.get.many"),
-      keys_(keys), valueAsBuffer_(valueAsBuffer) {
-      options_.fill_cache = fillCache;
-      options_.snapshot = database->NewSnapshot();
-    }
+      keys_(keys), valueAsBuffer_(valueAsBuffer), fillCache_(fillCache),
+      snapshot_(database->NewSnapshot()) {
+  }
 
-  ~GetManyWorker() {
-    delete keys_;
+  ~GetManyWorker () {
+    if (snapshot_) {
+      database_->ReleaseSnapshot(snapshot_);
+      snapshot_ = nullptr;
+    }
   }
 
   void DoExecute () override {
-    cache_.reserve(keys_->size());
+    cache_.reserve(keys_.size());
 
-    for (const std::string& key: *keys_) {
-      std::string* value = new std::string();
-      leveldb::Status status = database_->Get(options_, key, *value);
+    leveldb::ReadOptions options;
+    options.snapshot = snapshot_;
+    options.fill_cache = fillCache_;
+    
+    rocksdb::PinnableSlice value;
+
+    for (const auto& key: keys_) {
+      const auto status = database_->Get(options, key, value);
 
       if (status.ok()) {
-        cache_.push_back(value);
+        cache_.push_back(std::move(value));
       } else if (status.IsNotFound()) {
-        delete value;
-        cache_.push_back(NULL);
+        cache_.push_back({});
       } else {
-        delete value;
-        for (const std::string* value: cache_) {
-          if (value != NULL) delete value;
-        }
         SetStatus(status);
         break;
       }
+
+      value.Reset();
     }
 
-    database_->ReleaseSnapshot(options_.snapshot);
+    database_->ReleaseSnapshot(snapshot_);
+    snapshot_ = nullptr;
   }
 
   void HandleOKCallback (napi_env env, napi_value callback) override {
-    size_t size = cache_.size();
+    const auto size = cache_.size();
+
     napi_value array;
     napi_create_array_with_length(env, size, &array);
 
     for (size_t idx = 0; idx < size; idx++) {
-      std::string* value = cache_[idx];
       napi_value element;
-      Entry::Convert(env, value, valueAsBuffer_, &element);
+      Convert(env, cache_[idx], valueAsBuffer_, element);
       napi_set_element(env, array, static_cast<uint32_t>(idx), element);
-      if (value != NULL) delete value;
     }
 
     napi_value argv[2];
@@ -1275,139 +1096,115 @@ struct GetManyWorker final : public PriorityWorker {
   }
 
 private:
-  leveldb::ReadOptions options_;
-  const std::vector<std::string>* keys_;
+  const std::vector<std::string> keys_;
   const bool valueAsBuffer_;
-  std::vector<std::string*> cache_;
+  std::vector<std::optional<rocksdb::PinnableSlice>> cache_;
+  const bool fillCache_;
+  const leveldb::Snapshot* snapshot_;
 };
 
-/**
- * Gets many values from a database.
- */
 NAPI_METHOD(db_get_many) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const std::vector<std::string>* keys = KeyArray(env, argv[1]);
-  napi_value options = argv[2];
-  const bool asBuffer = BooleanProperty(env, options, "asBuffer", true);
+  const auto keys = KeyArray(env, argv[1]);
+  const auto options = argv[2];
+  const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const bool fillCache = BooleanProperty(env, options, "fillCache", true);
-  napi_value callback = argv[3];
-
-  GetManyWorker* worker = new GetManyWorker(
-    env, database, keys, callback, asBuffer, fillCache
-  );
+  const auto callback = argv[3];
 
+  auto worker = new GetManyWorker(env, database, keys, callback, asBuffer, fillCache);
   worker->Queue(env);
-  NAPI_RETURN_UNDEFINED();
+
+  return 0;
 }
 
-/**
- * Worker class for deleting a value from a database.
- */
 struct DelWorker final : public PriorityWorker {
   DelWorker (napi_env env,
              Database* database,
              napi_value callback,
-             leveldb::Slice key,
+             const std::string& key,
              bool sync)
-    : PriorityWorker(env, database, callback, "leveldown.db.del"),
-      key_(key) {
-    options_.sync = sync;
-  }
-
-  ~DelWorker () {
-    DisposeSliceBuffer(key_);
+    : PriorityWorker(env, database, callback, "classic_level.db.del"),
+      key_(key), sync_(sync) {
   }
 
   void DoExecute () override {
-    SetStatus(database_->Del(options_, key_));
+    leveldb::WriteOptions options;
+    options.sync = sync_;
+    SetStatus(database_->Del(options, key_));
   }
 
-  leveldb::WriteOptions options_;
-  leveldb::Slice key_;
+  const std::string key_;
+  const bool sync_;
 };
 
-/**
- * Delete a value from a database.
- */
 NAPI_METHOD(db_del) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  leveldb::Slice key = ToSlice(env, argv[1]);
-  bool sync = BooleanProperty(env, argv[2], "sync", false);
-  napi_value callback = argv[3];
+  const auto key = ToString(env, argv[1]).value_or(std::string());
+  const auto sync = BooleanProperty(env, argv[2], "sync", false);
+  const auto callback = argv[3];
 
-  DelWorker* worker = new DelWorker(env, database, callback, key, sync);
+  auto worker = new DelWorker(env, database, callback, key, sync);
   worker->Queue(env);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for deleting a range from a database.
- */
 struct ClearWorker final : public PriorityWorker {
   ClearWorker (napi_env env,
                Database* database,
                napi_value callback,
                const bool reverse,
                const int limit,
-               std::string* lt,
-               std::string* lte,
-               std::string* gt,
-               std::string* gte)
-    : PriorityWorker(env, database, callback, "leveldown.db.clear") {
-    iterator_ = new BaseIterator(database, reverse, lt, lte, gt, gte, limit, false);
-    writeOptions_ = new leveldb::WriteOptions();
-    writeOptions_->sync = false;
-  }
-
-  ~ClearWorker () {
-    delete iterator_;
-    delete writeOptions_;
+               const std::optional<std::string>& lt,
+               const std::optional<std::string>& lte,
+               const std::optional<std::string>& gt,
+               const std::optional<std::string>& gte)
+    : PriorityWorker(env, database, callback, "classic_level.db.clear"),
+      iterator_(database, reverse, lt, lte, gt, gte, limit, false) {
   }
 
   void DoExecute () override {
-    iterator_->SeekToRange();
+    iterator_.SeekToRange();
 
     // TODO: add option
-    uint32_t hwm = 16 * 1024;
+    const uint32_t hwm = 16 * 1024;
     leveldb::WriteBatch batch;
 
+    leveldb::WriteOptions options;
+    options.sync = false;
+
     while (true) {
       size_t bytesRead = 0;
 
-      while (bytesRead <= hwm && iterator_->Valid() && iterator_->Increment()) {
-        leveldb::Slice key = iterator_->CurrentKey();
+      while (bytesRead <= hwm && iterator_.Valid() && iterator_.Increment()) {
+        const auto key = iterator_.CurrentKey();
         batch.Delete(key);
         bytesRead += key.size();
-        iterator_->Next();
+        iterator_.Next();
       }
 
-      if (!SetStatus(iterator_->Status()) || bytesRead == 0) {
+      if (!SetStatus(iterator_.Status()) || bytesRead == 0) {
         break;
       }
 
-      if (!SetStatus(database_->WriteBatch(*writeOptions_, &batch))) {
+      if (!SetStatus(database_->WriteBatch(options, &batch))) {
         break;
       }
 
       batch.Clear();
     }
 
-    iterator_->End();
+    iterator_.Close();
   }
 
 private:
-  BaseIterator* iterator_;
-  leveldb::WriteOptions* writeOptions_;
+  BaseIterator iterator_;
 };
 
-/**
- * Delete a range from a database.
- */
 NAPI_METHOD(db_clear) {
   NAPI_ARGV(3);
   NAPI_DB_CONTEXT();
@@ -1415,301 +1212,85 @@ NAPI_METHOD(db_clear) {
   napi_value options = argv[1];
   napi_value callback = argv[2];
 
-  const bool reverse = BooleanProperty(env, options, "reverse", false);
-  const int limit = Int32Property(env, options, "limit", -1);
-
-  std::string* lt = RangeOption(env, options, "lt");
-  std::string* lte = RangeOption(env, options, "lte");
-  std::string* gt = RangeOption(env, options, "gt");
-  std::string* gte = RangeOption(env, options, "gte");
-
-  ClearWorker* worker = new ClearWorker(env, database, callback, reverse, limit, lt, lte, gt, gte);
-  worker->Queue(env);
-
-  NAPI_RETURN_UNDEFINED();
-}
-
-/**
- * Worker class for calculating the size of a range.
- */
-struct ApproximateSizeWorker final : public PriorityWorker {
-  ApproximateSizeWorker (napi_env env,
-                         Database* database,
-                         napi_value callback,
-                         leveldb::Slice start,
-                         leveldb::Slice end)
-    : PriorityWorker(env, database, callback, "leveldown.db.approximate_size"),
-      start_(start), end_(end) {}
-
-  ~ApproximateSizeWorker () {
-    DisposeSliceBuffer(start_);
-    DisposeSliceBuffer(end_);
-  }
-
-  void DoExecute () override {
-    leveldb::Range range(start_, end_);
-    size_ = database_->ApproximateSize(&range);
-  }
-
-  void HandleOKCallback (napi_env env, napi_value callback) override {
-    napi_value argv[2];
-    napi_get_null(env, &argv[0]);
-    napi_create_int64(env, (uint64_t)size_, &argv[1]);
-    CallFunction(env, callback, 2, argv);
-  }
-
-  leveldb::Slice start_;
-  leveldb::Slice end_;
-  uint64_t size_;
-};
-
-/**
- * Calculates the approximate size of a range in a database.
- */
-NAPI_METHOD(db_approximate_size) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
-
-  leveldb::Slice start = ToSlice(env, argv[1]);
-  leveldb::Slice end = ToSlice(env, argv[2]);
-
-  napi_value callback = argv[3];
-
-  ApproximateSizeWorker* worker  = new ApproximateSizeWorker(env, database,
-                                                             callback, start,
-                                                             end);
-  worker->Queue(env);
-
-  NAPI_RETURN_UNDEFINED();
-}
-
-/**
- * Worker class for compacting a range in a database.
- */
-struct CompactRangeWorker final : public PriorityWorker {
-  CompactRangeWorker (napi_env env,
-                      Database* database,
-                      napi_value callback,
-                      leveldb::Slice start,
-                      leveldb::Slice end)
-    : PriorityWorker(env, database, callback, "leveldown.db.compact_range"),
-      start_(start), end_(end) {}
-
-  ~CompactRangeWorker () {
-    DisposeSliceBuffer(start_);
-    DisposeSliceBuffer(end_);
-  }
-
-  void DoExecute () override {
-    database_->CompactRange(&start_, &end_);
-  }
-
-  leveldb::Slice start_;
-  leveldb::Slice end_;
-};
-
-/**
- * Compacts a range in a database.
- */
-NAPI_METHOD(db_compact_range) {
-  NAPI_ARGV(4);
-  NAPI_DB_CONTEXT();
-
-  leveldb::Slice start = ToSlice(env, argv[1]);
-  leveldb::Slice end = ToSlice(env, argv[2]);
-  napi_value callback = argv[3];
-
-  CompactRangeWorker* worker  = new CompactRangeWorker(env, database, callback,
-                                                       start, end);
-  worker->Queue(env);
-
-  NAPI_RETURN_UNDEFINED();
-}
-
-/**
- * Get a property from a database.
- */
-NAPI_METHOD(db_get_property) {
-  NAPI_ARGV(2);
-  NAPI_DB_CONTEXT();
-
-  leveldb::Slice property = ToSlice(env, argv[1]);
-
-  std::string value;
-  database->GetProperty(property, &value);
-
-  napi_value result;
-  napi_create_string_utf8(env, value.data(), value.size(), &result);
-
-  DisposeSliceBuffer(property);
-
-  return result;
-}
-
-/**
- * Worker class for destroying a database.
- */
-struct DestroyWorker final : public BaseWorker {
-  DestroyWorker (napi_env env,
-                 const std::string& location,
-                 napi_value callback)
-    : BaseWorker(env, NULL, callback, "leveldown.destroy_db"),
-      location_(location) {}
-
-  ~DestroyWorker () {}
-
-  void DoExecute () override {
-    leveldb::Options options;
-
-    // TODO: support overriding infoLogLevel the same as db.open(options)
-    options.info_log_level = rocksdb::InfoLogLevel::HEADER_LEVEL;
-    options.info_log.reset(new NullLogger());
-
-    SetStatus(leveldb::DestroyDB(location_, options));
-  }
-
-  std::string location_;
-};
-
-/**
- * Destroys a database.
- */
-NAPI_METHOD(destroy_db) {
-  NAPI_ARGV(2);
-  NAPI_ARGV_UTF8_NEW(location, 0);
-  napi_value callback = argv[1];
-
-  DestroyWorker* worker = new DestroyWorker(env, location, callback);
-  worker->Queue(env);
-
-  delete [] location;
-
-  NAPI_RETURN_UNDEFINED();
-}
-
-/**
- * Worker class for repairing a database.
- */
-struct RepairWorker final : public BaseWorker {
-  RepairWorker (napi_env env,
-                const std::string& location,
-                napi_value callback)
-    : BaseWorker(env, NULL, callback, "leveldown.repair_db"),
-      location_(location) {}
-
-  ~RepairWorker () {}
-
-  void DoExecute () override {
-    leveldb::Options options;
-
-    // TODO: support overriding infoLogLevel the same as db.open(options)
-    options.info_log_level = rocksdb::InfoLogLevel::HEADER_LEVEL;
-    options.info_log.reset(new NullLogger());
+  const auto reverse = BooleanProperty(env, options, "reverse", false);
+  const auto limit = Int32Property(env, options, "limit", -1);
 
-    SetStatus(leveldb::RepairDB(location_, options));
-  }
+  const auto lt = RangeOption(env, options, "lt");
+  const auto lte = RangeOption(env, options, "lte");
+  const auto gt = RangeOption(env, options, "gt");
+  const auto gte = RangeOption(env, options, "gte");
 
-  std::string location_;
-};
-
-/**
- * Repairs a database.
- */
-NAPI_METHOD(repair_db) {
-  NAPI_ARGV(2);
-  NAPI_ARGV_UTF8_NEW(location, 0);
-  napi_value callback = argv[1];
-
-  RepairWorker* worker = new RepairWorker(env, location, callback);
+  auto worker = new ClearWorker(env, database, callback, reverse, limit, lt, lte, gt, gte);
   worker->Queue(env);
 
-  delete [] location;
-
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Runs when an Iterator is garbage collected.
- */
 static void FinalizeIterator (napi_env env, void* data, void* hint) {
   if (data) {
-    delete (Iterator*)data;
+    delete reinterpret_cast<Iterator*>(data);
   }
 }
 
-/**
- * Create an iterator.
- */
 NAPI_METHOD(iterator_init) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  napi_value options = argv[1];
-  const bool reverse = BooleanProperty(env, options, "reverse", false);
-  const bool keys = BooleanProperty(env, options, "keys", true);
-  const bool values = BooleanProperty(env, options, "values", true);
-  const bool fillCache = BooleanProperty(env, options, "fillCache", false);
-  const bool keyAsBuffer = BooleanProperty(env, options, "keyAsBuffer", true);
-  const bool valueAsBuffer = BooleanProperty(env, options, "valueAsBuffer", true);
-  const int limit = Int32Property(env, options, "limit", -1);
-  const uint32_t highWaterMark = Uint32Property(env, options, "highWaterMark",
-                                          16 * 1024);
-
-  std::string* lt = RangeOption(env, options, "lt");
-  std::string* lte = RangeOption(env, options, "lte");
-  std::string* gt = RangeOption(env, options, "gt");
-  std::string* gte = RangeOption(env, options, "gte");
-
-  const uint32_t id = database->currentIteratorId_++;
-  Iterator* iterator = new Iterator(database, id, reverse, keys,
-                                    values, limit, lt, lte, gt, gte, fillCache,
-                                    keyAsBuffer, valueAsBuffer, highWaterMark);
+  const auto options = argv[1];
+  const auto reverse = BooleanProperty(env, options, "reverse", false);
+  const auto keys = BooleanProperty(env, options, "keys", true);
+  const auto values = BooleanProperty(env, options, "values", true);
+  const auto fillCache = BooleanProperty(env, options, "fillCache", false);
+  const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
+  const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
+  const auto limit = Int32Property(env, options, "limit", -1);
+  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes", 16 * 1024);
+
+  const auto lt = RangeOption(env, options, "lt");
+  const auto lte = RangeOption(env, options, "lte");
+  const auto gt = RangeOption(env, options, "gt");
+  const auto gte = RangeOption(env, options, "gte");
+
+  auto iterator = new Iterator(database, reverse, keys,
+                               values, limit, lt, lte, gt, gte, fillCache,
+                               keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
   napi_value result;
 
   NAPI_STATUS_THROWS(napi_create_external(env, iterator,
                                           FinalizeIterator,
-                                          NULL, &result));
+                                          nullptr, &result));
 
-  // Prevent GC of JS object before the iterator is ended (explicitly or on
-  // db close) and keep track of non-ended iterators to end them on db close.
+  // 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.
   iterator->Attach(env, result);
 
   return result;
 }
 
-/**
- * Seeks an iterator.
- */
 NAPI_METHOD(iterator_seek) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  if (iterator->isEnding_ || iterator->hasEnded_) {
-    napi_throw_error(env, NULL, "iterator has ended");
+  if (iterator->isClosing_) {
+    napi_throw_error(env, nullptr, "iterator has closed");
   }
 
-  leveldb::Slice target = ToSlice(env, argv[1]);
-  iterator->landed_ = false;
+  const auto target = ToString(env, argv[1]).value_or(std::string());
+  iterator->first_ = true;
   iterator->Seek(target);
 
-  DisposeSliceBuffer(target);
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for ending an iterator
- */
-struct EndWorker final : public BaseWorker {
-  EndWorker (napi_env env,
-             Iterator* iterator,
-             napi_value callback)
+struct CloseIteratorWorker final : public BaseWorker {
+  CloseIteratorWorker (napi_env env,
+                       Iterator* iterator,
+                       napi_value callback)
     : BaseWorker(env, iterator->database_, callback, "leveldown.iterator.end"),
       iterator_(iterator) {}
 
-  ~EndWorker () {}
-
   void DoExecute () override {
-    iterator_->End();
+    iterator_->Close();
   }
 
   void DoFinally (napi_env env) override {
@@ -1722,46 +1303,39 @@ private:
 };
 
 /**
- * Called by NAPI_METHOD(iterator_end) and also when closing
+ * Called by NAPI_METHOD(iterator_) and also when closing
  * open iterators during NAPI_METHOD(db_close).
  */
-static void iterator_end_do (napi_env env, Iterator* iterator, napi_value cb) {
-  if (!iterator->isEnding_ && !iterator->hasEnded_) {
-    EndWorker* worker = new EndWorker(env, iterator, cb);
-    iterator->isEnding_ = true;
+static void iterator_do_close (napi_env env, Iterator* iterator, napi_value cb) {
+  if (!iterator->isClosing_) {
+    auto worker = new CloseIteratorWorker(env, iterator, cb);
+    iterator->isClosing_ = true;
 
     if (iterator->nexting_) {
-      iterator->endWorker_ = worker;
+      iterator->closeWorker_ = worker;
     } else {
       worker->Queue(env);
     }
   }
 }
 
-/**
- * Ends an iterator.
- */
-NAPI_METHOD(iterator_end) {
+NAPI_METHOD(iterator_close) {
   NAPI_ARGV(2);
   NAPI_ITERATOR_CONTEXT();
 
-  iterator_end_do(env, iterator, argv[1]);
+  iterator_do_close(env, iterator, argv[1]);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for nexting an iterator.
- */
 struct NextWorker final : public BaseWorker {
   NextWorker (napi_env env,
               Iterator* iterator,
+              uint32_t size,
               napi_value callback)
     : BaseWorker(env, iterator->database_, callback,
                  "leveldown.iterator.next"),
-      iterator_(iterator), ok_() {}
-
-  ~NextWorker () {}
+      iterator_(iterator), size_(size), ok_() {}
 
   void DoExecute () override {
     if (!iterator_->DidSeek()) {
@@ -1770,7 +1344,7 @@ struct NextWorker final : public BaseWorker {
 
     // 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(1000);
+    ok_ = iterator_->ReadMany(size_);
 
     if (!ok_) {
       SetStatus(iterator_->Status());
@@ -1778,28 +1352,26 @@ struct NextWorker final : public BaseWorker {
   }
 
   void HandleOKCallback (napi_env env, napi_value callback) override {
-    size_t arraySize = iterator_->cache_.size();
-    napi_value jsArray;
-    napi_create_array_with_length(env, arraySize, &jsArray);
+    const auto size = iterator_->cache_.size();
+    napi_value result;
+    napi_create_array_with_length(env, size, &result);
 
     for (size_t idx = 0; idx < iterator_->cache_.size(); idx += 2) {
-      std::string key = iterator_->cache_[idx];
-      std::string value = iterator_->cache_[idx + 1];
+      napi_value key;
+      napi_value val;
 
-      napi_value returnKey;
-      napi_value returnValue;
+      Convert(env, iterator_->cache_[idx + 0], iterator_->keyAsBuffer_, key);
+      Convert(env, iterator_->cache_[idx + 1], iterator_->valueAsBuffer_, val);
 
-      Entry::Convert(env, &key, iterator_->keyAsBuffer_, &returnKey);
-      Entry::Convert(env, &value, iterator_->valueAsBuffer_, &returnValue);
-
-      // put the key & value in a descending order, so that they can be .pop:ed in javascript-land
-      napi_set_element(env, jsArray, static_cast<int>(arraySize - idx - 1), returnKey);
-      napi_set_element(env, jsArray, static_cast<int>(arraySize - idx - 2), returnValue);
+      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();
+
     napi_value argv[3];
     napi_get_null(env, &argv[0]);
-    argv[1] = jsArray;
+    argv[1] = result;
     napi_get_boolean(env, !ok_, &argv[2]);
     CallFunction(env, callback, 3, argv);
   }
@@ -1808,9 +1380,9 @@ struct NextWorker final : public BaseWorker {
     // clean up & handle the next/end state
     iterator_->nexting_ = false;
 
-    if (iterator_->endWorker_ != NULL) {
-      iterator_->endWorker_->Queue(env);
-      iterator_->endWorker_ = NULL;
+    if (iterator_->closeWorker_) {
+      iterator_->closeWorker_->Queue(env);
+      iterator_->closeWorker_ = nullptr;
     }
 
     BaseWorker::DoFinally(env);
@@ -1818,30 +1390,31 @@ struct NextWorker final : public BaseWorker {
 
 private:
   Iterator* iterator_;
+  uint32_t size_;
   bool ok_;
 };
 
-/**
- * Moves an iterator to next element.
- */
-NAPI_METHOD(iterator_next) {
-  NAPI_ARGV(2);
+NAPI_METHOD(iterator_nextv) {
+  NAPI_ARGV(3);
   NAPI_ITERATOR_CONTEXT();
 
-  napi_value callback = argv[1];
+  uint32_t size;
+  NAPI_STATUS_THROWS(napi_get_value_uint32(env, argv[1], &size));
+  if (size == 0) size = 1;
 
-  if (iterator->isEnding_ || iterator->hasEnded_) {
-    napi_value argv = CreateError(env, "iterator has ended");
-    CallFunction(env, callback, 1, &argv);
+  const auto callback = argv[2];
 
-    NAPI_RETURN_UNDEFINED();
+  if (iterator->isClosing_) {
+    napi_value argv = CreateCodeError(env, "LEVEL_ITERATOR_NOT_OPEN", "Iterator is not open");
+    NAPI_STATUS_THROWS(CallFunction(env, callback, 1, &argv));
+    return 0;
   }
 
-  NextWorker* worker = new NextWorker(env, iterator, callback);
+  auto worker = new NextWorker(env, iterator, size, callback);
   iterator->nexting_ = true;
   worker->Queue(env);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
 /**
@@ -1854,7 +1427,7 @@ struct BatchWorker final : public PriorityWorker {
                leveldb::WriteBatch* batch,
                const bool sync,
                const bool hasData)
-    : PriorityWorker(env, database, callback, "leveldown.batch.do"),
+    : PriorityWorker(env, database, callback, "classic_level.batch.do"),
       batch_(batch), hasData_(hasData) {
     options_.sync = sync;
   }
@@ -1875,16 +1448,13 @@ private:
   const bool hasData_;
 };
 
-/**
- * Does a batch write operation on a database.
- */
 NAPI_METHOD(batch_do) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  napi_value array = argv[1];
-  const bool sync = BooleanProperty(env, argv[2], "sync", false);
-  napi_value callback = argv[3];
+  const auto array = argv[1];
+  const auto sync = BooleanProperty(env, argv[2], "sync", false);
+  const auto callback = argv[3];
 
   uint32_t length;
   napi_get_array_length(env, array, &length);
@@ -1902,194 +1472,126 @@ NAPI_METHOD(batch_do) {
 
     if (type == "del") {
       if (!HasProperty(env, element, "key")) continue;
-      leveldb::Slice key = ToSlice(env, GetProperty(env, element, "key"));
+      const auto key = ToString(env, GetProperty(env, element, "key")).value_or(std::string());
 
       batch->Delete(key);
       if (!hasData) hasData = true;
-
-      DisposeSliceBuffer(key);
     } else if (type == "put") {
       if (!HasProperty(env, element, "key")) continue;
       if (!HasProperty(env, element, "value")) continue;
 
-      leveldb::Slice key = ToSlice(env, GetProperty(env, element, "key"));
-      leveldb::Slice value = ToSlice(env, GetProperty(env, element, "value"));
+      const auto key = ToString(env, GetProperty(env, element, "key")).value_or(std::string());
+      const auto value = ToString(env, GetProperty(env, element, "value")).value_or(std::string());
 
       batch->Put(key, value);
       if (!hasData) hasData = true;
-
-      DisposeSliceBuffer(key);
-      DisposeSliceBuffer(value);
     }
   }
 
-  BatchWorker* worker = new BatchWorker(env, database, callback, batch, sync, hasData);
+  auto worker = new BatchWorker(env, database, callback, batch, sync, hasData);
   worker->Queue(env);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Owns a WriteBatch.
- */
-struct Batch {
-  Batch (Database* database)
-    : database_(database),
-      batch_(new leveldb::WriteBatch()),
-      hasData_(false) {}
-
-  ~Batch () {
-    delete batch_;
-  }
-
-  void Put (leveldb::Slice key, leveldb::Slice value) {
-    batch_->Put(key, value);
-    hasData_ = true;
-  }
-
-  void Del (leveldb::Slice key) {
-    batch_->Delete(key);
-    hasData_ = true;
-  }
-
-  void Clear () {
-    batch_->Clear();
-    hasData_ = false;
-  }
-
-  leveldb::Status Write (bool sync) {
-    leveldb::WriteOptions options;
-    options.sync = sync;
-    return database_->WriteBatch(options, batch_);
-  }
-
-  Database* database_;
-  leveldb::WriteBatch* batch_;
-  bool hasData_;
-};
-
-/**
- * Runs when a Batch is garbage collected.
- */
 static void FinalizeBatch (napi_env env, void* data, void* hint) {
   if (data) {
-    delete (Batch*)data;
+    delete reinterpret_cast<leveldb::WriteBatch*>(data);
   }
 }
 
-/**
- * Return a batch object.
- */
 NAPI_METHOD(batch_init) {
   NAPI_ARGV(1);
   NAPI_DB_CONTEXT();
 
-  Batch* batch = new Batch(database);
+  auto batch = new leveldb::WriteBatch();
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, batch,
                                           FinalizeBatch,
-                                          NULL, &result));
+                                          nullptr, &result));
   return result;
 }
 
-/**
- * Adds a put instruction to a batch object.
- */
 NAPI_METHOD(batch_put) {
   NAPI_ARGV(3);
   NAPI_BATCH_CONTEXT();
 
-  leveldb::Slice key = ToSlice(env, argv[1]);
-  leveldb::Slice value = ToSlice(env, argv[2]);
+  const auto key = ToString(env, argv[1]).value_or(std::string());
+  const auto value = ToString(env, argv[2]).value_or(std::string());
+
   batch->Put(key, value);
-  DisposeSliceBuffer(key);
-  DisposeSliceBuffer(value);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Adds a delete instruction to a batch object.
- */
 NAPI_METHOD(batch_del) {
   NAPI_ARGV(2);
   NAPI_BATCH_CONTEXT();
 
-  leveldb::Slice key = ToSlice(env, argv[1]);
-  batch->Del(key);
-  DisposeSliceBuffer(key);
+  const auto key = ToString(env, argv[1]).value_or(std::string());
+
+  batch->Delete(key);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Clears a batch object.
- */
 NAPI_METHOD(batch_clear) {
   NAPI_ARGV(1);
   NAPI_BATCH_CONTEXT();
 
   batch->Clear();
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * Worker class for batch write operation.
- */
 struct BatchWriteWorker final : public PriorityWorker {
   BatchWriteWorker (napi_env env,
-                    napi_value context,
-                    Batch* batch,
+                    Database* database,
+                    napi_value batch,
                     napi_value callback,
                     const bool sync)
-    : PriorityWorker(env, batch->database_, callback, "leveldown.batch.write"),
-      batch_(batch),
+    : PriorityWorker(env, database, callback, "leveldown.batch.write"),
       sync_(sync) {
-        // Prevent GC of batch object before we execute
-        NAPI_STATUS_THROWS_VOID(napi_create_reference(env, context, 1, &contextRef_));
-      }
 
-  ~BatchWriteWorker () {}
+    NAPI_STATUS_THROWS_VOID(napi_get_value_external(env, batch, reinterpret_cast<void**>(&batch_)));
+
+    // Prevent GC of batch object before we execute
+    NAPI_STATUS_THROWS_VOID(napi_create_reference(env, batch, 1, &batchRef_));
+  }
 
   void DoExecute () override {
-    if (batch_->hasData_) {
-      SetStatus(batch_->Write(sync_));
-    }
+    leveldb::WriteOptions options;
+    options.sync = sync_;
+    SetStatus(database_->WriteBatch(options, batch_));
   }
 
   void DoFinally (napi_env env) override {
-    napi_delete_reference(env, contextRef_);
+    napi_delete_reference(env, batchRef_);
     PriorityWorker::DoFinally(env);
   }
 
 private:
-  Batch* batch_;
+  leveldb::WriteBatch* batch_;
   const bool sync_;
-  napi_ref contextRef_;
+  napi_ref batchRef_;
 };
 
-/**
- * Writes a batch object.
- */
 NAPI_METHOD(batch_write) {
-  NAPI_ARGV(3);
-  NAPI_BATCH_CONTEXT();
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
 
-  napi_value options = argv[1];
-  const bool sync = BooleanProperty(env, options, "sync", false);
-  napi_value callback = argv[2];
+  const auto batch = argv[1];
+  const auto options = argv[2];
+  const auto sync = BooleanProperty(env, options, "sync", false);
+  const auto callback = argv[3];
 
-  BatchWriteWorker* worker  = new BatchWriteWorker(env, argv[0], batch, callback, sync);
+  auto worker = new BatchWriteWorker(env, database, batch, callback, sync);
   worker->Queue(env);
 
-  NAPI_RETURN_UNDEFINED();
+  return 0;
 }
 
-/**
- * All exported functions.
- */
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
@@ -2099,17 +1601,11 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_get_many);
   NAPI_EXPORT_FUNCTION(db_del);
   NAPI_EXPORT_FUNCTION(db_clear);
-  NAPI_EXPORT_FUNCTION(db_approximate_size);
-  NAPI_EXPORT_FUNCTION(db_compact_range);
-  NAPI_EXPORT_FUNCTION(db_get_property);
-
-  NAPI_EXPORT_FUNCTION(destroy_db);
-  NAPI_EXPORT_FUNCTION(repair_db);
 
   NAPI_EXPORT_FUNCTION(iterator_init);
   NAPI_EXPORT_FUNCTION(iterator_seek);
-  NAPI_EXPORT_FUNCTION(iterator_end);
-  NAPI_EXPORT_FUNCTION(iterator_next);
+  NAPI_EXPORT_FUNCTION(iterator_close);
+  NAPI_EXPORT_FUNCTION(iterator_nextv);
 
   NAPI_EXPORT_FUNCTION(batch_do);
   NAPI_EXPORT_FUNCTION(batch_init);