@nxtedition/rocksdb 10.3.3 → 10.3.5

package/binding.cc

@@ -965,9 +965,6 @@ NAPI_METHOD(db_get_many) {
   rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
   NAPI_STATUS_THROWS(GetProperty(env, options, "column", column));
 
-  Encoding valueEncoding = Encoding::Buffer;
-  NAPI_STATUS_THROWS(GetProperty(env, options, "valueEncoding", valueEncoding));
-
   bool takeSnapshot = true;
   NAPI_STATUS_THROWS(GetProperty(env, options, "snapshot", takeSnapshot));
 
@@ -1041,43 +1038,20 @@ NAPI_METHOD(db_get_many) {
       [=](auto& state, auto env, auto& argv) {
         argv.resize(3);
 
-        if (valueEncoding == Encoding::String) {
-          napi_value arr;
-          NAPI_STATUS_RETURN(napi_create_array_with_length(env, state.sizes.size(), &argv[1]));
-
-          const auto ptr = reinterpret_cast<char*>(state.data.data());
-          auto offset = 0;
-          for (auto n = 0; n < state.sizes.size(); n++) {
-            napi_value str;
-            const auto size = state.sizes[n];
-            if (size >= 0) {
-              NAPI_STATUS_RETURN(napi_create_string_utf8(env, ptr + offset, static_cast<size_t>(size), &str));
-              offset += size;
-              if (offset & 0x7) {
-                offset = (offset | 0x7) + 1;
-              }
-            } else {
-              NAPI_STATUS_RETURN(napi_get_undefined(env, &str));
-            }
-            NAPI_STATUS_RETURN(napi_set_element(env, argv[1], n, str));
-          }
-          NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[2]));
+        if (state.sizes.size() > 0) {
+          auto sizes = std::make_unique<std::vector<int32_t>>(std::move(state.sizes));
+          NAPI_STATUS_RETURN(napi_create_external_buffer(env, sizes->size() * 4, sizes->data(), Finalize<std::vector<int32_t>>, sizes.get(), &argv[1]));
+          sizes.release();
         } else {
-          if (state.sizes.size() > 0) {
-            auto sizes = std::make_unique<std::vector<int32_t>>(std::move(state.sizes));
-            NAPI_STATUS_RETURN(napi_create_external_buffer(env, sizes->size() * 4, sizes->data(), Finalize<std::vector<int32_t>>, sizes.get(), &argv[1]));
-            sizes.release();
-          } else {
-            NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[1]));
-          }
+          NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[1]));
+        }
 
-          if (state.data.size() > 0) {
-            auto data = std::make_unique<std::vector<uint8_t>>(std::move(state.data));
-            NAPI_STATUS_RETURN(napi_create_external_buffer(env, data->size(), data->data(), Finalize<std::vector<uint8_t>>, data.get(), &argv[2]));
-            data.release();
-          } else {
-            NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[2]));
-          };
+        if (state.data.size() > 0) {
+          auto data = std::make_unique<std::vector<uint8_t>>(std::move(state.data));
+          NAPI_STATUS_RETURN(napi_create_external_buffer(env, data->size(), data->data(), Finalize<std::vector<uint8_t>>, data.get(), &argv[2]));
+          data.release();
+        } else {
+          NAPI_STATUS_RETURN(napi_get_undefined(env, &argv[2]));
         }
 
         return napi_ok;
@@ -1086,6 +1060,97 @@ NAPI_METHOD(db_get_many) {
   return 0;
 }
 
