@nxtedition/rocksdb 7.0.64 → 7.1.0

package/binding.cc

@@ -18,6 +18,7 @@
 #include <rocksdb/table.h>
 #include <rocksdb/write_batch.h>
 
+#include <iostream>
 #include <memory>
 #include <optional>
 #include <set>
@@ -519,7 +520,7 @@ template <typename T, typename U>
 napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   rocksdb::ConfigOptions configOptions;
 
-  size_t memtable_memory_budget = 256 * 1024 * 1024;
+  uint64_t memtable_memory_budget = 256 * 1024 * 1024;
   NAPI_STATUS_RETURN(GetProperty(env, options, "memtableMemoryBudget", memtable_memory_budget));
 
   std::optional<std::string> compactionOpt;
@@ -555,7 +556,7 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
 
       // only compress levels >= 2
       columnOptions.compression_per_level.resize(columnOptions.num_levels);
-      for (int i = 0; i < columnOptions.compression_per_level.size(); ++i) {
+      for (int i = 0; i < columnOptions.num_levels; ++i) {
         if (i < 2) {
           columnOptions.compression_per_level[i] = rocksdb::kNoCompression;
         } else {
@@ -594,8 +595,12 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   std::optional<std::string> mergeOperatorOpt;
   NAPI_STATUS_RETURN(GetProperty(env, options, "mergeOperator", mergeOperatorOpt));
   if (mergeOperatorOpt) {
-    ROCKS_STATUS_RETURN_NAPI(
-        rocksdb::MergeOperator::CreateFromString(configOptions, *mergeOperatorOpt, &columnOptions.merge_operator));
+    if (*mergeOperatorOpt == "maxRev") {
+      columnOptions.merge_operator = std::make_shared<MaxRevOperator>();
+    } else {
+      ROCKS_STATUS_RETURN_NAPI(
+          rocksdb::MergeOperator::CreateFromString(configOptions, *mergeOperatorOpt, &columnOptions.merge_operator));
+    }
   }
 
   uint32_t cacheSize = 8 << 20;
@@ -1107,7 +1112,7 @@ NAPI_METHOD(db_get_property) {
   Database* database;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
 
-  rocksdb::PinnableSlice property;
+  NapiSlice property;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], property));
 
   std::string value;
@@ -1203,7 +1208,7 @@ NAPI_METHOD(iterator_seek) {
   Iterator* iterator;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&iterator)));
 
-  rocksdb::PinnableSlice target;
+  NapiSlice target;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], target));
 
   iterator->first_ = true;
@@ -1338,14 +1343,10 @@ NAPI_METHOD(batch_do) {
   uint32_t length;
   NAPI_STATUS_THROWS(napi_get_array_length(env, elements, &length));
 
-  rocksdb::PinnableSlice type;
-  rocksdb::PinnableSlice key;
-  rocksdb::PinnableSlice value;
-
   for (uint32_t i = 0; i < length; i++) {
-    type.Reset();
-    key.Reset();
-    value.Reset();
+    NapiSlice type;
+    NapiSlice key;
+    NapiSlice value;
 
     napi_value element;
     NAPI_STATUS_THROWS(napi_get_element(env, elements, i, &element));
@@ -1395,10 +1396,10 @@ NAPI_METHOD(batch_put) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::PinnableSlice key;
+  NapiSlice key;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
-  rocksdb::PinnableSlice val;
+  NapiSlice val;
   NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
   const auto options = argv[3];
@@ -1421,7 +1422,7 @@ NAPI_METHOD(batch_del) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::PinnableSlice key;
+  NapiSlice key;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
   const auto options = argv[2];
@@ -1444,10 +1445,10 @@ NAPI_METHOD(batch_merge) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], (void**)(&batch)));
 
-  rocksdb::PinnableSlice key;
+  NapiSlice key;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], key));
 
-  rocksdb::PinnableSlice val;
+  NapiSlice val;
   NAPI_STATUS_THROWS(GetValue(env, argv[2], val));
 
   const auto options = argv[3];
@@ -1496,7 +1497,7 @@ NAPI_METHOD(batch_put_log_data) {
   rocksdb::WriteBatch* batch;
   NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&batch)));
 
-  rocksdb::PinnableSlice logData;
+  NapiSlice logData;
   NAPI_STATUS_THROWS(GetValue(env, argv[1], logData));
 
   ROCKS_STATUS_THROWS_NAPI(batch->PutLogData(logData));
@@ -1553,6 +1554,58 @@ NAPI_METHOD(batch_iterate) {
   return result;
 }
 
