@nxtedition/rocksdb 13.1.0 → 13.1.2

package/binding.cc

@@ -18,8 +18,6 @@
 #include <rocksdb/table.h>
 #include <rocksdb/write_batch.h>
 
-#include <re2/re2.h>
-
 #include <iostream>
 #include <memory>
 #include <optional>
@@ -412,7 +410,6 @@ class Iterator final : public BaseIterator {
   bool first_ = true;
   const Encoding keyEncoding_;
   const Encoding valueEncoding_;
-  std::unique_ptr<re2::RE2> expr_;
 
  public:
   Iterator(Database* database,
@@ -428,18 +425,13 @@ class Iterator final : public BaseIterator {
            const size_t highWaterMarkBytes,
            Encoding keyEncoding = Encoding::Invalid,
            Encoding valueEncoding = Encoding::Invalid,
-           rocksdb::ReadOptions readOptions = {},
-           const std::string& selector = "")
+           rocksdb::ReadOptions readOptions = {})
       : BaseIterator(database, column, reverse, lt, lte, gt, gte, limit, readOptions),
         keys_(keys),
         values_(values),
         highWaterMarkBytes_(highWaterMarkBytes),
         keyEncoding_(keyEncoding),
         valueEncoding_(valueEncoding) {
-    if (selector != "") {
-      // TODO (fix): Pool selectors?
-      expr_.reset(new re2::RE2(selector));
-    }
   }
 
   void Seek(const rocksdb::Slice& target) override {
@@ -513,9 +505,6 @@ class Iterator final : public BaseIterator {
     readOptions.ignore_range_deletions = false;
     NAPI_STATUS_THROWS(GetProperty(env, options, "ignoreRangeDeletions", readOptions.ignore_range_deletions));
 
-    std::string selector;
-    NAPI_STATUS_THROWS(GetProperty(env, options, "selector", selector));
-
     // uint32_t timeout = 0;
     // NAPI_STATUS_THROWS(GetProperty(env, options, "timeout", timeout));
 
@@ -524,7 +513,7 @@ class Iterator final : public BaseIterator {
     //   : std::chrono::microseconds::zero();
 
     return std::make_unique<Iterator>(database, column, reverse, keys, values, limit, lt, lte, gt, gte,
-                                      highWaterMarkBytes, keyEncoding, valueEncoding, readOptions, selector);
+                                      highWaterMarkBytes, keyEncoding, valueEncoding, readOptions);
   }
 
   napi_value nextv(napi_env env, uint32_t count, uint32_t timeout, napi_value callback) {
@@ -559,28 +548,26 @@ class Iterator final : public BaseIterator {
               break;
             }
 
-            if (!expr_ || re2::RE2::PartialMatch(CurrentKey().ToStringView(), *expr_)) {
-              if (keys_ && values_) {
-                rocksdb::PinnableSlice k;
-                k.PinSelf(CurrentKey());
-                state.keys.push_back(std::move(k));
-
-                rocksdb::PinnableSlice v;
-                v.PinSelf(CurrentValue());
-                state.values.push_back(std::move(v));
-              } else if (keys_) {
-                rocksdb::PinnableSlice k;
-                k.PinSelf(CurrentKey());
-                state.keys.push_back(std::move(k));
-              } else if (values_) {
-                rocksdb::PinnableSlice v;
-                v.PinSelf(CurrentValue());
-                state.values.push_back(std::move(v));
-              } else {
-                assert(false);
-              }
-              state.count += 1;
+            if (keys_ && values_) {
+              rocksdb::PinnableSlice k;
+              k.PinSelf(CurrentKey());
+              state.keys.push_back(std::move(k));
+
+              rocksdb::PinnableSlice v;
+              v.PinSelf(CurrentValue());
+              state.values.push_back(std::move(v));
+            } else if (keys_) {
+              rocksdb::PinnableSlice k;
+              k.PinSelf(CurrentKey());
+              state.keys.push_back(std::move(k));
+            } else if (values_) {
+              rocksdb::PinnableSlice v;
+              v.PinSelf(CurrentValue());
+              state.values.push_back(std::move(v));
+            } else {
+              assert(false);
             }
+            state.count += 1;
 
             bytesRead += CurrentKey().size() + CurrentValue().size();
             if (bytesRead > highWaterMarkBytes_) {
@@ -661,31 +648,29 @@ class Iterator final : public BaseIterator {
         break;
       }
 
-      if (!expr_ || re2::RE2::PartialMatch(CurrentKey().ToStringView(), *expr_)) {
-        napi_value key;
-        napi_value val;
-
-        if (keys_ && values_) {
-          const auto k = CurrentKey();
-          const auto v = CurrentValue();
-          NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key));
-          NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val));
-        } else if (keys_) {
-          const auto k = CurrentKey();
-          NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key));
-          NAPI_STATUS_THROWS(napi_get_undefined(env, &val));
-        } else if (values_) {
-          const auto v = CurrentValue();
-          NAPI_STATUS_THROWS(napi_get_undefined(env, &key));
-          NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val));
-        } else {
-          assert(false);
-        }
+      napi_value key;
+      napi_value val;
 
