@nxtedition/rocksdb 7.1.14 → 7.1.16

package/deps/rocksdb/rocksdb/db/table_cache.cc

@@ -116,14 +116,14 @@ void TableCache::ReleaseHandle(Cache::Handle* handle) {
 
 Status TableCache::GetTableReader(
     const ReadOptions& ro, const FileOptions& file_options,
-    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
-    bool sequential_mode, bool record_read_stats, HistogramImpl* file_read_hist,
-    std::unique_ptr<TableReader>* table_reader,
+    const InternalKeyComparator& internal_comparator,
+    const FileMetaData& file_meta, bool sequential_mode, bool record_read_stats,
+    HistogramImpl* file_read_hist, std::unique_ptr<TableReader>* table_reader,
     const std::shared_ptr<const SliceTransform>& prefix_extractor,
     bool skip_filters, int level, bool prefetch_index_and_filter_in_cache,
     size_t max_file_size_for_l0_meta_pin, Temperature file_temperature) {
-  std::string fname =
-      TableFileName(ioptions_.cf_paths, fd.GetNumber(), fd.GetPathId());
+  std::string fname = TableFileName(
+      ioptions_.cf_paths, file_meta.fd.GetNumber(), file_meta.fd.GetPathId());
   std::unique_ptr<FSRandomAccessFile> file;
   FileOptions fopts = file_options;
   fopts.temperature = file_temperature;
@@ -156,14 +156,21 @@ Status TableCache::GetTableReader(
             record_read_stats ? ioptions_.stats : nullptr, SST_READ_MICROS,
             file_read_hist, ioptions_.rate_limiter.get(), ioptions_.listeners,
             file_temperature, level == ioptions_.num_levels - 1));
+    UniqueId64x2 expected_unique_id;
+    if (ioptions_.verify_sst_unique_id_in_manifest) {
+      expected_unique_id = file_meta.unique_id;
+    } else {
+      expected_unique_id = kNullUniqueId64x2;  // null ID == no verification
+    }
     s = ioptions_.table_factory->NewTableReader(
         ro,
-        TableReaderOptions(
-            ioptions_, prefix_extractor, file_options, internal_comparator,
-            skip_filters, immortal_tables_, false /* force_direct_prefetch */,
-            level, fd.largest_seqno, block_cache_tracer_,
-            max_file_size_for_l0_meta_pin, db_session_id_, fd.GetNumber()),
-        std::move(file_reader), fd.GetFileSize(), table_reader,
+        TableReaderOptions(ioptions_, prefix_extractor, file_options,
+                           internal_comparator, skip_filters, immortal_tables_,
+                           false /* force_direct_prefetch */, level,
+                           block_cache_tracer_, max_file_size_for_l0_meta_pin,
+                           db_session_id_, file_meta.fd.GetNumber(),
+                           expected_unique_id, file_meta.fd.largest_seqno),
+        std::move(file_reader), file_meta.fd.GetFileSize(), table_reader,
         prefetch_index_and_filter_in_cache);
     TEST_SYNC_POINT("TableCache::GetTableReader:0");
   }