+NAPI_METHOD(db_get_sorted_wal_files) {
+  NAPI_ARGV(3);
+
+  Database* database;
+  NAPI_STATUS_THROWS(napi_get_value_external(env, argv[0], reinterpret_cast<void**>(&database)));
+
+  auto callback = argv[1];
+
+  runAsync<rocksdb::VectorLogPtr>(
+      "leveldown.open", env, callback,
+      [=](auto& files) {
+        return database->db->GetSortedWalFiles(files);
+      },
+      [=](auto& files, auto env, auto& argv) {
+        argv.resize(2);
+
+        const auto size = files.size();
+        NAPI_STATUS_RETURN(napi_create_array_with_length(env, size, &argv[1]));
+
+        for (size_t n = 0; n < size; ++n) {
+          napi_value element;
+          NAPI_STATUS_RETURN(napi_create_object(env, &element));
+
+          napi_value pathName;
+          NAPI_STATUS_RETURN(napi_create_string_utf8(env, files[n]->PathName().data(), NAPI_AUTO_LENGTH, &pathName))
+          NAPI_STATUS_RETURN(napi_set_named_property(env, element, "pathName", pathName));
+
+          napi_value logNumber;
+          NAPI_STATUS_RETURN(napi_create_int32(env, files[n]->LogNumber(), &logNumber))
+          NAPI_STATUS_RETURN(napi_set_named_property(env, element, "logNumber", logNumber));
+
+          napi_value type;
+          NAPI_STATUS_RETURN(napi_create_int32(env, files[n]->Type(), &type))
+          NAPI_STATUS_RETURN(napi_set_named_property(env, element, "type", type));
+
+          napi_value startSequence;
+          NAPI_STATUS_RETURN(napi_create_int64(env, files[n]->StartSequence(), &startSequence))
+          NAPI_STATUS_RETURN(napi_set_named_property(env, element, "startSequence", startSequence));
+
+          napi_value sizeFileBytes;
+          NAPI_STATUS_RETURN(napi_create_int64(env, files[n]->SizeFileBytes(), &sizeFileBytes))
+          NAPI_STATUS_RETURN(napi_set_named_property(env, element, "sizeFileBytes", sizeFileBytes));
+
+          NAPI_STATUS_RETURN(napi_set_element(env, argv[1], n, element));
+        }
+
+        return napi_ok;
+      });
+
+  return 0;
+}
+
 NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_init);
   NAPI_EXPORT_FUNCTION(db_open);
@@ -1561,6 +1614,7 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_clear);
   NAPI_EXPORT_FUNCTION(db_get_property);
   NAPI_EXPORT_FUNCTION(db_get_latest_sequence);
+  NAPI_EXPORT_FUNCTION(db_get_sorted_wal_files);
 
   NAPI_EXPORT_FUNCTION(iterator_init);
   NAPI_EXPORT_FUNCTION(iterator_seek);

package/binding.gyp

