@nxtedition/rocksdb 5.2.2 → 5.2.13

package/binding.cc

@@ -17,7 +17,8 @@
 namespace leveldb = rocksdb;
 
 #include <set>
-#include <optional>
+#include <memory>
+#include <string>
 #include <vector>
 
 class NullLogger : public rocksdb::Logger {
@@ -63,28 +64,38 @@ static bool IsObject (napi_env env, napi_value value) {
 
 static napi_value CreateError (napi_env env, const std::string& str) {
   napi_value msg;
-  napi_create_string_utf8(env, str.c_str(), str.size(), &msg);
+  napi_create_string_utf8(env, str.data(), str.size(), &msg);
   napi_value error;
   napi_create_error(env, nullptr, msg, &error);
   return error;
 }
 
-static bool HasProperty (napi_env env, napi_value obj, const char* key) {
+static napi_value CreateCodeError (napi_env env, const std::string& code, const std::string& 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& key) {
   bool has = false;
-  napi_has_named_property(env, obj, key, &has);
+  napi_has_named_property(env, obj, key.data(), &has);
   return has;
 }
 
-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& key) {
   napi_value value;
-  napi_get_named_property(env, obj, key, &value);
+  napi_get_named_property(env, obj, key.data(), &value);
   return value;
 }
 
-static bool BooleanProperty (napi_env env, napi_value obj, const char* key,
+static bool BooleanProperty (napi_env env, napi_value obj, const std::string& key,
                              bool defaultValue) {
-  if (HasProperty(env, obj, key)) {
-    const auto value = GetProperty(env, obj, key);
+  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;
@@ -93,10 +104,23 @@ static bool BooleanProperty (napi_env env, napi_value obj, const char* key,
   return defaultValue;
 }
 
-static uint32_t Uint32Property (napi_env env, napi_value obj, const char* key,
+static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string& 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, nullptr, 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& key,
                                 uint32_t defaultValue) {
-  if (HasProperty(env, obj, key)) {
-    const auto value = GetProperty(env, obj, key);
+  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;
@@ -105,10 +129,10 @@ static uint32_t Uint32Property (napi_env env, napi_value obj, const char* key,
   return defaultValue;
 }
 
-static int Int32Property (napi_env env, napi_value obj, const char* key,
+static int Int32Property (napi_env env, napi_value obj, const std::string& key,
                           int defaultValue) {
-  if (HasProperty(env, obj, key)) {
-    const auto value = GetProperty(env, obj, key);
+  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;
@@ -117,7 +141,7 @@ static int Int32Property (napi_env env, napi_value obj, const char* key,
   return defaultValue;
 }
 
-static std::string ToString (napi_env env, napi_value from) {
+static std::string ToString (napi_env env, napi_value from, const std::string& defaultValue = "") {
   if (IsString(env, from)) {
     size_t length = 0;
     napi_get_value_string_utf8(env, from, nullptr, 0, &length);
@@ -131,10 +155,10 @@ static std::string ToString (napi_env env, napi_value from) {
     return std::string(buf, length);
   }
 
-  return {};
+  return defaultValue;
 }
 
-static std::string StringProperty (napi_env env, napi_value obj, const char* key) {
+static std::string StringProperty (napi_env env, napi_value obj, const std::string& key) {
   if (HasProperty(env, obj, key)) {
     napi_value value = GetProperty(env, obj, key);
     if (IsString(env, value)) {
@@ -158,16 +182,13 @@ static size_t StringOrBufferLength (napi_env env, napi_value value) {
   return size;
 }
 
-static std::optional<std::string> RangeOption (napi_env env, napi_value opts, const char* name) {
+static std::string* RangeOption (napi_env env, napi_value opts, const std::string& name) {
   if (HasProperty(env, opts, name)) {
     const auto value = GetProperty(env, opts, name);
-
-    if (StringOrBufferLength(env, value) > 0) {
-      return ToString(env, value);
-    }
+    return new std::string(ToString(env, value));
   }
 
-  return {};
+  return nullptr;
 }
 
 static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
@@ -199,13 +220,12 @@ static napi_status CallFunction (napi_env env,
   return napi_call_function(env, global, callback, argc, argv, nullptr);
 }
 
-void Convert (napi_env env, const std::optional<std::string>& 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);
+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);
+    napi_create_string_utf8(env, s.data(), s.size(), &result);
   }
 }
 
@@ -247,8 +267,9 @@ struct BaseWorker {
     self->DoExecute();
   }
 
-  void SetStatus (const leveldb::Status& status) {
+  bool SetStatus (const leveldb::Status& status) {
     status_ = status;
+    return status.ok();
   }
 
   virtual void DoExecute () = 0;
@@ -278,7 +299,28 @@ struct BaseWorker {
   }
 
   virtual void HandleErrorCallback (napi_env env, napi_value callback) {
-    auto argv = CreateError(env, status_.ToString());
+    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);
   }
 
@@ -333,18 +375,18 @@ struct Database {
   leveldb::Status Put (const leveldb::WriteOptions& options,
                        const std::string& key,
                        const std::string& value) {
-    return db_->Put(options, key, value);
+    return db_->Put(options, db_->DefaultColumnFamily(), key, value);
   }
 
   leveldb::Status Get (const leveldb::ReadOptions& options,
                        const std::string& key,
-                       std::string& value) {
-    return db_->Get(options, key, &value);
+                       rocksdb::PinnableSlice& value) {
+    return db_->Get(options, db_->DefaultColumnFamily(), key, &value);
   }
 
   leveldb::Status Del (const leveldb::WriteOptions& options,
                        const std::string& key) {
-    return db_->Delete(options, key);
+    return db_->Delete(options, db_->DefaultColumnFamily(), key);
   }
 
   leveldb::Status WriteBatch (const leveldb::WriteOptions& options,
@@ -352,6 +394,18 @@ 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 std::string& property, std::string& value) {
     db_->GetProperty(property, &value);
   }
@@ -424,10 +478,10 @@ struct PriorityWorker : public BaseWorker {
 struct BaseIterator {
   BaseIterator(Database* database,
                const bool reverse,
-               const std::optional<std::string>& lt,
-               const std::optional<std::string>& lte,
-               const std::optional<std::string>& gt,
-               const std::optional<std::string>& gte,
+               const std::string* lt,
+               const std::string* lte,
+               const std::string* gt,
+               const std::string* gte,
                const int limit,
                const bool fillCache)
     : database_(database),
@@ -451,6 +505,11 @@ struct BaseIterator {
 
   virtual ~BaseIterator () {
     assert(!dbIterator_);
+
+    delete lt_;
+    delete lte_;
+    delete gt_;
+    delete gte_;
   }
 
   bool DidSeek () const {
@@ -571,10 +630,19 @@ struct BaseIterator {
   }
 
   bool OutOfRange (const leveldb::Slice& target) const {
-    return ((lt_  && target.compare(*lt_) >= 0) ||
-            (lte_ && target.compare(*lte_) > 0) ||
-            (gt_  && target.compare(*gt_) <= 0) ||
-            (gte_ && target.compare(*gte_) < 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 false;
   }
 
   Database* database_;
@@ -584,10 +652,10 @@ private:
   leveldb::Iterator* dbIterator_;
   bool didSeek_;
   const bool reverse_;
-  const std::optional<std::string> lt_;
-  const std::optional<std::string> lte_;
-  const std::optional<std::string> gt_;
-  const std::optional<std::string> gte_;
+  const std::string* lt_;
+  const std::string* lte_;
+  const std::string* gt_;
+  const std::string* gte_;
   const int limit_;
   int count_;
 };
@@ -598,21 +666,21 @@ struct Iterator final : public BaseIterator {
             const bool keys,
             const bool values,
             const int limit,
-            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 std::string* lt,
+            const std::string* lte,
+            const std::string* gt,
+            const 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),
       keys_(keys),
       values_(values),
       keyAsBuffer_(keyAsBuffer),
       valueAsBuffer_(valueAsBuffer),
-      highWaterMark_(highWaterMark),
-      landed_(false),
+      highWaterMarkBytes_(highWaterMarkBytes),
+      first_(true),
       nexting_(false),
       isClosing_(false),
       closeWorker_(nullptr),
@@ -631,34 +699,34 @@ struct Iterator final : public BaseIterator {
 
   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_) {
-        const auto& slice = CurrentKey();
-        cache_.emplace_back(slice.data(), slice.size());
-        bytesRead += slice.size();
-      } else {
-        cache_.emplace_back("");
-      }
-
-      if (values_) {
-        const auto& 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;
       }
     }
@@ -670,8 +738,8 @@ struct Iterator final : public BaseIterator {
   const bool values_;
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
-  const uint32_t highWaterMark_;
-  bool landed_;
+  const uint32_t highWaterMarkBytes_;
+  bool first_;
   bool nexting_;
   bool isClosing_;
   BaseWorker* closeWorker_;
@@ -687,7 +755,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
@@ -697,8 +765,8 @@ static void env_cleanup_hook (void* arg) {
   // be a safe noop if called before db_open() or after db_close().
   if (database && database->db_) {
     // TODO: does not do `napi_delete_reference(env, iterator->ref_)`. Problem?
-    for (auto it = database->iterators_.begin(); it != database->iterators_.end(); ++it) {
-      (*it)->Close();
+    for (auto it : database->iterators_) {
+      it->Close();
     }
 
     // Having closed the iterators (and released snapshots) we can safely close.
@@ -866,8 +934,8 @@ NAPI_METHOD(db_close) {
   napi_value noop;
   napi_create_function(env, nullptr, 0, noop_callback, nullptr, &noop);
 
-  for (auto it = database->iterators_.begin(); it != database->iterators_.end(); ++it) {
-    iterator_do_close(env, *it, noop);
+  for (auto it : database->iterators_) {
+    iterator_do_close(env, it, noop);
   }
   
   auto worker = new CloseWorker(env, database, callback);
@@ -881,6 +949,90 @@ NAPI_METHOD(db_close) {
   return 0;
 }
 
+struct PutWorker final : public PriorityWorker {
+  PutWorker (napi_env env,
+             Database* database,
+             napi_value callback,
+             const std::string& key,
+             const std::string& value,
+             bool sync)
+    : PriorityWorker(env, database, callback, "rocks_level.db.put"),
+      key_(key), value_(value), sync_(sync) {
+  }
+
+  void DoExecute () override {
+    leveldb::WriteOptions options;
+    options.sync = sync_;
+    SetStatus(database_->Put(options, key_, value_));
+  }
+
+  const std::string key_;
+  const std::string value_;
+  const bool sync_;
+};
+
+NAPI_METHOD(db_put) {
+  NAPI_ARGV(5);
+  NAPI_DB_CONTEXT();
+
+  const auto key = ToString(env, argv[1]);
+  const auto value = ToString(env, argv[2]);
+  const auto sync = BooleanProperty(env, argv[3], "sync", false);
+  const auto callback = argv[4];
+
+  auto worker = new PutWorker(env, database, callback, key, value, sync);
+  worker->Queue(env);
+
+  return 0;
+}
+
+struct GetWorker final : public PriorityWorker {
+  GetWorker (napi_env env,
+             Database* database,
+             napi_value callback,
+             const std::string& key,
+             const bool asBuffer,
+             const bool fillCache)
+    : PriorityWorker(env, database, callback, "rocks_level.db.get"),
+      key_(key), asBuffer_(asBuffer), fillCache_(fillCache) {
+  }
+
+  void DoExecute () override {
+    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]);
+    Convert(env, std::move(value_), asBuffer_, argv[1]);
+    CallFunction(env, callback, 2, argv);
+  }
+
+private:
+  const std::string key_;
+  rocksdb::PinnableSlice value_;
+  const bool asBuffer_;
+  const bool fillCache_;
+};
+
+NAPI_METHOD(db_get) {
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
+
+  const auto key = ToString(env, argv[1]);
+  const auto options = argv[2];
+  const auto asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
+  const auto fillCache = BooleanProperty(env, options, "fillCache", true);
+  const auto callback = argv[3];
+
+  auto worker = new GetWorker(env, database, callback, key, asBuffer, fillCache);
+  worker->Queue(env);
+
+  return 0;
+}
+
 struct GetManyWorker final : public PriorityWorker {
   GetManyWorker (napi_env env,
                  Database* database,
@@ -907,18 +1059,21 @@ struct GetManyWorker final : public PriorityWorker {
     options.snapshot = snapshot_;
     options.fill_cache = fillCache_;
     
+    rocksdb::PinnableSlice value;
+
     for (const auto& key: keys_) {
-      std::string value;
       const auto status = database_->Get(options, key, value);
 
       if (status.ok()) {
-        cache_.push_back(std::move(value));
+        cache_.emplace_back(std::move(value));
       } else if (status.IsNotFound()) {
-        cache_.push_back({});
+        cache_.emplace_back(nullptr);
       } else {
         SetStatus(status);
         break;
       }
+
+      value.Reset();
     }
 
     database_->ReleaseSnapshot(snapshot_);
@@ -933,7 +1088,11 @@ struct GetManyWorker final : public PriorityWorker {
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
-      Convert(env, cache_[idx], valueAsBuffer_, element);
+      if (cache_[idx].GetSelf() != nullptr) {
+        Convert(env, cache_[idx], valueAsBuffer_, element);
+      } else {
+        napi_get_undefined(env, &element);
+      }
       napi_set_element(env, array, static_cast<uint32_t>(idx), element);
     }
 
@@ -946,7 +1105,7 @@ struct GetManyWorker final : public PriorityWorker {
 private:
   const std::vector<std::string> keys_;
   const bool valueAsBuffer_;
-  std::vector<std::optional<std::string>> cache_;
+  std::vector<rocksdb::PinnableSlice> cache_;
   const bool fillCache_;
   const leveldb::Snapshot* snapshot_;
 };
@@ -957,7 +1116,7 @@ NAPI_METHOD(db_get_many) {
 
   const auto keys = KeyArray(env, argv[1]);
   const auto options = argv[2];
-  const bool asBuffer = BooleanProperty(env, options, "asBuffer", true);
+  const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const bool fillCache = BooleanProperty(env, options, "fillCache", true);
   const auto callback = argv[3];
 
@@ -967,6 +1126,257 @@ NAPI_METHOD(db_get_many) {
   return 0;
 }
 
+struct DelWorker final : public PriorityWorker {
+  DelWorker (napi_env env,
+             Database* database,
+             napi_value callback,
+             const std::string& key,
+             bool sync)
+    : PriorityWorker(env, database, callback, "rocks_level.db.del"),
+      key_(key), sync_(sync) {
+  }
+
+  void DoExecute () override {
+    leveldb::WriteOptions options;
+    options.sync = sync_;
+    SetStatus(database_->Del(options, key_));
+  }
+
+  const std::string key_;
+  const bool sync_;
+};
+
+NAPI_METHOD(db_del) {
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
+
+  const auto key = ToString(env, argv[1]);
+  const auto sync = BooleanProperty(env, argv[2], "sync", false);
+  const auto callback = argv[3];
+
+  auto worker = new DelWorker(env, database, callback, key, sync);
+  worker->Queue(env);
+
+  return 0;
+}
+
+struct ClearWorker final : public PriorityWorker {
+  ClearWorker (napi_env env,
+               Database* database,
+               napi_value callback,
+               const bool reverse,
+               const int limit,
+               const std::string* lt,
+               const std::string* lte,
+               const std::string* gt,
+               const std::string* gte)
+    : PriorityWorker(env, database, callback, "rocks_level.db.clear"),
+      iterator_(database, reverse, lt, lte, gt, gte, limit, false) {
+  }
+
+  void DoExecute () override {
+    iterator_.SeekToRange();
+
+    // TODO: add option
+    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()) {
+        const auto key = iterator_.CurrentKey();
+        batch.Delete(key);
+        bytesRead += key.size();
+        iterator_.Next();
+      }
+
+      if (!SetStatus(iterator_.Status()) || bytesRead == 0) {
+        break;
+      }
+
+      if (!SetStatus(database_->WriteBatch(options, &batch))) {
+        break;
+      }
+
+      batch.Clear();
+    }
+
+    iterator_.Close();
+  }
+
+private:
+  BaseIterator iterator_;
+};
+
+NAPI_METHOD(db_clear) {
+  NAPI_ARGV(3);
+  NAPI_DB_CONTEXT();
+
+  napi_value options = argv[1];
+  napi_value callback = argv[2];
+
+  const auto reverse = BooleanProperty(env, options, "reverse", false);
+  const auto limit = Int32Property(env, options, "limit", -1);
+
+  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 worker = new ClearWorker(env, database, callback, reverse, limit, lt, lte, gt, gte);
+  worker->Queue(env);
+
+  return 0;
+}
+
+struct ApproximateSizeWorker final : public PriorityWorker {
+  ApproximateSizeWorker (napi_env env,
+                         Database* database,
+                         napi_value callback,
+                         const std::string& start,
+                         const std::string& end)
+    : PriorityWorker(env, database, callback, "rocks_level.db.approximate_size"),
+      start_(start), end_(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, size_, &argv[1]);
+    CallFunction(env, callback, 2, argv);
+  }
+
+  std::string start_;
+  std::string end_;
+  uint64_t size_;
+};
+
+NAPI_METHOD(db_approximate_size) {
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
+
+  const auto start = ToString(env, argv[1]);
+  const auto end = ToString(env, argv[2]);
+  const auto callback = argv[3];
+
+  auto worker  = new ApproximateSizeWorker(env, database, callback, start, end);
+  worker->Queue(env);
+
+  return 0;
+}
+
+struct CompactRangeWorker final : public PriorityWorker {
+  CompactRangeWorker (napi_env env,
+                      Database* database,
+                      napi_value callback,
+                      const std::string& start,
+                      const std::string& end)
+    : PriorityWorker(env, database, callback, "rocks_level.db.compact_range"),
+      start_(start), end_(end) {}
+
+  void DoExecute () override {
+    leveldb::Slice start = start_;
+    leveldb::Slice end = end_;
+    database_->CompactRange(&start, &end);
+  }
+
+  const std::string start_;
+  const std::string end_;
+};
+
+NAPI_METHOD(db_compact_range) {
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
+
+  const auto start = ToString(env, argv[1]);
+  const auto end = ToString(env, argv[2]);
+  const auto callback = argv[3];
+
+  auto worker  = new CompactRangeWorker(env, database, callback, start, end);
+  worker->Queue(env);
+
+  return 0;
+}
+
+NAPI_METHOD(db_get_property) {
+  NAPI_ARGV(2);
+  NAPI_DB_CONTEXT();
+
+  const auto property = ToString(env, argv[1]);
+
+  std::string value;
+  database->GetProperty(property, value);
+
+  napi_value result;
+  napi_create_string_utf8(env, value.data(), value.size(), &result);
+
+  return result;
+}
+
+struct DestroyWorker final : public BaseWorker {
+  DestroyWorker (napi_env env,
+                 const std::string& location,
+                 napi_value callback)
+    : BaseWorker(env, nullptr, callback, "rocks_level.destroy_db"),
+      location_(location) {}
+
+  ~DestroyWorker () {}
+
+  void DoExecute () override {
+    leveldb::Options options;
+    SetStatus(leveldb::DestroyDB(location_, options));
+  }
+
+  const std::string location_;
+};
+
+NAPI_METHOD(destroy_db) {
+  NAPI_ARGV(2);
+
+  const auto location = ToString(env, argv[0]);
+  const auto callback = argv[1];
+
+  auto worker = new DestroyWorker(env, location, callback);
+  worker->Queue(env);
+
+  return 0;
+}
+
+struct RepairWorker final : public BaseWorker {
+  RepairWorker (napi_env env,
+                const std::string& location,
+                napi_value callback)
+    : BaseWorker(env, nullptr, callback, "rocks_level.repair_db"),
+      location_(location) {}
+
+  void DoExecute () override {
+    leveldb::Options options;
+    SetStatus(leveldb::RepairDB(location_, options));
+  }
+
+  const std::string location_;
+};
+
+NAPI_METHOD(repair_db) {
+  NAPI_ARGV(2);
+
+  const auto location = ToString(env, argv[1]);
+  const auto callback = argv[1];
+
+  auto worker = new RepairWorker(env, location, callback);
+  worker->Queue(env);
+
+  return 0;
+}
+
 static void FinalizeIterator (napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<Iterator*>(data);
@@ -982,10 +1392,10 @@ NAPI_METHOD(iterator_init) {
   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 auto keyAsBuffer = BooleanProperty(env, options, "keyAsBuffer", true);
-  const auto valueAsBuffer = BooleanProperty(env, options, "valueAsBuffer", true);
+  const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
+  const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const auto limit = Int32Property(env, options, "limit", -1);
-  const auto highWaterMark = Uint32Property(env, options, "highWaterMark", 16 * 1024);
+  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes", 16 * 1024);
 
   const auto lt = RangeOption(env, options, "lt");
   const auto lte = RangeOption(env, options, "lte");
@@ -994,7 +1404,7 @@ NAPI_METHOD(iterator_init) {
 
   auto iterator = new Iterator(database, reverse, keys,
                                values, limit, lt, lte, gt, gte, fillCache,
-                               keyAsBuffer, valueAsBuffer, highWaterMark);
+                               keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
   napi_value result;
 
   NAPI_STATUS_THROWS(napi_create_external(env, iterator,
@@ -1017,7 +1427,7 @@ NAPI_METHOD(iterator_seek) {
   }
 
   const auto target = ToString(env, argv[1]);
-  iterator->landed_ = false;
+  iterator->first_ = true;
   iterator->Seek(target);
 
   return 0;
@@ -1104,8 +1514,8 @@ struct NextWorker final : public BaseWorker {
       Convert(env, iterator_->cache_[idx + 0], iterator_->keyAsBuffer_, key);
       Convert(env, iterator_->cache_[idx + 1], iterator_->valueAsBuffer_, val);
 
-      napi_set_element(env, result, static_cast<int>(size - idx - 1), key);
-      napi_set_element(env, result, static_cast<int>(size - idx - 2), 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();
@@ -1146,9 +1556,8 @@ NAPI_METHOD(iterator_nextv) {
   const auto callback = argv[2];
 
   if (iterator->isClosing_) {
-    auto argv = CreateError(env, "iterator has closed");
-    CallFunction(env, callback, 1, &argv);
-
+    napi_value argv = CreateCodeError(env, "LEVEL_ITERATOR_NOT_OPEN", "Iterator is not open");
+    NAPI_STATUS_THROWS(CallFunction(env, callback, 1, &argv));
     return 0;
   }
 
@@ -1159,6 +1568,83 @@ NAPI_METHOD(iterator_nextv) {
   return 0;
 }
 
+/**
+ * Worker class for batch write operation.
+ */
+struct BatchWorker final : public PriorityWorker {
+  BatchWorker (napi_env env,
+               Database* database,
+               napi_value callback,
+               leveldb::WriteBatch* batch,
+               const bool sync,
+               const bool hasData)
+    : PriorityWorker(env, database, callback, "rocks_level.batch.do"),
+      batch_(batch), hasData_(hasData) {
+    options_.sync = sync;
+  }
+
+  ~BatchWorker () {
+    delete batch_;
+  }
+
+  void DoExecute () override {
+    if (hasData_) {
+      SetStatus(database_->WriteBatch(options_, batch_));
+    }
+  }
+
+private:
+  leveldb::WriteOptions options_;
+  leveldb::WriteBatch* batch_;
+  const bool hasData_;
+};
+
+NAPI_METHOD(batch_do) {
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
+
+  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);
+
+  leveldb::WriteBatch* batch = new leveldb::WriteBatch();
+  bool hasData = false;
+
+  for (uint32_t i = 0; i < length; i++) {
+    napi_value element;
+    napi_get_element(env, array, i, &element);
+
+    if (!IsObject(env, element)) continue;
+
+    std::string type = StringProperty(env, element, "type");
+
+    if (type == "del") {
+      if (!HasProperty(env, element, "key")) continue;
+      const auto key = ToString(env, GetProperty(env, element, "key"));
+
+      batch->Delete(key);
+      if (!hasData) hasData = true;
+    } else if (type == "put") {
+      if (!HasProperty(env, element, "key")) continue;
+      if (!HasProperty(env, element, "value")) continue;
+
+      const auto key = ToString(env, GetProperty(env, element, "key"));
+      const auto value = ToString(env, GetProperty(env, element, "value"));
+
+      batch->Put(key, value);
+      if (!hasData) hasData = true;
+    }
+  }
+
+  auto worker = new BatchWorker(env, database, callback, batch, sync, hasData);
+  worker->Queue(env);
+
+  return 0;
+}
+
 static void FinalizeBatch (napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<leveldb::WriteBatch*>(data);
@@ -1261,13 +1747,24 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
   NAPI_EXPORT_FUNCTION(db_close);
+  NAPI_EXPORT_FUNCTION(db_put);
+  NAPI_EXPORT_FUNCTION(db_get);
   NAPI_EXPORT_FUNCTION(db_get_many);
+  NAPI_EXPORT_FUNCTION(db_del);
+  NAPI_EXPORT_FUNCTION(db_clear);
+  NAPI_EXPORT_FUNCTION(db_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_close);
   NAPI_EXPORT_FUNCTION(iterator_nextv);
 
+  NAPI_EXPORT_FUNCTION(batch_do);
   NAPI_EXPORT_FUNCTION(batch_init);
   NAPI_EXPORT_FUNCTION(batch_put);
   NAPI_EXPORT_FUNCTION(batch_del);