@nxtedition/rocksdb 5.2.35 → 5.2.36

package/binding.cc

@@ -101,7 +101,7 @@ static napi_value GetProperty(napi_env env, napi_value obj, const std::string_vi
   return value;
 }
 
-static bool BooleanProperty(napi_env env, napi_value obj, const std::string_view& key, bool defaultValue) {
+static std::optional<bool> BooleanProperty(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     bool result;
@@ -109,7 +109,7 @@ static bool BooleanProperty(napi_env env, napi_value obj, const std::string_view
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
 static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_view& option) {
@@ -125,7 +125,7 @@ static bool EncodingIsBuffer(napi_env env, napi_value obj, const std::string_vie
   return false;
 }
 
-static uint32_t Uint32Property(napi_env env, napi_value obj, const std::string_view& key, uint32_t defaultValue) {
+static std::optional<uint32_t> Uint32Property(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     uint32_t result;
@@ -133,10 +133,10 @@ static uint32_t Uint32Property(napi_env env, napi_value obj, const std::string_v
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
-static int Int32Property(napi_env env, napi_value obj, const std::string_view& key, int defaultValue) {
+static std::optional<int> Int32Property(napi_env env, napi_value obj, const std::string_view& key) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
     int result;
@@ -144,7 +144,7 @@ static int Int32Property(napi_env env, napi_value obj, const std::string_view& k
     return result;
   }
 
-  return defaultValue;
+  return {};
 }
 
 static std::string ToString(napi_env env, napi_value from, const std::string& defaultValue = "") {
@@ -164,26 +164,11 @@ static std::string ToString(napi_env env, napi_value from, const std::string& de
   return defaultValue;
 }
 
-static std::string StringProperty(napi_env env,
-                                  napi_value obj,
-                                  const std::string_view& key,
-                                  const std::string& defaultValue = "") {
-  if (HasProperty(env, obj, key)) {
-    napi_value value = GetProperty(env, obj, key);
-    if (IsString(env, value)) {
-      return ToString(env, value);
-    }
-  }
-
-  return defaultValue;
-}
-
-static std::optional<std::string> RangeOption(napi_env env, napi_value opts, const std::string_view& name) {
+static std::optional<std::string> StringProperty(napi_env env, napi_value opts, const std::string_view& name) {
   if (HasProperty(env, opts, name)) {
     const auto value = GetProperty(env, opts, name);
     return ToString(env, value);
   }
-
   return {};
 }
 
@@ -238,6 +223,16 @@ napi_status Convert(napi_env env, std::string s, bool asBuffer, napi_value& resu
   }
 }
 
+napi_status Convert(napi_env env, rocksdb::PinnableSlice s, bool asBuffer, napi_value& result) {
+  if (asBuffer) {
+    auto ptr = new rocksdb::PinnableSlice(std::move(s));
+    return napi_create_external_buffer(env, ptr->size(), const_cast<char*>(ptr->data()), Finalize<std::string>, ptr,
+                                       &result);
+  } else {
+    return napi_create_string_utf8(env, s.data(), s.size(), &result);
+  }
+}
+
 struct NapiSlice : public rocksdb::Slice {
   NapiSlice(napi_env env, napi_value from) {
     if (IsString(env, from)) {
@@ -383,21 +378,21 @@ struct BaseIterator {
         limit_(limit),
         fillCache_(fillCache) {
     if (lte) {
-      upper_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      upper_bound_ = rocksdb::PinnableSlice();
       *upper_bound_->GetSelf() = std::move(*lte) + '\0';
       upper_bound_->PinSelf();
     } else if (lt) {
-      upper_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      upper_bound_ = rocksdb::PinnableSlice();
       *upper_bound_->GetSelf() = std::move(*lt);
       upper_bound_->PinSelf();
     }
 
     if (gte) {
-      lower_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      lower_bound_ = rocksdb::PinnableSlice();
       *lower_bound_->GetSelf() = std::move(*gte);
       lower_bound_->PinSelf();
     } else if (gt) {
-      lower_bound_ = std::make_unique<rocksdb::PinnableSlice>();
+      lower_bound_ = rocksdb::PinnableSlice();
       *lower_bound_->GetSelf() = std::move(*gt) + '\0';
       lower_bound_->PinSelf();
     }
@@ -477,8 +472,8 @@ struct BaseIterator {
     iterator_.reset(database_->db_->NewIterator(options));
   }
 
-  std::unique_ptr<rocksdb::PinnableSlice> lower_bound_;
-  std::unique_ptr<rocksdb::PinnableSlice> upper_bound_;
+  std::optional<rocksdb::PinnableSlice> lower_bound_;
+  std::optional<rocksdb::PinnableSlice> upper_bound_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
   std::unique_ptr<rocksdb::Iterator> iterator_;
   const bool reverse_;
@@ -506,9 +501,7 @@ struct Iterator final : public BaseIterator {
         values_(values),
         keyAsBuffer_(keyAsBuffer),
         valueAsBuffer_(valueAsBuffer),
-        highWaterMarkBytes_(highWaterMarkBytes),
-        first_(true),
-        ref_(nullptr) {}
+        highWaterMarkBytes_(highWaterMarkBytes) {}
 
   void Attach(napi_env env, napi_value context) {
     napi_create_reference(env, context, 1, &ref_);
@@ -527,10 +520,10 @@ struct Iterator final : public BaseIterator {
   const bool keyAsBuffer_;
   const bool valueAsBuffer_;
   const uint32_t highWaterMarkBytes_;
-  bool first_;
+  bool first_ = true;
 
  private:
-  napi_ref ref_;
+  napi_ref ref_ = nullptr;
 };
 
 /**
@@ -593,11 +586,10 @@ struct OpenWorker final : public Worker {
         readOnly_(readOnly),
         location_(location) {}
 
-  rocksdb::Status Execute(Database& database) override { 
+  rocksdb::Status Execute(Database& database) override {
     rocksdb::DB* db;
-    const auto status = readOnly_
-      ? rocksdb::DB::OpenForReadOnly(options_, location_, &db)
-      : rocksdb::DB::Open(options_, location_, &db);
+    const auto status = readOnly_ ? rocksdb::DB::OpenForReadOnly(options_, location_, &db)
+                                  : rocksdb::DB::Open(options_, location_, &db);
     database.db_.reset(db);
     return status;
   }
@@ -613,19 +605,16 @@ NAPI_METHOD(db_open) {
 
   rocksdb::Options options;
 
-  options.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism", 4));
+  options.IncreaseParallelism(Uint32Property(env, argv[2], "parallelism").value_or(4));
 
   const auto location = ToString(env, argv[1]);
-  options.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing", true);
-  options.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists", false);
-  options.compression =
-      BooleanProperty(env, argv[2], "compression", true) ? rocksdb::kSnappyCompression : rocksdb::kNoCompression;
-  options.max_open_files = Uint32Property(env, argv[2], "maxOpenFiles", 1000);
-  options.max_log_file_size = Uint32Property(env, argv[2], "maxFileSize", 2 << 20);
-  options.write_buffer_size = Uint32Property(env, argv[2], "writeBufferSize", 4 << 20);
+  options.create_if_missing = BooleanProperty(env, argv[2], "createIfMissing").value_or(true);
+  options.error_if_exists = BooleanProperty(env, argv[2], "errorIfExists").value_or(false);
+  options.compression = BooleanProperty(env, argv[2], "compression").value_or((true)) ? rocksdb::kSnappyCompression
+                                                                                      : rocksdb::kNoCompression;
   options.use_adaptive_mutex = true;
 
-  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel");
+  const auto infoLogLevel = StringProperty(env, argv[2], "infoLogLevel").value_or("");
   if (infoLogLevel.size() > 0) {
     rocksdb::InfoLogLevel lvl = {};
 
@@ -652,8 +641,8 @@ NAPI_METHOD(db_open) {
     options.info_log.reset(new NullLogger());
   }
 
-  const auto readOnly = BooleanProperty(env, argv[2], "readOnly", false);
-  const auto cacheSize = Uint32Property(env, argv[2], "cacheSize", 8 << 20);
+  const auto readOnly = BooleanProperty(env, argv[2], "readOnly").value_or(false);
+  const auto cacheSize = Uint32Property(env, argv[2], "cacheSize").value_or(8 << 20);
 
   rocksdb::BlockBasedTableOptions tableOptions;
 
@@ -663,8 +652,8 @@ NAPI_METHOD(db_open) {
     tableOptions.no_block_cache = true;
   }
 
-  tableOptions.block_size = Uint32Property(env, argv[2], "blockSize", 4096);
-  tableOptions.block_restart_interval = Uint32Property(env, argv[2], "blockRestartInterval", 16);
+  tableOptions.block_size = Uint32Property(env, argv[2], "blockSize").value_or(4096);
+  tableOptions.block_restart_interval = Uint32Property(env, argv[2], "blockRestartInterval").value_or(16);
   tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
   tableOptions.format_version = 5;
   tableOptions.checksum = rocksdb::kxxHash64;
@@ -778,7 +767,7 @@ NAPI_METHOD(db_get) {
   const auto key = ToString(env, argv[1]);
   const auto options = argv[2];
   const auto asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const auto fillCache = BooleanProperty(env, options, "fillCache", true);
+  const auto fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
   const auto callback = argv[3];
 
   NAPI_PENDING_EXCEPTION();
@@ -810,12 +799,24 @@ struct GetManyWorker final : public Worker {
     options.fill_cache = fillCache_;
     options.snapshot = snapshot_.get();
 
-    status_ = database.db_->MultiGet(options, std::vector<rocksdb::Slice>(keys_.begin(), keys_.end()), &values_);
+    const auto numKeys = keys_.size();
+
+    std::vector<rocksdb::Slice> keys;
+    keys.reserve(keys_.size());
+    for (const auto& key : keys_) {
+      keys.emplace_back(key);
+    }
+
+    statuses_.resize(numKeys);
+    values_.resize(numKeys);
+
+    database.db_->MultiGet(options, database.db_->DefaultColumnFamily(), numKeys, keys.data(), values_.data(),
+                           statuses_.data());
 
     keys_.clear();
     snapshot_ = nullptr;
 
-    for (auto status : status_) {
+    for (auto status : statuses_) {
       if (!status.ok() && !status.IsNotFound()) {
         return status;
       }
@@ -832,7 +833,7 @@ struct GetManyWorker final : public Worker {
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
-      if (status_[idx].ok()) {
+      if (statuses_[idx].ok()) {
         NAPI_STATUS_RETURN(Convert(env, std::move(values_[idx]), valueAsBuffer_, element));
       } else {
         NAPI_STATUS_RETURN(napi_get_undefined(env, &element));
@@ -841,7 +842,7 @@ struct GetManyWorker final : public Worker {
     }
 
     values_.clear();
-    status_.clear();
+    statuses_.clear();
 
     napi_value argv[2];
     NAPI_STATUS_RETURN(napi_get_null(env, &argv[0]));
@@ -856,8 +857,8 @@ struct GetManyWorker final : public Worker {
 
  private:
   std::vector<std::string> keys_;
-  std::vector<std::string> values_;
-  std::vector<rocksdb::Status> status_;
+  std::vector<rocksdb::PinnableSlice> values_;
+  std::vector<rocksdb::Status> statuses_;
   const bool valueAsBuffer_;
   const bool fillCache_;
   std::shared_ptr<const rocksdb::Snapshot> snapshot_;
@@ -884,7 +885,7 @@ NAPI_METHOD(db_get_many) {
 
   const auto options = argv[2];
   const bool asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const bool fillCache = BooleanProperty(env, options, "fillCache", true);
+  const bool fillCache = BooleanProperty(env, options, "fillCache").value_or(true);
   const auto callback = argv[3];
 
   NAPI_PENDING_EXCEPTION();
@@ -911,15 +912,13 @@ NAPI_METHOD(db_clear) {
   NAPI_ARGV(2);
   NAPI_DB_CONTEXT();
 
-  const auto reverse = BooleanProperty(env, argv[1], "reverse", false);
-  const auto limit = Int32Property(env, argv[1], "limit", -1);
+  const auto reverse = BooleanProperty(env, argv[1], "reverse").value_or(false);
+  const auto limit = Int32Property(env, argv[1], "limit").value_or(-1);
 
-  const auto lt = RangeOption(env, argv[1], "lt");
-  const auto lte = RangeOption(env, argv[1], "lte");
-  const auto gt = RangeOption(env, argv[1], "gt");
-  const auto gte = RangeOption(env, argv[1], "gte");
-
-  NAPI_PENDING_EXCEPTION();
+  const auto lt = StringProperty(env, argv[1], "lt");
+  const auto lte = StringProperty(env, argv[1], "lte");
+  const auto gt = StringProperty(env, argv[1], "gt");
+  const auto gte = StringProperty(env, argv[1], "gte");
 
   // TODO (perf): Use DeleteRange.
 
@@ -984,24 +983,22 @@ NAPI_METHOD(iterator_init) {
   NAPI_DB_CONTEXT();
 
   const auto options = argv[1];
-  const auto reverse = BooleanProperty(env, options, "reverse", false);
-  const auto keys = BooleanProperty(env, options, "keys", true);
-  const auto values = BooleanProperty(env, options, "values", true);
-  const auto fillCache = BooleanProperty(env, options, "fillCache", false);
+  const auto reverse = BooleanProperty(env, options, "reverse").value_or(false);
+  const auto keys = BooleanProperty(env, options, "keys").value_or(true);
+  const auto values = BooleanProperty(env, options, "values").value_or(true);
+  const auto fillCache = BooleanProperty(env, options, "fillCache").value_or(false);
   const bool keyAsBuffer = EncodingIsBuffer(env, options, "keyEncoding");
   const bool valueAsBuffer = EncodingIsBuffer(env, options, "valueEncoding");
-  const auto limit = Int32Property(env, options, "limit", -1);
-  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes", 16 * 1024);
+  const auto limit = Int32Property(env, options, "limit").value_or(-1);
+  const auto highWaterMarkBytes = Uint32Property(env, options, "highWaterMarkBytes").value_or(16 * 1024);
 
-  const auto lt = RangeOption(env, options, "lt");
-  const auto lte = RangeOption(env, options, "lte");
-  const auto gt = RangeOption(env, options, "gt");
-  const auto gte = RangeOption(env, options, "gte");
-
-  NAPI_PENDING_EXCEPTION();
+  const auto lt = StringProperty(env, options, "lt");
+  const auto lte = StringProperty(env, options, "lte");
+  const auto gt = StringProperty(env, options, "gt");
+  const auto gte = StringProperty(env, options, "gte");
 
-  auto iterator = std::make_unique<Iterator>(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache, keyAsBuffer,
-                               valueAsBuffer, highWaterMarkBytes);
+  auto iterator = std::make_unique<Iterator>(database, reverse, keys, values, limit, lt, lte, gt, gte, fillCache,
+                                             keyAsBuffer, valueAsBuffer, highWaterMarkBytes);
 
   napi_value result;
   NAPI_STATUS_THROWS(napi_create_external(env, iterator.get(), Finalize<Iterator>, iterator.get(), &result));
@@ -1158,6 +1155,8 @@ NAPI_METHOD(batch_do) {
 
       const auto key = NapiSlice(env, GetProperty(env, element, "key"));
 
+      NAPI_PENDING_EXCEPTION();
+
       batch.Delete(key);
     } else if (type == "put") {
       if (!HasProperty(env, element, "key"))
@@ -1168,12 +1167,12 @@ NAPI_METHOD(batch_do) {
       const auto key = NapiSlice(env, GetProperty(env, element, "key"));
       const auto value = NapiSlice(env, GetProperty(env, element, "value"));
 
+      NAPI_PENDING_EXCEPTION();
+
       batch.Put(key, value);
     }
   }
 
-  NAPI_PENDING_EXCEPTION();
-
   rocksdb::WriteOptions options;
   return ToError(env, database->db_->Write(options, &batch));
 }

package/binding.gyp

@@ -62,7 +62,7 @@
               ],
               "OTHER_CPLUSPLUSFLAGS": [
                 "-mmacosx-version-min=10.15",
-                "-std=c++17",
+                "-std=c++20",
                 "-fno-omit-frame-pointer",
                 "-momit-leaf-frame-pointer",
                 "-arch x86_64",

package/deps/rocksdb/rocksdb/README.md

@@ -0,0 +1,32 @@
+## RocksDB: A Persistent Key-Value Store for Flash and RAM Storage
+
+[![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb)
+[![TravisCI Status](https://api.travis-ci.com/facebook/rocksdb.svg?branch=main)](https://travis-ci.com/github/facebook/rocksdb)
+[![Appveyor Build status](https://ci.appveyor.com/api/projects/status/fbgfu0so3afcno78/branch/main?svg=true)](https://ci.appveyor.com/project/Facebook/rocksdb/branch/main)
+[![PPC64le Build Status](http://140-211-168-68-openstack.osuosl.org:8080/buildStatus/icon?job=rocksdb&style=plastic)](http://140-211-168-68-openstack.osuosl.org:8080/job/rocksdb)
+
+RocksDB is developed and maintained by Facebook Database Engineering Team.
+It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com)
+and Jeff Dean (jeff@google.com)
+
+This code is a library that forms the core building block for a fast
+key-value server, especially suited for storing data on flash drives.
+It has a Log-Structured-Merge-Database (LSM) design with flexible tradeoffs
+between Write-Amplification-Factor (WAF), Read-Amplification-Factor (RAF)
+and Space-Amplification-Factor (SAF). It has multi-threaded compactions,
+making it especially suitable for storing multiple terabytes of data in a
+single database.
+
+Start with example usage here: https://github.com/facebook/rocksdb/tree/main/examples
+
+See the [github wiki](https://github.com/facebook/rocksdb/wiki) for more explanation.
+
+The public interface is in `include/`.  Callers should not include or
+rely on the details of any other header files in this package.  Those
+internal APIs may be changed without warning.
+
+Questions and discussions are welcome on the [RocksDB Developers Public](https://www.facebook.com/groups/rocksdb.dev/) Facebook group and [email list](https://groups.google.com/g/rocksdb) on Google Groups.
+
+## License
+
+RocksDB is dual-licensed under both the GPLv2 (found in the COPYING file in the root directory) and Apache 2.0 License (found in the LICENSE.Apache file in the root directory).  You may select, at your option, one of the above-listed licenses.

package/deps/rocksdb/rocksdb/microbench/README.md

@@ -0,0 +1,60 @@
+# RocksDB Micro-Benchmark
+
+## Overview
+
+RocksDB micro-benchmark is a set of tests for benchmarking a single component or simple DB operations. The test artificially generates input data and executes the same operation with it to collect and report performance metrics. As it's focusing on testing a single, well-defined operation, the result is more precise and reproducible, which also has its limitation of not representing a real production use case. The test author needs to carefully design the microbench to represent its true purpose.
+
+The tests are based on [Google Benchmark](https://github.com/google/benchmark) library, which provides a standard framework for writing benchmarks.
+
+## How to Run
+### Prerequisite
+Install the [Google Benchmark](https://github.com/google/benchmark) version `1.6.0` or above.
+
+*Note: Google Benchmark `1.6.x` is incompatible with previous versions like `1.5.x`, please make sure you're using the newer version.*
+
+### Build and Run
+With `Makefile`:
+```bash
+$ DEBUG_LEVEL=0 make run_microbench
+```
+Or with cmake:
+```bash
+$ mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DWITH_BENCHMARK
+$ make run_microbench
+```
+
+*Note: Please run the benchmark code in release build.*
+### Run Single Test
+Example:
+```bash
+$ make db_basic_bench
+$ ./db_basic_bench --benchmark_filter=<TEST_NAME>
+```
+
+## Best Practices
+#### * Use the Same Test Directory Setting as Unittest
+Most of the Micro-benchmark tests use the same test directory setup as unittest, so it could be overridden by:
+```bash
+$ TEST_TMPDIR=/mydata/tmp/ ./db_basic_bench --benchmark_filter=<TEST_NAME>
+```
+Please also follow that when designing new tests.
+
+#### * Avoid Using Debug API
+Even though micro-benchmark is a test, avoid using internal Debug API like TEST_WaitForRun() which is designed for unittest. As benchmark tests are designed for release build, don't use any of that.
+
+#### * Pay Attention to Local Optimization
+As a micro-benchmark is focusing on a single component or area, make sure it is a key part for impacting the overall application performance.
+
+The compiler might be able to optimize the code that not the same way as the whole application, and if the test data input is simple and small, it may be able to all cached in CPU memory, which is leading to a wrong metric. Take these into consideration when designing the tests.
+
+#### * Names of user-defined counters/metrics has to be `[A-Za-z0-9_]`
+It's a restriction of the metrics collecting and reporting system RocksDB is using internally. It will also help integrate with more systems.
+
+#### * Minimize the Metrics Variation
+Try reducing the test result variation, one way to check that is running the test multiple times and check the CV (Coefficient of Variation) reported by gbenchmark.
+```bash
+$ ./db_basic_bench --benchmark_filter=<TEST_NAME> --benchmark_repetitions=10
+...
+<TEST_NAME>_cv    3.2%
+```
+RocksDB has background compaction jobs which may cause the test result to vary a lot. If the micro-benchmark is not purposely testing the operation while compaction is in progress, it should wait for the compaction to finish (`db_impl->WaitForCompact()`) or disable auto-compaction.

package/deps/rocksdb/rocksdb/plugin/README.md

@@ -0,0 +1,43 @@
+## Building external plugins together with RocksDB
+
+RocksDB offers several plugin interfaces for developers to customize its behavior. One difficulty developers face is how to make their plugin available to end users. The approach discussed here involves building the external code together with the RocksDB code into a single binary. Note another approach we plan to support involves loading plugins dynamically from shared libraries.
+
+### Discovery
+
+We hope developers will mention their work in "PLUGINS.md" so users can easily discover and reuse solutions for customizing RocksDB.
+
+### Directory organization
+
+External plugins will be linked according to their name into a subdirectory of "plugin/". For example, a plugin called "dedupfs" would be linked into "plugin/dedupfs/".
+
+### Build standard
+
+Currently the only supported build system are make and cmake.
+
+For make, files in the plugin directory ending in the .mk extension can define the following variables.
+
+* `$(PLUGIN_NAME)_SOURCES`: these files will be compiled and linked with RocksDB. They can access RocksDB public header files.
+* `$(PLUGIN_NAME)_HEADERS`: these files will be installed in the RocksDB header directory. Their paths will be prefixed by "rocksdb/plugin/$(PLUGIN_NAME)/".
+* `$(PLUGIN_NAME)_LDFLAGS`: these flags will be passed to the final link step. For example, library dependencies can be propagated here, or symbols can be forcibly included, e.g., for static registration.
+* `$(PLUGIN_NAME)_CXXFLAGS`: these flags will be passed to the compiler. For example, they can specify locations of header files in non-standard locations.
+
+Users will run the usual make commands from the RocksDB directory, specifying the plugins to include in a space-separated list in the variable `ROCKSDB_PLUGINS`.
+
+For CMake, the CMakeLists.txt file in the plugin directory can define the following variables.
+
+* `${PLUGIN_NAME}_SOURCES`: these files will be compiled and linked with RocksDB. They can access RocksDB public header files.
+* `${PLUGIN_NAME}_COMPILE_FLAGS`: these flags will be passed to the compiler. For example, they can specify locations of header files in non-standard locations.
+* `${PLUGIN_NAME}_INCLUDE_PATHS`: paths to directories to search for plugin-specific header files during compilation.
+* `${PLUGIN_NAME}_LIBS`: list of library names required to build the plugin, e.g. `dl`, `java`, `jvm`, `rados`, etc. CMake will generate proper flags for linking.
+* `${PLUGIN_NAME}_LINK_PATHS`: list of paths for the linker to search for required libraries in additional to standard locations.
+* `${PLUGIN_NAME}_CMAKE_SHARED_LINKER_FLAGS` additional linker flags used to generate shared libraries. For example, symbols can be forcibly included, e.g., for static registration.
+* `${PLUGIN_NAME}_CMAKE_EXE_LINKER_FLAGS`: additional linker flags used to generate executables. For example, symbols can be forcibly included, e.g., for static registration.
+
+Users will run the usual cmake commands, specifying the plugins to include in a space-separated list in the command line variable `ROCKSDB_PLUGINS` when invoking cmake.
+```
+cmake .. -DROCKSDB_PLUGINS="dedupfs hdfs rados"
+```
+
+### Example
+
+For a working example, see [Dedupfs](https://github.com/ajkr/dedupfs).

package/deps/rocksdb/rocksdb/port/README

@@ -0,0 +1,10 @@
+This directory contains interfaces and implementations that isolate the
+rest of the package from platform details.
+
+Code in the rest of the package includes "port.h" from this directory.
+"port.h" in turn includes a platform specific "port_<platform>.h" file
+that provides the platform specific implementation.
+
+See port_posix.h for an example of what must be provided in a platform
+specific header file.
+

package/deps/rocksdb/rocksdb/utilities/transactions/lock/range/range_tree/lib/README

@@ -0,0 +1,13 @@
+The files in this directory originally come from
+https://github.com/percona/PerconaFT/.
+
+This directory only includes the "locktree" part of PerconaFT, and its
+dependencies.
+
+The following modifications were made:
+- Make locktree usable outside of PerconaFT library
+- Add shared read-only lock support
+
+The files named *_subst.* are substitutes of the PerconaFT's files, they
+contain replacements of PerconaFT's functionality.
+

package/deps/rocksdb/rocksdb.gyp

@@ -118,7 +118,7 @@
             "xcode_settings": {
               "OTHER_CPLUSPLUSFLAGS": [
                 "-mmacosx-version-min=10.15",
-                "-std=c++17",
+                "-std=c++20",
                 "-fno-omit-frame-pointer",
                 "-momit-leaf-frame-pointer",
                 "-arch x86_64",