@@ -179,14 +186,14 @@ void TableCache::EraseHandle(const FileDescriptor& fd, Cache::Handle* handle) {
 
 Status TableCache::FindTable(
     const ReadOptions& ro, const FileOptions& file_options,
-    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
-    Cache::Handle** handle,
+    const InternalKeyComparator& internal_comparator,
+    const FileMetaData& file_meta, Cache::Handle** handle,
     const std::shared_ptr<const SliceTransform>& prefix_extractor,
     const bool no_io, bool record_read_stats, HistogramImpl* file_read_hist,
     bool skip_filters, int level, bool prefetch_index_and_filter_in_cache,
     size_t max_file_size_for_l0_meta_pin, Temperature file_temperature) {
   PERF_TIMER_GUARD_WITH_CLOCK(find_table_nanos, ioptions_.clock);
-  uint64_t number = fd.GetNumber();
+  uint64_t number = file_meta.fd.GetNumber();
   Slice key = GetSliceForFileNumber(&number);
   *handle = cache_->Lookup(key);
   TEST_SYNC_POINT_CALLBACK("TableCache::FindTable:0",
@@ -204,11 +211,12 @@ Status TableCache::FindTable(
     }
 
     std::unique_ptr<TableReader> table_reader;
-    Status s = GetTableReader(
-        ro, file_options, internal_comparator, fd, false /* sequential mode */,
-        record_read_stats, file_read_hist, &table_reader, prefix_extractor,
-        skip_filters, level, prefetch_index_and_filter_in_cache,
-        max_file_size_for_l0_meta_pin, file_temperature);
+    Status s =
+        GetTableReader(ro, file_options, internal_comparator, file_meta,
+                       false /* sequential mode */, record_read_stats,
+                       file_read_hist, &table_reader, prefix_extractor,
+                       skip_filters, level, prefetch_index_and_filter_in_cache,
+                       max_file_size_for_l0_meta_pin, file_temperature);
     if (!s.ok()) {
       assert(table_reader == nullptr);
       RecordTick(ioptions_.stats, NO_FILE_ERRORS);
@@ -236,7 +244,8 @@ InternalIterator* TableCache::NewIterator(
     TableReaderCaller caller, Arena* arena, bool skip_filters, int level,
     size_t max_file_size_for_l0_meta_pin,
     const InternalKey* smallest_compaction_key,
-    const InternalKey* largest_compaction_key, bool allow_unprepared_value) {
+    const InternalKey* largest_compaction_key, bool allow_unprepared_value,
+    TruncatedRangeDelIterator** range_del_iter) {
   PERF_TIMER_GUARD(new_table_iterator_nanos);
 
   Status s;
@@ -250,8 +259,8 @@ InternalIterator* TableCache::NewIterator(
   table_reader = fd.table_reader;
   if (table_reader == nullptr) {
     s = FindTable(
-        options, file_options, icomparator, fd, &handle, prefix_extractor,
-        options.read_tier == kBlockCacheTier /* no_io */,
+        options, file_options, icomparator, file_meta, &handle,
+        prefix_extractor, options.read_tier == kBlockCacheTier /* no_io */,
         !for_compaction /* record_read_stats */, file_read_hist, skip_filters,
         level, true /* prefetch_index_and_filter_in_cache */,
         max_file_size_for_l0_meta_pin, file_meta.temperature);
@@ -281,25 +290,40 @@ InternalIterator* TableCache::NewIterator(
       *table_reader_ptr = table_reader;
     }
   }
-  if (s.ok() && range_del_agg != nullptr && !options.ignore_range_deletions) {
-    if (range_del_agg->AddFile(fd.GetNumber())) {
-      std::unique_ptr<FragmentedRangeTombstoneIterator> range_del_iter(
-          static_cast<FragmentedRangeTombstoneIterator*>(
-              table_reader->NewRangeTombstoneIterator(options)));
-      if (range_del_iter != nullptr) {
-        s = range_del_iter->status();
+  if (s.ok() && !options.ignore_range_deletions) {
+    if (range_del_iter != nullptr) {
+      auto new_range_del_iter =
+          table_reader->NewRangeTombstoneIterator(options);
+      if (new_range_del_iter == nullptr || new_range_del_iter->empty()) {
+        delete new_range_del_iter;
+        *range_del_iter = nullptr;
+      } else {
+        *range_del_iter = new TruncatedRangeDelIterator(
+            std::unique_ptr<FragmentedRangeTombstoneIterator>(
+                new_range_del_iter),
+            &icomparator, &file_meta.smallest, &file_meta.largest);
       }
-      if (s.ok()) {
-        const InternalKey* smallest = &file_meta.smallest;
-        const InternalKey* largest = &file_meta.largest;
-        if (smallest_compaction_key != nullptr) {
-          smallest = smallest_compaction_key;
+    }
+    if (range_del_agg != nullptr) {
+      if (range_del_agg->AddFile(fd.GetNumber())) {
+        std::unique_ptr<FragmentedRangeTombstoneIterator> new_range_del_iter(
+            static_cast<FragmentedRangeTombstoneIterator*>(
+                table_reader->NewRangeTombstoneIterator(options)));
+        if (new_range_del_iter != nullptr) {
+          s = new_range_del_iter->status();
         }
-        if (largest_compaction_key != nullptr) {
-          largest = largest_compaction_key;
+        if (s.ok()) {
+          const InternalKey* smallest = &file_meta.smallest;
+          const InternalKey* largest = &file_meta.largest;
+          if (smallest_compaction_key != nullptr) {
+            smallest = smallest_compaction_key;
+          }
+          if (largest_compaction_key != nullptr) {
+            largest = largest_compaction_key;
+          }
+          range_del_agg->AddTombstones(std::move(new_range_del_iter), smallest,
+                                       largest);
         }
-        range_del_agg->AddTombstones(std::move(range_del_iter), smallest,
-                                     largest);
       }
     }
   }
@@ -325,7 +349,8 @@ Status TableCache::GetRangeTombstoneIterator(
   TableReader* t = fd.table_reader;
   Cache::Handle* handle = nullptr;
   if (t == nullptr) {
-    s = FindTable(options, file_options_, internal_comparator, fd, &handle);
+    s = FindTable(options, file_options_, internal_comparator, file_meta,
+                  &handle);
     if (s.ok()) {
       t = GetTableReaderFromHandle(handle);
     }
@@ -448,8 +473,8 @@ Status TableCache::Get(
   if (!done) {
     assert(s.ok());
     if (t == nullptr) {
-      s = FindTable(options, file_options_, internal_comparator, fd, &handle,
-                    prefix_extractor,
+      s = FindTable(options, file_options_, internal_comparator, file_meta,
+                    &handle, prefix_extractor,
                     options.read_tier == kBlockCacheTier /* no_io */,
                     true /* record_read_stats */, file_read_hist, skip_filters,
                     level, true /* prefetch_index_and_filter_in_cache */,
@@ -544,7 +569,7 @@ Status TableCache::MultiGetFilter(
                                          mget_range->end());
   if (t == nullptr) {
     s = FindTable(
-        options, file_options_, internal_comparator, fd, &handle,
+        options, file_options_, internal_comparator, file_meta, &handle,
         prefix_extractor, options.read_tier == kBlockCacheTier /* no_io */,
         true /* record_read_stats */, file_read_hist, /*skip_filters=*/false,
         level, true /* prefetch_index_and_filter_in_cache */,
@@ -573,10 +598,11 @@ Status TableCache::MultiGetFilter(
 
 Status TableCache::GetTableProperties(
     const FileOptions& file_options,
-    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
+    const InternalKeyComparator& internal_comparator,
+    const FileMetaData& file_meta,
     std::shared_ptr<const TableProperties>* properties,
     const std::shared_ptr<const SliceTransform>& prefix_extractor, bool no_io) {
-  auto table_reader = fd.table_reader;
+  auto table_reader = file_meta.fd.table_reader;
   // table already been pre-loaded?
   if (table_reader) {
     *properties = table_reader->GetTableProperties();
@@ -585,8 +611,8 @@ Status TableCache::GetTableProperties(
   }
 
   Cache::Handle* table_handle = nullptr;
-  Status s = FindTable(ReadOptions(), file_options, internal_comparator, fd,
-                       &table_handle, prefix_extractor, no_io);
+  Status s = FindTable(ReadOptions(), file_options, internal_comparator,
+                       file_meta, &table_handle, prefix_extractor, no_io);
   if (!s.ok()) {
     return s;
   }
@@ -599,12 +625,12 @@ Status TableCache::GetTableProperties(
 
 Status TableCache::ApproximateKeyAnchors(
     const ReadOptions& ro, const InternalKeyComparator& internal_comparator,
-    const FileDescriptor& fd, std::vector<TableReader::Anchor>& anchors) {
+    const FileMetaData& file_meta, std::vector<TableReader::Anchor>& anchors) {
   Status s;
-  TableReader* t = fd.table_reader;
+  TableReader* t = file_meta.fd.table_reader;
   Cache::Handle* handle = nullptr;
   if (t == nullptr) {
-    s = FindTable(ro, file_options_, internal_comparator, fd, &handle);
+    s = FindTable(ro, file_options_, internal_comparator, file_meta, &handle);
     if (s.ok()) {
       t = GetTableReaderFromHandle(handle);
     }
@@ -620,17 +646,18 @@ Status TableCache::ApproximateKeyAnchors(
 
 size_t TableCache::GetMemoryUsageByTableReader(
     const FileOptions& file_options,
-    const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
+    const InternalKeyComparator& internal_comparator,
+    const FileMetaData& file_meta,
     const std::shared_ptr<const SliceTransform>& prefix_extractor) {
-  auto table_reader = fd.table_reader;
+  auto table_reader = file_meta.fd.table_reader;
   // table already been pre-loaded?
   if (table_reader) {
     return table_reader->ApproximateMemoryUsage();
   }
 
   Cache::Handle* table_handle = nullptr;
-  Status s = FindTable(ReadOptions(), file_options, internal_comparator, fd,
-                       &table_handle, prefix_extractor, true);
+  Status s = FindTable(ReadOptions(), file_options, internal_comparator,
+                       file_meta, &table_handle, prefix_extractor, true);
   if (!s.ok()) {
     return 0;
   }
@@ -656,17 +683,18 @@ void TableCache::Evict(Cache* cache, uint64_t file_number) {
 }
 
 uint64_t TableCache::ApproximateOffsetOf(
-    const Slice& key, const FileDescriptor& fd, TableReaderCaller caller,
+    const Slice& key, const FileMetaData& file_meta, TableReaderCaller caller,
     const InternalKeyComparator& internal_comparator,
     const std::shared_ptr<const SliceTransform>& prefix_extractor) {
   uint64_t result = 0;
-  TableReader* table_reader = fd.table_reader;
+  TableReader* table_reader = file_meta.fd.table_reader;
   Cache::Handle* table_handle = nullptr;
   if (table_reader == nullptr) {
     const bool for_compaction = (caller == TableReaderCaller::kCompaction);
-    Status s = FindTable(ReadOptions(), file_options_, internal_comparator, fd,
-                         &table_handle, prefix_extractor, false /* no_io */,
-                         !for_compaction /* record_read_stats */);
+    Status s =
+        FindTable(ReadOptions(), file_options_, internal_comparator, file_meta,
+                  &table_handle, prefix_extractor, false /* no_io */,
+                  !for_compaction /* record_read_stats */);
     if (s.ok()) {
       table_reader = GetTableReaderFromHandle(table_handle);
     }
@@ -683,17 +711,18 @@ uint64_t TableCache::ApproximateOffsetOf(
 }
 
 uint64_t TableCache::ApproximateSize(
-    const Slice& start, const Slice& end, const FileDescriptor& fd,
+    const Slice& start, const Slice& end, const FileMetaData& file_meta,
     TableReaderCaller caller, const InternalKeyComparator& internal_comparator,
     const std::shared_ptr<const SliceTransform>& prefix_extractor) {
   uint64_t result = 0;
-  TableReader* table_reader = fd.table_reader;
+  TableReader* table_reader = file_meta.fd.table_reader;
   Cache::Handle* table_handle = nullptr;
   if (table_reader == nullptr) {
     const bool for_compaction = (caller == TableReaderCaller::kCompaction);
-    Status s = FindTable(ReadOptions(), file_options_, internal_comparator, fd,
-                         &table_handle, prefix_extractor, false /* no_io */,
-                         !for_compaction /* record_read_stats */);
+    Status s =
+        FindTable(ReadOptions(), file_options_, internal_comparator, file_meta,
+                  &table_handle, prefix_extractor, false /* no_io */,
+                  !for_compaction /* record_read_stats */);
     if (s.ok()) {
       table_reader = GetTableReaderFromHandle(table_handle);
     }

package/deps/rocksdb/rocksdb/db/table_cache.h

@@ -63,6 +63,11 @@ class TableCache {
   // the returned iterator.  The returned "*table_reader_ptr" object is owned
   // by the cache and should not be deleted, and is valid for as long as the
   // returned iterator is live.
+  // If !options.ignore_range_deletions, and range_del_iter is non-nullptr,
+  // then range_del_iter is set to a TruncatedRangeDelIterator for range
+  // tombstones in the SST file corresponding to the specified file number. The
+  // upper/lower bounds for the TruncatedRangeDelIterator are set to the SST
+  // file's boundary.
   // @param options Must outlive the returned iterator.
   // @param range_del_agg If non-nullptr, adds range deletions to the
   //    aggregator. If an error occurs, returns it in a NewErrorInternalIterator
@@ -79,7 +84,8 @@ class TableCache {
       TableReaderCaller caller, Arena* arena, bool skip_filters, int level,
       size_t max_file_size_for_l0_meta_pin,
       const InternalKey* smallest_compaction_key,
-      const InternalKey* largest_compaction_key, bool allow_unprepared_value);
+      const InternalKey* largest_compaction_key, bool allow_unprepared_value,
+      TruncatedRangeDelIterator** range_del_iter = nullptr);
 
   // If a seek to internal key "k" in specified file finds an entry,
   // call get_context->SaveValue() repeatedly until
@@ -154,7 +160,7 @@ class TableCache {
   Status FindTable(
       const ReadOptions& ro, const FileOptions& toptions,
       const InternalKeyComparator& internal_comparator,
-      const FileDescriptor& file_fd, Cache::Handle**,
+      const FileMetaData& file_meta, Cache::Handle**,
       const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
       const bool no_io = false, bool record_read_stats = true,
       HistogramImpl* file_read_hist = nullptr, bool skip_filters = false,
@@ -174,14 +180,14 @@ class TableCache {
   Status GetTableProperties(
       const FileOptions& toptions,
       const InternalKeyComparator& internal_comparator,
-      const FileDescriptor& file_meta,
+      const FileMetaData& file_meta,
       std::shared_ptr<const TableProperties>* properties,
       const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
       bool no_io = false);
 
   Status ApproximateKeyAnchors(const ReadOptions& ro,
                                const InternalKeyComparator& internal_comparator,
-                               const FileDescriptor& file_meta,
+                               const FileMetaData& file_meta,
                                std::vector<TableReader::Anchor>& anchors);
 
   // Return total memory usage of the table reader of the file.
@@ -189,19 +195,19 @@ class TableCache {
   size_t GetMemoryUsageByTableReader(
       const FileOptions& toptions,
       const InternalKeyComparator& internal_comparator,
-      const FileDescriptor& fd,
+      const FileMetaData& file_meta,
       const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr);
 
   // Returns approximated offset of a key in a file represented by fd.
   uint64_t ApproximateOffsetOf(
-      const Slice& key, const FileDescriptor& fd, TableReaderCaller caller,
+      const Slice& key, const FileMetaData& file_meta, TableReaderCaller caller,
       const InternalKeyComparator& internal_comparator,
       const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr);
 
   // Returns approximated data size between start and end keys in a file
   // represented by fd (the start key must not be greater than the end key).
   uint64_t ApproximateSize(
-      const Slice& start, const Slice& end, const FileDescriptor& fd,
+      const Slice& start, const Slice& end, const FileMetaData& file_meta,
       TableReaderCaller caller,
       const InternalKeyComparator& internal_comparator,
       const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr);
@@ -228,8 +234,9 @@ class TableCache {
   Status GetTableReader(
       const ReadOptions& ro, const FileOptions& file_options,
       const InternalKeyComparator& internal_comparator,
-      const FileDescriptor& fd, bool sequential_mode, bool record_read_stats,
-      HistogramImpl* file_read_hist, std::unique_ptr<TableReader>* table_reader,
+      const FileMetaData& file_meta, bool sequential_mode,
+      bool record_read_stats, HistogramImpl* file_read_hist,
+      std::unique_ptr<TableReader>* table_reader,
       const std::shared_ptr<const SliceTransform>& prefix_extractor = nullptr,
       bool skip_filters = false, int level = -1,
       bool prefetch_index_and_filter_in_cache = true,

package/deps/rocksdb/rocksdb/db/table_cache_sync_and_async.h

@@ -67,8 +67,8 @@ DEFINE_SYNC_AND_ASYNC(Status, TableCache::MultiGet)
   if (s.ok() && !table_range.empty()) {
     if (t == nullptr) {
       assert(handle == nullptr);
-      s = FindTable(options, file_options_, internal_comparator, fd, &handle,
-                    prefix_extractor,
+      s = FindTable(options, file_options_, internal_comparator, file_meta,
+                    &handle, prefix_extractor,
                     options.read_tier == kBlockCacheTier /* no_io */,
                     true /* record_read_stats */, file_read_hist, skip_filters,
                     level, true /* prefetch_index_and_filter_in_cache */,

package/deps/rocksdb/rocksdb/db/table_properties_collector.cc

@@ -43,9 +43,9 @@ Status UserKeyTablePropertiesCollector::InternalAdd(const Slice& key,
 }
 
 void UserKeyTablePropertiesCollector::BlockAdd(
-    uint64_t block_raw_bytes, uint64_t block_compressed_bytes_fast,
+    uint64_t block_uncomp_bytes, uint64_t block_compressed_bytes_fast,
     uint64_t block_compressed_bytes_slow) {
-  return collector_->BlockAdd(block_raw_bytes, block_compressed_bytes_fast,
+  return collector_->BlockAdd(block_uncomp_bytes, block_compressed_bytes_fast,
                               block_compressed_bytes_slow);
 }
 

package/deps/rocksdb/rocksdb/db/table_properties_collector.h

@@ -29,7 +29,7 @@ class IntTblPropCollector {
   virtual Status InternalAdd(const Slice& key, const Slice& value,
                              uint64_t file_size) = 0;
 
-  virtual void BlockAdd(uint64_t block_raw_bytes,
+  virtual void BlockAdd(uint64_t block_uncomp_bytes,
                         uint64_t block_compressed_bytes_fast,
                         uint64_t block_compressed_bytes_slow) = 0;
 
@@ -69,7 +69,7 @@ class UserKeyTablePropertiesCollector : public IntTblPropCollector {
   virtual Status InternalAdd(const Slice& key, const Slice& value,
                              uint64_t file_size) override;
 
-  virtual void BlockAdd(uint64_t block_raw_bytes,
+  virtual void BlockAdd(uint64_t block_uncomp_bytes,
                         uint64_t block_compressed_bytes_fast,
                         uint64_t block_compressed_bytes_slow) override;
 
@@ -143,7 +143,7 @@ class TimestampTablePropertiesCollector : public IntTblPropCollector {
     return Status::OK();
   }
 
-  void BlockAdd(uint64_t /* block_raw_bytes */,
+  void BlockAdd(uint64_t /* block_uncomp_bytes */,
                 uint64_t /* block_compressed_bytes_fast */,
                 uint64_t /* block_compressed_bytes_slow */) override {
     return;

package/deps/rocksdb/rocksdb/db/table_properties_collector_test.cc

@@ -176,7 +176,7 @@ class RegularKeysStartWithAInternal : public IntTblPropCollector {
     return Status::OK();
   }
 
-  void BlockAdd(uint64_t /* block_raw_bytes */,
+  void BlockAdd(uint64_t /* block_uncomp_bytes */,
                 uint64_t /* block_compressed_bytes_fast */,
                 uint64_t /* block_compressed_bytes_slow */) override {
     // Nothing to do.

package/deps/rocksdb/rocksdb/db/version_builder.cc

@@ -1274,7 +1274,7 @@ class VersionBuilder::Rep {
         int level = files_meta[file_idx].second;
         statuses[file_idx] = table_cache_->FindTable(
             ReadOptions(), file_options_,
-            *(base_vstorage_->InternalComparator()), file_meta->fd,
+            *(base_vstorage_->InternalComparator()), *file_meta,
             &file_meta->table_reader_handle, prefix_extractor, false /*no_io */,
             true /* record_read_stats */,
             internal_stats->GetFileReadHist(level), false, level,

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

@@ -23,6 +23,7 @@
 #include "rocksdb/advanced_options.h"
 #include "rocksdb/cache.h"
 #include "table/table_reader.h"
+#include "table/unique_id_impl.h"
 #include "util/autovector.h"
 
 namespace ROCKSDB_NAMESPACE {
@@ -104,8 +105,6 @@ constexpr uint64_t kUnknownFileCreationTime = 0;
 
 extern uint64_t PackFileNumberAndPathId(uint64_t number, uint64_t path_id);
 
-using UniqueId64x2 = std::array<uint64_t, 2>;
-
 // 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.