rocksdb-native 1.0.0 → 1.2.0

package/binding.c

@@ -45,14 +45,20 @@ typedef struct {
   js_ref_t *on_close;
 } rocksdb_native_close_t;
 
+typedef struct {
+  rocksdb_delete_range_t handle;
+
+  js_env_t *env;
+  js_ref_t *ctx;
+  js_ref_t *on_status;
+} rocksdb_native_delete_range_t;
+
 typedef struct {
   rocksdb_iterator_t handle;
 
   rocksdb_slice_t *keys;
   rocksdb_slice_t *values;
 
-  size_t capacity;
-
   js_env_t *env;
   js_ref_t *ctx;
   js_ref_t *on_open;
@@ -280,6 +286,101 @@ rocksdb_native_close (js_env_t *env, js_callback_info_t *info) {
   return handle;
 }
 
+static void
+rocksdb_native__on_delete_range (rocksdb_delete_range_t *handle, int status) {
+  int err;
+
+  assert(status == 0);
+
+  rocksdb_native_delete_range_t *req = (rocksdb_native_delete_range_t *) handle->data;
+
+  js_env_t *env = req->env;
+
+  js_handle_scope_t *scope;
+  err = js_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  js_value_t *ctx;
+  err = js_get_reference_value(env, req->ctx, &ctx);
+  assert(err == 0);
+
+  js_value_t *cb;
+  err = js_get_reference_value(env, req->on_status, &cb);
+  assert(err == 0);
+
+  js_value_t *error;
+
+  if (req->handle.error) {
+    err = js_create_string_utf8(env, (utf8_t *) req->handle.error, -1, &error);
+    assert(err == 0);
+  } else {
+    err = js_get_null(env, &error);
+    assert(err == 0);
+  }
+
+  js_call_function(env, ctx, cb, 1, (js_value_t *[]){error}, NULL);
+
+  err = js_close_handle_scope(env, scope);
+  assert(err == 0);
+
+  err = js_delete_reference(env, req->on_status);
+  assert(err == 0);
+
+  err = js_delete_reference(env, req->ctx);
+  assert(err == 0);
+}
+
+static js_value_t *
+rocksdb_native_delete_range (js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 7;
+  js_value_t *argv[7];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 7);
+
+  rocksdb_native_t *db;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
+  assert(err == 0);
+
+  js_value_t *handle;
+
+  rocksdb_native_delete_range_t *req;
+  err = js_create_arraybuffer(env, sizeof(rocksdb_native_delete_range_t), (void **) &req, &handle);
+  assert(err == 0);
+
+  req->env = env;
+  req->handle.data = (void *) req;
+
+  rocksdb_range_t range;
+
+  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &range.gt.data, &range.gt.len, NULL, NULL);
+  assert(err == 0);
+
+  err = js_get_typedarray_info(env, argv[2], NULL, (void **) &range.gte.data, &range.gte.len, NULL, NULL);
+  assert(err == 0);
+
+  err = js_get_typedarray_info(env, argv[3], NULL, (void **) &range.lt.data, &range.lt.len, NULL, NULL);
+  assert(err == 0);
+
+  err = js_get_typedarray_info(env, argv[4], NULL, (void **) &range.lte.data, &range.lte.len, NULL, NULL);
+  assert(err == 0);
+
+  err = js_create_reference(env, argv[5], 1, &req->ctx);
+  assert(err == 0);
+
+  err = js_create_reference(env, argv[6], 1, &req->on_status);
+  assert(err == 0);
+
+  err = rocksdb_delete_range(&db->handle, &req->handle, range, rocksdb_native__on_delete_range);
+  assert(err == 0);
+
+  return handle;
+}
+
 static js_value_t *
 rocksdb_native_iterator_init (js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -349,8 +450,6 @@ rocksdb_native_iterator_buffer (js_env_t *env, js_callback_info_t *info) {
   err = js_create_arraybuffer(env, 2 * capacity * sizeof(rocksdb_slice_t), (void **) &data, &handle);
   assert(err == 0);
 
-  iterator->capacity = capacity;
-
   size_t offset = 0;
 
   iterator->keys = (rocksdb_slice_t *) &data[offset];
@@ -404,27 +503,37 @@ static js_value_t *
 rocksdb_native_iterator_open (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 3;
-  js_value_t *argv[3];
+  size_t argc = 6;
+  js_value_t *argv[6];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 3);
+  assert(argc == 6);
 
   rocksdb_native_iterator_t *iterator;
   err = js_get_arraybuffer_info(env, argv[0], (void **) &iterator, NULL);
   assert(err == 0);
 
-  rocksdb_slice_t start;
-  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &start.data, &start.len, NULL, NULL);
+  rocksdb_range_t range;
+
+  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &range.gt.data, &range.gt.len, NULL, NULL);
+  assert(err == 0);
+
+  err = js_get_typedarray_info(env, argv[2], NULL, (void **) &range.gte.data, &range.gte.len, NULL, NULL);
+  assert(err == 0);
+
+  err = js_get_typedarray_info(env, argv[3], NULL, (void **) &range.lt.data, &range.lt.len, NULL, NULL);
+  assert(err == 0);
+
+  err = js_get_typedarray_info(env, argv[4], NULL, (void **) &range.lte.data, &range.lte.len, NULL, NULL);
   assert(err == 0);
 
