@nxtedition/rocksdb 13.1.4 → 13.2.0

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_iterator.cc

@@ -35,6 +35,17 @@ void BlockBasedTableIterator::SeekSecondPass(const Slice* target) {
 
 void BlockBasedTableIterator::SeekImpl(const Slice* target,
                                        bool async_prefetch) {
+  // TODO(hx235): set `seek_key_prefix_for_readahead_trimming_`
+  // even when `target == nullptr` that is when `SeekToFirst()` is called
+  if (target != nullptr && prefix_extractor_ &&
+      read_options_.prefix_same_as_start) {
+    const Slice& seek_user_key = ExtractUserKey(*target);
+    seek_key_prefix_for_readahead_trimming_ =
+        prefix_extractor_->InDomain(seek_user_key)
+            ? prefix_extractor_->Transform(seek_user_key).ToString()
+            : "";
+  }
+
   bool is_first_pass = !async_read_in_progress_;
 
   if (!is_first_pass) {
@@ -44,9 +55,9 @@ void BlockBasedTableIterator::SeekImpl(const Slice* target,
 
   ResetBlockCacheLookupVar();
 
-  bool autotune_readaheadsize = is_first_pass &&
-                                read_options_.auto_readahead_size &&
-                                read_options_.iterate_upper_bound;
+  bool autotune_readaheadsize =
+      is_first_pass && read_options_.auto_readahead_size &&
+      (read_options_.iterate_upper_bound || read_options_.prefix_same_as_start);
 
   if (autotune_readaheadsize &&
       table_->get_rep()->table_options.block_cache.get() &&
@@ -778,7 +789,7 @@ void BlockBasedTableIterator::BlockCacheLookupForReadAheadSize(
 
   size_t footer = table_->get_rep()->footer.GetBlockTrailerSize();
   if (read_curr_block && !DoesContainBlockHandles() &&
-      IsNextBlockOutOfBound()) {
+      IsNextBlockOutOfReadaheadBound()) {
     end_offset = index_iter_->value().handle.offset() + footer +
                  index_iter_->value().handle.size();
     return;
@@ -850,7 +861,7 @@ void BlockBasedTableIterator::BlockCacheLookupForReadAheadSize(
     // If curr block's index key >= iterate_upper_bound, it
     // means all the keys in next block or above are out of
     // bound.
-    if (IsNextBlockOutOfBound()) {
+    if (IsNextBlockOutOfReadaheadBound()) {
       is_index_out_of_bound_ = true;
       break;
     }

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

@@ -353,6 +353,11 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
   // is used to disable the lookup.
   IterDirection direction_ = IterDirection::kForward;
 
+  // The prefix of the key called with SeekImpl().
+  // This is for readahead trimming so no data blocks containing keys of a
+  // different prefix are prefetched
+  std::string seek_key_prefix_for_readahead_trimming_ = "";
+
   void SeekSecondPass(const Slice* target);
 
   // If `target` is null, seek to first.
@@ -408,15 +413,41 @@ class BlockBasedTableIterator : public InternalIteratorBase<Slice> {
     ClearBlockHandles();
   }
 
-  bool IsNextBlockOutOfBound() {
+  bool IsNextBlockOutOfReadaheadBound() {
+    const Slice& index_iter_user_key = index_iter_->user_key();
     // If curr block's index key >= iterate_upper_bound, it means all the keys
     // in next block or above are out of bound.
-    return (user_comparator_.CompareWithoutTimestamp(
-                index_iter_->user_key(),
-                /*a_has_ts=*/true, *read_options_.iterate_upper_bound,
-                /*b_has_ts=*/false) >= 0
-                ? true
-                : false);
+    bool out_of_upper_bound =
+        read_options_.iterate_upper_bound != nullptr &&
+        (user_comparator_.CompareWithoutTimestamp(
+             index_iter_user_key,
+             /*a_has_ts=*/true, *read_options_.iterate_upper_bound,
+             /*b_has_ts=*/false) >= 0
+             ? true
+             : false);
+    if (out_of_upper_bound) {
+      return true;
+    }
+
+    // If curr block's index key has a different prefix from the seek key's, it
+    // means all the keys in next block or above has a different prefix from the
+    // seek key's.
+    bool out_of_prefix_bound =
+        (read_options_.prefix_same_as_start &&
+         !seek_key_prefix_for_readahead_trimming_.empty() &&
+         (prefix_extractor_->InDomain(index_iter_user_key)
+              ? (prefix_extractor_->Transform(index_iter_user_key)
+                     .compare(seek_key_prefix_for_readahead_trimming_) != 0)
+              : user_comparator_.CompareWithoutTimestamp(
+                    index_iter_user_key,
+                    /*a_has_ts=*/true, seek_key_prefix_for_readahead_trimming_,
+                    /*b_has_ts=*/false) > 0));
+
+    if (out_of_prefix_bound) {
+      return true;
+    }
+
+    return false;
   }
 
   void ClearBlockHandles() {

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader.cc

@@ -137,7 +137,13 @@ extern const std::string kHashIndexPrefixesMetadataBlock;
 
 BlockBasedTable::~BlockBasedTable() {
   auto ua = rep_->uncache_aggressiveness.LoadRelaxed();
-  if (ua > 0 && rep_->table_options.block_cache) {
+  // NOTE: there is an undiagnosed incompatibility with mmap reads,
+  // where attempting to read the index below can result in bus error.
+  // In theory the mmap should remain in place until destruction of
+  // rep_, so even a page fault should be satisfiable. But also, combining
+  // mmap reads with block cache is weird, so it's not a concerning loss.
+  if (ua > 0 && rep_->table_options.block_cache &&
+      !rep_->ioptions.allow_mmap_reads) {
     if (rep_->filter) {
       rep_->filter->EraseFromCacheBeforeDestruction(ua);
     }
@@ -647,13 +653,14 @@ Status BlockBasedTable::Open(
   ro.rate_limiter_priority = read_options.rate_limiter_priority;
   ro.verify_checksums = read_options.verify_checksums;
   ro.io_activity = read_options.io_activity;
+  ro.fill_cache = read_options.fill_cache;
 
   // prefetch both index and filters, down to all partitions
   const bool prefetch_all = prefetch_index_and_filter_in_cache || level == 0;
   const bool preload_all = !table_options.cache_index_and_filter_blocks;
 
   if (!ioptions.allow_mmap_reads && !env_options.use_mmap_reads) {
-    s = PrefetchTail(ro, file.get(), file_size, force_direct_prefetch,
+    s = PrefetchTail(ro, ioptions, file.get(), file_size, force_direct_prefetch,
                      tail_prefetch_stats, prefetch_all, preload_all,
                      &prefetch_buffer, ioptions.stats, tail_size,
                      ioptions.logger);
@@ -870,7 +877,8 @@ Status BlockBasedTable::Open(
 }
 
 Status BlockBasedTable::PrefetchTail(
-    const ReadOptions& ro, RandomAccessFileReader* file, uint64_t file_size,
+    const ReadOptions& ro, const ImmutableOptions& ioptions,
+    RandomAccessFileReader* file, uint64_t file_size,
     bool force_direct_prefetch, TailPrefetchStats* tail_prefetch_stats,
     const bool prefetch_all, const bool preload_all,
     std::unique_ptr<FilePrefetchBuffer>* prefetch_buffer, Statistics* stats,
@@ -941,7 +949,7 @@ Status BlockBasedTable::PrefetchTail(
   // Use `FilePrefetchBuffer`
   prefetch_buffer->reset(new FilePrefetchBuffer(
       ReadaheadParams(), true /* enable */, true /* track_min_offset */,
-      nullptr /* fs */, nullptr /* clock */, stats,
+      ioptions.fs.get() /* fs */, nullptr /* clock */, stats,
       /* readahead_cb */ nullptr,
       FilePrefetchBufferUsage::kTableOpenPrefetchTail));
 

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

@@ -482,7 +482,8 @@ class BlockBasedTable : public TableReader {
   // If force_direct_prefetch is true, always prefetching to RocksDB
   //    buffer, rather than calling RandomAccessFile::Prefetch().
   static Status PrefetchTail(
-      const ReadOptions& ro, RandomAccessFileReader* file, uint64_t file_size,
+      const ReadOptions& ro, const ImmutableOptions& ioptions,
+      RandomAccessFileReader* file, uint64_t file_size,
       bool force_direct_prefetch, TailPrefetchStats* tail_prefetch_stats,
       const bool prefetch_all, const bool preload_all,
       std::unique_ptr<FilePrefetchBuffer>* prefetch_buffer, Statistics* stats,
@@ -500,6 +501,8 @@ class BlockBasedTable : public TableReader {
                            InternalIterator* meta_iter,
                            const InternalKeyComparator& internal_comparator,
                            BlockCacheLookupContext* lookup_context);
+  // If index and filter blocks do not need to be pinned, `prefetch_all`
+  // determines whether they will be read and add to cache.
   Status PrefetchIndexAndFilterBlocks(
       const ReadOptions& ro, FilePrefetchBuffer* prefetch_buffer,
       InternalIterator* meta_iter, BlockBasedTable* new_table,

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

@@ -303,12 +303,15 @@ DEFINE_SYNC_AND_ASYNC(void, BlockBasedTable::RetrieveMultipleBlocks)
             /*lookup_context=*/nullptr, &serialized_block,
             /*async_read=*/false, /*use_block_cache_for_lookup=*/true);
 
+        if (!s.ok()) {
+          statuses[idx_in_batch] = s;
+          continue;
+        }
         // block_entry value could be null if no block cache is present, i.e
         // BlockBasedTableOptions::no_block_cache is true and no compressed
         // block cache is configured. In that case, fall
         // through and set up the block explicitly
         if (block_entry->GetValue() != nullptr) {
-          s.PermitUncheckedError();
           continue;
         }
       }

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_test.cc

@@ -141,7 +141,8 @@ class BlockBasedTableReaderBaseTest : public testing::Test {
             TableBuilderOptions(ioptions, moptions, read_options, write_options,
                                 comparator, &factories, compression_type,
                                 compression_opts, 0 /* column_family_id */,
-                                kDefaultColumnFamilyName, -1 /* level */),
+                                kDefaultColumnFamilyName, -1 /* level */,
+                                kUnknownNewestKeyTime),
             writer.get()));
 
     // Build table.
@@ -722,6 +723,199 @@ TEST_P(ChargeTableReaderTest, Basic) {
   }
 }
 
+class StrictCapacityLimitReaderTest : public BlockBasedTableReaderTest {
+ public:
+  StrictCapacityLimitReaderTest() : BlockBasedTableReaderTest() {}
+
+ protected:
+  void ConfigureTableFactory() override {
+    BlockBasedTableOptions table_options;
+
+    table_options.block_cache = std::make_shared<
+        TargetCacheChargeTrackingCache<CacheEntryRole::kBlockBasedTableReader>>(
+        (NewLRUCache(4 * 1024, 0 /* num_shard_bits */,
+                     true /* strict_capacity_limit */)));
+
+    table_options.cache_index_and_filter_blocks = false;
+    table_options.filter_policy.reset(NewBloomFilterPolicy(10, false));
+    table_options.partition_filters = true;
+    table_options.index_type = BlockBasedTableOptions::kTwoLevelIndexSearch;
+
+    options_.table_factory.reset(NewBlockBasedTableFactory(table_options));
+  }
+};
+
+TEST_P(StrictCapacityLimitReaderTest, Get) {
+  // Test that we get error status when we exceed
+  // the strict_capacity_limit
+  Options options;
+  size_t ts_sz = options.comparator->timestamp_size();
+  std::vector<std::pair<std::string, std::string>> kv =
+      BlockBasedTableReaderBaseTest::GenerateKVMap(
+          2 /* num_block */, true /* mixed_with_human_readable_string_value */,
+          ts_sz, false);
+
+  std::string table_name = "StrictCapacityLimitReaderTest_Get" +
+                           CompressionTypeToString(compression_type_);
+
+  ImmutableOptions ioptions(options);
+  CreateTable(table_name, ioptions, compression_type_, kv);
+
+  std::unique_ptr<BlockBasedTable> table;
+  FileOptions foptions;
+  foptions.use_direct_reads = true;
+  InternalKeyComparator comparator(options.comparator);
+  NewBlockBasedTableReader(foptions, ioptions, comparator, table_name, &table,
+                           true /* prefetch_index_and_filter_in_cache */,
+                           nullptr /* status */);
+
+  ReadOptions read_opts;
+  ASSERT_OK(
+      table->VerifyChecksum(read_opts, TableReaderCaller::kUserVerifyChecksum));
+
+  bool hit_memory_limit = false;
+  for (size_t i = 0; i < kv.size(); i += 1) {
+    Slice key = kv[i].first;
+    Slice lkey = key;
+    std::string lookup_ikey;
+    // Reading the first entry in a block caches the whole block.
+    if (i % kEntriesPerBlock == 0) {
+      ASSERT_FALSE(table->TEST_KeyInCache(read_opts, lkey.ToString()));
+    } else if (!hit_memory_limit) {
+      ASSERT_TRUE(table->TEST_KeyInCache(read_opts, lkey.ToString()));
+    }
+    PinnableSlice value;
+    GetContext get_context(options.comparator, nullptr, nullptr, nullptr,
+                           GetContext::kNotFound, ExtractUserKey(key), &value,
+                           nullptr, nullptr, nullptr, nullptr,
+                           true /* do_merge */, nullptr, nullptr, nullptr,
+                           nullptr, nullptr, nullptr);
+    Status s = table->Get(read_opts, lkey, &get_context, nullptr);
+    if (!s.ok()) {
+      EXPECT_TRUE(s.IsMemoryLimit());
+      EXPECT_TRUE(s.ToString().find("Memory limit reached: Insert failed due "
+                                    "to LRU cache being full") !=
+                  std::string::npos);
+      hit_memory_limit = true;
+    } else {
+      ASSERT_EQ(value.ToString(), kv[i].second);
+      ASSERT_TRUE(table->TEST_KeyInCache(read_opts, lkey.ToString()));
+    }
+  }
+
+  ASSERT_TRUE(hit_memory_limit);
+}
+
+TEST_P(StrictCapacityLimitReaderTest, MultiGet) {
+  // Test that we get error status when we exceed
+  // the strict_capacity_limit
+  Options options;
+  ReadOptions read_opts;
+  std::string dummy_ts(sizeof(uint64_t), '\0');
+  Slice read_timestamp = dummy_ts;
+  if (udt_enabled_) {
+    options.comparator = test::BytewiseComparatorWithU64TsWrapper();
+    read_opts.timestamp = &read_timestamp;
+  }
+  options.persist_user_defined_timestamps = persist_udt_;
+  size_t ts_sz = options.comparator->timestamp_size();
+  std::vector<std::pair<std::string, std::string>> kv =
+      BlockBasedTableReaderBaseTest::GenerateKVMap(
+          2 /* num_block */, true /* mixed_with_human_readable_string_value */,
+          ts_sz);
+
+  // Prepare keys, values, and statuses for MultiGet.
+  autovector<Slice, MultiGetContext::MAX_BATCH_SIZE> keys;
+  autovector<Slice, MultiGetContext::MAX_BATCH_SIZE> keys_without_timestamps;
+  autovector<PinnableSlice, MultiGetContext::MAX_BATCH_SIZE> values;
+  autovector<Status, MultiGetContext::MAX_BATCH_SIZE> statuses;
+  autovector<const std::string*, MultiGetContext::MAX_BATCH_SIZE>
+      expected_values;
+  {
+    const int step =
+        static_cast<int>(kv.size()) / MultiGetContext::MAX_BATCH_SIZE;
+    auto it = kv.begin();
+    for (int i = 0; i < MultiGetContext::MAX_BATCH_SIZE; i++) {
+      keys.emplace_back(it->first);
+      if (ts_sz > 0) {
+        Slice ukey_without_ts =
+            ExtractUserKeyAndStripTimestamp(it->first, ts_sz);
+        keys_without_timestamps.push_back(ukey_without_ts);
+      } else {
+        keys_without_timestamps.emplace_back(ExtractUserKey(it->first));
+      }
+      values.emplace_back();
+      statuses.emplace_back();
+      expected_values.push_back(&(it->second));
+      std::advance(it, step);
+    }
+  }
+
+  std::string table_name = "StrictCapacityLimitReaderTest_MultiGet" +
+                           CompressionTypeToString(compression_type_);
+
+  ImmutableOptions ioptions(options);
+  CreateTable(table_name, ioptions, compression_type_, kv,
+              compression_parallel_threads_, compression_dict_bytes_);
+
+  std::unique_ptr<BlockBasedTable> table;
+  FileOptions foptions;
+  foptions.use_direct_reads = use_direct_reads_;
+  InternalKeyComparator comparator(options.comparator);
+  NewBlockBasedTableReader(foptions, ioptions, comparator, table_name, &table,
+                           true /* bool prefetch_index_and_filter_in_cache */,
+                           nullptr /* status */, persist_udt_);
+
+  ASSERT_OK(
+      table->VerifyChecksum(read_opts, TableReaderCaller::kUserVerifyChecksum));
+
+  // Ensure that keys are not in cache before MultiGet.
+  for (auto& key : keys) {
+    ASSERT_FALSE(table->TEST_KeyInCache(read_opts, key.ToString()));
+  }
+
+  // Prepare MultiGetContext.
+  autovector<GetContext, MultiGetContext::MAX_BATCH_SIZE> get_context;
+  autovector<KeyContext, MultiGetContext::MAX_BATCH_SIZE> key_context;
+  autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE> sorted_keys;
+  for (size_t i = 0; i < keys.size(); ++i) {
+    get_context.emplace_back(options.comparator, nullptr, nullptr, nullptr,
+                             GetContext::kNotFound, ExtractUserKey(keys[i]),
+                             &values[i], nullptr, nullptr, nullptr, nullptr,
+                             true /* do_merge */, nullptr, nullptr, nullptr,
+                             nullptr, nullptr, nullptr);
+    key_context.emplace_back(nullptr, keys_without_timestamps[i], &values[i],
+                             nullptr, nullptr, &statuses.back());
+    key_context.back().get_context = &get_context.back();
+  }
+  for (auto& key_ctx : key_context) {
+    sorted_keys.emplace_back(&key_ctx);
+  }
+  MultiGetContext ctx(&sorted_keys, 0, sorted_keys.size(), 0, read_opts,
+                      fs_.get(), nullptr);
+
+  // Execute MultiGet.
+  MultiGetContext::Range range = ctx.GetMultiGetRange();
+  PerfContext* perf_ctx = get_perf_context();
+  perf_ctx->Reset();
+  table->MultiGet(read_opts, &range, nullptr);
+
+  ASSERT_GE(perf_ctx->block_read_count - perf_ctx->index_block_read_count -
+                perf_ctx->filter_block_read_count -
+                perf_ctx->compression_dict_block_read_count,
+            1);
+  ASSERT_GE(perf_ctx->block_read_byte, 1);
+
+  bool hit_memory_limit = false;
+  for (const Status& status : statuses) {
+    if (!status.ok()) {
+      EXPECT_TRUE(status.IsMemoryLimit());
+      hit_memory_limit = true;
+    }
+  }
+  ASSERT_TRUE(hit_memory_limit);
+}
+
 class BlockBasedTableReaderTestVerifyChecksum
     : public BlockBasedTableReaderTest {
  public:
@@ -828,6 +1022,15 @@ INSTANTIATE_TEST_CASE_P(
         ::testing::Values(false), ::testing::ValuesIn(test::GetUDTTestModes()),
         ::testing::Values(1, 2), ::testing::Values(0, 4096),
         ::testing::Values(false, true)));
+INSTANTIATE_TEST_CASE_P(
+    StrictCapacityLimitReaderTest, StrictCapacityLimitReaderTest,
+    ::testing::Combine(
+        ::testing::ValuesIn(GetSupportedCompressions()), ::testing::Bool(),
+        ::testing::Values(
+            BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch),
+        ::testing::Values(false), ::testing::ValuesIn(test::GetUDTTestModes()),
+        ::testing::Values(1, 2), ::testing::Values(0),
+        ::testing::Values(false, true)));
 INSTANTIATE_TEST_CASE_P(
     VerifyChecksum, BlockBasedTableReaderTestVerifyChecksum,
     ::testing::Combine(

package/deps/rocksdb/rocksdb/table/block_based/data_block_hash_index_test.cc

@@ -555,13 +555,13 @@ void TestBoundary(InternalKey& ik1, std::string& v1, InternalKey& ik2,
   std::string column_family_name;
   const ReadOptions read_options;
   const WriteOptions write_options;
-  builder.reset(ioptions.table_factory->NewTableBuilder(
+  builder.reset(moptions.table_factory->NewTableBuilder(
       TableBuilderOptions(
           ioptions, moptions, read_options, write_options, internal_comparator,
           &internal_tbl_prop_coll_factories, options.compression,
           CompressionOptions(),
           TablePropertiesCollectorFactory::Context::kUnknownColumnFamily,
-          column_family_name, level_),
+          column_family_name, level_, kUnknownNewestKeyTime),
       file_writer.get()));
 
   builder->Add(ik1.Encode().ToString(), v1);
@@ -581,7 +581,7 @@ void TestBoundary(InternalKey& ik1, std::string& v1, InternalKey& ik2,
   file_reader.reset(new RandomAccessFileReader(std::move(file), "test"));
   const bool kSkipFilters = true;
   const bool kImmortal = true;
-  ASSERT_OK(ioptions.table_factory->NewTableReader(
+  ASSERT_OK(moptions.table_factory->NewTableReader(
       TableReaderOptions(ioptions, moptions.prefix_extractor, soptions,
                          internal_comparator,
                          0 /* block_protection_bytes_per_key */, !kSkipFilters,

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

@@ -83,7 +83,8 @@ class BlockFetcherTest : public testing::Test {
         TableBuilderOptions(ioptions, moptions, read_options, write_options,
                             comparator, &factories, compression_type,
                             CompressionOptions(), 0 /* column_family_id */,
-                            kDefaultColumnFamilyName, -1 /* level */),
+                            kDefaultColumnFamilyName, -1 /* level */,
+                            kUnknownNewestKeyTime),
         writer.get()));
 
     // Build table.

package/deps/rocksdb/rocksdb/table/cuckoo/cuckoo_table_factory.h

@@ -73,6 +73,10 @@ class CuckooTableFactory : public TableFactory {
 
   std::string GetPrintableOptions() const override;
 
+  std::unique_ptr<TableFactory> Clone() const override {
+    return std::make_unique<CuckooTableFactory>(*this);
+  }
+
  private:
   CuckooTableOptions table_options_;
 };

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

@@ -560,9 +560,9 @@ Status ReadFooterFromFile(const IOOptions& opts, RandomAccessFileReader* file,
     IOOptions new_opts = opts;
     new_opts.verify_and_reconstruct_read = true;
     footer->Reset();
-    s = ReadFooterFromFileInternal(new_opts, file, fs, prefetch_buffer,
-                                   file_size, footer,
-                                   enforce_table_magic_number);
+    s = ReadFooterFromFileInternal(new_opts, file, fs,
+                                   /*prefetch_buffer=*/nullptr, file_size,
+                                   footer, enforce_table_magic_number);
     RecordTick(stats, FILE_READ_CORRUPTION_RETRY_COUNT);
     if (s.ok()) {
       RecordTick(stats, FILE_READ_CORRUPTION_RETRY_SUCCESS_COUNT);

package/deps/rocksdb/rocksdb/table/meta_blocks.cc

@@ -105,6 +105,7 @@ void PropertyBlockBuilder::AddTableProperty(const TableProperties& props) {
   Add(TablePropertiesNames::kColumnFamilyId, props.column_family_id);
   Add(TablePropertiesNames::kCreationTime, props.creation_time);
   Add(TablePropertiesNames::kOldestKeyTime, props.oldest_key_time);
+  Add(TablePropertiesNames::kNewestKeyTime, props.newest_key_time);
   if (props.file_creation_time > 0) {
     Add(TablePropertiesNames::kFileCreationTime, props.file_creation_time);
   }
@@ -368,6 +369,8 @@ Status ReadTablePropertiesHelper(
          &new_table_properties->creation_time},
         {TablePropertiesNames::kOldestKeyTime,
          &new_table_properties->oldest_key_time},
+        {TablePropertiesNames::kNewestKeyTime,
+         &new_table_properties->newest_key_time},
         {TablePropertiesNames::kFileCreationTime,
          &new_table_properties->file_creation_time},
         {TablePropertiesNames::kSlowCompressionEstimatedDataSize,
@@ -570,7 +573,7 @@ Status ReadMetaIndexBlockInFile(RandomAccessFileReader* file,
     return s;
   }
   s = ReadFooterFromFile(opts, file, *ioptions.fs, prefetch_buffer, file_size,
-                         &footer, table_magic_number);
+                         &footer, table_magic_number, ioptions.stats);
   if (!s.ok()) {
     return s;
   }

package/deps/rocksdb/rocksdb/table/mock_table.cc

@@ -25,45 +25,6 @@ void SortKVVector(KVVector* kv_vector, const Comparator* ucmp) {
             });
 }
 
-class MockTableReader : public TableReader {
- public:
-  explicit MockTableReader(const KVVector& table) : table_(table) {}
-
-  InternalIterator* NewIterator(const ReadOptions&,
-                                const SliceTransform* prefix_extractor,
-                                Arena* arena, bool skip_filters,
-                                TableReaderCaller caller,
-                                size_t compaction_readahead_size = 0,
-                                bool allow_unprepared_value = false) override;
-
-  Status Get(const ReadOptions& readOptions, const Slice& key,
-             GetContext* get_context, const SliceTransform* prefix_extractor,
-             bool skip_filters = false) override;
-
-  uint64_t ApproximateOffsetOf(const ReadOptions& /*read_options*/,
-                               const Slice& /*key*/,
-                               TableReaderCaller /*caller*/) override {
-    return 0;
-  }
-
-  uint64_t ApproximateSize(const ReadOptions& /*read_options*/,
-                           const Slice& /*start*/, const Slice& /*end*/,
-                           TableReaderCaller /*caller*/) override {
-    return 0;
-  }
-
-  size_t ApproximateMemoryUsage() const override { return 0; }
-
-  void SetupForCompaction() override {}
-
-  std::shared_ptr<const TableProperties> GetTableProperties() const override;
-
-  ~MockTableReader() = default;
-
- private:
-  const KVVector& table_;
-};
-
 class MockTableIterator : public InternalIterator {
  public:
   explicit MockTableIterator(const KVVector& table) : table_(table) {
@@ -233,17 +194,6 @@ Status MockTableReader::Get(const ReadOptions&, const Slice& key,
   return Status::OK();
 }
 
-std::shared_ptr<const TableProperties> MockTableReader::GetTableProperties()
-    const {
-  TableProperties* tp = new TableProperties();
-  tp->num_entries = table_.size();
-  tp->num_range_deletions = 0;
-  tp->raw_key_size = 1;
-  tp->raw_value_size = 1;
-
-  return std::shared_ptr<const TableProperties>(tp);
-}
-
 MockTableFactory::MockTableFactory()
     : next_id_(1), corrupt_mode_(MockTableFactory::kCorruptNone) {}
 

package/deps/rocksdb/rocksdb/table/mock_table.h

@@ -76,6 +76,9 @@ class MockTableFactory : public TableFactory {
   // contents are equal to file_contents
   void AssertSingleFile(const KVVector& file_contents);
   void AssertLatestFiles(const std::vector<KVVector>& files_contents);
+  std::unique_ptr<TableFactory> Clone() const override {
+    return nullptr;  // Not implemented
+  }
 
  private:
   Status GetAndWriteNextID(WritableFileWriter* file, uint32_t* id) const;
@@ -88,5 +91,55 @@ class MockTableFactory : public TableFactory {
   size_t key_value_size_ = 1;
 };
 
+class MockTableReader : public TableReader {
+ public:
+  explicit MockTableReader(const mock::KVVector& table) : table_(table) {
+    tp_.num_entries = table_.size();
+    tp_.num_range_deletions = 0;
+    tp_.raw_key_size = 1;
+    tp_.raw_value_size = 1;
+  }
+  explicit MockTableReader(const mock::KVVector& table,
+                           const TableProperties& tp)
+      : table_(table), tp_(tp) {}
+
+  virtual InternalIterator* NewIterator(
+      const ReadOptions&, const SliceTransform* prefix_extractor, Arena* arena,
+      bool skip_filters, TableReaderCaller caller,
+      size_t compaction_readahead_size = 0,
+      bool allow_unprepared_value = false) override;
+
+  virtual Status Get(const ReadOptions& readOptions, const Slice& key,
+                     GetContext* get_context,
+                     const SliceTransform* prefix_extractor,
+                     bool skip_filters = false) override;
+
+  virtual uint64_t ApproximateOffsetOf(const ReadOptions& /*read_options*/,
+                                       const Slice& /*key*/,
+                                       TableReaderCaller /*caller*/) override {
+    return 0;
+  }
+
+  virtual uint64_t ApproximateSize(const ReadOptions& /*read_options*/,
+                                   const Slice& /*start*/, const Slice& /*end*/,
+                                   TableReaderCaller /*caller*/) override {
+    return 0;
+  }
+
+  virtual size_t ApproximateMemoryUsage() const override { return 0; }
+
+  virtual void SetupForCompaction() override {}
+
+  virtual std::shared_ptr<const TableProperties> GetTableProperties()
+      const override {
+    return std::make_shared<const TableProperties>(tp_);
+  }
+
+  ~MockTableReader() = default;
+
+ private:
+  const KVVector& table_;
+  TableProperties tp_;
+};
 }  // namespace mock
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/table/plain/plain_table_factory.h

@@ -173,6 +173,10 @@ class PlainTableFactory : public TableFactory {
   std::string GetPrintableOptions() const override;
   static const char kValueTypeSeqId0 = char(~0);
 
+  std::unique_ptr<TableFactory> Clone() const override {
+    return std::make_unique<PlainTableFactory>(*this);
+  }
+
  private:
   PlainTableOptions table_options_;
 };

package/deps/rocksdb/rocksdb/table/sst_file_dumper.cc

@@ -311,7 +311,7 @@ Status SstFileDumper::ShowCompressionSize(
       imoptions, moptions, read_options, write_options, ikc,
       &block_based_table_factories, compress_type, compress_opt,
       TablePropertiesCollectorFactory::Context::kUnknownColumnFamily,
-      column_family_name, unknown_level);
+      column_family_name, unknown_level, kUnknownNewestKeyTime);
   uint64_t num_data_blocks = 0;
   std::chrono::steady_clock::time_point start =
       std::chrono::steady_clock::now();