+NAPI_METHOD(db_get_many_sync) {
+  NAPI_ARGV(3);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  uint32_t count;
+  NAPI_STATUS_THROWS(napi_get_array_length(env, argv[1], &count));
+
+  bool fillCache = true;
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "fillCache", fillCache));
+
+  bool ignoreRangeDeletions = false;
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "ignoreRangeDeletions", ignoreRangeDeletions));
+
+  rocksdb::ColumnFamilyHandle* column = database->db->DefaultColumnFamily();
+  NAPI_STATUS_THROWS(GetProperty(env, argv[2], "column", column));
+
+  std::vector<rocksdb::Slice> keys{count};
+  std::vector<rocksdb::Status> statuses{count};
+  std::vector<rocksdb::PinnableSlice> values{count};
+
+  for (uint32_t n = 0; n < count; n++) {
+    napi_value element;
+    NAPI_STATUS_THROWS(napi_get_element(env, argv[1], n, &element));
+    NAPI_STATUS_THROWS(GetValue(env, element, keys[n]));
+  }
+
+  struct State {
+    std::vector<uint8_t> data;
+    std::vector<int32_t> sizes;
+  } state;
+
+  rocksdb::ReadOptions readOptions;
+  readOptions.fill_cache = fillCache;
+  readOptions.async_io = true;
+  readOptions.ignore_range_deletions = ignoreRangeDeletions;
+  readOptions.optimize_multiget_for_io = true;
+
+  database->db->MultiGet(readOptions, column, count, keys.data(), values.data(), statuses.data());
+
+  auto size = 0;
+  for (auto n = 0; n < count; n++) {
+    const auto valueSize = values[n].size();
+    size += valueSize & 0x7 ? (valueSize | 0x7) + 1 : valueSize;
+  }
+
+  state.data.reserve(size);
+
+  auto push = [&](rocksdb::Slice* slice){
+    if (slice) {
+      state.sizes.push_back(static_cast<int32_t>(slice->size()));
+      std::copy_n(slice->data(), slice->size(), std::back_inserter(state.data));
+
+      if (state.data.size() & 0x7) {
+        state.data.resize((state.data.size() | 0x7) + 1);
+      }
+    } else {
+      state.sizes.push_back(-1);
+    }
+  };
+
+  for (auto n = 0; n < count; n++) {
+    push(statuses[n].ok() ? &values[n] : nullptr);
+  }
+
+  napi_value sizes;
+  if (state.sizes.size() > 0) {
+    auto sizes_ptr = std::make_unique<std::vector<int32_t>>(std::move(state.sizes));
+    NAPI_STATUS_THROWS(napi_create_external_buffer(env, sizes_ptr->size() * 4, sizes_ptr->data(), Finalize<std::vector<int32_t>>, sizes_ptr.get(), &sizes));
+    sizes_ptr.release();
+  } else {
+    NAPI_STATUS_THROWS(napi_get_undefined(env, &sizes));
+  }
+
+  napi_value data;
+  if (state.data.size() > 0) {
+    auto data_ptr = std::make_unique<std::vector<uint8_t>>(std::move(state.data));
+    NAPI_STATUS_THROWS(napi_create_external_buffer(env, data_ptr->size(), data_ptr->data(), Finalize<std::vector<uint8_t>>, data_ptr.get(), &data));
+    data_ptr.release();
+  } else {
+    NAPI_STATUS_THROWS(napi_get_undefined(env, &data));
+  }
+
+  napi_value result;
+  NAPI_STATUS_THROWS(napi_create_array_with_length(env, 2, &result));
+  NAPI_STATUS_THROWS(napi_set_element(env, result, 0, sizes));
+  NAPI_STATUS_THROWS(napi_set_element(env, result, 1, data));
+  return result;
+}
+
 NAPI_METHOD(db_clear) {
   NAPI_ARGV(2);
 
@@ -1507,8 +1572,6 @@ NAPI_METHOD(batch_clear) {
 NAPI_METHOD(batch_write) {
   NAPI_ARGV(4);
 
-  napi_value result = 0;
-
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
@@ -1534,7 +1597,30 @@ NAPI_METHOD(batch_write) {
       },
       [=](int64_t& seq, auto env, auto& argv) { return napi_ok; });
 
-  return result;
+  return 0;
+}
+
+NAPI_METHOD(batch_write_sync) {
+  NAPI_ARGV(3);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  rocksdb::WriteBatch* batch;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[1], reinterpret_cast<void**>(&batch)));
+
+  auto options = argv[2];
+
+  bool sync = false;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "sync", sync));
+
+  bool lowPriority = false;
+  NAPI_STATUS_THROWS(GetProperty(env, options, "lowPriority", lowPriority));
+
+  rocksdb::WriteOptions writeOptions;
+  writeOptions.sync = sync;
+  writeOptions.low_pri = lowPriority;
+  ROCKS_STATUS_THROWS_NAPI(database->db->Write(writeOptions, batch));
 }
 
 NAPI_METHOD(batch_count) {
@@ -1594,6 +1680,7 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_get_location);
   NAPI_EXPORT_FUNCTION(db_close);
   NAPI_EXPORT_FUNCTION(db_get_many);
+  NAPI_EXPORT_FUNCTION(db_get_many_sync);
   NAPI_EXPORT_FUNCTION(db_clear);
   NAPI_EXPORT_FUNCTION(db_get_property);
   NAPI_EXPORT_FUNCTION(db_get_latest_sequence);
@@ -1609,6 +1696,7 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(batch_del);
   NAPI_EXPORT_FUNCTION(batch_clear);
   NAPI_EXPORT_FUNCTION(batch_write);
+  NAPI_EXPORT_FUNCTION(batch_write_sync);
   NAPI_EXPORT_FUNCTION(batch_merge);
   NAPI_EXPORT_FUNCTION(batch_count);
   NAPI_EXPORT_FUNCTION(batch_iterate);

package/chained-batch.js