-  rocksdb_slice_t end;
-  err = js_get_typedarray_info(env, argv[2], NULL, (void **) &end.data, &end.len, NULL, NULL);
+  bool reverse;
+  err = js_get_value_bool(env, argv[5], &reverse);
   assert(err == 0);
 
-  err = rocksdb_iterator_open(&iterator->handle, start, end, rocksdb_native__on_iterator_open);
+  err = rocksdb_iterator_open(&iterator->handle, range, reverse, rocksdb_native__on_iterator_open);
   assert(err == 0);
 
   return NULL;
@@ -562,19 +671,23 @@ static js_value_t *
 rocksdb_native_iterator_read (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 1;
-  js_value_t *argv[1];
+  size_t argc = 2;
+  js_value_t *argv[2];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 1);
+  assert(argc == 2);
 
   rocksdb_native_iterator_t *iterator;
   err = js_get_arraybuffer_info(env, argv[0], (void **) &iterator, NULL);
   assert(err == 0);
 
-  err = rocksdb_iterator_read(&iterator->handle, iterator->keys, iterator->values, iterator->capacity, rocksdb_native__on_iterator_read);
+  uint32_t capacity;
+  err = js_get_value_uint32(env, argv[1], &capacity);
+  assert(err == 0);
+
+  err = rocksdb_iterator_read(&iterator->handle, iterator->keys, iterator->values, capacity, rocksdb_native__on_iterator_read);
   assert(err == 0);
 
   return NULL;
