@nxtedition/rocksdb 15.4.1 → 16.0.0

package/deps/rocksdb/rocksdb/table/block_based/user_defined_index_wrapper.h

@@ -9,6 +9,7 @@
 #include <string>
 #include <unordered_map>
 
+#include "db/seqno_to_time_mapping.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
 #include "rocksdb/user_defined_index.h"
@@ -43,34 +44,48 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
                       const BlockHandle& block_handle,
                       std::string* separator_scratch,
                       bool skip_delta_encoding) override {
-    UserDefinedIndexBuilder::BlockHandle handle;
+    UserDefinedIndexBuilder::BlockHandle handle{};
     handle.offset = block_handle.offset();
     handle.size = block_handle.size();
-    // Forward the call to both index builders
+    // Forward the call to both index builders.
+    // Parse the internal keys to extract user keys and sequence numbers.
+    // There's no way to return an error here, so we remember the status and
+    // return it in Finish().
     ParsedInternalKey pkey_last;
     ParsedInternalKey pkey_first;
-    // There's no way to return an error here, so we remember the statsu and
-    // return it in Finish()
     if (status_.ok()) {
       status_ = ParseInternalKey(last_key_in_current_block, &pkey_last,
-                                 /*lof_err_key*/ false);
+                                 /*log_err_key*/ false);
     }
     if (status_.ok() && first_key_in_next_block) {
       status_ = ParseInternalKey(*first_key_in_next_block, &pkey_first,
-                                 /*lof_err_key*/ false);
+                                 /*log_err_key*/ false);
     }
     if (status_.ok()) {
+      // Pass both user keys AND sequence numbers to the UDI builder via
+      // the IndexEntryContext. The sequence numbers are needed when the
+      // same user key spans a data block boundary (e.g., due to snapshots
+      // keeping multiple versions). Without sequence numbers, the UDI
+      // cannot produce a separator that distinguishes the two blocks,
+      // causing incorrect Seek results.
+      UserDefinedIndexBuilder::IndexEntryContext ctx;
+      ctx.last_key_seq = pkey_last.sequence;
+      ctx.first_key_seq = first_key_in_next_block ? pkey_first.sequence : 0;
       user_defined_index_builder_->AddIndexEntry(
           pkey_last.user_key,
           first_key_in_next_block ? &pkey_first.user_key : nullptr, handle,
-          separator_scratch);
+          separator_scratch, ctx);
     }
     return internal_index_builder_->AddIndexEntry(
         last_key_in_current_block, first_key_in_next_block, block_handle,
         separator_scratch, skip_delta_encoding);
   }
 
-  // Not supported with parallel compression
+  // Parallel compression splits AddIndexEntry() into PrepareIndexEntry() (emit
+  // thread) and FinishIndexEntry() (worker thread). This wrapper does not
+  // implement that split yet, so parallel compression is rejected at option
+  // validation time (see BlockBasedTableFactory::ValidateOptions and the Rep
+  // constructor). These stubs exist only to satisfy the interface.
   std::unique_ptr<PreparedIndexEntry> CreatePreparedIndexEntry() override {
     return nullptr;
   }
@@ -93,35 +108,43 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
 
   void OnKeyAdded(const Slice& key,
                   const std::optional<Slice>& value) override {
+    // Always forward to internal index builder first. It relies on receiving
+    // OnKeyAdded for every key to maintain state (e.g.,
+    // current_block_first_internal_key_) needed by AddIndexEntry, which is
+    // always forwarded regardless of UDI status.
+    internal_index_builder_->OnKeyAdded(key, value);
+
     ParsedInternalKey pkey;
     if (status_.ok()) {
+      // Defensive: value should always be present since OnKeyAdded() is called
+      // on the main thread in Add() with the original value Slice. No current
+      // code path passes std::nullopt here.
       if (!value.has_value()) {
+        assert(false);
         status_ = Status::InvalidArgument(
-            "user_defined_index_factory not supported with parallel "
-            "compression");
+            "OnKeyAdded called without a value; UDI requires the value to "
+            "forward to the plugin builder");
       } else {
-        status_ = ParseInternalKey(key, &pkey, /*lof_err_key*/ false);
-        if (status_.ok() && pkey.type != ValueType::kTypeValue) {
-          status_ = Status::InvalidArgument(
-              "user_defined_index_factory only supported with Puts");
-        }
+        status_ = ParseInternalKey(key, &pkey, /*log_err_key*/ false);
       }
     }
     if (!status_.ok()) {
       return;
     }
 