-        NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, key));
-        NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, val));
+      if (keys_ && values_) {
+        const auto k = CurrentKey();
+        const auto v = CurrentValue();
+        NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key));
+        NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val));
+      } else if (keys_) {
+        const auto k = CurrentKey();
+        NAPI_STATUS_THROWS(Convert(env, &k, keyEncoding_, key));
+        NAPI_STATUS_THROWS(napi_get_undefined(env, &val));
+      } else if (values_) {
+        const auto v = CurrentValue();
+        NAPI_STATUS_THROWS(napi_get_undefined(env, &key));
+        NAPI_STATUS_THROWS(Convert(env, &v, valueEncoding_, val));
+      } else {
+        assert(false);
       }
 
+      NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, key));
+      NAPI_STATUS_THROWS(napi_set_element(env, rows, idx++, val));
+
       bytesRead += CurrentKey().size() + CurrentValue().size();
       if (bytesRead > highWaterMarkBytes_) {
         break;
@@ -865,53 +850,57 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
     // TODO (perf): compression_opts.parallel_threads
   }
 
-  std::optional<std::string> prefixExtractorOpt;
-  NAPI_STATUS_RETURN(GetProperty(env, options, "prefixExtractor", prefixExtractorOpt));
-  if (prefixExtractorOpt) {
+  std::string prefixExtractor;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "prefixExtractor", prefixExtractor));
+  if (prefixExtractor == "") {
+    // Do nothing...
+  } else {
     ROCKS_STATUS_RETURN_NAPI(
-        rocksdb::SliceTransform::CreateFromString(configOptions, *prefixExtractorOpt, &columnOptions.prefix_extractor));
+        rocksdb::SliceTransform::CreateFromString(configOptions, prefixExtractor, &columnOptions.prefix_extractor));
   }
 
-  std::optional<std::string> comparatorOpt;
-  NAPI_STATUS_RETURN(GetProperty(env, options, "comparator", comparatorOpt));
-  if (comparatorOpt) {
+  std::string comparator;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "comparator", comparator));
+  if (comparator == "") {
+    // Do nothing...
+  } else {
     ROCKS_STATUS_RETURN_NAPI(
-        rocksdb::Comparator::CreateFromString(configOptions, *comparatorOpt, &columnOptions.comparator));
+        rocksdb::Comparator::CreateFromString(configOptions, comparator, &columnOptions.comparator));
   }
 