@@ -1,83 +1,54 @@
 {
-  "variables": { "openssl_fips": "0" },
-  "targets": [
-    {
-      "target_name": "leveldown",
-      "conditions": [
-        [
-          "OS == 'win'",
-          {
-            "defines": ["_HAS_EXCEPTIONS=1", "OS_WIN=1"],
-            "msvs_settings": {
-              "VCCLCompilerTool": {
-                "RuntimeTypeInfo": "false",
-                "EnableFunctionLevelLinking": "true",
-                "ExceptionHandling": "2",
-                "DisableSpecificWarnings": [
-                  "4355",
-                  "4530",
-                  "4267",
-                  "4244",
-                  "4506"
+    "variables": {"openssl_fips": "0"},
+    "targets": [
+        {
+            "target_name": "leveldown",
+            "conditions": [
+                [
+                    "OS == 'linux'",
+                    {
+                        "cflags": [
+                            "-msse4.2",
+                            "-mpclmul",
+                            "-mavx",
+                            "-mavx2",
+                            "-mbmi",
+                            "-mlzcnt"
+                        ],
+                        "ccflags": ["-flto"],
+                        "cflags!": ["-fno-exceptions"],
+                        "cflags_cc!": ["-fno-exceptions"],
+                        "ldflags": ["-flto", "-fuse-linker-plugin"]
+                    }
+                ],
+                [
+                    "OS == 'mac'",
+                    {
+                        "xcode_settings": {
+                            "WARNING_CFLAGS": [
+                                "-Wno-sign-compare",
+                                "-Wno-unused-variable",
+                                "-Wno-unused-function",
+                                "-Wno-ignored-qualifiers"
+                            ],
+                            "OTHER_CPLUSPLUSFLAGS": [
+                                "-mmacosx-version-min=12.2.1",
+                                "-std=c++20",
+                                "-fno-omit-frame-pointer",
+                                "-momit-leaf-frame-pointer",
+                                "-arch x86_64",
+                                "-arch arm64"
+                            ],
+                            "GCC_ENABLE_CPP_RTTI": "YES",
+                            "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+                            "MACOSX_DEPLOYMENT_TARGET": "12.2.1"
+                        }
+                    }
                 ]
-              },
-              "VCLinkerTool": {
-                "AdditionalDependencies": ["Shlwapi.lib", "rpcrt4.lib"]
-              }
-            }
-          },
-          {
-            "cflags": ["-std=c++20"],
-            "cflags!": ["-fno-rtti"],
-            "cflags_cc!": ["-fno-rtti"],
-            "cflags_cc+": ["-frtti"]
-          }
-        ],
-        [
-          "OS == 'linux'",
-          {
-            "cflags": [
-              "-msse4.2",
-              "-mpclmul",
-              "-mavx",
-              "-mavx2",
-              "-mbmi",
-              "-mlzcnt"
             ],
-            "ccflags": ["-flto"],
-            "cflags!": ["-fno-exceptions"],
-            "cflags_cc!": ["-fno-exceptions"],
-            "ldflags": ["-flto", "-fuse-linker-plugin"]
-          }
-        ],
-        [
-          "OS == 'mac'",
-          {
-            "xcode_settings": {
-              "WARNING_CFLAGS": [
-                "-Wno-sign-compare",
-                "-Wno-unused-variable",
-                "-Wno-unused-function",
-                "-Wno-ignored-qualifiers"
-              ],
-              "OTHER_CPLUSPLUSFLAGS": [
-                "-mmacosx-version-min=12.2.1",
-                "-std=c++20",
-                "-fno-omit-frame-pointer",
-                "-momit-leaf-frame-pointer",
-                "-arch x86_64",
-                "-arch arm64"
-              ],
-              "GCC_ENABLE_CPP_RTTI": "YES",
-              "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
-              "MACOSX_DEPLOYMENT_TARGET": "12.2.1"
-            }
-          }
-        ]
-      ],
-      "dependencies": ["<(module_root_dir)/deps/rocksdb/rocksdb.gyp:rocksdb"],
-      "include_dirs": ["<!(node -e \"require('napi-macros')\")"],
-      "sources": ["binding.cc"]
-    }
-  ]
+            "dependencies": ["<(module_root_dir)/deps/rocksdb/rocksdb.gyp:rocksdb"],
+            "include_dirs": ["<!(node -e \"require('napi-macros')\")"],
+            "sources": ["binding.cc"]
+        }
+    ]
 }

package/index.js

@@ -441,6 +441,12 @@ class RocksLevel extends AbstractLevel {
       this[kUnref]()
     }
   }
+
+  async getSortedWalFiles () {
+    return new Promise((resolve, reject) => {
+      binding.db_get_sorted_wal_files(this[kContext], (err, val) => err ? reject(err) : resolve(val))
+    })
+  }
 }
 
 exports.RocksLevel = RocksLevel

package/max_rev_operator.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <rocksdb/slice.h>
+#include <rocksdb/merge_operator.h>
+
 int compareRev(const rocksdb::Slice& a, const rocksdb::Slice& b) {
   auto indexA = 0UL;
   auto indexB = 0UL;

package/package.json

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

package/util.h

@@ -111,22 +111,45 @@ static napi_status GetString(napi_env env, napi_value from, std::string& to) {
   return napi_ok;
 }
 
-void DestroyReference(void* arg1, void* arg2) {
-  auto env = reinterpret_cast<napi_env>(arg1);
-  auto ref = reinterpret_cast<napi_ref>(arg2);
-  napi_delete_reference(env, ref);
-}
+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, rocksdb::PinnableSlice& to) {
+static napi_status GetString(napi_env env, napi_value from, NapiSlice& 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));
-    to.GetSelf()->resize(length, '\0');
-    NAPI_STATUS_RETURN(napi_get_value_string_utf8(env, from, &(*to.GetSelf())[0], length + 1, &length));
-    to.PinSelf();
+
+    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));
@@ -136,9 +159,8 @@ static napi_status GetString(napi_env env, napi_value from, rocksdb::PinnableSli
       size_t length = 0;
       NAPI_STATUS_RETURN(napi_get_buffer_info(env, from, reinterpret_cast<void**>(&buf), &length));
 
-      napi_ref ref;
-      NAPI_STATUS_RETURN(napi_create_reference(env, from, 1, &ref));
-      to.PinSlice(rocksdb::Slice(buf, length), DestroyReference, env, ref);
+      to.data_ = buf;
+      to.size_ = length;
     } else {
       return napi_invalid_arg;
     }
@@ -172,18 +194,11 @@ static napi_status GetValue(napi_env env, napi_value value, uint64_t& result) {
   return napi_ok;
 }
 
-static napi_status GetValue(napi_env env, napi_value value, unsigned long& result) {
-  int64_t result2;
-  NAPI_STATUS_RETURN(napi_get_value_int64(env, value, &result2));
-  result = static_cast<unsigned long>(result2);
-  return napi_ok;
-}
-
 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, rocksdb::PinnableSlice& result) {
+static napi_status GetValue(napi_env env, napi_value value, NapiSlice& result) {
   return GetString(env, value, result);
 }