@nxtedition/rocksdb 8.1.4 → 8.1.5

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

@@ -986,6 +986,10 @@ rocksdb_block_based_options_set_partition_filters(
     rocksdb_block_based_table_options_t* options,
     unsigned char partition_filters);
 extern ROCKSDB_LIBRARY_API void
+rocksdb_block_based_options_set_optimize_filters_for_memory(
+    rocksdb_block_based_table_options_t* options,
+    unsigned char optimize_filters_for_memory);
+extern ROCKSDB_LIBRARY_API void
 rocksdb_block_based_options_set_use_delta_encoding(
     rocksdb_block_based_table_options_t* options,
     unsigned char use_delta_encoding);
@@ -1890,6 +1894,10 @@ extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_io_timeout(
     rocksdb_readoptions_t*, uint64_t microseconds);
 extern ROCKSDB_LIBRARY_API uint64_t
 rocksdb_readoptions_get_io_timeout(rocksdb_readoptions_t*);
+extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_async_io(
+    rocksdb_readoptions_t*, unsigned char);
+extern ROCKSDB_LIBRARY_API unsigned char rocksdb_readoptions_get_async_io(
+    rocksdb_readoptions_t*);
 extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_timestamp(
     rocksdb_readoptions_t*, const char* ts, size_t tslen);
 extern ROCKSDB_LIBRARY_API void rocksdb_readoptions_set_iter_start_ts(

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

@@ -7,18 +7,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 //
-// A Cache is an interface that maps keys to values.  It has internal
-// synchronization and may be safely accessed concurrently from
-// multiple threads.  It may automatically evict entries to make room
-// for new entries.  Values have a specified charge against the cache
-// capacity.  For example, a cache where the values are variable
-// length strings, may use the length of the string as the charge for
-// the string.
-//
-// A builtin cache implementation with a least-recently-used eviction
-// policy is provided.  Clients may use their own implementations if
-// they want something more sophisticated (like scan-resistance, a
-// custom eviction policy, variable cache sizing, etc.)
+// Various APIs for creating and customizing read caches in RocksDB.
 
 #pragma once
 
@@ -363,11 +352,33 @@ extern std::shared_ptr<Cache> NewClockCache(
     CacheMetadataChargePolicy metadata_charge_policy =
         kDefaultCacheMetadataChargePolicy);
 
+// A Cache maps keys to objects resident in memory, tracks reference counts
+// on those key-object entries, and is able to remove unreferenced entries
+// whenever it wants. All operations are fully thread safe except as noted.
+// Inserted entries have a specified "charge" which is some quantity in
+// unspecified units, typically bytes of memory used. A Cache will typically
+// have a finite capacity in units of charge, and evict entries as needed
+// to stay at or below that capacity.
+//
+// NOTE: This API is for expert use only and is more intended for providing
+// custom implementations than for calling into. It is subject to change
+// as RocksDB evolves, especially the RocksDB block cache.
+//
+// INTERNAL: See typed_cache.h for convenient wrappers on top of this API.
 class Cache {
- public:  // opaque types
+ public:  // types hidden from API client
   // Opaque handle to an entry stored in the cache.
   struct Handle {};
 
+ public:  // types hidden from Cache implementation
+  // Pointer to cached object of unspecified type. (This type alias is
+  // provided for clarity, not really for type checking.)
+  using ObjectPtr = void*;
+
+  // Opaque object providing context (settings, etc.) to create objects
+  // for primary cache from saved (serialized) secondary cache entries.
+  struct CreateContext {};
+
  public:  // type defs
   // Depending on implementation, cache entries with higher priority levels
   // could be less likely to get evicted than entries with lower priority
@@ -400,48 +411,84 @@ class Cache {
   // so anything required for these operations should be contained in the
   // object itself.
   //
-  // The SizeCallback takes a void* pointer to the object and returns the size
+  // The SizeCallback takes a pointer to the object and returns the size
   // of the persistable data. It can be used by the secondary cache to allocate
   // memory if needed.
   //
   // RocksDB callbacks are NOT exception-safe. A callback completing with an
   // exception can lead to undefined behavior in RocksDB, including data loss,
   // unreported corruption, deadlocks, and more.
-  using SizeCallback = size_t (*)(void* obj);
+  using SizeCallback = size_t (*)(ObjectPtr obj);
 
-  // The SaveToCallback takes a void* object pointer and saves the persistable
+  // The SaveToCallback takes an object pointer and saves the persistable
   // data into a buffer. The secondary cache may decide to not store it in a
   // contiguous buffer, in which case this callback will be called multiple
   // times with increasing offset
-  using SaveToCallback = Status (*)(void* from_obj, size_t from_offset,
-                                    size_t length, void* out);
-
-  // A function pointer type for custom destruction of an entry's
-  // value. The Cache is responsible for copying and reclaiming space
-  // for the key, but values are managed by the caller.
-  using DeleterFn = void (*)(const Slice& key, void* value);
+  using SaveToCallback = Status (*)(ObjectPtr from_obj, size_t from_offset,
+                                    size_t length, char* out_buf);
+
+  // A function pointer type for destruction of a cache object. This will
+  // typically call the destructor for the appropriate type of the object.
+  // The Cache is responsible for copying and reclaiming space for the key,
+  // but objects are managed in part using this callback. Generally a DeleterFn
+  // can be nullptr if the ObjectPtr does not need destruction (e.g. nullptr or
+  // pointer into static data).
+  using DeleterFn = void (*)(ObjectPtr obj, MemoryAllocator* allocator);
+
+  // The CreateCallback is takes in a buffer from the NVM cache and constructs
+  // an object using it. The callback doesn't have ownership of the buffer and
+  // should copy the contents into its own buffer. The CreateContext* is
+  // provided by Lookup and may be used to follow DB- or CF-specific settings.
+  // In case of some error, non-OK is returned and the caller should ignore
+  // any result in out_obj. (The implementation must clean up after itself.)
+  using CreateCallback = Status (*)(const Slice& data, CreateContext* context,
+                                    MemoryAllocator* allocator,
+                                    ObjectPtr* out_obj, size_t* out_charge);
 
   // A struct with pointers to helper functions for spilling items from the
   // cache into the secondary cache. May be extended in the future. An
   // instance of this struct is expected to outlive the cache.
   struct CacheItemHelper {
+    // Function for deleting an object on its removal from the Cache.
+    // nullptr is only for entries that require no destruction, such as
+    // "placeholder" cache entries with nullptr object.
+    DeleterFn del_cb;  // (<- Most performance critical)
+    // Next three are used for persisting values as described above.
+    // If any is nullptr, then all three should be nullptr and persisting the
+    // entry to/from secondary cache is not supported.
     SizeCallback size_cb;
     SaveToCallback saveto_cb;
-    DeleterFn del_cb;
-
-    CacheItemHelper() : size_cb(nullptr), saveto_cb(nullptr), del_cb(nullptr) {}
-    CacheItemHelper(SizeCallback _size_cb, SaveToCallback _saveto_cb,
-                    DeleterFn _del_cb)
-        : size_cb(_size_cb), saveto_cb(_saveto_cb), del_cb(_del_cb) {}
+    CreateCallback create_cb;
+    // Classification of the entry for monitoring purposes in block cache.
+    CacheEntryRole role;
+
+    constexpr CacheItemHelper()
+        : del_cb(nullptr),
+          size_cb(nullptr),
+          saveto_cb(nullptr),
+          create_cb(nullptr),
+          role(CacheEntryRole::kMisc) {}
+
+    explicit constexpr CacheItemHelper(CacheEntryRole _role,
+                                       DeleterFn _del_cb = nullptr,
+                                       SizeCallback _size_cb = nullptr,
+                                       SaveToCallback _saveto_cb = nullptr,
+                                       CreateCallback _create_cb = nullptr)
+        : del_cb(_del_cb),
+          size_cb(_size_cb),
+          saveto_cb(_saveto_cb),
+          create_cb(_create_cb),
+          role(_role) {
+      // Either all three secondary cache callbacks are non-nullptr or
+      // all three are nullptr
+      assert((size_cb != nullptr) == (saveto_cb != nullptr));
+      assert((size_cb != nullptr) == (create_cb != nullptr));
+    }
+    inline bool IsSecondaryCacheCompatible() const {
+      return size_cb != nullptr;
+    }
   };
 
-  // The CreateCallback is passed by the block cache user to Lookup(). It
-  // takes in a buffer from the NVM cache and constructs an object using
-  // it. The callback doesn't have ownership of the buffer and should
-  // copy the contents into its own buffer.
-  using CreateCallback = std::function<Status(const void* buf, size_t size,
-                                              void** out_obj, size_t* charge)>;
-
  public:  // ctor/dtor/create
   Cache(std::shared_ptr<MemoryAllocator> allocator = nullptr)
       : memory_allocator_(std::move(allocator)) {}
@@ -471,8 +518,6 @@ class Cache {
   // The type of the Cache
   virtual const char* Name() const = 0;
 
-  // EXPERIMENTAL SecondaryCache support:
-  // Some APIs here are experimental and might change in the future.
   // The Insert and Lookup APIs below are intended to allow cached objects
   // to be demoted/promoted between the primary block cache and a secondary
   // cache. The secondary cache could be a non-volatile cache, and will
@@ -484,46 +529,27 @@ class Cache {
   // multiple DBs share the same cache and the set of DBs can change
   // over time.
 
-  // Insert a mapping from key->value into the volatile cache only
-  // and assign it with the specified charge against the total cache capacity.
-  // If strict_capacity_limit is true and cache reaches its full capacity,
-  // return Status::MemoryLimit.
-  //
-  // If handle is not nullptr, returns a handle that corresponds to the
-  // mapping. The caller must call this->Release(handle) when the returned
-  // mapping is no longer needed. In case of error caller is responsible to
-  // cleanup the value (i.e. calling "deleter").
-  //
-  // If handle is nullptr, it is as if Release is called immediately after
-  // insert. In case of error value will be cleanup.
-  //
-  // When the inserted entry is no longer needed, the key and
-  // value will be passed to "deleter" which must delete the value.
-  // (The Cache is responsible for copying and reclaiming space for
-  // the key.)
-  virtual Status Insert(const Slice& key, void* value, size_t charge,
-                        DeleterFn deleter, Handle** handle = nullptr,
-                        Priority priority = Priority::LOW) = 0;
-
-  // EXPERIMENTAL
-  // Insert a mapping from key->value into the cache and assign it
+  // Insert a mapping from key->object into the cache and assign it
   // the specified charge against the total cache capacity. If
   // strict_capacity_limit is true and cache reaches its full capacity,
-  // return Status::MemoryLimit. `value` must be non-nullptr for this
-  // Insert() because Value() == nullptr is reserved for indicating failure
-  // with secondary-cache-compatible mappings.
+  // return Status::MemoryLimit. `obj` must be non-nullptr if compatible
+  // with secondary cache (helper->size_cb != nullptr), because Value() ==
+  // nullptr is reserved for indicating some secondary cache failure cases.
+  // On success, returns OK and takes ownership of `obj`, eventually deleting
+  // it with helper->del_cb. On non-OK return, the caller maintains ownership
+  // of `obj` so will often need to delete it in such cases.
   //
   // The helper argument is saved by the cache and will be used when the
-  // inserted object is evicted or promoted to the secondary cache. It,
-  // therefore, must outlive the cache.
-  //
-  // If handle is not nullptr, returns a handle that corresponds to the
-  // mapping. The caller must call this->Release(handle) when the returned
-  // mapping is no longer needed. In case of error caller is responsible to
-  // cleanup the value (i.e. calling "deleter").
+  // inserted object is evicted or considered for promotion to the secondary
+  // cache. Promotion to secondary cache is only enabled if helper->size_cb
+  // != nullptr. The helper must outlive the cache. Callers may use
+  // &kNoopCacheItemHelper as a trivial helper (no deleter for the object,
+  // no secondary cache). `helper` must not be nullptr (efficiency).
   //
-  // If handle is nullptr, it is as if Release is called immediately after
-  // insert. In case of error value will be cleanup.
+  // If `handle` is not nullptr and return status is OK, `handle` is set
+  // to a Handle* for the entry. The caller must call this->Release(handle)
+  // when the returned entry is no longer needed. If `handle` is nullptr, it is
+  // as if Release is called immediately after Insert.
   //
   // Regardless of whether the item was inserted into the cache,
   // it will attempt to insert it into the secondary cache if one is
@@ -532,42 +558,23 @@ class Cache {
   // the item is only inserted into the primary cache. It may
   // defer the insertion to the secondary cache as it sees fit.
   //
-  // When the inserted entry is no longer needed, the key and
-  // value will be passed to "deleter".
-  virtual Status Insert(const Slice& key, void* value,
+  // When the inserted entry is no longer needed, it will be destroyed using
+  // helper->del_cb (if non-nullptr).
+  virtual Status Insert(const Slice& key, ObjectPtr obj,
                         const CacheItemHelper* helper, size_t charge,
                         Handle** handle = nullptr,
-                        Priority priority = Priority::LOW) {
-    if (!helper) {
-      return Status::InvalidArgument();
-    }
-    return Insert(key, value, charge, helper->del_cb, handle, priority);
-  }
-
-  // If the cache has no mapping for "key", returns nullptr.
-  //
-  // Else return a handle that corresponds to the mapping.  The caller
-  // must call this->Release(handle) when the returned mapping is no
-  // longer needed.
-  // If stats is not nullptr, relative tickers could be used inside the
-  // function.
-  virtual Handle* Lookup(const Slice& key, Statistics* stats = nullptr) = 0;
+                        Priority priority = Priority::LOW) = 0;
 
-  // EXPERIMENTAL
-  // Lookup the key in the primary and secondary caches (if one is configured).
-  // The create_cb callback function object will be used to contruct the
-  // cached object.
-  // If none of the caches have the mapping for the key, returns nullptr.
-  // Else, returns a handle that corresponds to the mapping.
+  // Lookup the key, returning nullptr if not found. If found, returns
+  // a handle to the mapping that must eventually be passed to Release().
   //
-  // This call may promote the object from the secondary cache (if one is
-  // configured, and has the given key) to the primary cache.
-  //
-  // The helper argument should be provided if the caller wants the lookup
-  // to include the secondary cache (if one is configured) and the object,
-  // if it exists, to be promoted to the primary cache. The helper may be
-  // saved and used later when the object is evicted. Therefore, it must
-  // outlive the cache.
+  // If a non-nullptr helper argument is provided with a non-nullptr
+  // create_cb, and a secondary cache is configured, then the secondary
+  // cache is also queried if lookup in the primary cache fails. If found
+  // in secondary cache, the provided create_db and create_context are
+  // used to promote the entry to an object in the primary cache.
+  // In that case, the helper may be saved and used later when the object
+  // is evicted, so as usual, the pointed-to helper must outlive the cache.
   //
   // ======================== Async Lookup (wait=false) ======================
   // When wait=false, the handle returned might be in any of three states:
@@ -576,8 +583,8 @@ class Cache {
   // * Pending, not ready (IsReady() == false) - secondary cache is still
   // working to retrieve the value. Might become ready any time.
   // * Pending, ready (IsReady() == true) - secondary cache has the value
-  // but it has not been loaded into primary cache. Call to Wait()/WaitAll()
-  // will not block.
+  // but it has not been loaded as an object into primary cache. Call to
+  // Wait()/WaitAll() will not block.
   //
   // IMPORTANT: Pending handles are not thread-safe, and only these functions
   // are allowed on them: Value(), IsReady(), Wait(), WaitAll(). Even Release()
@@ -594,11 +601,15 @@ class Cache {
   // Pending+ready state from the Failed state is to Wait() on it. A cache
   // entry not compatible with secondary cache can also have Value()==nullptr
   // like the Failed state, but this is not generally a concern.
-  virtual Handle* Lookup(const Slice& key, const CacheItemHelper* /*helper_cb*/,
-                         const CreateCallback& /*create_cb*/,
-                         Priority /*priority*/, bool /*wait*/,
-                         Statistics* stats = nullptr) {
-    return Lookup(key, stats);
+  virtual Handle* Lookup(const Slice& key,
+                         const CacheItemHelper* helper = nullptr,
+                         CreateContext* create_context = nullptr,
+                         Priority priority = Priority::LOW, bool wait = true,
+                         Statistics* stats = nullptr) = 0;
+
+  // Convenience wrapper when secondary cache not supported
+  inline Handle* BasicLookup(const Slice& key, Statistics* stats) {
+    return Lookup(key, nullptr, nullptr, Priority::LOW, true, stats);
   }
 
   // Increments the reference count for the handle if it refers to an entry in
@@ -620,11 +631,12 @@ class Cache {
   // REQUIRES: handle must have been returned by a method on *this.
   virtual bool Release(Handle* handle, bool erase_if_last_ref = false) = 0;
 
-  // Return the value encapsulated in a handle returned by a
-  // successful Lookup().
+  // Return the object assiciated with a handle returned by a successful
+  // Lookup(). For historical reasons, this is also known at the "value"
+  // associated with the key.
   // REQUIRES: handle must not have been released yet.
   // REQUIRES: handle must have been returned by a method on *this.
-  virtual void* Value(Handle* handle) = 0;
+  virtual ObjectPtr Value(Handle* handle) = 0;
 
   // If the cache contains the entry for the key, erase it.  Note that the
   // underlying entry will be kept around until all existing handles
@@ -675,11 +687,8 @@ class Cache {
   // Returns the charge for the specific entry in the cache.
   virtual size_t GetCharge(Handle* handle) const = 0;
 
-  // Returns the deleter for the specified entry. This might seem useless
-  // as the Cache itself is responsible for calling the deleter, but
-  // the deleter can essentially verify that a cache entry is of an
-  // expected type from an expected code source.
-  virtual DeleterFn GetDeleter(Handle* handle) const = 0;
+  // Returns the helper for the specified entry.
+  virtual const CacheItemHelper* GetCacheItemHelper(Handle* handle) const = 0;
 
   // Call this on shutdown if you want to speed it up. Cache will disown
   // any underlying data and will not free it on delete. This call will leak
@@ -705,19 +714,10 @@ class Cache {
   // entries is iterated over if other threads are operating on the Cache
   // also.
   virtual void ApplyToAllEntries(
-      const std::function<void(const Slice& key, void* value, size_t charge,
-                               DeleterFn deleter)>& callback,
+      const std::function<void(const Slice& key, ObjectPtr obj, size_t charge,
+                               const CacheItemHelper* helper)>& callback,
       const ApplyToAllEntriesOptions& opts) = 0;
 
-  // DEPRECATED version of above. (Default implementation uses above.)
-  virtual void ApplyToAllCacheEntries(void (*callback)(void* value,
-                                                       size_t charge),
-                                      bool /*thread_safe*/) {
-    ApplyToAllEntries([callback](const Slice&, void* value, size_t charge,
-                                 DeleterFn) { callback(value, charge); },
-                      {});
-  }
-
   // Remove all entries.
   // Prerequisite: no entry is referenced.
   virtual void EraseUnRefEntries() = 0;
@@ -734,6 +734,8 @@ class Cache {
   MemoryAllocator* memory_allocator() const { return memory_allocator_.get(); }
 
   // EXPERIMENTAL
+  // The following APIs are experimental and might change in the future.
+
   // Release a mapping returned by a previous Lookup(). The "useful"
   // parameter specifies whether the data was actually used or not,
   // which may be used by the cache implementation to decide whether
@@ -744,24 +746,21 @@ class Cache {
     return Release(handle, erase_if_last_ref);
   }
 
-  // EXPERIMENTAL
   // Determines if the handle returned by Lookup() can give a value without
   // blocking, though Wait()/WaitAll() might be required to publish it to
   // Value(). See secondary cache compatible Lookup() above for details.
   // This call is not thread safe on "pending" handles.
   virtual bool IsReady(Handle* /*handle*/) { return true; }
 
-  // EXPERIMENTAL
   // Convert a "pending" handle into a full thread-shareable handle by
   // * If necessary, wait until secondary cache finishes loading the value.
-  // * Construct the value for primary cache and set it in the handle.
+  // * Construct the object for primary cache and set it in the handle.
   // Even after Wait() on a pending handle, the caller must check for
   // Value() == nullptr in case of failure. This call is not thread-safe
   // on pending handles. This call has no effect on non-pending handles.
   // See secondary cache compatible Lookup() above for details.
   virtual void Wait(Handle* /*handle*/) {}
 
-  // EXPERIMENTAL
   // Wait for a vector of handles to become ready. As with Wait(), the user
   // should check the Value() of each handle for nullptr. This call is not
   // thread-safe on pending handles.
@@ -771,5 +770,8 @@ class Cache {
   std::shared_ptr<MemoryAllocator> memory_allocator_;
 };
 
+// Useful for cache entries requiring no clean-up, such as for cache
+// reservations
+inline constexpr Cache::CacheItemHelper kNoopCacheItemHelper{};
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -1445,11 +1445,17 @@ class DB {
   virtual Status SyncWAL() = 0;
 
   // Lock the WAL. Also flushes the WAL after locking.
+  // After this method returns ok, writes to the database will be stopped until
+  // UnlockWAL() is called.
+  // This method may internally acquire and release DB mutex and the WAL write
+  // mutex, but after it returns, neither mutex is held by caller.
   virtual Status LockWAL() {
     return Status::NotSupported("LockWAL not implemented");
   }
 
   // Unlock the WAL.
+  // The write stop on the database will be cleared.
+  // This method may internally acquire and release DB mutex.
   virtual Status UnlockWAL() {
     return Status::NotSupported("UnlockWAL not implemented");
   }

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

@@ -140,7 +140,10 @@ enum class CompactionReason : int {
   // According to the comments in flush_job.cc, RocksDB treats flush as
   // a level 0 compaction in internal stats.
   kFlush,
-  // Compaction caused by external sst file ingestion
+  // [InternalOnly] External sst file ingestion treated as a compaction
+  // with placeholder input level L0 as file ingestion
+  // technically does not have an input level like other compactions.
+  // Used only for internal stats and conflict checking with other compactions
   kExternalSstIngestion,
   // Compaction due to SST file being too old
   kPeriodicCompaction,
@@ -151,6 +154,9 @@ enum class CompactionReason : int {
   // A special TTL compaction for RoundRobin policy, which basically the same as
   // kLevelMaxLevelSize, but the goal is to compact TTLed files.
   kRoundRobinTtl,
+  // [InternalOnly] DBImpl::ReFitLevel treated as a compaction,
+  // Used only for internal conflict checking with other compactions
+  kRefitLevel,
   // total number of compaction reasons, new reasons must be added above this.
   kNumOfReasons,
 };

package/deps/rocksdb/rocksdb/include/rocksdb/merge_operator.h

@@ -104,6 +104,13 @@ class MergeOperator : public Customizable {
     Logger* logger;
   };
 
+  enum class OpFailureScope {
+    kDefault,
+    kTryMerge,
+    kMustMerge,
+    kOpFailureScopeMax,
+  };
+
   struct MergeOperationOutput {
     explicit MergeOperationOutput(std::string& _new_value,
                                   Slice& _existing_operand)
@@ -115,6 +122,20 @@ class MergeOperator : public Customizable {
     // client can set this field to the operand (or existing_value) instead of
     // using new_value.
     Slice& existing_operand;
+    // Indicates the blast radius of the failure. It is only meaningful to
+    // provide a failure scope when returning `false` from the API populating
+    // the `MergeOperationOutput`. Currently RocksDB operations handle these
+    // values as follows:
+    //
+    // - `OpFailureScope::kDefault`: fallback to default
+    //   (`OpFailureScope::kTryMerge`)
+    // - `OpFailureScope::kTryMerge`: operations that try to merge that key will
+    //   fail. This includes flush and compaction, which puts the DB in
+    //   read-only mode.
+    // - `OpFailureScope::kMustMerge`: operations that must merge that key will
+    //   fail (e.g., `Get()`, `MultiGet()`, iteration). Flushes/compactions can
+    //   still proceed by copying the original input operands to the output.
+    OpFailureScope op_failure_scope = OpFailureScope::kDefault;
   };
 
   // This function applies a stack of merge operands in chronological order

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

@@ -82,7 +82,7 @@ struct SstFileMetaData : public FileStorageInfo {
                   bool _being_compacted, Temperature _temperature,
                   uint64_t _oldest_blob_file_number,
                   uint64_t _oldest_ancester_time, uint64_t _file_creation_time,
-                  std::string& _file_checksum,
+                  uint64_t _epoch_number, std::string& _file_checksum,
                   std::string& _file_checksum_func_name)
       : smallest_seqno(_smallest_seqno),
         largest_seqno(_largest_seqno),
@@ -94,7 +94,8 @@ struct SstFileMetaData : public FileStorageInfo {
         num_deletions(0),
         oldest_blob_file_number(_oldest_blob_file_number),
         oldest_ancester_time(_oldest_ancester_time),
-        file_creation_time(_file_creation_time) {
+        file_creation_time(_file_creation_time),
+        epoch_number(_epoch_number) {
     if (!_file_name.empty()) {
       if (_file_name[0] == '/') {
         relative_filename = _file_name.substr(1);
@@ -141,7 +142,12 @@ struct SstFileMetaData : public FileStorageInfo {
   // Timestamp when the SST file is created, provided by
   // SystemClock::GetCurrentTime(). 0 if the information is not available.
   uint64_t file_creation_time = 0;
-
+  // The order of a file being flushed or ingested/imported.
+  // Compaction output file will be assigned with the minimum `epoch_number`
+  // among input files'.
+  // For L0, larger `epoch_number` indicates newer L0 file.
+  // 0 if the information is not available.
+  uint64_t epoch_number = 0;
   // 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

@@ -1933,7 +1933,8 @@ struct IngestExternalFileOptions {
   // that where created before the file was ingested.
   bool snapshot_consistency = true;
   // If set to false, IngestExternalFile() will fail if the file key range
-  // overlaps with existing keys or tombstones in the DB.
+  // overlaps with existing keys or tombstones or output of ongoing compaction
+  // during file ingestion in the DB.
   bool allow_global_seqno = true;
   // If set to false and the file key range overlaps with the memtable key range
   // (memtable flush required), IngestExternalFile will fail.

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

@@ -20,7 +20,7 @@ namespace ROCKSDB_NAMESPACE {
 // A handle for lookup result. The handle may not be immediately ready or
 // have a valid value. The caller must call isReady() to determine if its
 // ready, and call Wait() in order to block until it becomes ready.
-// The caller must call value() after it becomes ready to determine if the
+// The caller must call Value() after it becomes ready to determine if the
 // handle successfullly read the item.
 class SecondaryCacheResultHandle {
  public:
@@ -32,8 +32,9 @@ class SecondaryCacheResultHandle {
   // Block until handle becomes ready
   virtual void Wait() = 0;
 
-  // Return the value. If nullptr, it means the lookup was unsuccessful
-  virtual void* Value() = 0;
+  // Return the cache entry object (also known as value). If nullptr, it means
+  // the lookup was unsuccessful.
+  virtual Cache::ObjectPtr Value() = 0;
 
   // Return the size of value
   virtual size_t Size() = 0;
@@ -74,7 +75,7 @@ class SecondaryCache : public Customizable {
   // Lookup() might return the same parsed value back. But more typically, if
   // the implementation only uses `value` for getting persistable data during
   // the call, then the default implementation of `InsertSaved()` suffices.
-  virtual Status Insert(const Slice& key, void* value,
+  virtual Status Insert(const Slice& key, Cache::ObjectPtr obj,
                         const Cache::CacheItemHelper* helper) = 0;
 
   // Insert a value from its saved/persistable data (typically uncompressed
@@ -101,8 +102,9 @@ class SecondaryCache : public Customizable {
   // is_in_sec_cache is to indicate whether the handle is possibly erased
   // from the secondary cache after the Lookup.
   virtual std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CreateCallback& create_cb, bool wait,
-      bool advise_erase, bool& is_in_sec_cache) = 0;
+      const Slice& key, const Cache::CacheItemHelper* helper,
+      Cache::CreateContext* create_context, bool wait, bool advise_erase,
+      bool& is_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/status.h

@@ -135,6 +135,9 @@ class Status {
   Status(Code _code, SubCode _subcode, Severity _sev, const Slice& msg)
       : Status(_code, _subcode, msg, "", _sev) {}
 
+  static Status CopyAppendMessage(const Status& s, const Slice& delim,
+                                  const Slice& msg);
+
   Severity severity() const {
     MarkChecked();
     return sev_;