-  std::optional<std::string> mergeOperatorOpt;
-  NAPI_STATUS_RETURN(GetProperty(env, options, "mergeOperator", mergeOperatorOpt));
-  if (mergeOperatorOpt) {
-    if (*mergeOperatorOpt == "maxRev") {
-      columnOptions.merge_operator = std::make_shared<MaxRevOperator>();
-    } else {
-      ROCKS_STATUS_RETURN_NAPI(
-          rocksdb::MergeOperator::CreateFromString(configOptions, *mergeOperatorOpt, &columnOptions.merge_operator));
-    }
+  std::string mergeOperator;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "mergeOperator", mergeOperator));
+  if (mergeOperator == "") {
+    // Do nothing...
+  } else if (mergeOperator == "maxRev") {
+    columnOptions.merge_operator = std::make_shared<MaxRevOperator>();
+  } else {
+    ROCKS_STATUS_RETURN_NAPI(
+        rocksdb::MergeOperator::CreateFromString(configOptions, mergeOperator, &columnOptions.merge_operator));
   }
 
-  std::optional<std::string> compactionPriority;
+  std::string compactionPriority;
   NAPI_STATUS_RETURN(GetProperty(env, options, "compactionPriority", compactionPriority));
-  if (compactionPriority) {
-    if (compactionPriority == "byCompensatedSize") {
-      columnOptions.compaction_pri = rocksdb::kByCompensatedSize;
-    } else if (compactionPriority == "oldestLargestSeqFirst") {
-      columnOptions.compaction_pri = rocksdb::kOldestLargestSeqFirst;
-    } else if (compactionPriority == "smallestSeqFirst") {
-      columnOptions.compaction_pri = rocksdb::kOldestSmallestSeqFirst;
-    } else if (compactionPriority == "overlappingRatio") {
-      columnOptions.compaction_pri = rocksdb::kMinOverlappingRatio;
-    } else if (compactionPriority == "roundRobin") {
-      columnOptions.compaction_pri = rocksdb::kRoundRobin;
-    } else {
-      // Throw?
-    }
+  if (compactionPriority == "") {
+    // Do nothing...
+  } else if (compactionPriority == "byCompensatedSize") {
+    columnOptions.compaction_pri = rocksdb::kByCompensatedSize;
+  } else if (compactionPriority == "oldestLargestSeqFirst") {
+    columnOptions.compaction_pri = rocksdb::kOldestLargestSeqFirst;
+  } else if (compactionPriority == "smallestSeqFirst") {
+    columnOptions.compaction_pri = rocksdb::kOldestSmallestSeqFirst;
+  } else if (compactionPriority == "overlappingRatio") {
+    columnOptions.compaction_pri = rocksdb::kMinOverlappingRatio;
+  } else if (compactionPriority == "roundRobin") {
+    columnOptions.compaction_pri = rocksdb::kRoundRobin;
+  } else {
+    return napi_invalid_arg;
   }
 
-  columnOptions.optimize_filters_for_hits = false;
   NAPI_STATUS_RETURN(GetProperty(env, options, "optimizeFiltersForHits", columnOptions.optimize_filters_for_hits));
 
   rocksdb::BlockBasedTableOptions tableOptions;
+  tableOptions.decouple_partitioned_filters = true;
 
   {
     uint32_t cacheSize = 8 << 20;
@@ -927,7 +916,9 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   std::string optimize = "";
   NAPI_STATUS_RETURN(GetProperty(env, options, "optimize", optimize));
 
-  if (optimize == "point-lookup") {
+  if (optimize == "") {
+    tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
+  } else if (optimize == "point-lookup") {
     tableOptions.data_block_index_type = rocksdb::BlockBasedTableOptions::kDataBlockBinaryAndHash;
     tableOptions.data_block_hash_table_util_ratio = 0.75;
     tableOptions.filter_policy.reset(rocksdb::NewRibbonFilterPolicy(10, 2));
@@ -937,7 +928,35 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
   } else if (optimize == "range-lookup") {
     // TODO?
   } else {
-    tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
+    return napi_invalid_arg;
+  }
+
+  std::string indexType;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "indexType", indexType));
+  if (indexType == "") {
+    // Do nothing...
+  } else if (indexType == "binarySearch") {
+    tableOptions.index_type = rocksdb::BlockBasedTableOptions::kBinarySearch;
+  } else if (indexType == "hashSearch") {
+    tableOptions.index_type = rocksdb::BlockBasedTableOptions::kHashSearch;
+  } else if (indexType == "twoLevelIndexSearch") {
+    tableOptions.index_type = rocksdb::BlockBasedTableOptions::kTwoLevelIndexSearch;
+  } else if (indexType == "binarySearchWithFirstKey") {
+    tableOptions.index_type = rocksdb::BlockBasedTableOptions::kBinarySearchWithFirstKey;
+  } else {
+    return napi_invalid_arg;
+  }
+
+  std::string dataBlockIndexType;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "dataBlockIndexType", dataBlockIndexType));
+  if (dataBlockIndexType == "") {
+    // Do nothing...
+  } else if (dataBlockIndexType == "dataBlockBinarySearch") {
+    tableOptions.data_block_index_type = rocksdb::BlockBasedTableOptions::kDataBlockBinarySearch;
+  } else if (dataBlockIndexType == "dataBlockBinaryAndHash") {
+    tableOptions.data_block_index_type = rocksdb::BlockBasedTableOptions::kDataBlockBinaryAndHash;
+  } else {
+    return napi_invalid_arg;
   }
 
   std::string filterPolicy;
