rocksdb-native 1.2.0 → 2.0.0

package/README.md

@@ -13,13 +13,13 @@ const RocksDB = require('rocksdb-native')
 
 const db = new RocksDB('./example.db')
 
-const b = db.batch()
+const w = db.write()
+w.put('hello', 'world')
+await w.flush()
 
-b.add('hello', 'world')
-await b.write()
-
-const p = b.add('hello')
-b.read()
+const r = db.read()
+const p = r.get('hello')
+r.flush()
 
 console.log(await p)
 ```

package/binding.c

@@ -45,14 +45,6 @@ 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;
 
@@ -67,10 +59,22 @@ typedef struct {
 } rocksdb_native_iterator_t;
 
 typedef struct {
-  rocksdb_batch_t handle;
+  rocksdb_read_batch_t handle;
 
-  rocksdb_slice_t *keys;
-  rocksdb_slice_t *values;
+  rocksdb_read_t *reads;
+  char **errors;
+
+  size_t capacity;
+
+  js_env_t *env;
+  js_ref_t *ctx;
+  js_ref_t *on_status;
+} rocksdb_native_read_batch_t;
+
+typedef struct {
+  rocksdb_write_batch_t handle;
+
+  rocksdb_write_t *writes;
   char **errors;
 
   size_t capacity;
@@ -78,7 +82,7 @@ typedef struct {
   js_env_t *env;
   js_ref_t *ctx;
   js_ref_t *on_status;
-} rocksdb_native_batch_t;
+} rocksdb_native_write_batch_t;
 
 static void
 rocksdb_native__on_free (js_env_t *env, void *data, void *finalize_hint) {
@@ -286,116 +290,17 @@ 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;
 
-  size_t argc = 5;
-  js_value_t *argv[5];
+  size_t argc = 4;
+  js_value_t *argv[4];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 5);
-
-  rocksdb_native_t *db;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
-  assert(err == 0);
+  assert(argc == 4);
 
   js_value_t *handle;
 
@@ -403,22 +308,19 @@ rocksdb_native_iterator_init (js_env_t *env, js_callback_info_t *info) {
   err = js_create_arraybuffer(env, sizeof(rocksdb_native_iterator_t), (void **) &iterator, &handle);
   assert(err == 0);
 
-  err = rocksdb_iterator_init(&db->handle, &iterator->handle);
-  assert(err == 0);
-
   iterator->env = env;
   iterator->handle.data = (void *) iterator;
 
-  err = js_create_reference(env, argv[1], 1, &iterator->ctx);
+  err = js_create_reference(env, argv[0], 1, &iterator->ctx);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[2], 1, &iterator->on_open);
+  err = js_create_reference(env, argv[1], 1, &iterator->on_open);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[3], 1, &iterator->on_close);
+  err = js_create_reference(env, argv[2], 1, &iterator->on_close);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[4], 1, &iterator->on_read);
+  err = js_create_reference(env, argv[3], 1, &iterator->on_read);
   assert(err == 0);
 
   return handle;
@@ -503,37 +405,41 @@ static js_value_t *
 rocksdb_native_iterator_open (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 6;
-  js_value_t *argv[6];
+  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 == 6);
+  assert(argc == 7);
+
+  rocksdb_native_t *db;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
+  assert(err == 0);
 
   rocksdb_native_iterator_t *iterator;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &iterator, NULL);
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &iterator, NULL);
   assert(err == 0);
 
   rocksdb_range_t range;
 
-  err = js_get_typedarray_info(env, argv[1], NULL, (void **) &range.gt.data, &range.gt.len, NULL, NULL);
+  err = js_get_typedarray_info(env, argv[2], 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);
+  err = js_get_typedarray_info(env, argv[3], 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);
+  err = js_get_typedarray_info(env, argv[4], 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);
+  err = js_get_typedarray_info(env, argv[5], NULL, (void **) &range.lte.data, &range.lte.len, NULL, NULL);
   assert(err == 0);
 
   bool reverse;
-  err = js_get_value_bool(env, argv[5], &reverse);
+  err = js_get_value_bool(env, argv[6], &reverse);
   assert(err == 0);
 
-  err = rocksdb_iterator_open(&iterator->handle, range, reverse, rocksdb_native__on_iterator_open);
+  err = rocksdb_iterator_open(&db->handle, &iterator->handle, range, reverse, rocksdb_native__on_iterator_open);
   assert(err == 0);
 
   return NULL;
@@ -694,41 +600,34 @@ rocksdb_native_iterator_read (js_env_t *env, js_callback_info_t *info) {
 }
 
 static js_value_t *
-rocksdb_native_batch_init (js_env_t *env, js_callback_info_t *info) {
+rocksdb_native_read_init (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 2;
-  js_value_t *argv[2];
+  size_t argc = 1;
+  js_value_t *argv[1];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 2);
-
-  rocksdb_native_t *db;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
-  assert(err == 0);
+  assert(argc == 1);
 
   js_value_t *handle;
 
-  rocksdb_native_batch_t *batch;
-  err = js_create_arraybuffer(env, sizeof(rocksdb_native_batch_t), (void **) &batch, &handle);
-  assert(err == 0);
-
-  err = rocksdb_batch_init(&db->handle, &batch->handle);
+  rocksdb_native_read_batch_t *batch;
+  err = js_create_arraybuffer(env, sizeof(rocksdb_native_read_batch_t), (void **) &batch, &handle);
   assert(err == 0);
 
   batch->env = env;
   batch->handle.data = (void *) batch;
 
-  err = js_create_reference(env, argv[1], 1, &batch->ctx);
+  err = js_create_reference(env, argv[0], 1, &batch->ctx);
   assert(err == 0);
 
   return handle;
 }
 
 static js_value_t *
-rocksdb_native_batch_buffer (js_env_t *env, js_callback_info_t *info) {
+rocksdb_native_read_buffer (js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 2;
@@ -739,7 +638,7 @@ rocksdb_native_batch_buffer (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 2);
 
-  rocksdb_native_batch_t *batch;
+  rocksdb_native_read_batch_t *batch;
   err = js_get_arraybuffer_info(env, argv[0], (void **) &batch, NULL);
   assert(err == 0);
 
@@ -750,51 +649,29 @@ rocksdb_native_batch_buffer (js_env_t *env, js_callback_info_t *info) {
   js_value_t *handle;
 
   uint8_t *data;
-  err = js_create_arraybuffer(env, 2 * capacity * sizeof(rocksdb_slice_t) + capacity * sizeof(char *), (void **) &data, &handle);
+  err = js_create_arraybuffer(env, capacity * sizeof(rocksdb_read_t) + capacity * sizeof(char *), (void **) &data, &handle);
   assert(err == 0);
 
   batch->capacity = capacity;
 
   size_t offset = 0;
 
-  batch->keys = (rocksdb_slice_t *) &data[offset];
-
-  offset += capacity * sizeof(rocksdb_slice_t);
+  batch->reads = (rocksdb_read_t *) &data[offset];
 
-  batch->values = (rocksdb_slice_t *) &data[offset];
-
-  offset += capacity * sizeof(rocksdb_slice_t);
+  offset += capacity * sizeof(rocksdb_read_t);
 
   batch->errors = (char **) &data[offset];
 
   return handle;
 }
 
-static inline int
-rocksdb_native__get_slices (js_env_t *env, js_value_t *arr, uint32_t len, rocksdb_slice_t *result) {
-  int err;
-
-  for (uint32_t i = 0; i < len; i++) {
-    js_value_t *value;
-    err = js_get_element(env, arr, i, &value);
-    assert(err == 0);
-
-    rocksdb_slice_t *slice = &result[i];
-
-    err = js_get_typedarray_info(env, value, NULL, (void **) &slice->data, &slice->len, NULL, NULL);
-    assert(err == 0);
-  }
-
-  return 0;
-}
-
 static void
-rocksdb_native__on_batch_read (rocksdb_batch_t *handle, int status) {
+rocksdb_native__on_read (rocksdb_read_batch_t *handle, int status) {
   int err;
 
   assert(status == 0);
 
-  rocksdb_native_batch_t *batch = (rocksdb_native_batch_t *) handle->data;
+  rocksdb_native_read_batch_t *batch = (rocksdb_native_read_batch_t *) handle->data;
 
   js_env_t *env = batch->env;
 
@@ -824,7 +701,7 @@ rocksdb_native__on_batch_read (rocksdb_batch_t *handle, int status) {
       err = js_set_element(env, errors, i, result);
       assert(err == 0);
     } else {
-      rocksdb_slice_t *slice = &batch->values[i];
+      rocksdb_slice_t *slice = &batch->reads[i].value;
 
       err = js_create_external_arraybuffer(env, (void *) slice->data, slice->len, rocksdb_native__on_free, NULL, &result);
       assert(err == 0);
@@ -849,44 +726,140 @@ rocksdb_native__on_batch_read (rocksdb_batch_t *handle, int status) {
 }
 
 static js_value_t *
-rocksdb_native_batch_read (js_env_t *env, js_callback_info_t *info) {
+rocksdb_native_read (js_env_t *env, js_callback_info_t *info) {
   int err;
 
-  size_t argc = 3;
-  js_value_t *argv[3];
+  size_t argc = 4;
+  js_value_t *argv[4];
 
   err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
   assert(err == 0);
 
-  assert(argc == 3);
+  assert(argc == 4);
 
-  rocksdb_native_batch_t *batch;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &batch, NULL);
+  rocksdb_native_t *db;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
   assert(err == 0);
 
-  uint32_t len;
-  err = js_get_array_length(env, argv[1], &len);
+  rocksdb_native_read_batch_t *batch;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &batch, NULL);
   assert(err == 0);
 
-  err = js_create_reference(env, argv[2], 1, &batch->on_status);
+  uint32_t len;
+  err = js_get_array_length(env, argv[2], &len);
   assert(err == 0);
 
-  err = rocksdb_native__get_slices(env, argv[1], len, batch->keys);
+  err = js_create_reference(env, argv[3], 1, &batch->on_status);
   assert(err == 0);
 
-  err = rocksdb_batch_read(&batch->handle, batch->keys, batch->values, batch->errors, len, rocksdb_native__on_batch_read);
+  for (uint32_t i = 0; i < len; i++) {
+    js_value_t *read;
+    err = js_get_element(env, argv[2], i, &read);
+    assert(err == 0);
+
+    js_value_t *property;
+    err = js_get_named_property(env, read, "type", &property);
+    assert(err == 0);
+
+    rocksdb_read_type_t type;
+    err = js_get_value_uint32(env, property, &type);
+    assert(err == 0);
+
+    batch->reads[i].type = type;
+
+    switch (type) {
+    case rocksdb_get: {
+      rocksdb_slice_t *key = &batch->reads[i].key;
+
+      err = js_get_named_property(env, read, "key", &property);
+      assert(err == 0);
+
+      err = js_get_typedarray_info(env, property, NULL, (void **) &key->data, &key->len, NULL, NULL);
+      assert(err == 0);
+      break;
+    }
+    }
+  }
+
+  err = rocksdb_read(&db->handle, &batch->handle, batch->reads, batch->errors, len, rocksdb_native__on_read);
   assert(err == 0);
 
   return NULL;
 }
 
+static js_value_t *
+rocksdb_native_write_init (js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 1;
+  js_value_t *argv[1];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  js_value_t *handle;
+
+  rocksdb_native_write_batch_t *batch;
+  err = js_create_arraybuffer(env, sizeof(rocksdb_native_write_batch_t), (void **) &batch, &handle);
+  assert(err == 0);
+
+  batch->env = env;
+  batch->handle.data = (void *) batch;
+
+  err = js_create_reference(env, argv[0], 1, &batch->ctx);
+  assert(err == 0);
+
+  return handle;
+}
+
+static js_value_t *
+rocksdb_native_write_buffer (js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  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 == 2);
+
+  rocksdb_native_write_batch_t *batch;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &batch, NULL);
+  assert(err == 0);
+
+  uint32_t capacity;
+  err = js_get_value_uint32(env, argv[1], &capacity);
+  assert(err == 0);
+
+  js_value_t *handle;
+
+  uint8_t *data;
+  err = js_create_arraybuffer(env, capacity * sizeof(rocksdb_write_t) + capacity * sizeof(char *), (void **) &data, &handle);
+  assert(err == 0);
+
+  batch->capacity = capacity;
+
+  size_t offset = 0;
+
+  batch->writes = (rocksdb_write_t *) &data[offset];
+
+  offset += capacity * sizeof(rocksdb_write_t);
+
+  batch->errors = (char **) &data[offset];
+
+  return handle;
+}
+
 static void
-rocksdb_native__on_batch_write (rocksdb_batch_t *handle, int status) {
+rocksdb_native__on_write (rocksdb_write_batch_t *handle, int status) {
   int err;
 
   assert(status == 0);
 
-  rocksdb_native_batch_t *batch = (rocksdb_native_batch_t *) handle->data;
+  rocksdb_native_write_batch_t *batch = (rocksdb_native_write_batch_t *) handle->data;
 
   js_env_t *env = batch->env;
 
@@ -919,7 +892,7 @@ rocksdb_native__on_batch_write (rocksdb_batch_t *handle, int status) {
 }
 
 static js_value_t *
-rocksdb_native_batch_write (js_env_t *env, js_callback_info_t *info) {
+rocksdb_native_write (js_env_t *env, js_callback_info_t *info) {
   int err;
 
   size_t argc = 4;
@@ -930,24 +903,89 @@ rocksdb_native_batch_write (js_env_t *env, js_callback_info_t *info) {
 
   assert(argc == 4);
 
-  rocksdb_native_batch_t *batch;
-  err = js_get_arraybuffer_info(env, argv[0], (void **) &batch, NULL);
+  rocksdb_native_t *db;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &db, NULL);
+  assert(err == 0);
+
+  rocksdb_native_write_batch_t *batch;
+  err = js_get_arraybuffer_info(env, argv[1], (void **) &batch, NULL);
   assert(err == 0);
 
   uint32_t len;
-  err = js_get_array_length(env, argv[1], &len);
+  err = js_get_array_length(env, argv[2], &len);
   assert(err == 0);
 
   err = js_create_reference(env, argv[3], 1, &batch->on_status);
   assert(err == 0);
 
-  err = rocksdb_native__get_slices(env, argv[1], len, batch->keys);
-  assert(err == 0);
+  for (uint32_t i = 0; i < len; i++) {
+    js_value_t *write;
+    err = js_get_element(env, argv[2], i, &write);
+    assert(err == 0);
 
-  err = rocksdb_native__get_slices(env, argv[2], len, batch->values);
-  assert(err == 0);
+    js_value_t *property;
+    err = js_get_named_property(env, write, "type", &property);
+    assert(err == 0);
+
+    rocksdb_write_type_t type;
+    err = js_get_value_uint32(env, property, &type);
+    assert(err == 0);
+
+    batch->writes[i].type = type;
+
+    switch (type) {
+    case rocksdb_put: {
+      rocksdb_slice_t *key = &batch->writes[i].key;
+
+      err = js_get_named_property(env, write, "key", &property);
+      assert(err == 0);
+
+      err = js_get_typedarray_info(env, property, NULL, (void **) &key->data, &key->len, NULL, NULL);
+      assert(err == 0);
 
-  err = rocksdb_batch_write(&batch->handle, batch->keys, batch->values, len, rocksdb_native__on_batch_write);
+      rocksdb_slice_t *value = &batch->writes[i].value;
+
+      err = js_get_named_property(env, write, "value", &property);
+      assert(err == 0);
+
+      err = js_get_typedarray_info(env, property, NULL, (void **) &value->data, &value->len, NULL, NULL);
+      assert(err == 0);
+      break;
+    }
+
+    case rocksdb_delete: {
+      rocksdb_slice_t *key = &batch->writes[i].key;
+
+      err = js_get_named_property(env, write, "key", &property);
+      assert(err == 0);
+
+      err = js_get_typedarray_info(env, property, NULL, (void **) &key->data, &key->len, NULL, NULL);
+      assert(err == 0);
+      break;
+    }
+
+    case rocksdb_delete_range: {
+      rocksdb_slice_t *start = &batch->writes[i].start;
+
+      err = js_get_named_property(env, write, "start", &property);
+      assert(err == 0);
+
+      err = js_get_typedarray_info(env, property, NULL, (void **) &start->data, &start->len, NULL, NULL);
+      assert(err == 0);
+
+      rocksdb_slice_t *end = &batch->writes[i].end;
+
+      err = js_get_named_property(env, write, "end", &property);
+      assert(err == 0);
+
+      err = js_get_typedarray_info(env, property, NULL, (void **) &end->data, &end->len, NULL, NULL);
+      assert(err == 0);
+      break;
+    }
+    }
+  }
+
+  err = rocksdb_write(&db->handle, &batch->handle, batch->writes, len, rocksdb_native__on_write);
   assert(err == 0);
 
   return NULL;
@@ -969,7 +1007,6 @@ 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)
@@ -977,10 +1014,28 @@ rocksdb_native_exports (js_env_t *env, js_value_t *exports) {
   V("iteratorClose", rocksdb_native_iterator_close)
   V("iteratorRead", rocksdb_native_iterator_read)
 
-  V("batchInit", rocksdb_native_batch_init)
-  V("batchBuffer", rocksdb_native_batch_buffer)
-  V("batchRead", rocksdb_native_batch_read)
-  V("batchWrite", rocksdb_native_batch_write)
+  V("readInit", rocksdb_native_read_init)
+  V("readBuffer", rocksdb_native_read_buffer)
+  V("read", rocksdb_native_read)
+
+  V("writeInit", rocksdb_native_write_init)
+  V("writeBuffer", rocksdb_native_write_buffer)
+  V("write", rocksdb_native_write)
+#undef V
+
+#define V(name, n) \
+  { \
+    js_value_t *val; \
+    err = js_create_uint32(env, n, &val); \
+    assert(err == 0); \
+    err = js_set_named_property(env, exports, name, val); \
+    assert(err == 0); \
+  }
+
+  V("GET", rocksdb_get)
+  V("PUT", rocksdb_put)
+  V("DELETE", rocksdb_delete)
+  V("DELETE_RANGE", rocksdb_delete_range)
 #undef V
 
   return exports;