@nxtedition/rocksdb 10.0.13 → 10.0.15

package/deps/rocksdb/rocksdb/include/rocksdb/advanced_options.h

@@ -51,6 +51,8 @@ enum CompactionPri : char {
   // First compact files whose ratio between overlapping size in next level
   // and its size is the smallest. It in many cases can optimize write
   // amplification.
+  // Files marked for compaction will be prioritized over files that are not
+  // marked.
   kMinOverlappingRatio = 0x3,
   // Keeps a cursor(s) of the successor of the file (key range) was/were
   // compacted before, and always picks the next files (key range) in that
@@ -59,151 +61,6 @@ enum CompactionPri : char {
   kRoundRobin = 0x4,
 };
 
-// Compression options for different compression algorithms like Zlib
-struct CompressionOptions {
-  // ==> BEGIN options that can be set by deprecated configuration syntax, <==
-  // ==> e.g. compression_opts=5:6:7:8:9:10:true:11:false                  <==
-  // ==> Please use compression_opts={level=6;strategy=7;} form instead.   <==
-
-  // RocksDB's generic default compression level. Internally it'll be translated
-  // to the default compression level specific to the library being used (see
-  // comment above `ColumnFamilyOptions::compression`).
-  //
-  // The default value is the max 16-bit int as it'll be written out in OPTIONS
-  // file, which should be portable.
-  static constexpr int kDefaultCompressionLevel = 32767;
-
-  // zlib only: windowBits parameter. See https://www.zlib.net/manual.html
-  int window_bits = -14;
-
-  // Compression "level" applicable to zstd, zlib, LZ4, and LZ4HC. Except for
-  // kDefaultCompressionLevel (see above), the meaning of each value depends
-  // on the compression algorithm. Decreasing across non-
-  // `kDefaultCompressionLevel` values will either favor speed over
-  // compression ratio or have no effect.
-  //
-  // In LZ4 specifically, the absolute value of a negative `level` internally
-  // configures the `acceleration` parameter. For example, set `level=-10` for
-  // `acceleration=10`. This negation is necessary to ensure decreasing `level`
-  // values favor speed over compression ratio.
-  int level = kDefaultCompressionLevel;
-
-  // zlib only: strategy parameter. See https://www.zlib.net/manual.html
-  int strategy = 0;
-
-  // Maximum size of dictionaries used to prime the compression library.
-  // Enabling dictionary can improve compression ratios when there are
-  // repetitions across data blocks.
-  //
-  // The dictionary is created by sampling the SST file data. If
-  // `zstd_max_train_bytes` is nonzero, the samples are passed through zstd's
-  // dictionary generator (see comments for option `use_zstd_dict_trainer` for
-  // detail on dictionary generator). If `zstd_max_train_bytes` is zero, the
-  // random samples are used directly as the dictionary.
-  //
-  // When compression dictionary is disabled, we compress and write each block
-  // before buffering data for the next one. When compression dictionary is
-  // enabled, we buffer SST file data in-memory so we can sample it, as data
-  // can only be compressed and written after the dictionary has been finalized.
-  //
-  // The amount of data buffered can be limited by `max_dict_buffer_bytes`. This
-  // buffered memory is charged to the block cache when there is a block cache.
-  // If block cache insertion fails with `Status::MemoryLimit` (i.e., it is
-  // full), we finalize the dictionary with whatever data we have and then stop
-  // buffering.
-  uint32_t max_dict_bytes = 0;
-
-  // Maximum size of training data passed to zstd's dictionary trainer. Using
-  // zstd's dictionary trainer can achieve even better compression ratio
-  // improvements than using `max_dict_bytes` alone.
-  //
-  // The training data will be used to generate a dictionary of max_dict_bytes.
-  uint32_t zstd_max_train_bytes = 0;
-
-  // Number of threads for parallel compression.
-  // Parallel compression is enabled only if threads > 1.
-  // THE FEATURE IS STILL EXPERIMENTAL
-  //
-  // This option is valid only when BlockBasedTable is used.
-  //
-  // When parallel compression is enabled, SST size file sizes might be
-  // more inflated compared to the target size, because more data of unknown
-  // compressed size is in flight when compression is parallelized. To be
-  // reasonably accurate, this inflation is also estimated by using historical
-  // compression ratio and current bytes inflight.
-  uint32_t parallel_threads = 1;
-
-  // When the compression options are set by the user, it will be set to "true".
-  // For bottommost_compression_opts, to enable it, user must set enabled=true.
-  // Otherwise, bottommost compression will use compression_opts as default
-  // compression options.
-  //
-  // For compression_opts, if compression_opts.enabled=false, it is still
-  // used as compression options for compression process.
-  bool enabled = false;
-
-  // Limit on data buffering when gathering samples to build a dictionary. Zero
-  // means no limit. When dictionary is disabled (`max_dict_bytes == 0`),
-  // enabling this limit (`max_dict_buffer_bytes != 0`) has no effect.
-  //
-  // In compaction, the buffering is limited to the target file size (see
-  // `target_file_size_base` and `target_file_size_multiplier`) even if this
-  // setting permits more buffering. Since we cannot determine where the file
-  // should be cut until data blocks are compressed with dictionary, buffering
-  // more than the target file size could lead to selecting samples that belong
-  // to a later output SST.
-  //
-  // Limiting too strictly may harm dictionary effectiveness since it forces
-  // RocksDB to pick samples from the initial portion of the output SST, which
-  // may not be representative of the whole file. Configuring this limit below
-  // `zstd_max_train_bytes` (when enabled) can restrict how many samples we can
-  // pass to the dictionary trainer. Configuring it below `max_dict_bytes` can
-  // restrict the size of the final dictionary.
-  uint64_t max_dict_buffer_bytes = 0;
-
-  // Use zstd trainer to generate dictionaries. When this option is set to true,
-  // zstd_max_train_bytes of training data sampled from max_dict_buffer_bytes
-  // buffered data will be passed to zstd dictionary trainer to generate a
-  // dictionary of size max_dict_bytes.
-  //
-  // When this option is false, zstd's API ZDICT_finalizeDictionary() will be
-  // called to generate dictionaries. zstd_max_train_bytes of training sampled
-  // data will be passed to this API. Using this API should save CPU time on
-  // dictionary training, but the compression ratio may not be as good as using
-  // a dictionary trainer.
-  bool use_zstd_dict_trainer = true;
-
-  // ===> END options that can be set by deprecated configuration syntax <===
-  // ===> Use compression_opts={level=6;strategy=7;} form for below opts <===
-
-  // Essentially specifies a minimum acceptable compression ratio. A block is
-  // stored uncompressed if the compressed block does not achieve this ratio,
-  // because the downstream cost of decompression is not considered worth such
-  // a small savings (if any).
-  // However, the ratio is specified in a way that is efficient for checking.
-  // An integer from 1 to 1024 indicates the maximum allowable compressed bytes
-  // per 1KB of input, so the minimum acceptable ratio is 1024.0 / this value.
-  // For example, for a minimum ratio of 1.5:1, set to 683. See SetMinRatio().
-  // Default: abandon use of compression for a specific block or entry if
-  // compressed by less than 12.5% (minimum ratio of 1.143:1).
-  int max_compressed_bytes_per_kb = 1024 * 7 / 8;
-
-  // ZSTD only.
-  // Enable compression algorithm's checksum feature.
-  // (https://github.com/facebook/zstd/blob/d857369028d997c92ff1f1861a4d7f679a125464/lib/zstd.h#L428)
-  // Each compressed frame will have a 32-bit checksum attached. The checksum
-  // computed from the uncompressed data and can be verified during
-  // decompression.
-  bool checksum = false;
-
-  // A convenience function for setting max_compressed_bytes_per_kb based on a
-  // minimum acceptable compression ratio (uncompressed size over compressed
-  // size).
-  void SetMinRatio(double min_ratio) {
-    max_compressed_bytes_per_kb = static_cast<int>(1024.0 / min_ratio + 0.5);
-  }
-};
-
 // Temperature of a file. Used to pass to FileSystem for a different
 // placement and/or coding.
 // Reserve some numbers in the middle, in case we need to insert new tier
@@ -372,11 +229,18 @@ struct AdvancedColumnFamilyOptions {
   // if it is not explicitly set by the user.  Otherwise, the default is 0.
   int64_t max_write_buffer_size_to_maintain = 0;
 
-  // Allows thread-safe inplace updates. If this is true, there is no way to
+  // Allows thread-safe inplace updates.
+  //
+  // If this is true, there is no way to
   // achieve point-in-time consistency using snapshot or iterator (assuming
   // concurrent updates). Hence iterator and multi-get will return results
   // which are not consistent as of any point-in-time.
+  //
   // Backward iteration on memtables will not work either.
+  //
+  // It is intended to work or be compatible with a limited set of features:
+  // (1) Non-snapshot Get()
+  //
   // If inplace_callback function is not set,
   //   Put(key, new_value) will update inplace the existing_value iff
   //   * key exists in current memtable
@@ -690,15 +554,6 @@ struct AdvancedColumnFamilyOptions {
   // Default: true
   bool level_compaction_dynamic_level_bytes = true;
 
-  // Allows RocksDB to generate files that are not exactly the target_file_size
-  // only for the non-bottommost files. Which can reduce the write-amplification
-  // from compaction. The file size could be from 0 to 2x target_file_size.
-  // Once enabled, non-bottommost compaction will try to cut the files align
-  // with the next level file boundaries (grandparent level).
-  //
-  // Default: true
-  bool level_compaction_dynamic_file_size = true;
-
   // Default: 10.
   //
   // Dynamically changeable through SetOptions() API
@@ -714,7 +569,7 @@ struct AdvancedColumnFamilyOptions {
   //
   // Dynamically changeable through SetOptions() API
   std::vector<int> max_bytes_for_level_multiplier_additional =
-      std::vector<int>(num_levels, 1);
+      std::vector<int>(static_cast<size_t>(num_levels), 1);
 
   // We try to limit number of bytes in one compaction to be lower than this
   // threshold. But it's not guaranteed.
@@ -725,17 +580,6 @@ struct AdvancedColumnFamilyOptions {
   // Dynamically changeable through SetOptions() API
   uint64_t max_compaction_bytes = 0;
 
-  // When setting up compaction input files, we ignore the
-  // `max_compaction_bytes` limit when pulling in input files that are entirely
-  // within output key range.
-  //
-  // Default: true
-  //
-  // Dynamically changeable through SetOptions() API
-  // We could remove this knob and always ignore the limit once it is proven
-  // safe.
-  bool ignore_max_compaction_bytes_for_input = true;
-
   // All writes will be slowed down to at least delayed_write_rate if estimated
   // bytes needed to be compaction exceed this threshold.
   //
@@ -812,18 +656,29 @@ struct AdvancedColumnFamilyOptions {
   TablePropertiesCollectorFactories table_properties_collector_factories;
 
   // Maximum number of successive merge operations on a key in the memtable.
+  // It may be violated when filesystem reads would be needed to stay under the
+  // limit, unless `strict_max_successive_merges` is explicitly set.
   //
   // When a merge operation is added to the memtable and the maximum number of
-  // successive merges is reached, the value of the key will be calculated and
-  // inserted into the memtable instead of the merge operation. This will
-  // ensure that there are never more than max_successive_merges merge
-  // operations in the memtable.
+  // successive merges is reached, RocksDB will attempt to read the value. Upon
+  // success, the value will be inserted into the memtable instead of the merge
+  // operation.
   //
   // Default: 0 (disabled)
   //
   // Dynamically changeable through SetOptions() API
   size_t max_successive_merges = 0;
 
+  // Whether to allow filesystem reads to stay under the `max_successive_merges`
+  // limit. When true, this can lead to merge writes blocking the write path
+  // waiting on filesystem reads.
+  //
+  // This option is temporary in case the recent change to disallow filesystem
+  // reads during merge writes has a problem and users need to undo it quickly.
+  //
+  // Default: false
+  bool strict_max_successive_merges = false;
+
   // This flag specifies that the implementation should optimize the filters
   // mainly for cases where keys are found rather than also optimize for keys
   // missed. This would be used in cases where the application knows that
@@ -840,14 +695,6 @@ struct AdvancedColumnFamilyOptions {
   // Default: false
   bool optimize_filters_for_hits = false;
 
-  // During flush or compaction, check whether keys inserted to output files
-  // are in order.
-  //
-  // Default: true
-  //
-  // Dynamically changeable through SetOptions() API
-  bool check_flush_compaction_key_order = true;
-
   // After writing every SST file, reopen it and read all the keys.
   // Checks the hash of all of the keys and values written versus the
   // keys in the file and signals a corruption if they do not match
@@ -912,7 +759,9 @@ struct AdvancedColumnFamilyOptions {
   //
   // Leveled: files older than `periodic_compaction_seconds` will be picked up
   //    for compaction and will be re-written to the same level as they were
-  //    before.
+  //    before if level_compaction_dynamic_level_bytes is disabled. Otherwise,
+  //    it will rewrite files to the next level except for the last level files
+  //    to the same level.
   //
   // FIFO: not supported. Setting this option has no effect for FIFO compaction.
   //
@@ -961,27 +810,28 @@ struct AdvancedColumnFamilyOptions {
   uint64_t sample_for_compression = 0;
 
   // EXPERIMENTAL
-  // The feature is still in development and is incomplete.
   // If this option is set, when creating the last level files, pass this
   // temperature to FileSystem used. Should be no-op for default FileSystem
   // and users need to plug in their own FileSystem to take advantage of it.
-  //
-  // Note: the feature is changed from `bottommost_temperature` to
-  //  `last_level_temperature` which now only apply for the last level files.
-  //  The option name `bottommost_temperature` is kept only for migration, the
-  //  behavior is the same as `last_level_temperature`. Please stop using
-  //  `bottommost_temperature` and will be removed in next release.
+  // When using FIFO compaction, this option is ignored.
   //
   // Dynamically changeable through the SetOptions() API
-  Temperature bottommost_temperature = Temperature::kUnknown;
   Temperature last_level_temperature = Temperature::kUnknown;
 
+  // EXPERIMENTAL
+  // When no other option such as last_level_temperature determines the
+  // temperature of a new SST file, it will be written with this temperature,
+  // which can be set differently for each column family.
+  //
+  // Dynamically changeable through the SetOptions() API
+  Temperature default_write_temperature = Temperature::kUnknown;
+
   // EXPERIMENTAL
   // When this field is set, all SST files without an explicitly set temperature
   // will be treated as if they have this temperature for file reading
   // accounting purpose, such as io statistics, io perf context.
   //
-  // Not dynamically changeable, change it requires db restart.
+  // Not dynamically changeable; change requires DB restart.
   Temperature default_temperature = Temperature::kUnknown;
 
   // EXPERIMENTAL

package/deps/rocksdb/rocksdb/include/rocksdb/attribute_groups.h

@@ -0,0 +1,114 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//  This source code is 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).
+
+#pragma once
+
+#include "rocksdb/iterator_base.h"
+#include "rocksdb/wide_columns.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class ColumnFamilyHandle;
+
+// Class representing attribute group. Attribute group is a logical grouping of
+// wide-column entities by leveraging Column Families.
+// Used in Write Path
+class AttributeGroup {
+ public:
+  explicit AttributeGroup(ColumnFamilyHandle* column_family,
+                          const WideColumns& columns)
+      : column_family_(column_family), columns_(columns) {}
+
+  ColumnFamilyHandle* column_family() const { return column_family_; }
+  const WideColumns& columns() const { return columns_; }
+  WideColumns& columns() { return columns_; }
+
+ private:
+  ColumnFamilyHandle* column_family_;
+  WideColumns columns_;
+};
+
+inline bool operator==(const AttributeGroup& lhs, const AttributeGroup& rhs) {
+  return lhs.column_family() == rhs.column_family() &&
+         lhs.columns() == rhs.columns();
+}
+
+// A collection of Attribute Groups.
+using AttributeGroups = std::vector<AttributeGroup>;
+
+// An empty set of Attribute Groups.
+extern const AttributeGroups kNoAttributeGroups;
+
+// Used in Read Path. Wide-columns returned from the query are pinnable.
+class PinnableAttributeGroup {
+ public:
+  explicit PinnableAttributeGroup(ColumnFamilyHandle* column_family)
+      : column_family_(column_family), status_(Status::OK()) {}
+
+  ColumnFamilyHandle* column_family() const { return column_family_; }
+  const Status& status() const { return status_; }
+  const WideColumns& columns() const { return columns_.columns(); }
+
+  void SetStatus(const Status& status);
+  void SetColumns(PinnableWideColumns&& columns);
+
+  void Reset();
+
+ private:
+  ColumnFamilyHandle* column_family_;
+  Status status_;
+  PinnableWideColumns columns_;
+};
+
+inline void PinnableAttributeGroup::SetStatus(const Status& status) {
+  status_ = status;
+}
+inline void PinnableAttributeGroup::SetColumns(PinnableWideColumns&& columns) {
+  columns_ = std::move(columns);
+}
+
+inline void PinnableAttributeGroup::Reset() {
+  SetStatus(Status::OK());
+  columns_.Reset();
+}
+
+// A collection of Pinnable Attribute Groups.
+using PinnableAttributeGroups = std::vector<PinnableAttributeGroup>;
+
+// Used in Iterator Path. Uses pointers to the columns to avoid having to copy
+// all WideColumns objs during iteration.
+class IteratorAttributeGroup {
+ public:
+  explicit IteratorAttributeGroup(ColumnFamilyHandle* column_family,
+                                  const WideColumns* columns)
+      : column_family_(column_family), columns_(columns) {}
+  ColumnFamilyHandle* column_family() const { return column_family_; }
+  const WideColumns& columns() const { return *columns_; }
+
+ private:
+  ColumnFamilyHandle* column_family_;
+  const WideColumns* columns_;
+};
+
+using IteratorAttributeGroups = std::vector<IteratorAttributeGroup>;
+
+extern const IteratorAttributeGroups kNoIteratorAttributeGroups;
+
+// EXPERIMENTAL
+// A cross-column-family iterator that collects and returns attribute groups for
+// each key in order provided by comparator
+class AttributeGroupIterator : public IteratorBase {
+ public:
+  AttributeGroupIterator() {}
+  ~AttributeGroupIterator() override {}
+
+  // No copy allowed
+  AttributeGroupIterator(const AttributeGroupIterator&) = delete;
+  AttributeGroupIterator& operator=(const AttributeGroupIterator&) = delete;
+
+  virtual const IteratorAttributeGroups& attribute_groups() const = 0;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/include/rocksdb/c.h

@@ -78,6 +78,7 @@ typedef struct rocksdb_lru_cache_options_t rocksdb_lru_cache_options_t;
 typedef struct rocksdb_hyper_clock_cache_options_t
     rocksdb_hyper_clock_cache_options_t;
 typedef struct rocksdb_cache_t rocksdb_cache_t;
+typedef struct rocksdb_write_buffer_manager_t rocksdb_write_buffer_manager_t;
 typedef struct rocksdb_compactionfilter_t rocksdb_compactionfilter_t;
 typedef struct rocksdb_compactionfiltercontext_t
     rocksdb_compactionfiltercontext_t;
@@ -607,6 +608,9 @@ extern ROCKSDB_LIBRARY_API const rocksdb_snapshot_t* rocksdb_create_snapshot(
 extern ROCKSDB_LIBRARY_API void rocksdb_release_snapshot(
     rocksdb_t* db, const rocksdb_snapshot_t* snapshot);
 
+extern ROCKSDB_LIBRARY_API uint64_t
+rocksdb_snapshot_get_sequence_number(const rocksdb_snapshot_t* snapshot);
+
 /* Returns NULL if property name is unknown.
    Else returns a pointer to a malloc()-ed null-terminated value. */
 extern ROCKSDB_LIBRARY_API char* rocksdb_property_value(rocksdb_t* db,
@@ -690,8 +694,8 @@ extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db,
 extern ROCKSDB_LIBRARY_API void rocksdb_disable_file_deletions(rocksdb_t* db,
                                                                char** errptr);
 
-extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(
-    rocksdb_t* db, unsigned char force, char** errptr);
+extern ROCKSDB_LIBRARY_API void rocksdb_enable_file_deletions(rocksdb_t* db,
+                                                              char** errptr);
 
 /* Management operations */
 
@@ -1060,6 +1064,23 @@ rocksdb_block_based_options_set_pin_top_level_index_and_filter(
     rocksdb_block_based_table_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_block_based_table_factory(
     rocksdb_options_t* opt, rocksdb_block_based_table_options_t* table_options);
+enum {
+  rocksdb_block_based_k_fallback_pinning_tier = 0,
+  rocksdb_block_based_k_none_pinning_tier = 1,
+  rocksdb_block_based_k_flush_and_similar_pinning_tier = 2,
+  rocksdb_block_based_k_all_pinning_tier = 3,
+};
+extern ROCKSDB_LIBRARY_API void
+rocksdb_block_based_options_set_top_level_index_pinning_tier(
+    rocksdb_block_based_table_options_t*, int);
+extern ROCKSDB_LIBRARY_API void
+rocksdb_block_based_options_set_partition_pinning_tier(
+    rocksdb_block_based_table_options_t*, int);
+extern ROCKSDB_LIBRARY_API void
+rocksdb_block_based_options_set_unpartitioned_pinning_tier(
+    rocksdb_block_based_table_options_t*, int);
+extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_buffer_manager(
+    rocksdb_options_t* opt, rocksdb_write_buffer_manager_t* wbm);
 
 /* Cuckoo table options */
 
@@ -1143,14 +1164,22 @@ extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_paranoid_checks(
     rocksdb_options_t*);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_db_paths(
     rocksdb_options_t*, const rocksdb_dbpath_t** path_values, size_t num_paths);
+extern ROCKSDB_LIBRARY_API void rocksdb_options_set_cf_paths(
+    rocksdb_options_t*, const rocksdb_dbpath_t** path_values, size_t num_paths);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_env(rocksdb_options_t*,
                                                         rocksdb_env_t*);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_info_log(rocksdb_options_t*,
                                                              rocksdb_logger_t*);
+extern ROCKSDB_LIBRARY_API rocksdb_logger_t* rocksdb_options_get_info_log(
+    rocksdb_options_t* opt);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_info_log_level(
     rocksdb_options_t*, int);
 extern ROCKSDB_LIBRARY_API int rocksdb_options_get_info_log_level(
     rocksdb_options_t*);
+extern ROCKSDB_LIBRARY_API rocksdb_logger_t*
+rocksdb_logger_create_stderr_logger(int log_level, const char* prefix);
+extern ROCKSDB_LIBRARY_API void rocksdb_logger_destroy(
+    rocksdb_logger_t* logger);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_write_buffer_size(
     rocksdb_options_t*, size_t);
 extern ROCKSDB_LIBRARY_API size_t
@@ -1256,6 +1285,13 @@ rocksdb_options_set_max_bytes_for_level_multiplier_additional(
     rocksdb_options_t*, int* level_values, size_t num_levels);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_enable_statistics(
     rocksdb_options_t*);
+extern ROCKSDB_LIBRARY_API void rocksdb_options_set_ttl(rocksdb_options_t*,
+                                                        uint64_t);
+extern ROCKSDB_LIBRARY_API uint64_t rocksdb_options_get_ttl(rocksdb_options_t*);
+extern ROCKSDB_LIBRARY_API void rocksdb_options_set_periodic_compaction_seconds(
+    rocksdb_options_t*, uint64_t);
+extern ROCKSDB_LIBRARY_API uint64_t
+rocksdb_options_get_periodic_compaction_seconds(rocksdb_options_t*);
 
 enum {
   rocksdb_statistics_level_disable_all = 0,
@@ -1487,10 +1523,6 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_advise_random_on_open(
     rocksdb_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API unsigned char
 rocksdb_options_get_advise_random_on_open(rocksdb_options_t*);
-extern ROCKSDB_LIBRARY_API void
-rocksdb_options_set_access_hint_on_compaction_start(rocksdb_options_t*, int);
-extern ROCKSDB_LIBRARY_API int
-rocksdb_options_get_access_hint_on_compaction_start(rocksdb_options_t*);
 extern ROCKSDB_LIBRARY_API void rocksdb_options_set_use_adaptive_mutex(
     rocksdb_options_t*, unsigned char);
 extern ROCKSDB_LIBRARY_API unsigned char rocksdb_options_get_use_adaptive_mutex(
@@ -1665,9 +1697,29 @@ extern ROCKSDB_LIBRARY_API void rocksdb_options_set_wal_compression(
 extern ROCKSDB_LIBRARY_API int rocksdb_options_get_wal_compression(
     rocksdb_options_t* opt);
 
+enum {
+  rocksdb_k_by_compensated_size_compaction_pri = 0,
+  rocksdb_k_oldest_largest_seq_first_compaction_pri = 1,
+  rocksdb_k_oldest_smallest_seq_first_compaction_pri = 2,
+  rocksdb_k_min_overlapping_ratio_compaction_pri = 3,
+  rocksdb_k_round_robin_compaction_pri = 4
+};
+extern ROCKSDB_LIBRARY_API void rocksdb_options_set_compaction_pri(
+    rocksdb_options_t*, int);
+extern ROCKSDB_LIBRARY_API int rocksdb_options_get_compaction_pri(
+    rocksdb_options_t*);
+
 /* RateLimiter */
 extern ROCKSDB_LIBRARY_API rocksdb_ratelimiter_t* rocksdb_ratelimiter_create(
     int64_t rate_bytes_per_sec, int64_t refill_period_us, int32_t fairness);
+extern ROCKSDB_LIBRARY_API rocksdb_ratelimiter_t*
+rocksdb_ratelimiter_create_auto_tuned(int64_t rate_bytes_per_sec,
+                                      int64_t refill_period_us,
+                                      int32_t fairness);
+extern ROCKSDB_LIBRARY_API rocksdb_ratelimiter_t*
+rocksdb_ratelimiter_create_with_mode(int64_t rate_bytes_per_sec,
+                                     int64_t refill_period_us, int32_t fairness,
+                                     int mode, bool auto_tuned);
 extern ROCKSDB_LIBRARY_API void rocksdb_ratelimiter_destroy(
     rocksdb_ratelimiter_t*);
 
@@ -2067,6 +2119,36 @@ rocksdb_cache_get_table_address_count(const rocksdb_cache_t* cache);
 extern ROCKSDB_LIBRARY_API size_t
 rocksdb_cache_get_occupancy_count(const rocksdb_cache_t* cache);
 
+/* WriteBufferManager */
+
+extern ROCKSDB_LIBRARY_API rocksdb_write_buffer_manager_t*
+rocksdb_write_buffer_manager_create(size_t buffer_size, bool allow_stall);
+extern ROCKSDB_LIBRARY_API rocksdb_write_buffer_manager_t*
+rocksdb_write_buffer_manager_create_with_cache(size_t buffer_size,
+                                               const rocksdb_cache_t* cache,
+                                               bool allow_stall);
+
+extern ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_destroy(
+    rocksdb_write_buffer_manager_t* wbm);
+extern ROCKSDB_LIBRARY_API bool rocksdb_write_buffer_manager_enabled(
+    rocksdb_write_buffer_manager_t* wbm);
+extern ROCKSDB_LIBRARY_API bool rocksdb_write_buffer_manager_cost_to_cache(
+    rocksdb_write_buffer_manager_t* wbm);
+extern ROCKSDB_LIBRARY_API size_t
+rocksdb_write_buffer_manager_memory_usage(rocksdb_write_buffer_manager_t* wbm);
+extern ROCKSDB_LIBRARY_API size_t
+rocksdb_write_buffer_manager_mutable_memtable_memory_usage(
+    rocksdb_write_buffer_manager_t* wbm);
+extern ROCKSDB_LIBRARY_API size_t
+rocksdb_write_buffer_manager_dummy_entries_in_cache_usage(
+    rocksdb_write_buffer_manager_t* wbm);
+extern ROCKSDB_LIBRARY_API size_t
+rocksdb_write_buffer_manager_buffer_size(rocksdb_write_buffer_manager_t* wbm);
+extern ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_set_buffer_size(
+    rocksdb_write_buffer_manager_t* wbm, size_t new_size);
+extern ROCKSDB_LIBRARY_API void rocksdb_write_buffer_manager_set_allow_stall(
+    rocksdb_write_buffer_manager_t* wbm, bool new_allow_stall);
+
 /* HyperClockCache */
 
 extern ROCKSDB_LIBRARY_API rocksdb_hyper_clock_cache_options_t*
@@ -2427,6 +2509,9 @@ extern ROCKSDB_LIBRARY_API char*
 rocksdb_sst_file_metadata_get_relative_filename(
     rocksdb_sst_file_metadata_t* file_meta);
 
+extern ROCKSDB_LIBRARY_API char* rocksdb_sst_file_metadata_get_directory(
+    rocksdb_sst_file_metadata_t* file_meta);
+
 extern ROCKSDB_LIBRARY_API uint64_t
 rocksdb_sst_file_metadata_get_size(rocksdb_sst_file_metadata_t* file_meta);