@@ -947,31 +966,42 @@ napi_status InitOptions(napi_env env, T& columnOptions, const U& options) {
         rocksdb::FilterPolicy::CreateFromString(configOptions, filterPolicy, &tableOptions.filter_policy));
   }
 
-  tableOptions.block_size = 4 * 1024;
-  NAPI_STATUS_RETURN(GetProperty(env, options, "blockSize", tableOptions.block_size));
+  std::string indexShortening;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "indexShortening", indexShortening));
+  if (indexShortening == "") {
+    // Do nothing..
+  } else if (indexShortening == "noShortening") {
+    tableOptions.index_shortening = rocksdb::BlockBasedTableOptions::IndexShorteningMode::kNoShortening;
+  } else if (indexShortening == "shortenSeparators") {
+    tableOptions.index_shortening = rocksdb::BlockBasedTableOptions::IndexShorteningMode::kShortenSeparators;
+  } else if (indexShortening == "shortenSeparatorsAndSuccessor") {
+    tableOptions.index_shortening = rocksdb::BlockBasedTableOptions::IndexShorteningMode::kShortenSeparatorsAndSuccessor;
+  } else {
+    return napi_invalid_arg;
+  }
 
-  tableOptions.block_restart_interval = 16;
-  NAPI_STATUS_RETURN(GetProperty(env, options, "blockRestartInterval", tableOptions.block_restart_interval));
+  std::string prepopulateBlockCache;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "prepopulateBlockCache", prepopulateBlockCache));
+  if (prepopulateBlockCache == "") {
+    // Do nothing...
+  } else if (prepopulateBlockCache == "disable") {
+    tableOptions.prepopulate_block_cache = rocksdb::BlockBasedTableOptions::PrepopulateBlockCache::kDisable;
+  } else if (prepopulateBlockCache == "flushOnly") {
+    tableOptions.prepopulate_block_cache = rocksdb::BlockBasedTableOptions::PrepopulateBlockCache::kFlushOnly;
+  } else {
+    return napi_invalid_arg;
+  }
 
-  tableOptions.block_align = false;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "dataBlockHashTableUtilRatio", tableOptions.data_block_hash_table_util_ratio));
+  NAPI_STATUS_RETURN(GetProperty(env, options, "blockSize", tableOptions.block_size));
+  NAPI_STATUS_RETURN(GetProperty(env, options, "blockRestartInterval", tableOptions.block_restart_interval));
   NAPI_STATUS_RETURN(GetProperty(env, options, "blockAlign", tableOptions.block_align));
-
-  tableOptions.cache_index_and_filter_blocks = false;
   NAPI_STATUS_RETURN(GetProperty(env, options, "cacheIndexAndFilterBlocks", tableOptions.cache_index_and_filter_blocks));
