@nxtedition/rocksdb 10.0.15 → 10.0.16

package/binding.cc

@@ -512,17 +512,17 @@ NAPI_METHOD(db_init) {
     NAPI_STATUS_THROWS(napi_get_value_string_utf8(env, argv[0], &location[0], length + 1, &length));
 
     database = new Database(location);
-  	napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
-  	NAPI_STATUS_THROWS(napi_create_external(env, database, FinalizeDatabase, nullptr, &result));
+    napi_add_env_cleanup_hook(env, env_cleanup_hook, database);
+    NAPI_STATUS_THROWS(napi_create_external(env, database, FinalizeDatabase, nullptr, &result));
   } else if (type == napi_bigint) {
     int64_t value;
     bool lossless;
     NAPI_STATUS_THROWS(napi_get_value_bigint_int64(env, argv[0], &value, &lossless));
 
     database = reinterpret_cast<Database*>(value);
-  	NAPI_STATUS_THROWS(napi_create_external(env, database, nullptr, nullptr, &result));
+    NAPI_STATUS_THROWS(napi_create_external(env, database, nullptr, nullptr, &result));
 
-		// We should have an env_cleanup_hook for closing iterators...
+    // We should have an env_cleanup_hook for closing iterators...
   } else {
     NAPI_STATUS_THROWS(napi_invalid_arg);
   }
@@ -966,6 +966,7 @@ NAPI_METHOD(db_get_many) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
+  // TODO (fix): Ensure lifetime of buffer?
   std::vector<rocksdb::Slice> keys;
   {
     uint32_t length;
@@ -975,12 +976,7 @@ NAPI_METHOD(db_get_many) {
     for (uint32_t n = 0; n < length; n++) {
       napi_value element;
       NAPI_STATUS_THROWS(napi_get_element(env, argv[1], n, &element));
-
-      char* buf = nullptr;
-      size_t length = 0;
-      NAPI_STATUS_THROWS(napi_get_buffer_info(env, element, reinterpret_cast<void**>(&buf), &length));
-
-			keys[n] = { buf, length };
+      NAPI_STATUS_THROWS(GetValue(env, element, keys[n]));
     }
   }
 
@@ -1037,8 +1033,8 @@ NAPI_METHOD(db_get_many) {
         for (size_t idx = 0; idx < values.size(); idx++) {
           napi_value element;
           if (values[idx].GetSelf()) {
-						auto ptr = new rocksdb::PinnableSlice(std::move(values[idx]));
-						NAPI_STATUS_RETURN(napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<rocksdb::PinnableSlice>, ptr, &element));
+            auto ptr = new rocksdb::PinnableSlice(std::move(values[idx]));
+            NAPI_STATUS_RETURN(napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<rocksdb::PinnableSlice>, ptr, &element));
           } else {
             NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
           }
@@ -1160,7 +1156,7 @@ NAPI_METHOD(db_get_property) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  NapiSlice property;
+  rocksdb::PinnableSlice property;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], property));
 
   std::string value;
@@ -1259,7 +1255,7 @@ NAPI_METHOD(iterator_seek) {
   Iterator* iterator;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
-  NapiSlice target;
+  rocksdb::PinnableSlice target;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], target));
 
   iterator->first_ = true;