-    // Forward the call to both index builders
-    internal_index_builder_->OnKeyAdded(key, value);
-
-    // Pass the user key to the UDI. We don't expect multiple entries with
-    // different sequence numbers for the same key in the file. RocksDB may
-    // enforce it in the future by allowing UDIs only for read only
-    // bulkloaded use cases, and only allow ingestion of files with
-    // sequence number 0.
+    // Pass the user key to the UDI with the mapped value type. In SST files
+    // produced by flush or compaction, there may be multiple entries for the
+    // same user key with different sequence numbers (e.g., when snapshots are
+    // active). UDI builders that use OnKeyAdded() should handle this; builders
+    // that only use AddIndexEntry() separator keys (e.g., trie) are unaffected.
+    Slice udi_value = value.value();
+    if (pkey.type == kTypeValuePreferredSeqno) {
+      // Strip the packed preferred seqno suffix so the UDI plugin receives
+      // only the user value, consistent with the kValue contract.
+      udi_value = ParsePackedValueForValue(udi_value);
+    }
     user_defined_index_builder_->OnKeyAdded(
-        pkey.user_key, UserDefinedIndexBuilder::ValueType::kValue,
-        value.value());
+        pkey.user_key, MapToUDIValueType(pkey.type), udi_value);
   }
 
   Status Finish(IndexBlocks* index_blocks,
@@ -158,13 +181,39 @@ class UserDefinedIndexBuilderWrapper : public IndexBuilder {
 
   size_t IndexSize() const override { return index_size_; }
 
-  uint64_t CurrentIndexSizeEstimate() const override { return 0; }
+  uint64_t CurrentIndexSizeEstimate() const override {
+    return internal_index_builder_->CurrentIndexSizeEstimate();
+  }
 
   bool separator_is_key_plus_seq() override {
     return internal_index_builder_->separator_is_key_plus_seq();
   }
 
  private:
+  static UserDefinedIndexBuilder::ValueType MapToUDIValueType(
+      ROCKSDB_NAMESPACE::ValueType t) {
+    switch (t) {
+      case kTypeValue:
+      case kTypeValuePreferredSeqno:
+        return UserDefinedIndexBuilder::kValue;
+      case kTypeDeletion:
+      case kTypeSingleDeletion:
+      case kTypeDeletionWithTimestamp:
+        return UserDefinedIndexBuilder::kDelete;
+      case kTypeMerge:
+        return UserDefinedIndexBuilder::kMerge;
+      case kTypeBlobIndex:
+      case kTypeWideColumnEntity:
+        return UserDefinedIndexBuilder::kOther;
+      default:
+        // Any new type that reaches OnKeyAdded() should be explicitly mapped
+        // above. Falling through to kOther is a safe default but indicates a
+        // missing case that should be added.
+        assert(false);
+        return UserDefinedIndexBuilder::kOther;
+    }
+  }
+
   const std::string name_;
   std::unique_ptr<IndexBuilder> internal_index_builder_;
   std::unique_ptr<UserDefinedIndexBuilder> user_defined_index_builder_;
@@ -179,13 +228,24 @@ class UserDefinedIndexIteratorWrapper
       std::unique_ptr<UserDefinedIndexIterator>&& udi_iter)
       : udi_iter_(std::move(udi_iter)), valid_(false) {}
 
+  ~UserDefinedIndexIteratorWrapper() override = default;
+
   bool Valid() const override { return valid_; }
 
   void SeekToFirst() override {
-    status_ = Status::NotSupported("SeekToFirst not supported");
+    status_ = udi_iter_->SeekToFirstAndGetResult(&result_);
+    if (status_.ok()) {
+      valid_ = result_.bound_check_result == IterBoundCheck::kInbound;
+      if (valid_) {
+        SetInternalKeyFromUDIResult();
+      }
+    } else {
+      valid_ = false;
+    }
   }
 
   void SeekToLast() override {
+    valid_ = false;
     status_ = Status::NotSupported("SeekToLast not supported");
   }
 
@@ -193,12 +253,19 @@ class UserDefinedIndexIteratorWrapper
     ParsedInternalKey pkey;
     status_ = ParseInternalKey(target, &pkey, /*log_err_key=*/false);
     if (status_.ok()) {
-      status_ = udi_iter_->SeekAndGetResult(pkey.user_key, &result_);
+      // Pass both user key AND sequence number to the UDI iterator via
+      // SeekContext. The sequence number is needed when the same user key
+      // spans multiple data blocks with different sequence numbers (e.g.,
+      // due to snapshots). Without it, the UDI cannot distinguish which
+      // block to return for a given (user_key, seqno) target.
+      UserDefinedIndexIterator::SeekContext ctx;
+      ctx.target_seq = pkey.sequence;
+      status_ = udi_iter_->SeekAndGetResult(pkey.user_key, &result_, ctx);
     }
     if (status_.ok()) {
       valid_ = result_.bound_check_result == IterBoundCheck::kInbound;
       if (valid_) {
-        ikey_.Set(result_.key, 0, ValueType::kTypeValue);
+        SetInternalKeyFromUDIResult();
       }
     } else {
       valid_ = false;
@@ -210,7 +277,7 @@ class UserDefinedIndexIteratorWrapper
     if (status_.ok()) {
       valid_ = result_.bound_check_result == IterBoundCheck::kInbound;
       if (valid_) {
-        ikey_.Set(result_.key, 0, ValueType::kTypeValue);
+        SetInternalKeyFromUDIResult();
       }
     } else {
       valid_ = false;
@@ -222,11 +289,11 @@ class UserDefinedIndexIteratorWrapper
     if (status_.ok()) {
       valid_ = result_.bound_check_result == IterBoundCheck::kInbound;
       if (valid_) {
-        ikey_.Set(result_.key, 0, ValueType::kTypeValue);
-      }
-      if (status_.ok()) {
-        *result = result_;
+        SetInternalKeyFromUDIResult();
+        result->key = key();
       }
+      result->bound_check_result = result_.bound_check_result;
+      result->value_prepared = result_.value_prepared;
     } else {
       valid_ = false;
     }
@@ -234,10 +301,14 @@ class UserDefinedIndexIteratorWrapper
   }
 
   void SeekForPrev(const Slice& /*target*/) override {
+    valid_ = false;
     status_ = Status::NotSupported("SeekForPrev not supported");
   }
 
-  void Prev() override { status_ = Status::NotSupported("Prev not supported"); }
+  void Prev() override {
+    valid_ = false;
+    status_ = Status::NotSupported("Prev not supported");
+  }
 
   Slice key() const override { return Slice(*ikey_.const_rep()); }
 
@@ -261,6 +332,17 @@ class UserDefinedIndexIteratorWrapper
   }
 
  private:
+  // Convert the UDI result's user key into an internal key for the index
+  // iterator contract. UDI separators are user keys, but
+  // InternalIteratorBase<IndexValue> must expose internal keys (user key +
+  // 8-byte trailer). We use seq=0 / kTypeValue so that the resulting
+  // internal key compares as "greater than or equal to" any real data key
+  // with the same user key (lower seqno = later in internal key order),
+  // which is the correct upper-bound semantics for an index separator.
+  void SetInternalKeyFromUDIResult() {
+    ikey_.Set(result_.key, 0, ValueType::kTypeValue);
+  }
+
   std::unique_ptr<UserDefinedIndexIterator> udi_iter_;
   IterateResult result_;
   InternalKey ikey_;
@@ -278,7 +360,7 @@ class UserDefinedIndexReaderWrapper : public BlockBasedTable::IndexReader {
         reader_(std::move(reader)),
         udi_reader_(std::move(udi_reader)) {}
 
-  virtual InternalIteratorBase<IndexValue>* NewIterator(
+  InternalIteratorBase<IndexValue>* NewIterator(
       const ReadOptions& read_options, bool disable_prefix_seek,
       IndexBlockIter* iter, GetContext* get_context,
       BlockCacheLookupContext* lookup_context) override {
@@ -288,32 +370,30 @@ class UserDefinedIndexReaderWrapper : public BlockBasedTable::IndexReader {
     }
     if (name_ != read_options.table_index_factory->Name()) {
       return NewErrorInternalIterator<IndexValue>(Status::InvalidArgument(
-          "Bad index name" +
+          "Bad index name: " +
           std::string(read_options.table_index_factory->Name()) +
           ". Only supported UDI is " + name_));
     }
     std::unique_ptr<UserDefinedIndexIterator> udi_iter =
         udi_reader_->NewIterator(read_options);
     if (udi_iter) {
-      InternalIteratorBase<IndexValue>* wrap_iter =
-          new UserDefinedIndexIteratorWrapper(std::move(udi_iter));
-      return wrap_iter;
+      return new UserDefinedIndexIteratorWrapper(std::move(udi_iter));
     }
     return NewErrorInternalIterator<IndexValue>(
-        Status::NotFound("COuld not create UDI iterator"));
+        Status::NotFound("Could not create UDI iterator"));
   }
 
-  virtual Status CacheDependencies(
-      const ReadOptions& ro, bool pin,
-      FilePrefetchBuffer* tail_prefetch_buffer) override {
+  Status CacheDependencies(const ReadOptions& ro, bool pin,
+                           FilePrefetchBuffer* tail_prefetch_buffer) override {
     return reader_->CacheDependencies(ro, pin, tail_prefetch_buffer);
   }
 
   size_t ApproximateMemoryUsage() const override {
-    return reader_->ApproximateMemoryUsage();
+    return reader_->ApproximateMemoryUsage() +
+           udi_reader_->ApproximateMemoryUsage();
   }
 
-  virtual void EraseFromCacheBeforeDestruction(
+  void EraseFromCacheBeforeDestruction(
       uint32_t uncache_aggressiveness) override {
     reader_->EraseFromCacheBeforeDestruction(uncache_aggressiveness);
   }

package/deps/rocksdb/rocksdb/table/block_fetcher.cc

@@ -29,13 +29,40 @@
 
 namespace ROCKSDB_NAMESPACE {
 
+namespace {
+
+inline void RecordBlockReadBytePerfCounter(BlockType block_type,
+                                           uint64_t block_size_with_trailer) {
+  switch (block_type) {
+    case BlockType::kData:
+      PERF_COUNTER_ADD(data_block_read_byte, block_size_with_trailer);
+      break;
+    case BlockType::kFilter:
+    case BlockType::kFilterPartitionIndex:
+      PERF_COUNTER_ADD(filter_block_read_byte, block_size_with_trailer);
+      break;
+    case BlockType::kCompressionDictionary:
+      PERF_COUNTER_ADD(compression_dict_block_read_byte,
+                       block_size_with_trailer);
+      break;
+    case BlockType::kIndex:
+      PERF_COUNTER_ADD(index_block_read_byte, block_size_with_trailer);
+      break;
+    default:
+      PERF_COUNTER_ADD(metadata_block_read_byte, block_size_with_trailer);
+      break;
+  }
+}
+
+}  // namespace
+
 inline void BlockFetcher::ProcessTrailerIfPresent() {
   if (footer_.GetBlockTrailerSize() > 0) {
     assert(footer_.GetBlockTrailerSize() == BlockBasedTable::kBlockTrailerSize);
     if (read_options_.verify_checksums) {
-      io_status_ = status_to_io_status(
-          VerifyBlockChecksum(footer_, slice_.data(), block_size_,
-                              file_->file_name(), handle_.offset()));
+      io_status_ = status_to_io_status(VerifyBlockChecksum(
+          footer_, slice_.data(), block_size_, file_->file_name(),
+          handle_.offset(), block_type_));
       RecordTick(ioptions_.stats, BLOCK_CHECKSUM_COMPUTE_COUNT);
       if (!io_status_.ok()) {
         assert(io_status_.IsCorruption());
@@ -324,6 +351,7 @@ void BlockFetcher::ReadBlock(bool retry) {
   }
 
   PERF_COUNTER_ADD(block_read_byte, block_size_with_trailer_);
+  RecordBlockReadBytePerfCounter(block_type_, block_size_with_trailer_);
   IGNORE_STATUS_IF_ERROR(io_status_);
   if (io_status_.ok()) {
     if (use_fs_scratch_ && !read_req.status.ok()) {

package/deps/rocksdb/rocksdb/table/block_fetcher_test.cc

@@ -319,8 +319,7 @@ class BlockFetcherTest : public testing::Test {
     PersistentCacheOptions persistent_cache_options;
     Footer footer;
     ReadFooter(file, &footer);
-    auto mgr = GetBuiltinCompressionManager(
-        GetCompressFormatForVersion(footer.format_version()));
+    auto mgr = GetBuiltinV2CompressionManager();
     std::unique_ptr<BlockFetcher> fetcher(new BlockFetcher(
         file, nullptr /* prefetch_buffer */, footer, roptions, block, contents,
         ioptions, do_uncompress, compressed, block_type,

package/deps/rocksdb/rocksdb/table/cleanable_test.cc

@@ -31,7 +31,9 @@ void Multiplier(void* arg1, void* arg2) {
 TEST_F(CleanableTest, Register) {
   int n2 = 2, n3 = 3;
   int res = 1;
-  { Cleanable c1; }
+  {
+    Cleanable c1;
+  }
   // ~Cleanable
   ASSERT_EQ(1, res);
 

package/deps/rocksdb/rocksdb/table/external_table.cc

@@ -8,6 +8,7 @@
 #include "logging/logging.h"
 #include "rocksdb/table.h"
 #include "table/block_based/block.h"
+#include "table/get_context.h"
 #include "table/internal_iterator.h"
 #include "table/meta_blocks.h"
 #include "table/table_builder.h"
@@ -233,10 +234,30 @@ class ExternalTableReaderAdapter : public TableReader {
 
   size_t ApproximateMemoryUsage() const override { return 0; }
 
-  Status Get(const ReadOptions&, const Slice&, GetContext*,
-             const SliceTransform*, bool = false) override {
-    return Status::NotSupported(
-        "Get() not supported on external file iterator");
+  Status Get(const ReadOptions& read_options, const Slice& key,
+             GetContext* get_context, const SliceTransform* prefix_extractor,
+             bool /*skip_filters*/ = false) override {
+    ParsedInternalKey parsed_key;
+    Status s = ParseInternalKey(key, &parsed_key, /*log_err_key=*/false);
+    if (!s.ok()) {
+      return s;
+    }
+
+    PinnableSlice value;
+    s = reader_->Get(read_options, parsed_key.user_key, prefix_extractor,
+                     &value);
+    if (!s.ok()) {
+      if (s.IsNotFound()) {
+        return Status::OK();
+      }
+      return s;
+    }
+
+    ParsedInternalKey found_key(parsed_key.user_key, 0, ValueType::kTypeValue);
+    bool matched = false;
+    get_context->SaveValue(found_key, value, &matched, &s,
+                           value.IsPinned() ? &value : nullptr);
+    return s;
   }
 
   Status VerifyChecksum(const ReadOptions& /*ro*/, TableReaderCaller /*caller*/,

package/deps/rocksdb/rocksdb/table/format.cc

@@ -154,23 +154,18 @@ std::string IndexValue::ToString(bool hex, bool have_first_key) const {
 
 namespace {
 inline bool IsLegacyFooterFormat(uint64_t magic_number) {
-  return magic_number == kLegacyBlockBasedTableMagicNumber ||
-         magic_number == kLegacyPlainTableMagicNumber;
+  return magic_number == kLegacyPlainTableMagicNumber;
 }
+// Used when reading format_version=0 footers (plain tables)
 inline uint64_t UpconvertLegacyFooterFormat(uint64_t magic_number) {
-  if (magic_number == kLegacyBlockBasedTableMagicNumber) {
-    return kBlockBasedTableMagicNumber;
-  }
   if (magic_number == kLegacyPlainTableMagicNumber) {
     return kPlainTableMagicNumber;
   }
   assert(false);
   return magic_number;
 }
+// Used by plain tables to write format_version=0 footers
 inline uint64_t DownconvertToLegacyFooterFormat(uint64_t magic_number) {
-  if (magic_number == kBlockBasedTableMagicNumber) {
-    return kLegacyBlockBasedTableMagicNumber;
-  }
   if (magic_number == kPlainTableMagicNumber) {
     return kLegacyPlainTableMagicNumber;
   }
@@ -178,14 +173,18 @@ inline uint64_t DownconvertToLegacyFooterFormat(uint64_t magic_number) {
   return magic_number;
 }
 inline uint8_t BlockTrailerSizeForMagicNumber(uint64_t magic_number) {
-  if (magic_number == kBlockBasedTableMagicNumber ||
-      magic_number == kLegacyBlockBasedTableMagicNumber) {
+  if (magic_number == kBlockBasedTableMagicNumber) {
     return static_cast<uint8_t>(BlockBasedTable::kBlockTrailerSize);
   } else {
     return 0;
   }
 }
 
+// NOTE: format_version 0 is still used by plain tables and format_version 1 by
+// cuckoo table. For block-based tables, format_version < 2 is no longer
+// supported for reading or writing. Legacy magic numbers on block-based tables
+// are used only for good error reporting.
+//
 // Footer format, in three parts:
 // * Part1
 //   -> format_version == 0 (inferred from legacy magic number)
@@ -229,7 +228,7 @@ Status FooterBuilder::Build(uint64_t magic_number, uint32_t format_version,
                             const BlockHandle& index_handle,
                             uint32_t base_context_checksum) {
   assert(magic_number != Footer::kNullTableMagicNumber);
-  assert(IsSupportedFormatVersion(format_version) ||
+  assert(IsSupportedFormatVersionForWrite(magic_number, format_version) ||
          TEST_AllowUnsupportedFormatVersion());
 
   char* part2;
@@ -251,6 +250,7 @@ Status FooterBuilder::Build(uint64_t magic_number, uint32_t format_version,
     EncodeFixed64(cur, magic_number);
     assert(cur + 8 == slice_.data() + slice_.size());
   } else {
+    // format_version == 0 is used by plain tables
     slice_ = Slice(data_.data(), Footer::kVersion0EncodedLength);
     // Legacy SST files use kCRC32c checksum but it's not stored in footer.
     assert(checksum_type == kNoChecksum || checksum_type == kCRC32c);
@@ -337,9 +337,18 @@ Status Footer::DecodeFrom(Slice input, uint64_t input_offset,
   const char* magic_ptr = input.data() + input.size() - kMagicNumberLengthByte;
   uint64_t magic = DecodeFixed64(magic_ptr);
 
-  // We check for legacy formats here and silently upconvert them
+  // Legacy block-based tables (format_version < 2) are no longer supported.
+  // (This constant is only used here and in the corresponding test.)
+  if (magic == 0xdb4775248b80fb57ull) {
+    return Status::NotSupported(
+        "Unsupported legacy magic number for block-based SST format. Load with "
+        "RocksDB >= 4.6.0 and < 11.0.0 and run full compaction to upgrade.");
+  }
+
+  // Check for legacy formats
   bool legacy = IsLegacyFooterFormat(magic);
   if (legacy) {
+    // Legacy plain tables are still supported - upconvert magic
     magic = UpconvertLegacyFooterFormat(magic);
   }
   if (enforce_table_magic_number != 0 && enforce_table_magic_number != magic) {
@@ -355,6 +364,7 @@ Status Footer::DecodeFrom(Slice input, uint64_t input_offset,
   uint32_t computed_checksum = 0;
   uint64_t footer_offset = 0;
   if (legacy) {
+    // Legacy format (format_version=0, used by plain tables)
     // The size is already asserted to be at least kMinEncodedLength
     // at the beginning of the function
     input.remove_prefix(input.size() - kVersion0EncodedLength);
@@ -363,10 +373,11 @@ Status Footer::DecodeFrom(Slice input, uint64_t input_offset,
   } else {
     part3_ptr = magic_ptr - 4;
     format_version_ = DecodeFixed32(part3_ptr);
-    if (UNLIKELY(!IsSupportedFormatVersion(format_version_) &&
+    if (UNLIKELY(!IsSupportedFormatVersionForRead(magic, format_version_) &&
                  !TEST_AllowUnsupportedFormatVersion())) {
-      return Status::Corruption("Corrupt or unsupported format_version: " +
-                                std::to_string(format_version_));
+      return Status::Corruption("Corrupt or unsupported format_version " +
+                                std::to_string(format_version_) +
+                                " for magic " + std::to_string(magic));
     }
     // All known format versions >= 1 occupy exactly this many bytes.
     if (UNLIKELY(input.size() < kNewVersionsEncodedLength)) {
@@ -701,6 +712,7 @@ Status DecompressBlockData(Decompressor::Args& args, Decompressor& decompressor,
              args.compressed_data.size());
   RecordTick(ioptions.stats, BYTES_DECOMPRESSED_TO, out_contents->data.size());
   RecordTick(ioptions.stats, NUMBER_BLOCK_DECOMPRESSED);
+  PERF_COUNTER_ADD(block_decompress_count, 1);
 
   TEST_SYNC_POINT_CALLBACK("DecompressBlockData:TamperWithReturnValue",
                            static_cast<void*>(&s));

package/deps/rocksdb/rocksdb/table/format.h

@@ -34,7 +34,6 @@ bool ShouldReportDetailedTime(Env* env, Statistics* stats);
 // the length of the magic number in bytes.
 constexpr uint32_t kMagicNumberLengthByte = 8;
 
-extern const uint64_t kLegacyBlockBasedTableMagicNumber;
 extern const uint64_t kBlockBasedTableMagicNumber;
 
 extern const uint64_t kLegacyPlainTableMagicNumber;
@@ -163,22 +162,49 @@ inline uint32_t ChecksumModifierForContext(uint32_t base_context_checksum,
   return modifier & all_or_nothing;
 }
 
-inline uint32_t GetCompressFormatForVersion(uint32_t format_version) {
-  // As of format_version 2, we encode compressed block with
-  // compress_format_version == 2. Before that, the version is 1.
-  // DO NOT CHANGE THIS FUNCTION, it affects disk format
-  // As of format_version 7 and opening up to custom compression, the
-  // compression format version is essentially independent of the block-based
-  // table format version, and encoded in the compression_name table property.
-  // Thus, this function can go away once we remove support for reading
-  // format_version=1.
-  return format_version >= 2 ? 2 : 1;
-}
+constexpr uint32_t kLatestBbtFormatVersion = 7;
 
-constexpr uint32_t kLatestFormatVersion = 7;
+// Minimum format version supported for reading SST files in block-based format.
+//
+// When phasing out old format versions, first increase the write minimum,
+// then later (>= 6 mo) increase the read minimum when removing the
+// implementation for both read and write.
+constexpr uint32_t kMinSupportedBbtFormatVersionForRead = 2;
 
-inline bool IsSupportedFormatVersion(uint32_t version) {
-  return version <= kLatestFormatVersion;
+// Minimum format version supported for writing new SST files in block-based
+// format. This should be >= kMinSupportedFormatVersionForRead.
+//
+// When phasing out old format versions, first increase the write minimum,
+// then later (>= 6 mo) increase the read minimum when removing the
+// implementation for both read and write.
+constexpr uint32_t kMinSupportedBbtFormatVersionForWrite = 2;
+static_assert(kMinSupportedBbtFormatVersionForWrite >=
+              kMinSupportedBbtFormatVersionForRead);
+
+inline bool IsSupportedFormatVersionForRead(uint64_t magic, uint32_t version) {
+  if (magic == kBlockBasedTableMagicNumber) {
+    return version >= kMinSupportedBbtFormatVersionForRead &&
+           version <= kLatestBbtFormatVersion;
+  } else if (magic == kPlainTableMagicNumber) {
+    return version == 0;
+  } else if (magic == kCuckooTableMagicNumber) {
+    return version == 1;
+  } else {
+    return false;
+  }
+}
+
+inline bool IsSupportedFormatVersionForWrite(uint64_t magic, uint32_t version) {
+  if (magic == kBlockBasedTableMagicNumber) {
+    return version >= kMinSupportedBbtFormatVersionForWrite &&
+           version <= kLatestBbtFormatVersion;
+  } else if (magic == kPlainTableMagicNumber) {
+    return version == 0;
+  } else if (magic == kCuckooTableMagicNumber) {
+    return version == 1;
+  } else {
+    return false;
+  }
 }
 
 // Same as having a unique id in footer.

package/deps/rocksdb/rocksdb/table/merging_iterator.cc

@@ -10,6 +10,7 @@
 #include "table/merging_iterator.h"
 
 #include "db/arena_wrapped_db_iter.h"
+#include "monitoring/file_read_sample.h"
 
 namespace ROCKSDB_NAMESPACE {
 // MergingIterator uses a min/max heap to combine data from point iterators.