-
-  tableOptions.cache_index_and_filter_blocks_with_high_priority = true;
   NAPI_STATUS_RETURN(GetProperty(env, options, "cacheIndexAndFilterBlocksWithHighPriority", tableOptions.cache_index_and_filter_blocks_with_high_priority));
-
-  tableOptions.decouple_partitioned_filters = true;
   NAPI_STATUS_RETURN(GetProperty(env, options, "decouplePartitionedFilters", tableOptions.block_restart_interval));
-
-  tableOptions.optimize_filters_for_memory = true;
   NAPI_STATUS_RETURN(GetProperty(env, options, "optimizeFiltersForMemory", tableOptions.optimize_filters_for_memory));
-
-  tableOptions.max_auto_readahead_size = 256 * 1024;
   NAPI_STATUS_RETURN(GetProperty(env, options, "maxAutoReadaheadSize", tableOptions.max_auto_readahead_size));
-
-  tableOptions.num_file_reads_for_auto_readahead = 2;
+  NAPI_STATUS_RETURN(GetProperty(env, options, "initialAutoReadaheadSize", tableOptions.initial_auto_readahead_size));
   NAPI_STATUS_RETURN(GetProperty(env, options, "numFileReadsForAutoReadahead", tableOptions.num_file_reads_for_auto_readahead));
 
   columnOptions.table_factory.reset(rocksdb::NewBlockBasedTableFactory(tableOptions));

package/binding.gyp

@@ -10,7 +10,6 @@
                     {
                         "direct_dependent_settings": {
                           "libraries": [
-                            "/usr/lib/x86_64-linux-gnu/libre2.a",
                           ],
                         },
                         "include_dirs": [
@@ -29,12 +28,9 @@
                     {
                         "direct_dependent_settings": {
                           "libraries": [
-                            "/opt/homebrew/Cellar/re2/20240702_1/lib/re2.a"
                           ],
                         },
                         "include_dirs": [
-                          "/opt/homebrew/Cellar/re2/20240702_1/include",
-                          "/opt/homebrew/Cellar/abseil/20240722.0/include"
                         ],
                         "xcode_settings": {
                             "WARNING_CFLAGS": [

package/deps/rocksdb/rocksdb.gyp

@@ -93,8 +93,8 @@
               "USE_COROUTINES=1",
               "HAVE_UINT128_EXTENSION=1",
               "HAVE_ALIGNED_NEW=1",
-              "ROCKSDB_JEMALLOC=1",
-              "JEMALLOC_NO_DEMANGLE=1"
+              # "ROCKSDB_JEMALLOC=1",
+              # "JEMALLOC_NO_DEMANGLE=1"
               # "HAVE_FULLFSYNC=1",
               # "NUMA=1",
             ],
@@ -107,8 +107,8 @@
                 "/usr/lib/x86_64-linux-gnu/libglog.a",
                 "/usr/lib/x86_64-linux-gnu/libiberty.a",
                 "/usr/lib/x86_64-linux-gnu/libunwind.a",
-                "/usr/lib/x86_64-linux-gnu/libgflags.a",
-                "/usr/lib/x86_64-linux-gnu/libjemalloc.a"
+                "/usr/lib/x86_64-linux-gnu/libgflags.a"
+                # "/usr/lib/x86_64-linux-gnu/libjemalloc.a"
               ],
             },
             "include_dirs": [

package/package.json

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

package/util.h

@@ -244,6 +244,12 @@ static napi_status GetValue(napi_env env, napi_value value, unsigned long long&
   return napi_ok;
 }
 
+static napi_status GetValue(napi_env env, napi_value value, double& result) {
+  NAPI_STATUS_RETURN(napi_get_value_double(env, value, &result));
+  return napi_ok;
+}
+
+
 static napi_status GetValue(napi_env env, napi_value value, std::string& result) {
   return GetString(env, value, result);
 }