@@ -1306,7 +1302,7 @@ NAPI_METHOD(iterator_nextv) {
   auto callback = argv[2];
 
   struct State {
-    std::vector<std::optional<std::string>> cache;
+    std::vector<rocksdb::PinnableSlice> cache;
     bool finished = false;
   };
 
@@ -1329,24 +1325,22 @@ NAPI_METHOD(iterator_nextv) {
           if (!iterator->Valid() || !iterator->Increment())
             break;
 
+          auto k = rocksdb::PinnableSlice();
+          auto v = rocksdb::PinnableSlice();
+
           if (iterator->keys_ && iterator->values_) {
-            auto k = iterator->CurrentKey();
-            auto v = iterator->CurrentValue();
-            bytesRead += k.size() + v.size();
-            state.cache.push_back(k.ToString());
-            state.cache.push_back(v.ToString());
+            k.PinSelf(iterator->CurrentKey());
+            v.PinSelf(iterator->CurrentValue());
           } else if (iterator->keys_) {
-            auto k = iterator->CurrentKey();
-            bytesRead += k.size();
-            state.cache.push_back(k.ToString());
-            state.cache.push_back(std::nullopt);
+            k.PinSelf(iterator->CurrentKey());
           } else if (iterator->values_) {
-            auto v = iterator->CurrentValue();
-            bytesRead += v.size();
-            state.cache.push_back(std::nullopt);
-            state.cache.push_back(v.ToString());
+            v.PinSelf(iterator->CurrentValue());
           }
 
+          bytesRead += k.size() + v.size();
+          state.cache.push_back(std::move(k));
+          state.cache.push_back(std::move(v));
+
           if (bytesRead > iterator->highWaterMarkBytes_ || state.cache.size() / 2 >= size) {
             state.finished = false;
             return rocksdb::Status::OK();
@@ -1366,8 +1360,8 @@ NAPI_METHOD(iterator_nextv) {
           napi_value key;
           napi_value val;
 
-          NAPI_STATUS_RETURN(Convert(env, state.cache[n + 0], iterator->keyEncoding_, key));
-          NAPI_STATUS_RETURN(Convert(env, state.cache[n + 1], iterator->valueEncoding_, val));
+          NAPI_STATUS_RETURN(Convert(env, &state.cache[n + 0], iterator->keyEncoding_, key));
+          NAPI_STATUS_RETURN(Convert(env, &state.cache[n + 1], iterator->valueEncoding_, val));
 
           NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(n + 0), key));
           NAPI_STATUS_RETURN(napi_set_element(env, argv[1], static_cast<int>(n + 1), val));
@@ -1400,9 +1394,9 @@ NAPI_METHOD(batch_do) {
   NAPI_STATUS_THROWS(napi_get_array_length(env, elements, &length));
 
   for (uint32_t i = 0; i < length; i++) {
-    NapiSlice type;
-    NapiSlice key;
-    NapiSlice value;
+    rocksdb::PinnableSlice type;
+    rocksdb::PinnableSlice key;
+    rocksdb::PinnableSlice value;
 
     napi_value element;
     NAPI_STATUS_THROWS(napi_get_element(env, elements, i, &element));
@@ -1466,10 +1460,10 @@ NAPI_METHOD(batch_put) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  NapiSlice key;
+  rocksdb::Slice key;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
-  NapiSlice val;
+  rocksdb::Slice val;
   NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
   const auto options = argv[3];
@@ -1492,7 +1486,7 @@ NAPI_METHOD(batch_del) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  NapiSlice key;
+  rocksdb::Slice key;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
   const auto options = argv[2];
@@ -1515,10 +1509,10 @@ NAPI_METHOD(batch_merge) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  NapiSlice key;
+  rocksdb::Slice key;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
-  NapiSlice val;
+  rocksdb::Slice val;
   NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
   const auto options = argv[3];
@@ -1549,7 +1543,7 @@ NAPI_METHOD(batch_clear) {
 NAPI_METHOD(batch_write) {
   NAPI_ARGV(4);
 
-	napi_value result = 0;
+  napi_value result = 0;
 
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
@@ -1566,51 +1560,37 @@ NAPI_METHOD(batch_write) {
   bool lowPriority = false;
   NAPI_STATUS_THROWS(GetProperty(env, options, "lowPriority", lowPriority));
 
-	rocksdb::WriteOptions writeOptions;
-	writeOptions.sync = sync;
-	writeOptions.low_pri = lowPriority;
-	writeOptions.no_slowdown = true;
-
-	const auto status = database->db->Write(writeOptions, batch);
-
-	if (status == rocksdb::Status::Incomplete()) {
-		napi_ref batchRef;
-		NAPI_STATUS_THROWS(napi_create_reference(env, argv[1], 1, &batchRef));
-
-		runAsync<int64_t>(
-				"leveldown.batch.write", env, callback,
-				[=](int64_t& seq) {
-					rocksdb::WriteOptions writeOptions;
-					writeOptions.sync = sync;
-					writeOptions.low_pri = lowPriority;
-					return database->db->Write(writeOptions, batch);
-				},
-				[=](int64_t& seq, auto env, auto& argv) {
-					NAPI_STATUS_RETURN(napi_delete_reference(env, batchRef));
-					return napi_ok;
-				});
-
-		NAPI_STATUS_THROWS(napi_get_boolean(env, false, &result));
-	} else {
-		ROCKS_STATUS_THROWS_NAPI(status);
-		NAPI_STATUS_THROWS(napi_get_boolean(env, true, &result));
-	}
+  rocksdb::WriteOptions writeOptions;
+  writeOptions.sync = sync;
+  writeOptions.low_pri = lowPriority;
+  writeOptions.no_slowdown = true;
 
-  return result;
-}
+  const auto status = database->db->Write(writeOptions, batch);
 
-NAPI_METHOD(batch_put_log_data) {
-  NAPI_ARGV(3);
+  if (status == rocksdb::Status::Incomplete()) {
+    napi_ref batchRef;
+    NAPI_STATUS_THROWS(napi_create_reference(env, argv[1], 1, &batchRef));
 
-  rocksdb::WriteBatch* batch;
-  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
-
-  NapiSlice logData;
-  NAPI_STATUS_THROWS(GetValue(env, argv[1], logData));
+    runAsync<int64_t>(
+        "leveldown.batch.write", env, callback,
+        [=](int64_t& seq) {
+          rocksdb::WriteOptions writeOptions;
+          writeOptions.sync = sync;
+          writeOptions.low_pri = lowPriority;
+          return database->db->Write(writeOptions, batch);
+        },
+        [=](int64_t& seq, auto env, auto& argv) {
+          NAPI_STATUS_RETURN(napi_delete_reference(env, batchRef));
+          return napi_ok;
+        });
 
-  ROCKS_STATUS_THROWS_NAPI(batch->PutLogData(logData));
+    NAPI_STATUS_THROWS(napi_get_boolean(env, false, &result));
+  } else {
+    ROCKS_STATUS_THROWS_NAPI(status);
+    NAPI_STATUS_THROWS(napi_get_boolean(env, true, &result));
+  }
 
-  return 0;
+  return result;
 }
 
 NAPI_METHOD(batch_count) {
@@ -1687,7 +1667,6 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(batch_del);
   NAPI_EXPORT_FUNCTION(batch_clear);
   NAPI_EXPORT_FUNCTION(batch_write);
-  NAPI_EXPORT_FUNCTION(batch_put_log_data);
   NAPI_EXPORT_FUNCTION(batch_merge);
   NAPI_EXPORT_FUNCTION(batch_count);
   NAPI_EXPORT_FUNCTION(batch_iterate);

package/chained-batch.js

@@ -34,6 +34,9 @@ class ChainedBatch extends AbstractChainedBatch {
       })
     }
 
+    key = typeof key === 'string' ? Buffer.from(key) : key
+    value = typeof value === 'string' ? Buffer.from(value) : value
+
     binding.batch_put(this[kBatchContext], key, value, options ?? EMPTY)
   }
 
@@ -44,6 +47,8 @@ class ChainedBatch extends AbstractChainedBatch {
       })
     }
 
+    key = typeof key === 'string' ? Buffer.from(key) : key
+
     binding.batch_del(this[kBatchContext], key, options ?? EMPTY)
   }
 
@@ -67,16 +72,6 @@ class ChainedBatch extends AbstractChainedBatch {
     return binding.batch_count(this[kBatchContext])
   }
 
-  _putLogData (value, options) {
-    if (value === null || value === undefined) {
-      throw new ModuleError('value cannot be null or undefined', {
-        code: 'LEVEL_INVALID_VALUE'
-      })
-    }
-
-    binding.batch_put_log_data(this[kBatchContext], value, options ?? EMPTY)
-  }
-
   _merge (key, value, options) {
     if (key === null || key === undefined) {
       throw new ModuleError('Key cannot be null or undefined', {
@@ -90,6 +85,9 @@ class ChainedBatch extends AbstractChainedBatch {
       })
     }
 
+    key = typeof key === 'string' ? Buffer.from(key) : key
+    value = typeof value === 'string' ? Buffer.from(value) : value
+
     binding.batch_merge(this[kBatchContext], key, value, options ?? EMPTY)
   }
 

package/index.js

@@ -148,15 +148,17 @@ class RocksLevel extends AbstractLevel {
   _getMany (keys, options, callback) {
     callback = fromCallback(callback, kPromise)
 
-    if (options?.keysEncoding !== 'buffer') {
+    const { keysEncoding, valueEncoding } = options ?? EMPTY
+
+    if (keysEncoding !== 'buffer') {
       keys = keys.map(key => Buffer.from(key))
     }
 
     try {
       this[kRef]()
       binding.db_get_many(this[kContext], keys, options ?? EMPTY, (err, val) => {
-        if (options?.valueEncoding !== 'buffer') {
-          val = val.map(v => v != null ? v.toString(options?.valueEncoding) : v)
+        if (valueEncoding !== 'buffer') {
+          val = val.map(v => v != null ? v.toString(valueEncoding) : v)
         }
         callback(err, val, keys)
         this[kUnref]()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/rocksdb",
-  "version": "10.0.15",
+  "version": "10.0.16",
   "description": "A low-level Node.js RocksDB binding",
   "license": "MIT",
   "main": "index.js",

package/util.h

@@ -91,6 +91,22 @@ static napi_value ToError(napi_env env, const rocksdb::Status& status) {
   return CreateError(env, {}, msg);
 }
 
+static napi_status GetString(napi_env env, napi_value from, rocksdb::Slice& to) {
+  bool isBuffer;
+  NAPI_STATUS_RETURN(napi_is_buffer(env, from, &isBuffer));
+
+  if (isBuffer) {
+    char* buf = nullptr;
+    size_t length = 0;
+    NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length));
+    to = {buf, length};
+  } else {
+    return napi_invalid_arg;
+  }
+
+  return napi_ok;
+}
+
 static napi_status GetString(napi_env env, napi_value from, std::string& to) {
   napi_valuetype type;
   NAPI_STATUS_RETURN(napi_typeof(env, from, &type));
@@ -117,60 +133,12 @@ static napi_status GetString(napi_env env, napi_value from, std::string& to) {
   return napi_ok;
 }
 
-class NapiSlice : public rocksdb::Slice {
- public:
-  NapiSlice() {}
-
-  NapiSlice(NapiSlice&& other) = delete;
-  NapiSlice& operator=(NapiSlice&& other) = delete;
-
-  NapiSlice(NapiSlice&) = delete;
-  NapiSlice& operator=(NapiSlice&) = delete;
-
-  std::array<char, 128> stack_;
-  std::unique_ptr<char[]> heap_;
-  size_t heap_size_ = 0;
-};
-
-static napi_status GetString(napi_env env, napi_value from, NapiSlice& to) {
+static napi_status GetString(napi_env env, napi_value from, rocksdb::PinnableSlice& to) {
   napi_valuetype type;
   NAPI_STATUS_RETURN(napi_typeof(env, from, &type));
 
-  if (type == napi_string) {
-    size_t length = 0;
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, nullptr, 0, &length));
-
-    char* data;
-    if (length + 1 > to.stack_.size()) {
-      if (to.heap_size_ < length + 1) {
-        to.heap_size_ = length + 1;
-        to.heap_.reset(new char[to.heap_size_]);
-      }
-      data = to.heap_.get();
-    } else {
-      data = to.stack_.data();
-    }
-    data[length] = 0;
-
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, data, length + 1, &length));
-
-    to.data_ = data;
-    to.size_ = length;
-  } else {
-    bool isBuffer;
-    NAPI_STATUS_RETURN(napi_is_buffer(env, from, &isBuffer));
-
-    if (isBuffer) {
-      char* buf = nullptr;
-      size_t length = 0;
-      NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length));
-
-      to.data_ = buf;
-      to.size_ = length;
-    } else {
-      return napi_invalid_arg;
-    }
-  }
+  NAPI_STATUS_RETURN(GetString(env, from, *to.GetSelf()));
+  to.PinSelf();
 
   return napi_ok;
 }
@@ -204,7 +172,11 @@ static napi_status GetValue(napi_env env, napi_value value, std::string& result)
   return GetString(env, value, result);
 }
 
-static napi_status GetValue(napi_env env, napi_value value, NapiSlice& result) {
+static napi_status GetValue(napi_env env, napi_value value, rocksdb::PinnableSlice& result) {
+  return GetString(env, value, result);
+}
+
+static napi_status GetValue(napi_env env, napi_value value, rocksdb::Slice& result) {
   return GetString(env, value, result);
 }
 
@@ -270,11 +242,12 @@ static napi_status GetProperty(napi_env env,
 
 template <typename T>
 napi_status Convert(napi_env env, rocksdb::PinnableSlice* s, Encoding encoding, napi_value& result) {
-  if (!s) {
+  if (!s || !s->IsPinned()) {
     return napi_get_null(env, &result);
   } else if (encoding == Encoding::Buffer) {
-		auto ptr = new rocksdb::PinnableSlice(std::move(*s));
-		return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<rocksdb::PinnableSlice>, ptr, &result);
+    auto ptr = new rocksdb::PinnableSlice(std::move(*s));
+    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()),
+                                       Finalize<rocksdb::PinnableSlice>, ptr, &result);
   } else if (encoding == Encoding::String) {
     return napi_create_string_utf8(env, s->data(), s->size(), &result);
   } else {
@@ -287,8 +260,6 @@ napi_status Convert(napi_env env, T&& s, Encoding encoding, napi_value& result)
   if (!s) {
     return napi_get_null(env, &result);
   } else if (encoding == Encoding::Buffer) {
-    // napi_create_external_buffer would be nice but is unsafe since node
-    // buffers are not read-only.
     return napi_create_buffer_copy(env, s->size(), s->data(), nullptr, &result);
   } else if (encoding == Encoding::String) {
     return napi_create_string_utf8(env, s->data(), s->size(), &result);
@@ -298,7 +269,12 @@ napi_status Convert(napi_env env, T&& s, Encoding encoding, napi_value& result)
 }
 
 template <typename State, typename T1, typename T2>
-napi_status runAsync(State&& state, const std::string& name, napi_env env, napi_value callback, T1&& execute, T2&& then) {
+napi_status runAsync(State&& state,
+                     const std::string& name,
+                     napi_env env,
+                     napi_value callback,
+                     T1&& execute,
+                     T2&& then) {
   struct Worker final {
     static void Execute(napi_env env, void* data) {
       auto worker = reinterpret_cast<Worker*>(data);
@@ -355,17 +331,13 @@ napi_status runAsync(State&& state, const std::string& name, napi_env env, napi_
 
     State state;
 
-		napi_ref callbackRef = nullptr;
+    napi_ref callbackRef = nullptr;
     napi_async_work asyncWork = nullptr;
     rocksdb::Status status = rocksdb::Status::OK();
   };
 
-  auto worker = std::unique_ptr<Worker>(new Worker{
-		env,
-		std::forward<T1>(execute),
-		std::forward<T2>(then),
-		std::move(state)
-	});
+  auto worker =
+      std::unique_ptr<Worker>(new Worker{env, std::forward<T1>(execute), std::forward<T2>(then), std::move(state)});
 
   NAPI_STATUS_RETURN(napi_create_reference(env, callback, 1, &worker->callbackRef));
   napi_value asyncResourceName;
@@ -381,5 +353,5 @@ napi_status runAsync(State&& state, const std::string& name, napi_env env, napi_
 }
 template <typename State, typename T1, typename T2>
 napi_status runAsync(const std::string& name, napi_env env, napi_value callback, T1&& execute, T2&& then) {
-	return runAsync<State>(State{}, name, env, callback, std::forward<T1>(execute), std::forward<T2>(then));
+  return runAsync<State>(State{}, name, env, callback, std::forward<T1>(execute), std::forward<T2>(then));
 }