@nxtedition/rocksdb 8.2.0 → 8.2.2

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

@@ -14,9 +14,9 @@
 
 #include "block_fetcher.h"
 #include "file/random_access_file_reader.h"
-#include "memory/memory_allocator.h"
+#include "memory/memory_allocator_impl.h"
 #include "monitoring/perf_context_imp.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "options/options_helper.h"
 #include "rocksdb/env.h"
 #include "rocksdb/options.h"
@@ -530,8 +530,8 @@ Status UncompressBlockData(const UncompressionInfo& uncompression_info,
     RecordTimeToHistogram(ioptions.stats, DECOMPRESSION_TIMES_NANOS,
                           timer.ElapsedNanos());
   }
-  RecordTimeToHistogram(ioptions.stats, BYTES_DECOMPRESSED,
-                        out_contents->data.size());
+  RecordTick(ioptions.stats, BYTES_DECOMPRESSED_FROM, size);
+  RecordTick(ioptions.stats, BYTES_DECOMPRESSED_TO, out_contents->data.size());
   RecordTick(ioptions.stats, NUMBER_BLOCK_DECOMPRESSED);
 
   TEST_SYNC_POINT_CALLBACK("UncompressBlockData:TamperWithReturnValue",

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

@@ -15,7 +15,7 @@
 
 #include "file/file_prefetch_buffer.h"
 #include "file/random_access_file_reader.h"
-#include "memory/memory_allocator.h"
+#include "memory/memory_allocator_impl.h"
 #include "options/cf_options.h"
 #include "port/malloc.h"
 #include "port/port.h"  // noexcept

package/deps/rocksdb/rocksdb/table/get_context.cc

@@ -12,7 +12,7 @@
 #include "db/wide/wide_column_serialization.h"
 #include "monitoring/file_read_sample.h"
 #include "monitoring/perf_context_imp.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/statistics.h"
 #include "rocksdb/system_clock.h"

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

@@ -115,6 +115,7 @@ void PropertyBlockBuilder::AddTableProperty(const TableProperties& props) {
     Add(TablePropertiesNames::kFastCompressionEstimatedDataSize,
         props.fast_compression_estimated_data_size);
   }
+  Add(TablePropertiesNames::kTailStartOffset, props.tail_start_offset);
   if (!props.db_id.empty()) {
     Add(TablePropertiesNames::kDbId, props.db_id);
   }
@@ -307,6 +308,8 @@ Status ReadTablePropertiesHelper(
        &new_table_properties->slow_compression_estimated_data_size},
       {TablePropertiesNames::kFastCompressionEstimatedDataSize,
        &new_table_properties->fast_compression_estimated_data_size},
+      {TablePropertiesNames::kTailStartOffset,
+       &new_table_properties->tail_start_offset},
   };
 
   std::string last_key;