@@ -856,6 +969,7 @@ rocksdb_native_exports (js_env_t *env, js_value_t *exports) {
   V("init", rocksdb_native_init)
   V("open", rocksdb_native_open)
   V("close", rocksdb_native_close)
+  V("deleteRange", rocksdb_native_delete_range)
 
   V("iteratorInit", rocksdb_native_iterator_init)
   V("iteratorBuffer", rocksdb_native_iterator_buffer)

package/index.js

@@ -1,9 +1,12 @@
 /* global Bare */
 const ReadyResource = require('ready-resource')
+const b4a = require('b4a')
 const binding = require('./binding')
 const Batch = require('./lib/batch')
 const Iterator = require('./lib/iterator')
 
+const empty = b4a.alloc(0)
+
 const RocksDB = module.exports = class RocksDB extends ReadyResource {
   constructor (path, {
     // default options, https://github.com/facebook/rocksdb/wiki/Setup-Options-and-Basic-Tuning
@@ -101,6 +104,42 @@ const RocksDB = module.exports = class RocksDB extends ReadyResource {
     }
   }
 
+  async deleteRange (start, end, opts = {}) {
+    if (typeof start === 'string') start = b4a.from(start)
+    if (typeof end === 'string') end = b4a.from(end)
+
+    if (start && !b4a.isBuffer(start)) {
+      opts = start
+      start = empty
+    } else if (end && !b4a.isBuffer(end)) {
+      opts = end
+      end = empty
+    }
+
+    const {
+      gt = empty,
+      gte = start,
+      lt = end,
+      lte = empty
+    } = opts
+
+    const req = { resolve: null, reject: null, handle: null }
+
+    const promise = new Promise((resolve, reject) => {
+      req.resolve = resolve
+      req.reject = reject
+    })
+
+    req.handle = binding.deleteRange(this._handle, gt, gte, lt, lte, req, onstatus)
+
+    return promise
+
+    function onstatus (err) {
+      if (err) req.reject(new Error(err))
+      else req.resolve()
+    }
+  }
+
   batch (opts) {
     return new Batch(this, opts)
   }

package/lib/iterator.js

@@ -9,28 +9,43 @@ module.exports = class RocksDBIterator extends Readable {
     if (typeof start === 'string') start = b4a.from(start)
     if (typeof end === 'string') end = b4a.from(end)
 
-    if (end && !Buffer.isBuffer(end)) {
+    if (start && !b4a.isBuffer(start)) {
+      opts = start
+      start = empty
+    } else if (end && !b4a.isBuffer(end)) {
       opts = end
       end = empty
     }
 
     const {
+      gt = empty,
+      gte = start,
+      lt = end,
+      lte = empty,
+      reverse = false,
+      limit = Infinity,
       capacity = 8
     } = opts
 
     super()
 
     this._db = db
-    this._start = start
-    this._end = end || empty
+
+    this._gt = toBuffer(gt) || empty
+    this._gte = toBuffer(gte) || empty
+    this._lt = toBuffer(lt) || empty
+    this._lte = toBuffer(lte) || empty
+
+    this._reverse = reverse
+    this._limit = limit
     this._capacity = capacity
 
     this._pendingOpen = null
     this._pendingRead = null
     this._pendingDestroy = null
 
-    this._handle = null
     this._buffer = null
+    this._handle = null
 
     if (db.opened === true) this.ready()
   }
@@ -48,6 +63,8 @@ module.exports = class RocksDBIterator extends Readable {
 
     const n = keys.length
 
+    this._limit -= n
+
     for (let i = 0; i < n; i++) {
       this.push({ key: b4a.from(keys[i]), value: b4a.from(values[i]) })
     }
@@ -88,13 +105,13 @@ module.exports = class RocksDBIterator extends Readable {
 
     this._pendingOpen = cb
 
-    binding.iteratorOpen(this._handle, this._start, this._end)
+    binding.iteratorOpen(this._handle, this._gt, this._gte, this._lt, this._lte, this._reverse)
   }
 
   _read (cb) {
     this._pendingRead = cb
 
-    binding.iteratorRead(this._handle)
+    binding.iteratorRead(this._handle, Math.min(this._capacity, this._limit))
   }
 
   async _destroy (cb) {
@@ -105,3 +122,7 @@ module.exports = class RocksDBIterator extends Readable {
     binding.iteratorClose(this._handle)
   }
 }
+
+function toBuffer (data) {
+  return typeof data === 'string' ? b4a.from(data) : data
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rocksdb-native",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "librocksdb bindings for JavaScript",
   "exports": {
     ".": "./index.js",

package/vendor/librocksdb/include/rocksdb.h

@@ -13,6 +13,7 @@ typedef struct rocksdb_options_s rocksdb_options_t;
 typedef struct rocksdb_open_s rocksdb_open_t;
 typedef struct rocksdb_close_s rocksdb_close_t;
 typedef struct rocksdb_slice_s rocksdb_slice_t;
+typedef struct rocksdb_range_s rocksdb_range_t;
 typedef struct rocksdb_read_range_s rocksdb_read_range_t;
 typedef struct rocksdb_delete_range_s rocksdb_delete_range_t;
 typedef struct rocksdb_iterator_s rocksdb_iterator_t;
@@ -107,13 +108,21 @@ struct rocksdb_slice_s {
   size_t len;
 };
 
+struct rocksdb_range_s {
+  rocksdb_slice_t gt;
+  rocksdb_slice_t gte;
+
+  rocksdb_slice_t lt;
+  rocksdb_slice_t lte;
+};
+
 struct rocksdb_read_range_s {
   uv_work_t worker;
 
   rocksdb_t *db;
 
-  rocksdb_slice_t start;
-  rocksdb_slice_t end;
+  rocksdb_range_t range;
+  bool reverse;
 
   size_t len;
   size_t capacity;
@@ -133,8 +142,7 @@ struct rocksdb_delete_range_s {
 
   rocksdb_t *db;
 
-  rocksdb_slice_t start;
-  rocksdb_slice_t end;
+  rocksdb_range_t range;
 
   char *error;
 
@@ -150,8 +158,8 @@ struct rocksdb_iterator_s {
 
   void *handle; // Opaque iterator pointer
 
-  rocksdb_slice_t start;
-  rocksdb_slice_t end;
+  rocksdb_range_t range;
+  bool reverse;
 
   size_t len;
   size_t capacity;
@@ -214,22 +222,22 @@ rocksdb_slice_t
 rocksdb_slice_empty (void);
 
 int
-rocksdb_read_range (rocksdb_t *db, rocksdb_read_range_t *req, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_slice_t *keys, rocksdb_slice_t *values, size_t capacity, rocksdb_read_range_cb cb);
+rocksdb_read_range (rocksdb_t *db, rocksdb_read_range_t *req, rocksdb_range_t range, bool reverse, rocksdb_slice_t *keys, rocksdb_slice_t *values, size_t capacity, rocksdb_read_range_cb cb);
 
 int
-rocksdb_delete_range (rocksdb_t *db, rocksdb_delete_range_t *req, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_delete_range_cb cb);
+rocksdb_delete_range (rocksdb_t *db, rocksdb_delete_range_t *req, rocksdb_range_t range, rocksdb_delete_range_cb cb);
 
 int
 rocksdb_iterator_init (rocksdb_t *db, rocksdb_iterator_t *iterator);
 
 int
-rocksdb_iterator_open (rocksdb_iterator_t *iterator, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_iterator_cb cb);
+rocksdb_iterator_open (rocksdb_iterator_t *iterator, rocksdb_range_t range, bool reverse, rocksdb_iterator_cb cb);
 
 int
 rocksdb_iterator_close (rocksdb_iterator_t *iterator, rocksdb_iterator_cb cb);
 
 int
-rocksdb_iterator_refresh (rocksdb_iterator_t *iterator, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_iterator_cb cb);
+rocksdb_iterator_refresh (rocksdb_iterator_t *iterator, rocksdb_range_t range, bool reverse, rocksdb_iterator_cb cb);
 
 int
 rocksdb_iterator_read (rocksdb_iterator_t *iterator, rocksdb_slice_t *keys, rocksdb_slice_t *values, size_t capacity, rocksdb_iterator_cb cb);

package/vendor/librocksdb/src/rocksdb.cc

@@ -36,7 +36,7 @@ static const rocksdb_options_t rocksdb__default_options = {
 template <auto rocksdb_options_t::*P, typename T>
 static inline T
 rocksdb__option (const rocksdb_options_t *options, int min_version, T fallback = T(rocksdb__default_options.*P)) {
-  return T(options->version >= min_version ? options->*P : fallback);
+  return options->version >= min_version ? T(options->*P) : fallback;
 }
 
 extern "C" int
@@ -202,45 +202,170 @@ rocksdb__slice_copy (const Slice &slice) {
   return {.data = data, .len = len};
 }
 
+static inline const Slice &
+rocksdb__slice_cast (const rocksdb_slice_t &slice) {
+  return reinterpret_cast<const Slice &>(slice);
+}
+
+static inline const rocksdb_slice_t &
+rocksdb__slice_cast (const Slice &slice) {
+  return reinterpret_cast<const rocksdb_slice_t &>(slice);
+}
+
+static inline void
+rocksdb__iterator_seek_first (Iterator *iterator, const rocksdb_range_t &range) {
+  if (range.gte.len) {
+    auto gte = rocksdb__slice_cast(range.gte);
+
+    iterator->Seek(gte);
+  } else if (range.gt.len) {
+    auto gt = rocksdb__slice_cast(range.gt);
+
+    iterator->Seek(gt);
+
+    if (iterator->Valid() && iterator->key().compare(gt) == 0) {
+      iterator->Next();
+    }
+  } else {
+    iterator->SeekToFirst();
+  }
+}
+
+static inline void
+rocksdb__iterator_seek_last (Iterator *iterator, const rocksdb_range_t &range) {
+  if (range.lte.len) {
+    auto lte = rocksdb__slice_cast(range.lte);
+
+    iterator->Seek(lte);
+
+    if (iterator->Valid()) {
+      if (iterator->key().compare(lte) > 0) iterator->Prev();
+    } else {
+      iterator->SeekToLast();
+    }
+  } else if (range.lt.len) {
+
+    auto lt = rocksdb__slice_cast(range.lt);
+
+    iterator->Seek(lt);
+
+    if (iterator->Valid()) {
+      if (iterator->key().compare(lt) >= 0) iterator->Prev();
+    } else {
+      iterator->SeekToLast();
+    }
+  } else {
+    iterator->SeekToLast();
+  }
+}
+
+template <bool reverse>
+static inline void
+rocksdb__iterator_seek (Iterator *iterator, const rocksdb_range_t &range) {
+  if (reverse) {
+    rocksdb__iterator_seek_last(iterator, range);
+  } else {
+    rocksdb__iterator_seek_first(iterator, range);
+  }
+}
+
 template <typename T>
 static inline void
 rocksdb__iterator_seek (Iterator *iterator, T *req) {
-  iterator->Seek(reinterpret_cast<const Slice &>(req->start));
+  const auto &range = req->range;
+
+  if (req->reverse) {
+    rocksdb__iterator_seek<true>(iterator, range);
+  } else {
+    rocksdb__iterator_seek<false>(iterator, range);
+  }
+}
+
+template <bool reverse = false>
+static inline void
+rocksdb__iterator_next (Iterator *iterator) {
+  if (reverse) {
+    iterator->Prev();
+  } else {
+    iterator->Next();
+  }
 }
 
 template <typename T>
-static inline Iterator *
-rocksdb__iterator_open (T *req) {
-  auto db = reinterpret_cast<DB *>(req->db->handle);
+static inline void
+rocksdb__iterator_next (Iterator *iterator, T *req) {
+  if (req->reverse) {
+    rocksdb__iterator_next<true>(iterator);
+  } else {
+    rocksdb__iterator_next<false>(iterator);
+  }
+}
+
+static inline bool
+rocksdb__iterator_valid (Iterator *iterator, const rocksdb_range_t &range) {
+  if (!iterator->Valid()) return false;
+
+  auto key = iterator->key();
 
+  return (
+    (range.lt.len == 0 || key.compare(rocksdb__slice_cast(range.lt)) < 0) &&
+    (range.lte.len == 0 || key.compare(rocksdb__slice_cast(range.lte)) <= 0) &&
+    (range.gt.len == 0 || key.compare(rocksdb__slice_cast(range.gt)) > 0) &&
+    (range.gte.len == 0 || key.compare(rocksdb__slice_cast(range.gte)) >= 0)
+  );
+}
+
+template <typename T>
+static inline bool
+rocksdb__iterator_valid (Iterator *iterator, T *req) {
+  return rocksdb__iterator_valid(iterator, req->range);
+}
+
+template <bool reverse = false>
+static inline Iterator *
+rocksdb__iterator_open (DB *db, const rocksdb_range_t &range) {
   auto iterator = db->NewIterator(ReadOptions());
 
-  rocksdb__iterator_seek(iterator, req);
+  rocksdb__iterator_seek<reverse>(iterator, range);
 
   return iterator;
 }
 
 template <typename T>
-static inline void
-rocksdb__iterator_read (Iterator *iterator, T *req) {
-  while (iterator->Valid() && req->len < req->capacity) {
-    auto key = iterator->key();
+static inline Iterator *
+rocksdb__iterator_open (T *req) {
+  auto db = reinterpret_cast<DB *>(req->db->handle);
 
-    if (req->end.len && key.compare(reinterpret_cast<const Slice &>(req->end)) >= 0) {
-      break;
-    }
+  const auto &range = req->range;
 
-    auto value = iterator->value();
+  if (req->reverse) {
+    return rocksdb__iterator_open<true>(db, range);
+  } else {
+    return rocksdb__iterator_open<false>(db, range);
+  }
+}
 
-    req->keys[req->len] = rocksdb__slice_copy(key);
-    req->values[req->len] = rocksdb__slice_copy(value);
+template <typename T>
+static inline void
+rocksdb__iterator_read (Iterator *iterator, T *req) {
+  while (rocksdb__iterator_valid(iterator, req) && req->len < req->capacity) {
+    auto i = req->len++;
 
-    req->len++;
+    req->keys[i] = rocksdb__slice_copy(iterator->key());
+    req->values[i] = rocksdb__slice_copy(iterator->value());
 
-    iterator->Next();
+    rocksdb__iterator_next(iterator, req);
   }
 }
 
+template <typename T>
+static inline void
+rocksdb__iterator_refresh (Iterator *iterator, T *req) {
+  iterator->Refresh();
+
+  rocksdb__iterator_seek(iterator, req);
+}
+
 static void
 rocksdb__on_after_read_range (uv_work_t *handle, int status) {
   auto req = reinterpret_cast<rocksdb_read_range_t *>(handle->data);
@@ -272,10 +397,10 @@ rocksdb__on_read_range (uv_work_t *handle) {
 }
 
 extern "C" int
-rocksdb_read_range (rocksdb_t *db, rocksdb_read_range_t *req, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_slice_t *keys, rocksdb_slice_t *values, size_t capacity, rocksdb_read_range_cb cb) {
+rocksdb_read_range (rocksdb_t *db, rocksdb_read_range_t *req, rocksdb_range_t range, bool reverse, rocksdb_slice_t *keys, rocksdb_slice_t *values, size_t capacity, rocksdb_read_range_cb cb) {
   req->db = db;
-  req->start = start;
-  req->end = end;
+  req->range = range;
+  req->reverse = reverse;
   req->keys = keys;
   req->values = values;
   req->len = 0;
@@ -304,20 +429,40 @@ rocksdb__on_delete_range (uv_work_t *handle) {
 
   auto db = reinterpret_cast<DB *>(req->db->handle);
 
-  auto status = db->DeleteRange(WriteOptions(), reinterpret_cast<const Slice &>(req->start), reinterpret_cast<const Slice &>(req->end));
+  const auto &range = req->range;
 
-  if (status.ok()) {
-    req->error = nullptr;
+  if (range.gte.len && range.lt.len) {
+    auto status = db->DeleteRange(WriteOptions(), rocksdb__slice_cast(range.gte), rocksdb__slice_cast(range.lt));
+
+    if (status.ok()) {
+      req->error = nullptr;
+    } else {
+      req->error = strdup(status.getState());
+    }
   } else {
-    req->error = strdup(status.getState());
+    auto iterator = rocksdb__iterator_open(db, req->range);
+
+    req->error = nullptr;
+
+    while (rocksdb__iterator_valid(iterator, req->range)) {
+      auto status = db->Delete(WriteOptions(), iterator->key());
+
+      if (status.ok()) {
+        rocksdb__iterator_next(iterator);
+      } else {
+        req->error = strdup(status.getState());
+        break;
+      }
+    }
+
+    delete iterator;
   }
 }
 
 extern "C" int
-rocksdb_delete_range (rocksdb_t *db, rocksdb_delete_range_t *req, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_delete_range_cb cb) {
+rocksdb_delete_range (rocksdb_t *db, rocksdb_delete_range_t *req, rocksdb_range_t range, rocksdb_delete_range_cb cb) {
   req->db = db;
-  req->start = start;
-  req->end = end;
+  req->range = range;
   req->cb = cb;
 
   req->worker.data = static_cast<void *>(req);
@@ -363,9 +508,9 @@ rocksdb__on_iterator_open (uv_work_t *handle) {
 }
 
 extern "C" int
-rocksdb_iterator_open (rocksdb_iterator_t *iterator, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_iterator_cb cb) {
-  iterator->start = start;
-  iterator->end = end;
+rocksdb_iterator_open (rocksdb_iterator_t *iterator, rocksdb_range_t range, bool reverse, rocksdb_iterator_cb cb) {
+  iterator->range = range;
+  iterator->reverse = reverse;
   iterator->cb = cb;
 
   return uv_queue_work(iterator->db->loop, &iterator->worker, rocksdb__on_iterator_open, rocksdb__on_after_iterator);
@@ -393,9 +538,7 @@ rocksdb__on_iterator_refresh (uv_work_t *handle) {
 
   auto iterator = reinterpret_cast<Iterator *>(req->handle);
 
-  iterator->Refresh();
-
-  rocksdb__iterator_seek(iterator, req);
+  rocksdb__iterator_refresh(iterator, req);
 
   auto status = iterator->status();
 
@@ -407,9 +550,9 @@ rocksdb__on_iterator_refresh (uv_work_t *handle) {
 }
 
 extern "C" int
-rocksdb_iterator_refresh (rocksdb_iterator_t *iterator, rocksdb_slice_t start, rocksdb_slice_t end, rocksdb_iterator_cb cb) {
-  iterator->start = end;
-  iterator->end = end;
+rocksdb_iterator_refresh (rocksdb_iterator_t *iterator, rocksdb_range_t range, bool reverse, rocksdb_iterator_cb cb) {
+  iterator->range = range;
+  iterator->reverse = reverse;
   iterator->cb = cb;
 
   return uv_queue_work(iterator->db->loop, &iterator->worker, rocksdb__on_iterator_close, rocksdb__on_after_iterator);