@@ -59,14 +59,20 @@ class ChainedBatch extends AbstractChainedBatch {
   _write (options, callback) {
     callback = fromCallback(callback, kPromise)
 
-    // NOTE: `this` needs to be referenced until callback is called
-    this[kWrite](this, this[kBatchContext], options ?? EMPTY, (err) => {
-      callback(err, null, this)
-    })
+    try {
+      binding.batch_write_sync(this[kDbContext], this[kBatchContext], options)
+      process.nextTick(callback)
+    } catch (err) {
+      process.nextTick(callback, err)
+    }
 
     return callback[kPromise]
   }
 
+  _writeSync (options, callback) {
+    binding.batch_write_sync(this[kDbContext], this[kBatchContext], options)
+  }
+
   _close (callback) {
     process.nextTick(callback)
   }

package/index.js

@@ -8,8 +8,8 @@ const { ChainedBatch } = require('./chained-batch')
 const { Iterator } = require('./iterator')
 const fs = require('node:fs')
 const assert = require('node:assert')
-const { handleNextv } = require('./util')
-const FastBuffer = Buffer[Symbol.species]
+const { handleNextv, handleMany } = require('./util')
+
 const kContext = Symbol('context')
 const kColumns = Symbol('columns')
 const kPromise = Symbol('promise')
@@ -152,47 +152,29 @@ class RocksLevel extends AbstractLevel {
     return callback[kPromise]
   }
 
+  _getManySync (keys, options) {
+    keys = keys.map(key => Buffer.from(key))
+    const ret = binding.db_get_many_sync(this[kContext], keys, options ?? EMPTY)
+    const [sizes, data] = ret
+    return handleMany(sizes, data, options ?? EMPTY)
+  }
+
   _getMany (keys, options, callback) {
     callback = fromCallback(callback, kPromise)
 
-    const { valueEncoding } = options ?? EMPTY
     try {
       this[kRef]()
-
-      function bufferHandler (sizes, buffer) {
-        buffer ??= Buffer.alloc(0)
-        sizes ??= Buffer.alloc(0)
-
-        let offset = 0
-        const rows = []
-        const sizes32 = new Int32Array(sizes.buffer, sizes.byteOffset, sizes.byteLength / 4)
-        for (let n = 0; n < sizes32.length; n++) {
-          const size = sizes32[n]
-          const encoding = valueEncoding
-          if (size < 0) {
-            rows.push(undefined)
-          } else {
-            if (encoding === 'slice') {
-              rows.push({ buffer, byteOffset: offset, byteLength: size })
-            } else {
-              rows.push(new FastBuffer(buffer.buffer, offset, size))
-            }
-            offset += size
-            if (offset & 0x7) {
-              offset = (offset | 0x7) + 1
-            }
-          }
-        }
-        callback(null, rows)
-      }
-
-      binding.db_get_many(this[kContext], keys, options ?? EMPTY, (err, arg1, arg2) => {
+      binding.db_get_many(this[kContext], keys, options ?? EMPTY, (err, sizes, data) => {
         if (err) {
           callback(err)
-        } else if (valueEncoding === 'utf8') {
-          callback(null, arg1)
         } else {
-          bufferHandler(arg1, arg2)
+          let rows
+          try {
+            rows = handleMany(sizes, data, options ?? EMPTY)
+          } catch (err) {
+            callback(err)
+          }
+          callback(null, rows)
         }
         this[kUnref]()
       })

package/package.json

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

package/util.js

@@ -1,5 +1,36 @@
 'use strict'
 
+function handleMany (sizes, data, options) {
+  const { valueEncoding } = options ?? {}
+
+  data ??= Buffer.alloc(0)
+  sizes ??= Buffer.alloc(0)
+
+  const rows = []
+  let offset = 0
+  const sizes32 = new Int32Array(sizes.buffer, sizes.byteOffset, sizes.byteLength / 4)
+  for (let n = 0; n < sizes32.length; n++) {
+    const size = sizes32[n]
+    const encoding = valueEncoding
+    if (size < 0) {
+      rows.push(undefined)
+    } else {
+      if (!encoding || encoding === 'buffer') {
+        rows.push(data.subarray(offset, offset + size))
+      } else if (encoding === 'slice') {
+        rows.push({ buffer: data, byteOffset: offset, byteLength: size })
+      } else {
+        rows.push(data.toString(encoding, offset, offset + size))
+      }
+      offset += size
+      if (offset & 0x7) {
+        offset = (offset | 0x7) + 1
+      }
+    }
+  }
+
+  return rows
+}
 function handleNextv (err, sizes, buffer, finished, options, callback) {
   const { keyEncoding, valueEncoding } = options ?? {}
 
@@ -36,4 +67,5 @@ function handleNextv (err, sizes, buffer, finished, options, callback) {
   }
 }
 
+exports.handleMany = handleMany
 exports.handleNextv = handleNextv