@nxtedition/rocksdb 8.1.17 → 8.2.0-alpha.2

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

@@ -76,6 +76,8 @@ typedef struct rocksdb_backup_engine_options_t rocksdb_backup_engine_options_t;
 typedef struct rocksdb_restore_options_t rocksdb_restore_options_t;
 typedef struct rocksdb_memory_allocator_t rocksdb_memory_allocator_t;
 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_compactionfilter_t rocksdb_compactionfilter_t;
 typedef struct rocksdb_compactionfiltercontext_t
@@ -597,13 +599,14 @@ extern ROCKSDB_LIBRARY_API void rocksdb_release_snapshot(
 extern ROCKSDB_LIBRARY_API char* rocksdb_property_value(rocksdb_t* db,
                                                         const char* propname);
 /* returns 0 on success, -1 otherwise */
-int rocksdb_property_int(rocksdb_t* db, const char* propname,
-                         uint64_t* out_val);
+extern ROCKSDB_LIBRARY_API int rocksdb_property_int(rocksdb_t* db,
+                                                    const char* propname,
+                                                    uint64_t* out_val);
 
 /* returns 0 on success, -1 otherwise */
-int rocksdb_property_int_cf(rocksdb_t* db,
-                            rocksdb_column_family_handle_t* column_family,
-                            const char* propname, uint64_t* out_val);
+extern ROCKSDB_LIBRARY_API int rocksdb_property_int_cf(
+    rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
+    const char* propname, uint64_t* out_val);
 
 extern ROCKSDB_LIBRARY_API char* rocksdb_property_value_cf(
     rocksdb_t* db, rocksdb_column_family_handle_t* column_family,
@@ -662,6 +665,11 @@ extern ROCKSDB_LIBRARY_API void rocksdb_flush_cf(
     rocksdb_t* db, const rocksdb_flushoptions_t* options,
     rocksdb_column_family_handle_t* column_family, char** errptr);
 
+extern ROCKSDB_LIBRARY_API void rocksdb_flush_cfs(
+    rocksdb_t* db, const rocksdb_flushoptions_t* options,
+    rocksdb_column_family_handle_t** column_family, int num_column_families,
+    char** errptr);
+
 extern ROCKSDB_LIBRARY_API void rocksdb_flush_wal(rocksdb_t* db,
                                                   unsigned char sync,
                                                   char** errptr);
@@ -2012,6 +2020,29 @@ rocksdb_cache_get_usage(rocksdb_cache_t* cache);
 extern ROCKSDB_LIBRARY_API size_t
 rocksdb_cache_get_pinned_usage(rocksdb_cache_t* cache);
 
+/* HyperClockCache */
+extern ROCKSDB_LIBRARY_API rocksdb_hyper_clock_cache_options_t*
+rocksdb_hyper_clock_cache_options_create(size_t capacity,
+                                         size_t estimated_entry_charge);
+extern ROCKSDB_LIBRARY_API void rocksdb_hyper_clock_cache_options_destroy(
+    rocksdb_hyper_clock_cache_options_t*);
+extern ROCKSDB_LIBRARY_API void rocksdb_hyper_clock_cache_options_set_capacity(
+    rocksdb_hyper_clock_cache_options_t*, size_t);
+extern ROCKSDB_LIBRARY_API void
+rocksdb_hyper_clock_cache_options_set_estimated_entry_charge(
+    rocksdb_hyper_clock_cache_options_t*, size_t);
+extern ROCKSDB_LIBRARY_API void
+rocksdb_hyper_clock_cache_options_set_num_shard_bits(
+    rocksdb_hyper_clock_cache_options_t*, int);
+extern ROCKSDB_LIBRARY_API void
+rocksdb_hyper_clock_cache_options_set_memory_allocator(
+    rocksdb_hyper_clock_cache_options_t*, rocksdb_memory_allocator_t*);
+
+extern ROCKSDB_LIBRARY_API rocksdb_cache_t* rocksdb_cache_create_hyper_clock(
+    size_t capacity, size_t estimated_entry_charge);
+extern ROCKSDB_LIBRARY_API rocksdb_cache_t*
+rocksdb_cache_create_hyper_clock_opts(rocksdb_hyper_clock_cache_options_t*);
+
 /* DBPath */
 
 extern ROCKSDB_LIBRARY_API rocksdb_dbpath_t* rocksdb_dbpath_create(
@@ -2116,6 +2147,11 @@ rocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
 extern ROCKSDB_LIBRARY_API void
 rocksdb_ingestexternalfileoptions_set_ingest_behind(
     rocksdb_ingestexternalfileoptions_t* opt, unsigned char ingest_behind);
+extern ROCKSDB_LIBRARY_API void
+rocksdb_ingestexternalfileoptions_set_fail_if_not_bottommost_level(
+    rocksdb_ingestexternalfileoptions_t* opt,
+    unsigned char fail_if_not_bottommost_level);
+
 extern ROCKSDB_LIBRARY_API void rocksdb_ingestexternalfileoptions_destroy(
     rocksdb_ingestexternalfileoptions_t* opt);
 
@@ -2198,6 +2234,12 @@ extern ROCKSDB_LIBRARY_API void rocksdb_universal_compaction_options_destroy(
 extern ROCKSDB_LIBRARY_API rocksdb_fifo_compaction_options_t*
 rocksdb_fifo_compaction_options_create(void);
 extern ROCKSDB_LIBRARY_API void
+rocksdb_fifo_compaction_options_set_allow_compaction(
+    rocksdb_fifo_compaction_options_t* fifo_opts, unsigned char allow_compaction);
+extern ROCKSDB_LIBRARY_API unsigned char
+rocksdb_fifo_compaction_options_get_allow_compaction(
+    rocksdb_fifo_compaction_options_t* fifo_opts);
+extern ROCKSDB_LIBRARY_API void
 rocksdb_fifo_compaction_options_set_max_table_files_size(
     rocksdb_fifo_compaction_options_t* fifo_opts, uint64_t size);
 extern ROCKSDB_LIBRARY_API uint64_t
@@ -2622,6 +2664,11 @@ extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cf(
     rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
     rocksdb_column_family_handle_t* column_family, char** errptr);
 
+extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_cfs(
+    rocksdb_transactiondb_t* txn_db, const rocksdb_flushoptions_t* options,
+    rocksdb_column_family_handle_t** column_families, int num_column_families,
+    char** errptr);
+
 extern ROCKSDB_LIBRARY_API void rocksdb_transactiondb_flush_wal(
     rocksdb_transactiondb_t* txn_db, unsigned char sync, char** errptr);
 

package/deps/rocksdb/rocksdb/include/rocksdb/cache.h

@@ -135,6 +135,9 @@ struct ShardedCacheOptions {
   CacheMetadataChargePolicy metadata_charge_policy =
       kDefaultCacheMetadataChargePolicy;
 
+  // A SecondaryCache instance to use the non-volatile tier.
+  std::shared_ptr<SecondaryCache> secondary_cache;
+
   ShardedCacheOptions() {}
   ShardedCacheOptions(
       size_t _capacity, int _num_shard_bits, bool _strict_capacity_limit,
@@ -182,9 +185,6 @@ struct LRUCacheOptions : public ShardedCacheOptions {
   // -DROCKSDB_DEFAULT_TO_ADAPTIVE_MUTEX, false otherwise.
   bool use_adaptive_mutex = kDefaultToAdaptiveMutex;
 
-  // A SecondaryCache instance to use a the non-volatile tier.
-  std::shared_ptr<SecondaryCache> secondary_cache;
-
   LRUCacheOptions() {}
   LRUCacheOptions(size_t _capacity, int _num_shard_bits,
                   bool _strict_capacity_limit, double _high_pri_pool_ratio,

package/deps/rocksdb/rocksdb/include/rocksdb/compaction_filter.h

@@ -27,30 +27,129 @@ class SliceTransform;
 // CompactionFilter allows an application to modify/delete a key-value during
 // table file creation.
 //
-// Exceptions MUST NOT propagate out of overridden functions into RocksDB,
+// Some general notes:
+//
+// * RocksDB snapshots do not guarantee to preserve the state of the DB in the
+// presence of CompactionFilter. Data seen from a snapshot might disappear after
+// a table file created with a `CompactionFilter` is installed. If you use
+// snapshots, think twice about whether you want to use `CompactionFilter` and
+// whether you are using it in a safe way.
+//
+// * If multithreaded compaction is being used *and* a single CompactionFilter
+// instance was supplied via Options::compaction_filter, CompactionFilter
+// methods may be called from different threads concurrently.  The application
+// must ensure that such calls are thread-safe. If the CompactionFilter was
+// created by a factory, then it will only ever be used by a single thread that
+// is doing the table file creation, and this call does not need to be
+// thread-safe.  However, multiple filters may be in existence and operating
+// concurrently.
+//
+// * The key passed to the filtering methods includes the timestamp if
+// user-defined timestamps are enabled.
+//
+// * Exceptions MUST NOT propagate out of overridden functions into RocksDB,
 // because RocksDB is not exception-safe. This could cause undefined behavior
 // including data loss, unreported corruption, deadlocks, and more.
 class CompactionFilter : public Customizable {
  public:
+  // Value type of the key-value passed to the compaction filter's FilterV2/V3
+  // methods.
   enum ValueType {
+    // Plain key-value
     kValue,
+    // Merge operand
     kMergeOperand,
-    kBlobIndex,  // used internally by BlobDB.
+    // Used internally by the old stacked BlobDB implementation; this value type
+    // is never passed to application code. Note that when using the new
+    // integrated BlobDB, values stored separately as blobs are retrieved and
+    // presented to FilterV2/V3 with the type kValue above.
+    kBlobIndex,
+    // Wide-column entity
     kWideColumnEntity,
   };
 
+  // Potential decisions that can be returned by the compaction filter's
+  // FilterV2/V3 and FilterBlobByKey methods. See decision-specific caveats and
+  // constraints below.
   enum class Decision {
+    // Keep the current key-value as-is.
     kKeep,
+
+    // Remove the current key-value. Note that the semantics of removal are
+    // dependent on the value type. If the current key-value is a plain
+    // key-value or a wide-column entity, it is converted to a tombstone
+    // (Delete), resulting in the deletion of any earlier versions of the key.
+    // If it is a merge operand, it is simply dropped. Note: if you are using
+    // a TransactionDB, it is not recommended to filter out merge operands.
+    // If a Merge operation is filtered out, TransactionDB may not realize there
+    // is a write conflict and may allow a Transaction that should have failed
+    // to Commit. Instead, it is better to implement any Merge filtering inside
+    // the MergeOperator.
     kRemove,
+
+    // Change the value of the current key-value. If the current key-value is a
+    // plain key-value or a merge operand, its value is updated but its value
+    // type remains the same. If the current key-value is a wide-column entity,
+    // it is converted to a plain key-value with the new value specified.
     kChangeValue,
+
+    // Remove all key-values with key in [key, *skip_until). This range of keys
+    // will be skipped in a way that potentially avoids some IO operations
+    // compared to removing the keys one by one. Note that removal in this case
+    // means dropping the key-value regardless of value type; in other words, in
+    // contrast with kRemove, plain values and entities are not converted to
+    // tombstones.
+    //
+    // *skip_until <= key is treated the same as Decision::kKeep (since the
+    // range [key, *skip_until) is empty).
+    //
+    // Caveats:
+    // * The keys are skipped even if there are snapshots containing them,
+    //   i.e. values removed by kRemoveAndSkipUntil can disappear from a
+    //   snapshot - beware if you're using TransactionDB or DB::GetSnapshot().
+    // * If value for a key was overwritten or merged into (multiple Put()s
+    //   or Merge()s), and `CompactionFilter` skips this key with
+    //   kRemoveAndSkipUntil, it's possible that it will remove only
+    //   the new value, exposing the old value that was supposed to be
+    //   overwritten.
+    // * Doesn't work with PlainTableFactory in prefix mode.
+    // * If you use kRemoveAndSkipUntil for table files created by compaction,
+    //   consider also reducing compaction_readahead_size option.
     kRemoveAndSkipUntil,
-    kChangeBlobIndex,  // used internally by BlobDB.
-    kIOError,          // used internally by BlobDB.
-    kPurge,            // used for keys that can only be SingleDelete'ed
+
+    // Used internally by the old stacked BlobDB implementation. Returning this
+    // decision from application code is not supported.
+    kChangeBlobIndex,
+
+    // Used internally by the old stacked BlobDB implementation. Returning this
+    // decision from application code is not supported.
+    kIOError,
+
+    // Remove the current key-value by converting it to a SingleDelete-type
+    // tombstone. Only supported for plain-key values and wide-column entities;
+    // not supported for merge operands. All the caveats related to
+    // SingleDeletes apply.
+    kPurge,
+
+    // Change the current key-value to the wide-column entity specified. If the
+    // current key-value is already a wide-column entity, only its columns are
+    // updated; if it is a plain key-value, it is converted to a wide-column
+    // entity with the specified columns. Not supported for merge operands.
+    // Only applicable to FilterV3.
     kChangeWideColumnEntity,
+
+    // When using the integrated BlobDB implementation, it may be possible for
+    // applications to make a filtering decision for a given blob based on
+    // the key only without actually reading the blob value, which saves some
+    // I/O; see the FilterBlobByKey method below. Returning kUndetermined from
+    // FilterBlobByKey signals that making a decision solely based on the
+    // key is not possible; in this case, RocksDB reads the blob value and
+    // passes the key-value to the regular filtering method. Only applicable to
+    // FilterBlobByKey; returning this value from FilterV2/V3 is not supported.
     kUndetermined,
   };
 
+  // Used internally by the old stacked BlobDB implementation.
   enum class BlobDecision { kKeep, kChangeValue, kCorruption, kIOError };
 
   // Context information for a table file creation.
@@ -76,8 +175,8 @@ class CompactionFilter : public Customizable {
   // The table file creation process invokes this method before adding a kv to
   // the table file. A return value of false indicates that the kv should be
   // preserved in the new table file and a return value of true indicates
-  // that this key-value should be removed from the new table file. The
-  // application can inspect the existing value of the key and make decision
+  // that this key-value should be removed (that is, converted to a tombstone).
+  // The application can inspect the existing value of the key and make decision
   // based on it.
   //
   // Key-Values that are results of merge operation during table file creation
@@ -88,23 +187,6 @@ class CompactionFilter : public Customizable {
   // When the value is to be preserved, the application has the option
   // to modify the existing_value and pass it back through new_value.
   // value_changed needs to be set to true in this case.
-  //
-  // Note that RocksDB snapshots (i.e. call GetSnapshot() API on a
-  // DB* object) will not guarantee to preserve the state of the DB with
-  // CompactionFilter. Data seen from a snapshot might disappear after a
-  // table file created with a `CompactionFilter` is installed. If you use
-  // snapshots, think twice about whether you want to use `CompactionFilter` and
-  // whether you are using it in a safe way.
-  //
-  // If multithreaded compaction is being used *and* a single CompactionFilter
-  // instance was supplied via Options::compaction_filter, this method may be
-  // called from different threads concurrently.  The application must ensure
-  // that the call is thread-safe.
-  //
-  // If the CompactionFilter was created by a factory, then it will only ever
-  // be used by a single thread that is doing the table file creation, and this
-  // call does not need to be thread-safe.  However, multiple filters may be
-  // in existence and operating concurrently.
   virtual bool Filter(int /*level*/, const Slice& /*key*/,
                       const Slice& /*existing_value*/,
                       std::string* /*new_value*/,
@@ -126,48 +208,18 @@ class CompactionFilter : public Customizable {
     return false;
   }
 
-  // An extended API. Called for both values and merge operands.
-  // Allows changing value and skipping ranges of keys.
+  // A unified API for plain values and merge operands that may
+  // return a variety of decisions (see Decision above). The `value_type`
+  // parameter indicates the type of the key-value and the `existing_value`
+  // contains the current value or merge operand. The `new_value` output
+  // parameter can be used to set the updated value or merge operand when the
+  // kChangeValue decision is made by the filter. See the description of
+  // kRemoveAndSkipUntil above for the semantics of the `skip_until` output
+  // parameter, and see Decision above for more information on the semantics of
+  // the potential return values.
+  //
   // The default implementation uses Filter() and FilterMergeOperand().
   // If you're overriding this method, no need to override the other two.
-  // `value_type` indicates whether this key-value corresponds to a normal
-  // value (e.g. written with Put())  or a merge operand (written with Merge()).
-  //
-  // Possible return values:
-  //  * kKeep - keep the key-value pair.
-  //  * kRemove - remove the key-value pair or merge operand.
-  //  * kChangeValue - keep the key and change the value/operand to *new_value.
-  //  * kRemoveAndSkipUntil - remove this key-value pair, and also remove
-  //      all key-value pairs with key in [key, *skip_until). This range
-  //      of keys will be skipped without reading, potentially saving some
-  //      IO operations compared to removing the keys one by one.
-  //
-  //      *skip_until <= key is treated the same as Decision::kKeep
-  //      (since the range [key, *skip_until) is empty).
-  //
-  //      Caveats:
-  //       - The keys are skipped even if there are snapshots containing them,
-  //         i.e. values removed by kRemoveAndSkipUntil can disappear from a
-  //         snapshot - beware if you're using TransactionDB or
-  //         DB::GetSnapshot().
-  //       - If value for a key was overwritten or merged into (multiple Put()s
-  //         or Merge()s), and `CompactionFilter` skips this key with
-  //         kRemoveAndSkipUntil, it's possible that it will remove only
-  //         the new value, exposing the old value that was supposed to be
-  //         overwritten.
-  //       - Doesn't work with PlainTableFactory in prefix mode.
-  //       - If you use kRemoveAndSkipUntil for table files created by
-  //         compaction, consider also reducing compaction_readahead_size
-  //         option.
-  //
-  // Should never return kUndetermined.
-  // Note: If you are using a TransactionDB, it is not recommended to filter
-  // out or modify merge operands (ValueType::kMergeOperand).
-  // If a merge operation is filtered out, TransactionDB may not realize there
-  // is a write conflict and may allow a Transaction to Commit that should have
-  // failed. Instead, it is better to implement any Merge filtering inside the
-  // MergeOperator.
-  // key includes timestamp if user-defined timestamp is enabled.
   virtual Decision FilterV2(int level, const Slice& key, ValueType value_type,
                             const Slice& existing_value, std::string* new_value,
                             std::string* /*skip_until*/) const {
@@ -195,17 +247,21 @@ class CompactionFilter : public Customizable {
     }
   }
 
-  // Wide column aware API. Called for plain values, merge operands, and
+  // Wide column aware unified API. Called for plain values, merge operands, and
   // wide-column entities; the `value_type` parameter indicates the type of the
   // key-value. When the key-value is a plain value or a merge operand, the
   // `existing_value` parameter contains the existing value and the
   // `existing_columns` parameter is invalid (nullptr). When the key-value is a
   // wide-column entity, the `existing_columns` parameter contains the wide
   // columns of the existing entity and the `existing_value` parameter is
-  // invalid (nullptr). The output parameters `new_value` and `new_columns` can
-  // be used to change the value or wide columns of the key-value when
-  // `kChangeValue` or `kChangeWideColumnEntity` is returned. See above for more
-  // information on the semantics of the potential return values.
+  // invalid (nullptr). The `new_value` output parameter can be used to set the
+  // updated value or merge operand when the kChangeValue decision is made by
+  // the filter. The `new_columns` output parameter can be used to specify
+  // the pairs of column names and column values when the
+  // kChangeWideColumnEntity decision is returned. See the description of
+  // kRemoveAndSkipUntil above for the semantics of the `skip_until` output
+  // parameter, and see Decision above for more information on the semantics of
+  // the potential return values.
   //
   // For compatibility, the default implementation keeps all wide-column
   // entities, and falls back to FilterV2 for plain values and merge operands.
@@ -255,10 +311,15 @@ class CompactionFilter : public Customizable {
   virtual bool IsStackedBlobDbInternalCompactionFilter() const { return false; }
 
   // In the case of BlobDB, it may be possible to reach a decision with only
-  // the key without reading the actual value. Keys whose value_type is
-  // kBlobIndex will be checked by this method.
-  // Returning kUndetermined will cause FilterV3() to be called to make a
-  // decision as usual.
+  // the key without reading the actual value, saving some I/O operations.
+  // Keys where the value is stored separately in a blob file will be
+  // passed to this method. If the method returns a supported decision other
+  // than kUndetermined, it will be considered final and performed without
+  // reading the existing value. Returning kUndetermined will cause FilterV3()
+  // to be called to make a decision as usual. The output parameters
+  // `new_value` and `skip_until` are applicable to the decisions kChangeValue
+  // and kRemoveAndSkipUntil respectively, and have the same semantics as
+  // the corresponding parameters of FilterV2/V3.
   virtual Decision FilterBlobByKey(int /*level*/, const Slice& /*key*/,
                                    std::string* /*new_value*/,
                                    std::string* /*skip_until*/) const {

package/deps/rocksdb/rocksdb/include/rocksdb/db.h

@@ -301,6 +301,18 @@ class DB {
       std::vector<ColumnFamilyHandle*>* handles, DB** dbptr,
       std::string trim_ts);
 
+  // Manually, synchronously attempt to resume DB writes after a write failure
+  // to the underlying filesystem. See
+  // https://github.com/facebook/rocksdb/wiki/Background-Error-Handling
+  //
+  // Returns OK if writes are successfully resumed, or there was no
+  // outstanding error to recover from. Returns underlying write error if
+  // it is not recoverable.
+  //
+  // WART: Does not mix well with auto-resume. Will return Busy if an
+  // auto-resume is in progress, without waiting for it to complete.
+  // See DBOptions::max_bgerror_resume_count and
+  // EventListener::OnErrorRecoveryBegin
   virtual Status Resume() { return Status::NotSupported(); }
 
   // Close the DB by releasing resources, closing files etc. This should be
@@ -941,6 +953,18 @@ class DB {
     //      level, as well as the histogram of latency of single requests.
     static const std::string kCFFileHistogram;
 
+    // "rocksdb.cf-write-stall-stats" - returns a multi-line string or
+    //      map with statistics on CF-scope write stalls for a given CF
+    // See`WriteStallStatsMapKeys` for structured representation of keys
+    // available in the map form.
+    static const std::string kCFWriteStallStats;
+
+    // "rocksdb.db-write-stall-stats" - returns a multi-line string or
+    //      map with statistics on DB-scope write stalls
+    // See`WriteStallStatsMapKeys` for structured representation of keys
+    // available in the map form.
+    static const std::string kDBWriteStallStats;
+
     //  "rocksdb.dbstats" - As a string property, returns a multi-line string
     //      with general database stats, both cumulative (over the db's
     //      lifetime) and interval (since the last retrieval of kDBStats).
@@ -1717,11 +1741,12 @@ class DB {
       const std::vector<IngestExternalFileArg>& args) = 0;
 
   // CreateColumnFamilyWithImport() will create a new column family with
-  // column_family_name and import external SST files specified in metadata into
-  // this column family.
+  // column_family_name and import external SST files specified in `metadata`
+  // into this column family.
   // (1) External SST files can be created using SstFileWriter.
   // (2) External SST files can be exported from a particular column family in
-  //     an existing DB using Checkpoint::ExportColumnFamily.
+  //     an existing DB using Checkpoint::ExportColumnFamily. `metadata` should
+  //     be the output from Checkpoint::ExportColumnFamily.
   // Option in import_options specifies whether the external files are copied or
   // moved (default is copy). When option specifies copy, managing files at
   // external_file_path is caller's responsibility. When option specifies a
@@ -1860,6 +1885,24 @@ class DB {
   }
 };
 
+struct WriteStallStatsMapKeys {
+  static const std::string& TotalStops();
+  static const std::string& TotalDelays();
+
+  static const std::string& CFL0FileCountLimitDelaysWithOngoingCompaction();
+  static const std::string& CFL0FileCountLimitStopsWithOngoingCompaction();
+
+  // REQUIRES:
+  // `cause` isn't any of these: `WriteStallCause::kNone`,
+  // `WriteStallCause::kCFScopeWriteStallCauseEnumMax`,
+  // `WriteStallCause::kDBScopeWriteStallCauseEnumMax`
+  //
+  // REQUIRES:
+  // `condition` isn't any of these: `WriteStallCondition::kNormal`
+  static std::string CauseConditionCount(WriteStallCause cause,
+                                         WriteStallCondition condition);
+};
+
 // Overloaded operators for enum class SizeApproximationFlags.
 inline DB::SizeApproximationFlags operator&(DB::SizeApproximationFlags lhs,
                                             DB::SizeApproximationFlags rhs) {

package/deps/rocksdb/rocksdb/include/rocksdb/file_system.h

@@ -682,6 +682,10 @@ class FileSystem : public Customizable {
     return IOStatus::OK();
   }
 
+  // Indicates to upper layers whether the FileSystem supports/uses async IO
+  // or not
+  virtual bool use_async_io() { return true; }
+
   // If you're adding methods here, remember to add them to EnvWrapper too.
 
  private:
@@ -1522,6 +1526,8 @@ class FileSystemWrapper : public FileSystem {
     return target_->AbortIO(io_handles);
   }
 
+  virtual bool use_async_io() override { return target_->use_async_io(); }
+
  protected:
   std::shared_ptr<FileSystem> target_;
 };

package/deps/rocksdb/rocksdb/include/rocksdb/listener.h

@@ -194,12 +194,6 @@ enum class BackgroundErrorReason {
   kManifestWriteNoWAL,
 };
 
-enum class WriteStallCondition {
-  kNormal,
-  kDelayed,
-  kStopped,
-};
-
 struct WriteStallInfo {
   // the name of the column family
   std::string cf_name;

package/deps/rocksdb/rocksdb/include/rocksdb/metadata.h

@@ -148,6 +148,13 @@ struct SstFileMetaData : public FileStorageInfo {
   // For L0, larger `epoch_number` indicates newer L0 file.
   // 0 if the information is not available.
   uint64_t epoch_number = 0;
+
+  // These bounds define the effective key range for range tombstones
+  // in this file.
+  // Currently only used by CreateColumnFamilyWithImport().
+  std::string smallest{};  // Smallest internal key served by table
+  std::string largest{};   // Largest internal key served by table
+
   // DEPRECATED: The name of the file within its directory with a
   // leading slash (e.g. "/123456.sst"). Use relative_filename from base struct
   // instead.

package/deps/rocksdb/rocksdb/include/rocksdb/options.h

@@ -1311,12 +1311,12 @@ struct DBOptions {
   // Default: false
   bool best_efforts_recovery = false;
 
-  // It defines how many times db resume is called by a separate thread when
+  // It defines how many times DB::Resume() is called by a separate thread when
   // background retryable IO Error happens. When background retryable IO
   // Error happens, SetBGError is called to deal with the error. If the error
   // can be auto-recovered (e.g., retryable IO Error during Flush or WAL write),
   // then db resume is called in background to recover from the error. If this
-  // value is 0 or negative, db resume will not be called.
+  // value is 0 or negative, DB::Resume() will not be called automatically.
   //
   // Default: INT_MAX
   int max_bgerror_resume_count = INT_MAX;

package/deps/rocksdb/rocksdb/include/rocksdb/perf_context.h

@@ -135,9 +135,14 @@ struct PerfContext {
   // than the snapshot that iterator is using.
   //
   uint64_t internal_recent_skipped_count;
-  // How many values were fed into merge operator by iterators.
+  // How many merge operands were fed into the merge operator by iterators.
+  // Note: base values are not included in the count.
   //
   uint64_t internal_merge_count;
+  // How many merge operands were fed into the merge operator by point lookups.
+  // Note: base values are not included in the count.
+  //
+  uint64_t internal_merge_point_lookup_count;
   // Number of times we reseeked inside a merging iterator, specifically to skip
   // after or before a range of keys covered by a range deletion in a newer LSM
   // component.

package/deps/rocksdb/rocksdb/include/rocksdb/secondary_cache.h

@@ -99,12 +99,12 @@ class SecondaryCache : public Customizable {
   // needs to return true.
   // This hint can also be safely ignored.
   //
-  // is_in_sec_cache is to indicate whether the handle is possibly erased
-  // from the secondary cache after the Lookup.
+  // kept_in_sec_cache is to indicate whether the entry will be kept in the
+  // secondary cache after the Lookup (rather than erased because of Lookup)
   virtual std::unique_ptr<SecondaryCacheResultHandle> Lookup(
       const Slice& key, const Cache::CacheItemHelper* helper,
       Cache::CreateContext* create_context, bool wait, bool advise_erase,
-      bool& is_in_sec_cache) = 0;
+      bool& kept_in_sec_cache) = 0;
 
   // Indicate whether a handle can be erased in this secondary cache.
   [[nodiscard]] virtual bool SupportForceErase() const = 0;

package/deps/rocksdb/rocksdb/include/rocksdb/statistics.h

@@ -415,6 +415,20 @@ enum Tickers : uint32_t {
   // Number of errors returned to the async read callback
   ASYNC_READ_ERROR_COUNT,
 
+  // Fine grained secondary cache stats
+  SECONDARY_CACHE_FILTER_HITS,
+  SECONDARY_CACHE_INDEX_HITS,
+  SECONDARY_CACHE_DATA_HITS,
+
+  // Number of lookup into the prefetched tail (see
+  // `TABLE_OPEN_PREFETCH_TAIL_READ_BYTES`)
+  // that can't find its data for table open
+  TABLE_OPEN_PREFETCH_TAIL_MISS,
+  // Number of lookup into the prefetched tail (see
+  // `TABLE_OPEN_PREFETCH_TAIL_READ_BYTES`)
+  // that finds its data for table open
+  TABLE_OPEN_PREFETCH_TAIL_HIT,
+
   TICKER_ENUM_MAX
 };
 
@@ -528,6 +542,10 @@ enum Histograms : uint32_t {
   // Wait time for aborting async read in FilePrefetchBuffer destructor
   ASYNC_PREFETCH_ABORT_MICROS,
 
+  // Number of bytes read for RocksDB's prefetching contents (as opposed to file
+  // system's prefetch) from the end of SST table during block based table open
+  TABLE_OPEN_PREFETCH_TAIL_READ_BYTES,
+
   HISTOGRAM_ENUM_MAX
 };
 

package/deps/rocksdb/rocksdb/include/rocksdb/types.h

@@ -63,4 +63,32 @@ enum EntryType {
   kEntryOther,
 };
 
+enum class WriteStallCause {
+  // Beginning of CF-scope write stall causes
+  //
+  // Always keep `kMemtableLimit` as the first stat in this section
+  kMemtableLimit,
+  kL0FileCountLimit,
+  kPendingCompactionBytes,
+  kCFScopeWriteStallCauseEnumMax,
+  // End of CF-scope write stall causes
+
+  // Beginning of DB-scope write stall causes
+  //
+  // Always keep `kWriteBufferManagerLimit` as the first stat in this section
+  kWriteBufferManagerLimit,
+  kDBScopeWriteStallCauseEnumMax,
+  // End of DB-scope write stall causes
+
+  // Always add new WriteStallCause before `kNone`
+  kNone,
+};
+
+enum class WriteStallCondition {
+  kDelayed,
+  kStopped,
+  // Always add new WriteStallCondition before `kNormal`
+  kNormal,
+};
+
 }  // namespace ROCKSDB_NAMESPACE