@nxtedition/rocksdb 15.4.1 → 15.5.0

package/deps/rocksdb/rocksdb/db/version_builder_test.cc

@@ -76,7 +76,8 @@ class VersionBuilderTest : public testing::Test {
         oldest_blob_file_number, kUnknownOldestAncesterTime,
         kUnknownFileCreationTime, epoch_number, kUnknownFileChecksum,
         kUnknownFileChecksumFuncName, kNullUniqueId64x2, 0, 0,
-        /* user_defined_timestamps_persisted */ true);
+        /* user_defined_timestamps_persisted */ true, /* min timestamp */ "",
+        /* max timestamp */ "");
     f->compensated_file_size = file_size;
     f->num_entries = num_entries;
     f->num_deletions = num_deletions;

package/deps/rocksdb/rocksdb/db/version_edit.cc

@@ -22,6 +22,40 @@ namespace ROCKSDB_NAMESPACE {
 
 namespace {}  // anonymous namespace
 
+// After copying, we rely on the caller to ensure no double releases. Fragile,
+// but keeps copying cheap.
+PinnedTableReader& PinnedTableReader::operator=(
+    const PinnedTableReader& other) {
+  TableReader* r = other.reader_.load(std::memory_order_acquire);
+  // Only read handle_ when reader_ is non-null. Pin() writes handle_ before
+  // reader_ (with release), so a non-null reader_ guarantees handle_ is stable.
+  // If reader_ is null, Pin() may be in progress — avoid reading handle_.
+  handle_ = (r != nullptr) ? other.handle_ : nullptr;
+  reader_.store(r, std::memory_order_release);
+  return *this;
+}
+
+Cache::Handle* PinnedTableReader::GetCacheHandle() const {
+  (void)reader_.load(std::memory_order_acquire);
+  return handle_;
+}
+
+void PinnedTableReader::Pin(Cache::Handle* handle, TableReader* reader) {
+  assert(handle != nullptr);
+  assert(reader != nullptr);
+  handle_ = handle;
+  reader_.store(reader, std::memory_order_release);
+}
+
+void PinnedTableReader::Release(Cache* cache) {
+  (void)reader_.load(std::memory_order_acquire);
+  if (handle_ != nullptr) {
+    cache->Release(handle_);
+    handle_ = nullptr;
+    reader_.store(nullptr, std::memory_order_relaxed);
+  }
+}
+
 uint64_t PackFileNumberAndPathId(uint64_t number, uint64_t path_id) {
   assert(number <= kFileNumberMask);
   return number | (path_id * (kFileNumberMask + 1));
@@ -83,7 +117,7 @@ bool VersionEdit::EncodeTo(std::string* dst,
     PutVarint32Varint64(dst, kNextFileNumber, next_file_number_);
   }
   if (has_max_column_family_) {
-    PutVarint32Varint32(dst, kMaxColumnFamily, max_column_family_);
+    PutVarint32(dst, kMaxColumnFamily, max_column_family_);
   }
   if (has_min_log_number_to_keep_) {
     PutVarint32Varint64(dst, kMinLogNumberToKeep, min_log_number_to_keep_);
@@ -143,7 +177,7 @@ bool VersionEdit::EncodeTo(std::string* dst,
 
   // 0 is default and does not need to be explicitly written
   if (column_family_ != 0) {
-    PutVarint32Varint32(dst, kColumnFamily, column_family_);
+    PutVarint32(dst, kColumnFamily, column_family_);
   }
 
   if (is_column_family_add_) {
@@ -304,6 +338,15 @@ void VersionEdit::EncodeToNewFile4(const FileMetaData& f, int level,
     char p = static_cast<char>(0);
     PutLengthPrefixedSlice(dst, Slice(&p, 1));
   }
+  // Encode min/max timestamp if they are non-empty
+  if (!f.min_timestamp.empty()) {
+    PutVarint32(dst, NewFileCustomTag::kMinTimestamp);
+    PutLengthPrefixedSlice(dst, Slice(f.min_timestamp));
+  }
+  if (!f.max_timestamp.empty()) {
+    PutVarint32(dst, NewFileCustomTag::kMaxTimestamp);
+    PutLengthPrefixedSlice(dst, Slice(f.max_timestamp));
+  }
   TEST_SYNC_POINT_CALLBACK("VersionEdit::EncodeTo:NewFile4:CustomizeFields",
                            dst);
 
@@ -443,6 +486,12 @@ const char* VersionEdit::DecodeNewFile4From(Slice* input, int& max_level,
           }
           f.user_defined_timestamps_persisted = (field[0] == 1);
           break;
+        case kMinTimestamp:
+          f.min_timestamp = field.ToString();
+          break;
+        case kMaxTimestamp:
+          f.max_timestamp = field.ToString();
+          break;
         default:
           if ((custom_tag & kCustomTagNonSafeIgnoreMask) != 0) {
             // Should not proceed if cannot understand it

package/deps/rocksdb/rocksdb/db/version_edit.h

@@ -25,6 +25,7 @@
 #include "rocksdb/advanced_options.h"
 #include "table/table_reader.h"
 #include "table/unique_id_impl.h"
+#include "test_util/sync_point.h"
 #include "util/autovector.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -133,14 +134,57 @@ constexpr uint64_t kReservedEpochNumberForFileIngestedBehind = 1;
 
 uint64_t PackFileNumberAndPathId(uint64_t number, uint64_t path_id);
 
+// PinnedTableReader is used to safely access a table reader in a multi-threaded
+// context. It holds both a pointer to the table reader and a cache handle.
+class PinnedTableReader {
+ public:
+  PinnedTableReader() : reader_(nullptr), handle_(nullptr) {}
+  ~PinnedTableReader() = default;
+  PinnedTableReader(const PinnedTableReader& other)
+      : reader_(nullptr), handle_(nullptr) {
+    *this = other;
+  }
+  PinnedTableReader& operator=(const PinnedTableReader& other);
+  PinnedTableReader(PinnedTableReader&&) = delete;
+  PinnedTableReader& operator=(PinnedTableReader&&) = delete;
+
+  // Returns the pinned TableReader, or nullptr if not pinned.
+  TableReader* Get() const { return reader_.load(std::memory_order_acquire); }
+
+  // Returns the cache handle that keeps TableReader alive, or nullptr if not
+  // pinned.
+  Cache::Handle* GetCacheHandle() const;
+
+  // Pin a table reader with its cache handle.
+  void Pin(Cache::Handle* handle, TableReader* reader);
+
+  // Release the pinned handle via the given cache and reset state.
+  void Release(Cache* cache);
+
+  // Test-only: set a reader without a cache handle.
+  void TEST_SetReader(TableReader* reader) {
+    reader_.store(reader, std::memory_order_release);
+  }
+
+ private:
+  // Internally, we need to ensure reads and writes to reader_ and handle_ are
+  // properly ordered. handle_ must be written to before reader_ is written to
+  // with release semantics. handle_ must be read after reader_ is read with
+  // acquire semantics.
+  std::atomic<TableReader*> reader_;
+  Cache::Handle* handle_;
+};
+
 // A copyable structure contains information needed to read data from an SST
 // file. It can contain a pointer to a table reader opened for the file, or
 // file number and size, which can be used to create a new table reader for it.
 // The behavior is undefined when a copied of the structure is used when the
 // file is not in any live version any more.
 struct FileDescriptor {
-  // Table reader in table_reader_handle
-  TableReader* table_reader;
+  // Fast access to table reader without cache lookup. Marked mutable because
+  // reads can pin the table reader, but can also be done safely in a
+  // multi-threaded context.
+  mutable PinnedTableReader pinned_reader;
   uint64_t packed_number_and_path_id;
   uint64_t file_size;             // File size in bytes
   SequenceNumber smallest_seqno;  // The smallest seqno in this file
@@ -153,7 +197,7 @@ struct FileDescriptor {
 
   FileDescriptor(uint64_t number, uint32_t path_id, uint64_t _file_size,
                  SequenceNumber _smallest_seqno, SequenceNumber _largest_seqno)
-      : table_reader(nullptr),
+      : pinned_reader(),
         packed_number_and_path_id(PackFileNumberAndPathId(number, path_id)),
         file_size(_file_size),
         smallest_seqno(_smallest_seqno),
@@ -162,7 +206,7 @@ struct FileDescriptor {
   FileDescriptor(const FileDescriptor& fd) { *this = fd; }
 
   FileDescriptor& operator=(const FileDescriptor& fd) {
-    table_reader = fd.table_reader;
+    pinned_reader = fd.pinned_reader;
     packed_number_and_path_id = fd.packed_number_and_path_id;
     file_size = fd.file_size;
     smallest_seqno = fd.smallest_seqno;
@@ -181,15 +225,20 @@ struct FileDescriptor {
 };
 
 struct FileSampledStats {
-  FileSampledStats() : num_reads_sampled(0) {}
+  FileSampledStats()
+      : num_reads_sampled(0), num_collapsible_entry_reads_sampled(0) {}
   FileSampledStats(const FileSampledStats& other) { *this = other; }
   FileSampledStats& operator=(const FileSampledStats& other) {
     num_reads_sampled = other.num_reads_sampled.load();
+    num_collapsible_entry_reads_sampled =
+        other.num_collapsible_entry_reads_sampled.load();
     return *this;
   }
 
   // number of user reads to this file.
   mutable std::atomic<uint64_t> num_reads_sampled;
+  // number of reads of type kNotFound, kMerge, kTypeSingleDeletion
+  mutable std::atomic<uint64_t> num_collapsible_entry_reads_sampled;
 };
 
 struct FileMetaData {
@@ -197,9 +246,6 @@ struct FileMetaData {
   InternalKey smallest;  // Smallest internal key served by table
   InternalKey largest;   // Largest internal key served by table
 
-  // Needs to be disposed when refs becomes 0.
-  Cache::Handle* table_reader_handle = nullptr;
-
   FileSampledStats stats;
 
   // Stats for compensating deletion entries during compaction
@@ -276,6 +322,14 @@ struct FileMetaData {
   // false, it's explicitly written to Manifest.
   bool user_defined_timestamps_persisted = true;
 
+  // Minimum user-defined timestamp in the file. Empty if no UDT or unknown.
+  // This is populated from the table properties "rocksdb.timestamp_min".
+  std::string min_timestamp;
+
+  // Maximum user-defined timestamp in the file. Empty if no UDT or unknown.
+  // This is populated from the table properties "rocksdb.timestamp_max".
+  std::string max_timestamp;
+
   FileMetaData() = default;
 
   FileMetaData(uint64_t file, uint32_t file_path_id, uint64_t file_size,
@@ -288,7 +342,9 @@ struct FileMetaData {
                const std::string& _file_checksum_func_name,
                UniqueId64x2 _unique_id,
                const uint64_t _compensated_range_deletion_size,
-               uint64_t _tail_size, bool _user_defined_timestamps_persisted)
+               uint64_t _tail_size, bool _user_defined_timestamps_persisted,
+               const std::string& _min_timestamp,
+               const std::string& _max_timestamp)
       : fd(file, file_path_id, file_size, smallest_seq, largest_seq),
         smallest(smallest_key),
         largest(largest_key),
@@ -303,7 +359,9 @@ struct FileMetaData {
         file_checksum_func_name(_file_checksum_func_name),
         unique_id(std::move(_unique_id)),
         tail_size(_tail_size),
-        user_defined_timestamps_persisted(_user_defined_timestamps_persisted) {
+        user_defined_timestamps_persisted(_user_defined_timestamps_persisted),
+        min_timestamp(_min_timestamp),
+        max_timestamp(_max_timestamp) {
     TEST_SYNC_POINT_CALLBACK("FileMetaData::FileMetaData", this);
   }
 
@@ -334,9 +392,10 @@ struct FileMetaData {
   uint64_t TryGetOldestAncesterTime() {
     if (oldest_ancester_time != kUnknownOldestAncesterTime) {
       return oldest_ancester_time;
-    } else if (fd.table_reader != nullptr &&
-               fd.table_reader->GetTableProperties() != nullptr) {
-      return fd.table_reader->GetTableProperties()->creation_time;
+    }
+    TableReader* reader = fd.pinned_reader.Get();
+    if (reader != nullptr && reader->GetTableProperties() != nullptr) {
+      return reader->GetTableProperties()->creation_time;
     }
     return kUnknownOldestAncesterTime;
   }
@@ -344,9 +403,10 @@ struct FileMetaData {
   uint64_t TryGetFileCreationTime() {
     if (file_creation_time != kUnknownFileCreationTime) {
       return file_creation_time;
-    } else if (fd.table_reader != nullptr &&
-               fd.table_reader->GetTableProperties() != nullptr) {
-      return fd.table_reader->GetTableProperties()->file_creation_time;
+    }
+    TableReader* reader = fd.pinned_reader.Get();
+    if (reader != nullptr && reader->GetTableProperties() != nullptr) {
+      return reader->GetTableProperties()->file_creation_time;
     }
     return kUnknownFileCreationTime;
   }
@@ -354,10 +414,9 @@ struct FileMetaData {
   // Tries to get the newest key time from the current file
   // Falls back on oldest ancestor time of previous (newer) file
   uint64_t TryGetNewestKeyTime(FileMetaData* prev_file = nullptr) {
-    if (fd.table_reader != nullptr &&
-        fd.table_reader->GetTableProperties() != nullptr) {
-      uint64_t newest_key_time =
-          fd.table_reader->GetTableProperties()->newest_key_time;
+    TableReader* reader = fd.pinned_reader.Get();
+    if (reader != nullptr && reader->GetTableProperties() != nullptr) {
+      uint64_t newest_key_time = reader->GetTableProperties()->newest_key_time;
       if (newest_key_time != kUnknownNewestKeyTime) {
         return newest_key_time;
       }
@@ -386,7 +445,8 @@ struct FileMetaData {
     usage += sizeof(*this);
 #endif  // ROCKSDB_MALLOC_USABLE_SIZE
     usage += smallest.size() + largest.size() + file_checksum.size() +
-             file_checksum_func_name.size();
+             file_checksum_func_name.size() + min_timestamp.size() +
+             max_timestamp.size();
     return usage;
   }
 
@@ -737,17 +797,19 @@ class VersionEdit {
                const std::string& file_checksum_func_name,
                const UniqueId64x2& unique_id,
                const uint64_t compensated_range_deletion_size,
-               uint64_t tail_size, bool user_defined_timestamps_persisted) {
+               uint64_t tail_size, bool user_defined_timestamps_persisted,
+               const std::string& min_timestamp = "",
+               const std::string& max_timestamp = "") {
     assert(smallest_seqno <= largest_seqno);
     new_files_.emplace_back(
         level,
-        FileMetaData(file, file_path_id, file_size, smallest, largest,
-                     smallest_seqno, largest_seqno, marked_for_compaction,
-                     temperature, oldest_blob_file_number, oldest_ancester_time,
-                     file_creation_time, epoch_number, file_checksum,
-                     file_checksum_func_name, unique_id,
-                     compensated_range_deletion_size, tail_size,
-                     user_defined_timestamps_persisted));
+        FileMetaData(
+            file, file_path_id, file_size, smallest, largest, smallest_seqno,
+            largest_seqno, marked_for_compaction, temperature,
+            oldest_blob_file_number, oldest_ancester_time, file_creation_time,
+            epoch_number, file_checksum, file_checksum_func_name, unique_id,
+            compensated_range_deletion_size, tail_size,
+            user_defined_timestamps_persisted, min_timestamp, max_timestamp));
     files_to_quarantine_.push_back(file);
     if (!HasLastSequence() || largest_seqno > GetLastSequence()) {
       SetLastSequence(largest_seqno);

package/deps/rocksdb/rocksdb/db/version_edit_handler.h

@@ -146,13 +146,13 @@ class VersionEditHandler : public VersionEditHandlerBase {
       const std::shared_ptr<IOTracer>& io_tracer,
       const ReadOptions& read_options, bool allow_incomplete_valid_version,
       EpochNumberRequirement epoch_number_requirement =
-          EpochNumberRequirement::kMustPresent)
-      : VersionEditHandler(read_only, column_families, version_set,
-                           track_found_and_missing_files,
-                           no_error_if_files_missing, io_tracer, read_options,
-                           /*skip_load_table_files=*/false,
-                           allow_incomplete_valid_version,
-                           epoch_number_requirement) {}
+          EpochNumberRequirement::kMustPresent,
+      bool skip_load_table_files = false)
+      : VersionEditHandler(
+            read_only, column_families, version_set,
+            track_found_and_missing_files, no_error_if_files_missing, io_tracer,
+            read_options, skip_load_table_files, allow_incomplete_valid_version,
+            epoch_number_requirement) {}
 
   ~VersionEditHandler() override {}