@@ -412,20 +415,22 @@ Status ReadTablePropertiesHelper(
 Status ReadTableProperties(RandomAccessFileReader* file, uint64_t file_size,
                            uint64_t table_magic_number,
                            const ImmutableOptions& ioptions,
+                           const ReadOptions& read_options,
                            std::unique_ptr<TableProperties>* properties,
                            MemoryAllocator* memory_allocator,
                            FilePrefetchBuffer* prefetch_buffer) {
   BlockHandle block_handle;
   Footer footer;
-  Status s = FindMetaBlockInFile(file, file_size, table_magic_number, ioptions,
-                                 kPropertiesBlockName, &block_handle,
-                                 memory_allocator, prefetch_buffer, &footer);
+  Status s =
+      FindMetaBlockInFile(file, file_size, table_magic_number, ioptions,
+                          read_options, kPropertiesBlockName, &block_handle,
+                          memory_allocator, prefetch_buffer, &footer);
   if (!s.ok()) {
     return s;
   }
 
   if (!block_handle.IsNull()) {
-    s = ReadTablePropertiesHelper(ReadOptions(), block_handle, file,
+    s = ReadTablePropertiesHelper(read_options, block_handle, file,
                                   prefetch_buffer, footer, ioptions, properties,
                                   memory_allocator);
   } else {
@@ -473,14 +478,20 @@ Status FindMetaBlock(InternalIterator* meta_index_iter,
 Status ReadMetaIndexBlockInFile(RandomAccessFileReader* file,
                                 uint64_t file_size, uint64_t table_magic_number,
                                 const ImmutableOptions& ioptions,
+                                const ReadOptions& read_options,
                                 BlockContents* metaindex_contents,
                                 MemoryAllocator* memory_allocator,
                                 FilePrefetchBuffer* prefetch_buffer,
                                 Footer* footer_out) {
   Footer footer;
   IOOptions opts;
-  auto s = ReadFooterFromFile(opts, file, *ioptions.fs, prefetch_buffer,
-                              file_size, &footer, table_magic_number);
+  Status s;
+  s = file->PrepareIOOptions(read_options, opts);
+  if (!s.ok()) {
+    return s;
+  }
+  s = ReadFooterFromFile(opts, file, *ioptions.fs, prefetch_buffer, file_size,
+                         &footer, table_magic_number);
   if (!s.ok()) {
     return s;
   }
@@ -489,7 +500,7 @@ Status ReadMetaIndexBlockInFile(RandomAccessFileReader* file,
   }
 
   auto metaindex_handle = footer.metaindex_handle();
-  return BlockFetcher(file, prefetch_buffer, footer, ReadOptions(),
+  return BlockFetcher(file, prefetch_buffer, footer, read_options,
                       metaindex_handle, metaindex_contents, ioptions,
                       false /* do decompression */, false /*maybe_compressed*/,
                       BlockType::kMetaIndex, UncompressionDict::GetEmptyDict(),
@@ -497,18 +508,16 @@ Status ReadMetaIndexBlockInFile(RandomAccessFileReader* file,
       .ReadBlockContents();
 }
 
-Status FindMetaBlockInFile(RandomAccessFileReader* file, uint64_t file_size,
-                           uint64_t table_magic_number,
-                           const ImmutableOptions& ioptions,
-                           const std::string& meta_block_name,
-                           BlockHandle* block_handle,
-                           MemoryAllocator* memory_allocator,
-                           FilePrefetchBuffer* prefetch_buffer,
-                           Footer* footer_out) {
+Status FindMetaBlockInFile(
+    RandomAccessFileReader* file, uint64_t file_size,
+    uint64_t table_magic_number, const ImmutableOptions& ioptions,
+    const ReadOptions& read_options, const std::string& meta_block_name,
+    BlockHandle* block_handle, MemoryAllocator* memory_allocator,
+    FilePrefetchBuffer* prefetch_buffer, Footer* footer_out) {
   BlockContents metaindex_contents;
   auto s = ReadMetaIndexBlockInFile(
-      file, file_size, table_magic_number, ioptions, &metaindex_contents,
-      memory_allocator, prefetch_buffer, footer_out);
+      file, file_size, table_magic_number, ioptions, read_options,
+      &metaindex_contents, memory_allocator, prefetch_buffer, footer_out);
   if (!s.ok()) {
     return s;
   }
@@ -526,6 +535,7 @@ Status ReadMetaBlock(RandomAccessFileReader* file,
                      FilePrefetchBuffer* prefetch_buffer, uint64_t file_size,
                      uint64_t table_magic_number,
                      const ImmutableOptions& ioptions,
+                     const ReadOptions& read_options,
                      const std::string& meta_block_name, BlockType block_type,
                      BlockContents* contents,
                      MemoryAllocator* memory_allocator) {
@@ -535,15 +545,16 @@ Status ReadMetaBlock(RandomAccessFileReader* file,
 
   BlockHandle block_handle;
   Footer footer;
-  Status status = FindMetaBlockInFile(
-      file, file_size, table_magic_number, ioptions, meta_block_name,
-      &block_handle, memory_allocator, prefetch_buffer, &footer);
+  Status status =
+      FindMetaBlockInFile(file, file_size, table_magic_number, ioptions,
+                          read_options, meta_block_name, &block_handle,
+                          memory_allocator, prefetch_buffer, &footer);
   if (!status.ok()) {
     return status;
   }
 
-  return BlockFetcher(file, prefetch_buffer, footer, ReadOptions(),
-                      block_handle, contents, ioptions, false /* decompress */,
+  return BlockFetcher(file, prefetch_buffer, footer, read_options, block_handle,
+                      contents, ioptions, false /* decompress */,
                       false /*maybe_compressed*/, block_type,
                       UncompressionDict::GetEmptyDict(),
                       PersistentCacheOptions::kEmpty, memory_allocator)

package/deps/rocksdb/rocksdb/table/meta_blocks.h

@@ -119,6 +119,7 @@ Status ReadTablePropertiesHelper(
 Status ReadTableProperties(RandomAccessFileReader* file, uint64_t file_size,
                            uint64_t table_magic_number,
                            const ImmutableOptions& ioptions,
+                           const ReadOptions& read_options,
                            std::unique_ptr<TableProperties>* properties,
                            MemoryAllocator* memory_allocator = nullptr,
                            FilePrefetchBuffer* prefetch_buffer = nullptr);
@@ -139,6 +140,7 @@ Status FindMetaBlock(InternalIterator* meta_index_iter,
 Status FindMetaBlockInFile(RandomAccessFileReader* file, uint64_t file_size,
                            uint64_t table_magic_number,
                            const ImmutableOptions& ioptions,
+                           const ReadOptions& read_options,
                            const std::string& meta_block_name,
                            BlockHandle* block_handle,
                            MemoryAllocator* memory_allocator = nullptr,
@@ -149,6 +151,7 @@ Status FindMetaBlockInFile(RandomAccessFileReader* file, uint64_t file_size,
 Status ReadMetaIndexBlockInFile(RandomAccessFileReader* file,
                                 uint64_t file_size, uint64_t table_magic_number,
                                 const ImmutableOptions& ioptions,
+                                const ReadOptions& read_options,
                                 BlockContents* block_contents,
                                 MemoryAllocator* memory_allocator = nullptr,
                                 FilePrefetchBuffer* prefetch_buffer = nullptr,
@@ -161,6 +164,7 @@ Status ReadMetaBlock(RandomAccessFileReader* file,
                      FilePrefetchBuffer* prefetch_buffer, uint64_t file_size,
                      uint64_t table_magic_number,
                      const ImmutableOptions& ioptions,
+                     const ReadOptions& read_options,
                      const std::string& meta_block_name, BlockType block_type,
                      BlockContents* contents,
                      MemoryAllocator* memory_allocator = nullptr);

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

@@ -41,12 +41,14 @@ class MockTableReader : public TableReader {
              GetContext* get_context, const SliceTransform* prefix_extractor,
              bool skip_filters = false) override;
 
-  uint64_t ApproximateOffsetOf(const Slice& /*key*/,
+  uint64_t ApproximateOffsetOf(const ReadOptions& /*read_options*/,
+                               const Slice& /*key*/,
                                TableReaderCaller /*caller*/) override {
     return 0;
   }
 
-  uint64_t ApproximateSize(const Slice& /*start*/, const Slice& /*end*/,
+  uint64_t ApproximateSize(const ReadOptions& /*read_options*/,
+                           const Slice& /*start*/, const Slice& /*end*/,
                            TableReaderCaller /*caller*/) override {
     return 0;
   }

package/deps/rocksdb/rocksdb/table/persistent_cache_helper.h

@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "table/format.h"
 #include "table/persistent_cache_options.h"
 

package/deps/rocksdb/rocksdb/table/persistent_cache_options.h

@@ -7,7 +7,7 @@
 #include <string>
 
 #include "cache/cache_key.h"
-#include "monitoring/statistics.h"
+#include "monitoring/statistics_impl.h"
 #include "rocksdb/persistent_cache.h"
 
 namespace ROCKSDB_NAMESPACE {

package/deps/rocksdb/rocksdb/table/plain/plain_table_reader.cc

@@ -126,8 +126,10 @@ Status PlainTableReader::Open(
   }
 
   std::unique_ptr<TableProperties> props;
+  // TODO: plumb Env::IOActivity
+  const ReadOptions read_options;
   auto s = ReadTableProperties(file.get(), file_size, kPlainTableMagicNumber,
-                               ioptions, &props);
+                               ioptions, read_options, &props);
   if (!s.ok()) {
     return s;
   }
@@ -297,10 +299,14 @@ Status PlainTableReader::PopulateIndex(TableProperties* props,
   assert(props != nullptr);
 
   BlockContents index_block_contents;
-  Status s = ReadMetaBlock(file_info_.file.get(), nullptr /* prefetch_buffer */,
-                           file_size_, kPlainTableMagicNumber, ioptions_,
-                           PlainTableIndexBuilder::kPlainTableIndexBlock,
-                           BlockType::kIndex, &index_block_contents);
+
+  // TODO: plumb Env::IOActivity
+  const ReadOptions read_options;
+  Status s =
+      ReadMetaBlock(file_info_.file.get(), nullptr /* prefetch_buffer */,
+                    file_size_, kPlainTableMagicNumber, ioptions_, read_options,
+                    PlainTableIndexBuilder::kPlainTableIndexBlock,
+                    BlockType::kIndex, &index_block_contents);
 
   bool index_in_file = s.ok();
 
@@ -310,8 +316,8 @@ Status PlainTableReader::PopulateIndex(TableProperties* props,
   if (index_in_file) {
     s = ReadMetaBlock(file_info_.file.get(), nullptr /* prefetch_buffer */,
                       file_size_, kPlainTableMagicNumber, ioptions_,
-                      BloomBlockBuilder::kBloomBlock, BlockType::kFilter,
-                      &bloom_block_contents);
+                      read_options, BloomBlockBuilder::kBloomBlock,
+                      BlockType::kFilter, &bloom_block_contents);
     bloom_in_file = s.ok() && bloom_block_contents.data.size() > 0;
   }
 
@@ -614,12 +620,14 @@ Status PlainTableReader::Get(const ReadOptions& /*ro*/, const Slice& target,
   return Status::OK();
 }
 
-uint64_t PlainTableReader::ApproximateOffsetOf(const Slice& /*key*/,
-                                               TableReaderCaller /*caller*/) {
+uint64_t PlainTableReader::ApproximateOffsetOf(
+    const ReadOptions& /*read_options*/, const Slice& /*key*/,
+    TableReaderCaller /*caller*/) {
   return 0;
 }
 
-uint64_t PlainTableReader::ApproximateSize(const Slice& /*start*/,
+uint64_t PlainTableReader::ApproximateSize(const ReadOptions& /* read_options*/,
+                                           const Slice& /*start*/,
                                            const Slice& /*end*/,
                                            TableReaderCaller /*caller*/) {
   return 0;

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

@@ -92,11 +92,12 @@ class PlainTableReader : public TableReader {
              GetContext* get_context, const SliceTransform* prefix_extractor,
              bool skip_filters = false) override;
 
-  uint64_t ApproximateOffsetOf(const Slice& key,
+  uint64_t ApproximateOffsetOf(const ReadOptions& read_options,
+                               const Slice& key,
                                TableReaderCaller caller) override;
 
-  uint64_t ApproximateSize(const Slice& start, const Slice& end,
-                           TableReaderCaller caller) override;
+  uint64_t ApproximateSize(const ReadOptions& read_options, const Slice& start,
+                           const Slice& end, TableReaderCaller caller) override;
 
   uint32_t GetIndexSize() const { return index_.GetIndexSize(); }
   void SetupForCompaction() override;

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

@@ -165,10 +165,10 @@ Status SstFileDumper::NewTableReader(
     const ImmutableOptions& /*ioptions*/, const EnvOptions& /*soptions*/,
     const InternalKeyComparator& /*internal_comparator*/, uint64_t file_size,
     std::unique_ptr<TableReader>* /*table_reader*/) {
-  auto t_opt =
-      TableReaderOptions(ioptions_, moptions_.prefix_extractor, soptions_,
-                         internal_comparator_, false /* skip_filters */,
-                         false /* imortal */, true /* force_direct_prefetch */);
+  auto t_opt = TableReaderOptions(
+      ioptions_, moptions_.prefix_extractor, soptions_, internal_comparator_,
+      0 /* block_protection_bytes_per_key */, false /* skip_filters */,
+      false /* immortal */, true /* force_direct_prefetch */);
   // Allow open file with global sequence number for backward compatibility.
   t_opt.largest_seqno = kMaxSequenceNumber;
 
@@ -315,7 +315,8 @@ Status SstFileDumper::ShowCompressionSize(
   const uint64_t compressed_blocks =
       opts.statistics->getAndResetTickerCount(NUMBER_BLOCK_COMPRESSED);
   const uint64_t not_compressed_blocks =
-      opts.statistics->getAndResetTickerCount(NUMBER_BLOCK_NOT_COMPRESSED);
+      opts.statistics->getAndResetTickerCount(
+          NUMBER_BLOCK_COMPRESSION_REJECTED);
   // When the option enable_index_compression is true,
   // NUMBER_BLOCK_COMPRESSED is incremented for index block(s).
   if ((compressed_blocks + not_compressed_blocks) > num_data_blocks) {
@@ -355,8 +356,11 @@ Status SstFileDumper::ReadTableProperties(uint64_t table_magic_number,
                                           RandomAccessFileReader* file,
                                           uint64_t file_size,
                                           FilePrefetchBuffer* prefetch_buffer) {
+  // TODO: plumb Env::IOActivity
+  const ReadOptions read_options;
   Status s = ROCKSDB_NAMESPACE::ReadTableProperties(
-      file, file_size, table_magic_number, ioptions_, &table_properties_,
+      file, file_size, table_magic_number, ioptions_, read_options,
+      &table_properties_,
       /* memory_allocator= */ nullptr, prefetch_buffer);
   if (!s.ok()) {
     if (!silent_) {
@@ -514,4 +518,3 @@ Status SstFileDumper::ReadTableProperties(
   return init_result_;
 }
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/table/sst_file_reader.cc

@@ -56,7 +56,8 @@ Status SstFileReader::Open(const std::string& file_path) {
   }
   if (s.ok()) {
     TableReaderOptions t_opt(r->ioptions, r->moptions.prefix_extractor,
-                             r->soptions, r->ioptions.internal_comparator);
+                             r->soptions, r->ioptions.internal_comparator,
+                             r->moptions.block_protection_bytes_per_key);
     // Allow open file with global sequence number for backward compatibility.
     t_opt.largest_seqno = kMaxSequenceNumber;
     s = r->options.table_factory->NewTableReader(t_opt, std::move(file_reader),
@@ -66,6 +67,7 @@ Status SstFileReader::Open(const std::string& file_path) {
 }
 
 Iterator* SstFileReader::NewIterator(const ReadOptions& roptions) {
+  assert(roptions.io_activity == Env::IOActivity::kUnknown);
   auto r = rep_.get();
   auto sequence = roptions.snapshot != nullptr
                       ? roptions.snapshot->GetSequenceNumber()
@@ -91,9 +93,9 @@ std::shared_ptr<const TableProperties> SstFileReader::GetTableProperties()
 }
 
 Status SstFileReader::VerifyChecksum(const ReadOptions& read_options) {
+  assert(read_options.io_activity == Env::IOActivity::kUnknown);
   return rep_->table_reader->VerifyChecksum(read_options,
                                             TableReaderCaller::kSSTFileReader);
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/table/sst_file_writer.cc

@@ -134,6 +134,17 @@ struct SstFileWriter::Rep {
     if (!builder) {
       return Status::InvalidArgument("File is not opened");
     }
+    int cmp = internal_comparator.user_comparator()->CompareWithoutTimestamp(
+        begin_key, end_key);
+    if (cmp > 0) {
+      // It's an empty range where endpoints appear mistaken. Don't bother
+      // applying it to the DB, and return an error to the user.
+      return Status::InvalidArgument("end key comes before start key");
+    } else if (cmp == 0) {
+      // It's an empty range. Don't bother applying it to the DB.
+      return Status::OK();
+    }
+
     RangeTombstone tombstone(begin_key, end_key, 0 /* Sequence Number */);
     if (file_info.num_range_del_entries == 0) {
       file_info.smallest_range_del_key.assign(tombstone.start_key_.data(),

package/deps/rocksdb/rocksdb/table/table_builder.h

@@ -37,12 +37,13 @@ struct TableReaderOptions {
       const std::shared_ptr<const SliceTransform>& _prefix_extractor,
       const EnvOptions& _env_options,
       const InternalKeyComparator& _internal_comparator,
-      bool _skip_filters = false, bool _immortal = false,
-      bool _force_direct_prefetch = false, int _level = -1,
-      BlockCacheTracer* const _block_cache_tracer = nullptr,
+      uint8_t _block_protection_bytes_per_key, bool _skip_filters = false,
+      bool _immortal = false, bool _force_direct_prefetch = false,
+      int _level = -1, BlockCacheTracer* const _block_cache_tracer = nullptr,
       size_t _max_file_size_for_l0_meta_pin = 0,
       const std::string& _cur_db_session_id = "", uint64_t _cur_file_num = 0,
-      UniqueId64x2 _unique_id = {}, SequenceNumber _largest_seqno = 0)
+      UniqueId64x2 _unique_id = {}, SequenceNumber _largest_seqno = 0,
+      uint64_t _tail_size = 0)
       : ioptions(_ioptions),
         prefix_extractor(_prefix_extractor),
         env_options(_env_options),
@@ -56,7 +57,9 @@ struct TableReaderOptions {
         max_file_size_for_l0_meta_pin(_max_file_size_for_l0_meta_pin),
         cur_db_session_id(_cur_db_session_id),
         cur_file_num(_cur_file_num),
-        unique_id(_unique_id) {}
+        unique_id(_unique_id),
+        block_protection_bytes_per_key(_block_protection_bytes_per_key),
+        tail_size(_tail_size) {}
 
   const ImmutableOptions& ioptions;
   const std::shared_ptr<const SliceTransform>& prefix_extractor;
@@ -86,6 +89,10 @@ struct TableReaderOptions {
 
   // Known unique_id or {}, kNullUniqueId64x2 means unknown
   UniqueId64x2 unique_id;
+
+  uint8_t block_protection_bytes_per_key;
+
+  uint64_t tail_size;
 };
 
 struct TableBuilderOptions {
@@ -197,6 +204,8 @@ class TableBuilder {
   // is enabled.
   virtual uint64_t EstimatedFileSize() const { return FileSize(); }
 
+  virtual uint64_t GetTailSize() const { return 0; }
+
   // If the user defined table properties collector suggest the file to
   // be further compacted.
   virtual bool NeedCompact() const { return false; }

package/deps/rocksdb/rocksdb/table/table_properties.cc

@@ -303,6 +303,8 @@ const std::string TablePropertiesNames::kFastCompressionEstimatedDataSize =
     "rocksdb.sample_for_compression.fast.data.size";
 const std::string TablePropertiesNames::kSequenceNumberTimeMapping =
     "rocksdb.seqno.time.map";
+const std::string TablePropertiesNames::kTailStartOffset =
+    "rocksdb.tail.start.offset";
 
 #ifndef NDEBUG
 // WARNING: TEST_SetRandomTableProperties assumes the following layout of

package/deps/rocksdb/rocksdb/table/table_reader.h

@@ -76,7 +76,8 @@ class TableReader {
   // function and letting ApproximateSize take optional start and end, so
   // that absolute start and end can be specified and optimized without
   // key / index work.
-  virtual uint64_t ApproximateOffsetOf(const Slice& key,
+  virtual uint64_t ApproximateOffsetOf(const ReadOptions& read_options,
+                                       const Slice& key,
                                        TableReaderCaller caller) = 0;
 
   // Given start and end keys, return the approximate data size in the file
@@ -84,7 +85,8 @@ class TableReader {
   // includes effects like compression of the underlying data and applicable
   // portions of metadata including filters and indexes. Nullptr for start or
   // end (or both) indicates absolute start or end of the table.
-  virtual uint64_t ApproximateSize(const Slice& start, const Slice& end,
+  virtual uint64_t ApproximateSize(const ReadOptions& read_options,
+                                   const Slice& start, const Slice& end,
                                    TableReaderCaller caller) = 0;
 
   struct Anchor {
@@ -160,7 +162,8 @@ class TableReader {
   // Prefetch data corresponding to a give range of keys
   // Typically this functionality is required for table implementations that
   // persists the data on a non volatile storage medium like disk/SSD
-  virtual Status Prefetch(const Slice* begin = nullptr,
+  virtual Status Prefetch(const ReadOptions& /* read_options */,
+                          const Slice* begin = nullptr,
                           const Slice* end = nullptr) {
     (void)begin;
     (void)end;

package/deps/rocksdb/rocksdb/table/table_reader_bench.cc

@@ -144,7 +144,7 @@ void TableReaderBenchmark(Options& opts, EnvOptions& env_options,
         new RandomAccessFileReader(std::move(raf), file_name));
     s = opts.table_factory->NewTableReader(
         TableReaderOptions(ioptions, moptions.prefix_extractor, env_options,
-                           ikc),
+                           ikc, 0 /* block_protection_bytes_per_key */),
         std::move(file_reader), file_size, &table_reader);
     if (!s.ok()) {
       fprintf(stderr, "Open Table Error: %s\n", s.ToString().c_str());