rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/table/block_based/partitioned_index_reader.cc

@@ -1,264 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#include "table/block_based/partitioned_index_reader.h"
-
-#include "block_cache.h"
-#include "file/random_access_file_reader.h"
-#include "table/block_based/block_based_table_reader.h"
-#include "table/block_based/partitioned_index_iterator.h"
-
-namespace ROCKSDB_NAMESPACE {
-Status PartitionIndexReader::Create(
-    const BlockBasedTable* table, const ReadOptions& ro,
-    FilePrefetchBuffer* prefetch_buffer, bool use_cache, bool prefetch,
-    bool pin, BlockCacheLookupContext* lookup_context,
-    std::unique_ptr<IndexReader>* index_reader) {
-  assert(table != nullptr);
-  assert(table->get_rep());
-  assert(!pin || prefetch);
-  assert(index_reader != nullptr);
-
-  CachableEntry<Block> index_block;
-  if (prefetch || !use_cache) {
-    const Status s =
-        ReadIndexBlock(table, prefetch_buffer, ro, use_cache,
-                       /*get_context=*/nullptr, lookup_context, &index_block);
-    if (!s.ok()) {
-      return s;
-    }
-
-    if (use_cache && !pin) {
-      index_block.Reset();
-    }
-  }
-
-  index_reader->reset(new PartitionIndexReader(table, std::move(index_block)));
-
-  return Status::OK();
-}
-
-InternalIteratorBase<IndexValue>* PartitionIndexReader::NewIterator(
-    const ReadOptions& read_options, bool /* disable_prefix_seek */,
-    IndexBlockIter* iter, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context) {
-  CachableEntry<Block> index_block;
-  const Status s = GetOrReadIndexBlock(get_context, lookup_context,
-                                       &index_block, read_options);
-  if (!s.ok()) {
-    if (iter != nullptr) {
-      iter->Invalidate(s);
-      return iter;
-    }
-
-    return NewErrorInternalIterator<IndexValue>(s);
-  }
-
-  const BlockBasedTable::Rep* rep = table()->rep_;
-  InternalIteratorBase<IndexValue>* it = nullptr;
-
-  Statistics* kNullStats = nullptr;
-  // Filters are already checked before seeking the index
-  if (!partition_map_.empty()) {
-    // We don't return pinned data from index blocks, so no need
-    // to set `block_contents_pinned`.
-    it = NewTwoLevelIterator(
-        new BlockBasedTable::PartitionedIndexIteratorState(table(),
-                                                           &partition_map_),
-        index_block.GetValue()->NewIndexIterator(
-            internal_comparator()->user_comparator(),
-            rep->get_global_seqno(BlockType::kIndex), nullptr, kNullStats, true,
-            index_has_first_key(), index_key_includes_seq(),
-            index_value_is_full(), false /* block_contents_pinned */,
-            user_defined_timestamps_persisted()));
-  } else {
-    ReadOptions ro{read_options};
-    // FIXME? Possible regression seen in prefetch_test if this field is
-    // propagated
-    ro.readahead_size = ReadOptions{}.readahead_size;
-
-    // We don't return pinned data from index blocks, so no need
-    // to set `block_contents_pinned`.
-    std::unique_ptr<InternalIteratorBase<IndexValue>> index_iter(
-        index_block.GetValue()->NewIndexIterator(
-            internal_comparator()->user_comparator(),
-            rep->get_global_seqno(BlockType::kIndex), nullptr, kNullStats, true,
-            index_has_first_key(), index_key_includes_seq(),
-            index_value_is_full(), false /* block_contents_pinned */,
-            user_defined_timestamps_persisted()));
-
-    it = new PartitionedIndexIterator(
-        table(), ro, *internal_comparator(), std::move(index_iter),
-        lookup_context ? lookup_context->caller
-                       : TableReaderCaller::kUncategorized);
-  }
-
-  assert(it != nullptr);
-  index_block.TransferTo(it);
-
-  return it;
-
-  // TODO(myabandeh): Update TwoLevelIterator to be able to make use of
-  // on-stack BlockIter while the state is on heap. Currentlly it assumes
-  // the first level iter is always on heap and will attempt to delete it
-  // in its destructor.
-}
-Status PartitionIndexReader::CacheDependencies(
-    const ReadOptions& ro, bool pin, FilePrefetchBuffer* tail_prefetch_buffer) {
-  if (!partition_map_.empty()) {
-    // The dependencies are already cached since `partition_map_` is filled in
-    // an all-or-nothing manner.
-    return Status::OK();
-  }
-  // Before read partitions, prefetch them to avoid lots of IOs
-  BlockCacheLookupContext lookup_context{TableReaderCaller::kPrefetch};
-  const BlockBasedTable::Rep* rep = table()->rep_;
-  IndexBlockIter biter;
-  BlockHandle handle;
-  Statistics* kNullStats = nullptr;
-
-  CachableEntry<Block> index_block;
-  {
-    Status s = GetOrReadIndexBlock(nullptr /* get_context */, &lookup_context,
-                                   &index_block, ro);
-    if (!s.ok()) {
-      return s;
-    }
-  }
-
-  // We don't return pinned data from index blocks, so no need
-  // to set `block_contents_pinned`.
-  index_block.GetValue()->NewIndexIterator(
-      internal_comparator()->user_comparator(),
-      rep->get_global_seqno(BlockType::kIndex), &biter, kNullStats, true,
-      index_has_first_key(), index_key_includes_seq(), index_value_is_full(),
-      false /* block_contents_pinned */, user_defined_timestamps_persisted());
-  // Index partitions are assumed to be consecuitive. Prefetch them all.
-  // Read the first block offset
-  biter.SeekToFirst();
-  if (!biter.Valid()) {
-    // Empty index.
-    return biter.status();
-  }
-  handle = biter.value().handle;
-  uint64_t prefetch_off = handle.offset();
-
-  // Read the last block's offset
-  biter.SeekToLast();
-  if (!biter.Valid()) {
-    // Empty index.
-    return biter.status();
-  }
-  handle = biter.value().handle;
-  uint64_t last_off =
-      handle.offset() + BlockBasedTable::BlockSizeWithTrailer(handle);
-  uint64_t prefetch_len = last_off - prefetch_off;
-  std::unique_ptr<FilePrefetchBuffer> prefetch_buffer;
-  if (tail_prefetch_buffer == nullptr || !tail_prefetch_buffer->Enabled() ||
-      tail_prefetch_buffer->GetPrefetchOffset() > prefetch_off) {
-    rep->CreateFilePrefetchBuffer(ReadaheadParams(), &prefetch_buffer,
-                                  /*readaheadsize_cb*/ nullptr,
-                                  /*usage=*/FilePrefetchBufferUsage::kUnknown);
-    IOOptions opts;
-    {
-      Status s = rep->file->PrepareIOOptions(ro, opts);
-      if (s.ok()) {
-        s = prefetch_buffer->Prefetch(opts, rep->file.get(), prefetch_off,
-                                      static_cast<size_t>(prefetch_len));
-      }
-      if (!s.ok()) {
-        return s;
-      }
-    }
-  }
-  // For saving "all or nothing" to partition_map_
-  UnorderedMap<uint64_t, CachableEntry<Block>> map_in_progress;
-
-  // After prefetch, read the partitions one by one
-  biter.SeekToFirst();
-  size_t partition_count = 0;
-  for (; biter.Valid(); biter.Next()) {
-    handle = biter.value().handle;
-    CachableEntry<Block> block;
-    ++partition_count;
-    // TODO: Support counter batch update for partitioned index and
-    // filter blocks
-    Status s = table()->MaybeReadBlockAndLoadToCache(
-        prefetch_buffer ? prefetch_buffer.get() : tail_prefetch_buffer, ro,
-        handle, UncompressionDict::GetEmptyDict(),
-        /*for_compaction=*/false, &block.As<Block_kIndex>(),
-        /*get_context=*/nullptr, &lookup_context, /*contents=*/nullptr,
-        /*async_read=*/false, /*use_block_cache_for_lookup=*/true);
-
-    if (!s.ok()) {
-      return s;
-    }
-    if (block.GetValue() != nullptr) {
-      // Might need to "pin" some mmap-read blocks (GetOwnValue) if some
-      // partitions are successfully compressed (cached) and some are not
-      // compressed (mmap eligible)
-      if (block.IsCached() || block.GetOwnValue()) {
-        if (pin) {
-          map_in_progress[handle.offset()] = std::move(block);
-        }
-      }
-    }
-  }
-  Status s = biter.status();
-  // Save (pin) them only if everything checks out
-  if (map_in_progress.size() == partition_count && s.ok()) {
-    std::swap(partition_map_, map_in_progress);
-  }
-  return s;
-}
-
-void PartitionIndexReader::EraseFromCacheBeforeDestruction(
-    uint32_t uncache_aggressiveness) {
-  // NOTE: essentially a copy of
-  // PartitionedFilterBlockReader::EraseFromCacheBeforeDestruction
-  if (uncache_aggressiveness > 0) {
-    CachableEntry<Block> top_level_block;
-
-    ReadOptions ro_no_io;
-    ro_no_io.read_tier = ReadTier::kBlockCacheTier;
-    GetOrReadIndexBlock(/*get_context=*/nullptr,
-                        /*lookup_context=*/nullptr, &top_level_block, ro_no_io)
-        .PermitUncheckedError();
-
-    if (!partition_map_.empty()) {
-      // All partitions present if any
-      for (auto& e : partition_map_) {
-        e.second.ResetEraseIfLastRef();
-      }
-    } else if (!top_level_block.IsEmpty()) {
-      IndexBlockIter biter;
-      const InternalKeyComparator* const comparator = internal_comparator();
-      Statistics* kNullStats = nullptr;
-      top_level_block.GetValue()->NewIndexIterator(
-          comparator->user_comparator(),
-          table()->get_rep()->get_global_seqno(BlockType::kIndex), &biter,
-          kNullStats, true /* total_order_seek */, index_has_first_key(),
-          index_key_includes_seq(), index_value_is_full(),
-          false /* block_contents_pinned */,
-          user_defined_timestamps_persisted());
-
-      UncacheAggressivenessAdvisor advisor(uncache_aggressiveness);
-      for (biter.SeekToFirst(); biter.Valid() && advisor.ShouldContinue();
-           biter.Next()) {
-        bool erased = table()->EraseFromCache(biter.value().handle);
-        advisor.Report(erased);
-      }
-      biter.status().PermitUncheckedError();
-    }
-    top_level_block.ResetEraseIfLastRef();
-  }
-  // Might be needed to un-cache a pinned top-level block
-  BlockBasedTable::IndexReaderCommon::EraseFromCacheBeforeDestruction(
-      uncache_aggressiveness);
-}
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/partitioned_index_reader.h

@@ -1,58 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#pragma once
-#include "table/block_based/index_reader_common.h"
-#include "util/hash_containers.h"
-
-namespace ROCKSDB_NAMESPACE {
-// Index that allows binary search lookup in a two-level index structure.
-class PartitionIndexReader : public BlockBasedTable::IndexReaderCommon {
- public:
-  // Read the partition index from the file and create an instance for
-  // `PartitionIndexReader`.
-  // On success, index_reader will be populated; otherwise it will remain
-  // unmodified.
-  static Status Create(const BlockBasedTable* table, const ReadOptions& ro,
-                       FilePrefetchBuffer* prefetch_buffer, bool use_cache,
-                       bool prefetch, bool pin,
-                       BlockCacheLookupContext* lookup_context,
-                       std::unique_ptr<IndexReader>* index_reader);
-
-  // return a two-level iterator: first level is on the partition index
-  InternalIteratorBase<IndexValue>* NewIterator(
-      const ReadOptions& read_options, bool /* disable_prefix_seek */,
-      IndexBlockIter* iter, GetContext* get_context,
-      BlockCacheLookupContext* lookup_context) override;
-
-  Status CacheDependencies(const ReadOptions& ro, bool pin,
-                           FilePrefetchBuffer* tail_prefetch_buffer) override;
-  size_t ApproximateMemoryUsage() const override {
-    size_t usage = ApproximateIndexBlockMemoryUsage();
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-    usage += malloc_usable_size(const_cast<PartitionIndexReader*>(this));
-#else
-    usage += sizeof(*this);
-#endif  // ROCKSDB_MALLOC_USABLE_SIZE
-    // TODO(myabandeh): more accurate estimate of partition_map_ mem usage
-    return usage;
-  }
-  void EraseFromCacheBeforeDestruction(
-      uint32_t /*uncache_aggressiveness*/) override;
-
- private:
-  PartitionIndexReader(const BlockBasedTable* t,
-                       CachableEntry<Block>&& index_block)
-      : IndexReaderCommon(t, std::move(index_block)) {}
-
-  // For partition blocks pinned in cache. This is expected to be "all or
-  // none" so that !partition_map_.empty() can use an iterator expecting
-  // all partitions to be saved here.
-  UnorderedMap<uint64_t, CachableEntry<Block>> partition_map_;
-};
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/reader_common.cc

@@ -1,64 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#include "table/block_based/reader_common.h"
-
-#include "monitoring/perf_context_imp.h"
-#include "rocksdb/table.h"
-#include "table/format.h"
-#include "util/coding.h"
-#include "util/crc32c.h"
-#include "util/string_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-void ForceReleaseCachedEntry(void* arg, void* h) {
-  Cache* cache = static_cast<Cache*>(arg);
-  Cache::Handle* handle = static_cast<Cache::Handle*>(h);
-  cache->Release(handle, true /* erase_if_last_ref */);
-}
-
-// WART: this is specific to block-based table
-Status VerifyBlockChecksum(const Footer& footer, const char* data,
-                           size_t block_size, const std::string& file_name,
-                           uint64_t offset) {
-  PERF_TIMER_GUARD(block_checksum_time);
-
-  assert(footer.GetBlockTrailerSize() == 5);
-  ChecksumType type = footer.checksum_type();
-
-  // After block_size bytes is compression type (1 byte), which is part of
-  // the checksummed section.
-  size_t len = block_size + 1;
-  // And then the stored checksum value (4 bytes).
-  uint32_t stored = DecodeFixed32(data + len);
-
-  uint32_t computed = ComputeBuiltinChecksum(type, data, len);
-
-  // Unapply context to 'stored' rather than apply to 'computed, for people
-  // who might look for reference crc value in error message
-  uint32_t modifier =
-      ChecksumModifierForContext(footer.base_context_checksum(), offset);
-  stored -= modifier;
-
-  if (stored == computed) {
-    return Status::OK();
-  } else {
-    // Unmask for people who might look for reference crc value
-    if (type == kCRC32c) {
-      stored = crc32c::Unmask(stored);
-      computed = crc32c::Unmask(computed);
-    }
-    return Status::Corruption(
-        "block checksum mismatch: stored" +
-        std::string(modifier ? "(context removed)" : "") + " = " +
-        std::to_string(stored) + ", computed = " + std::to_string(computed) +
-        ", type = " + std::to_string(type) + "  in " + file_name + " offset " +
-        std::to_string(offset) + " size " + std::to_string(block_size));
-  }
-}
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/reader_common.h

@@ -1,36 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file. See the AUTHORS file for names of contributors.
-#pragma once
-
-#include "rocksdb/advanced_cache.h"
-#include "rocksdb/table.h"
-
-namespace ROCKSDB_NAMESPACE {
-class Footer;
-
-// Release the cached entry and decrement its ref count.
-void ForceReleaseCachedEntry(void* arg, void* h);
-
-inline MemoryAllocator* GetMemoryAllocator(
-    const BlockBasedTableOptions& table_options) {
-  return table_options.block_cache.get()
-             ? table_options.block_cache->memory_allocator()
-             : nullptr;
-}
-
-// Assumes block has a trailer past `data + block_size` as in format.h.
-// `file_name` provided for generating diagnostic message in returned status.
-// `offset` might be required for proper verification (also used for message).
-//
-// Returns Status::OK() on checksum match, or Status::Corruption() on checksum
-// mismatch.
-Status VerifyBlockChecksum(const Footer& footer, const char* data,
-                           size_t block_size, const std::string& file_name,
-                           uint64_t offset);
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/uncompression_dict_reader.cc

@@ -1,118 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-
-#include "table/block_based/uncompression_dict_reader.h"
-
-#include "logging/logging.h"
-#include "monitoring/perf_context_imp.h"
-#include "table/block_based/block_based_table_reader.h"
-#include "util/compression.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-Status UncompressionDictReader::Create(
-    const BlockBasedTable* table, const ReadOptions& ro,
-    FilePrefetchBuffer* prefetch_buffer, bool use_cache, bool prefetch,
-    bool pin, BlockCacheLookupContext* lookup_context,
-    std::unique_ptr<UncompressionDictReader>* uncompression_dict_reader) {
-  assert(table);
-  assert(table->get_rep());
-  assert(!pin || prefetch);
-  assert(uncompression_dict_reader);
-
-  CachableEntry<UncompressionDict> uncompression_dict;
-  if (prefetch || !use_cache) {
-    const Status s = ReadUncompressionDictionary(
-        table, prefetch_buffer, ro, use_cache, nullptr /* get_context */,
-        lookup_context, &uncompression_dict);
-    if (!s.ok()) {
-      return s;
-    }
-
-    if (use_cache && !pin) {
-      uncompression_dict.Reset();
-    }
-  }
-
-  uncompression_dict_reader->reset(
-      new UncompressionDictReader(table, std::move(uncompression_dict)));
-
-  return Status::OK();
-}
-
-Status UncompressionDictReader::ReadUncompressionDictionary(
-    const BlockBasedTable* table, FilePrefetchBuffer* prefetch_buffer,
-    const ReadOptions& read_options, bool use_cache, GetContext* get_context,
-    BlockCacheLookupContext* lookup_context,
-    CachableEntry<UncompressionDict>* uncompression_dict) {
-  // TODO: add perf counter for compression dictionary read time
-
-  assert(table);
-  assert(uncompression_dict);
-  assert(uncompression_dict->IsEmpty());
-
-  const BlockBasedTable::Rep* const rep = table->get_rep();
-  assert(rep);
-  assert(!rep->compression_dict_handle.IsNull());
-
-  const Status s = table->RetrieveBlock(
-      prefetch_buffer, read_options, rep->compression_dict_handle,
-      UncompressionDict::GetEmptyDict(), uncompression_dict, get_context,
-      lookup_context,
-      /* for_compaction */ false, use_cache,
-      /* async_read */ false, /* use_block_cache_for_lookup */ true);
-
-  if (!s.ok()) {
-    ROCKS_LOG_WARN(
-        rep->ioptions.logger,
-        "Encountered error while reading data from compression dictionary "
-        "block %s",
-        s.ToString().c_str());
-  }
-
-  return s;
-}
-
-Status UncompressionDictReader::GetOrReadUncompressionDictionary(
-    FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
-    GetContext* get_context, BlockCacheLookupContext* lookup_context,
-    CachableEntry<UncompressionDict>* uncompression_dict) const {
-  assert(uncompression_dict);
-
-  if (!uncompression_dict_.IsEmpty()) {
-    uncompression_dict->SetUnownedValue(uncompression_dict_.GetValue());
-    return Status::OK();
-  }
-
-  return ReadUncompressionDictionary(table_, prefetch_buffer, ro,
-                                     cache_dictionary_blocks(), get_context,
-                                     lookup_context, uncompression_dict);
-}
-
-size_t UncompressionDictReader::ApproximateMemoryUsage() const {
-  assert(!uncompression_dict_.GetOwnValue() ||
-         uncompression_dict_.GetValue() != nullptr);
-  size_t usage = uncompression_dict_.GetOwnValue()
-                     ? uncompression_dict_.GetValue()->ApproximateMemoryUsage()
-                     : 0;
-
-#ifdef ROCKSDB_MALLOC_USABLE_SIZE
-  usage += malloc_usable_size(const_cast<UncompressionDictReader*>(this));
-#else
-  usage += sizeof(*this);
-#endif  // ROCKSDB_MALLOC_USABLE_SIZE
-
-  return usage;
-}
-
-bool UncompressionDictReader::cache_dictionary_blocks() const {
-  assert(table_);
-  assert(table_->get_rep());
-
-  return table_->get_rep()->table_options.cache_index_and_filter_blocks;
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/block_based/uncompression_dict_reader.h

@@ -1,60 +0,0 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-//
-
-#pragma once
-
-#include <cassert>
-
-#include "table/block_based/cachable_entry.h"
-#include "table/format.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class BlockBasedTable;
-struct BlockCacheLookupContext;
-class FilePrefetchBuffer;
-class GetContext;
-struct ReadOptions;
-struct UncompressionDict;
-
-// Provides access to the uncompression dictionary regardless of whether
-// it is owned by the reader or stored in the cache, or whether it is pinned
-// in the cache or not.
-class UncompressionDictReader {
- public:
-  static Status Create(
-      const BlockBasedTable* table, const ReadOptions& ro,
-      FilePrefetchBuffer* prefetch_buffer, bool use_cache, bool prefetch,
-      bool pin, BlockCacheLookupContext* lookup_context,
-      std::unique_ptr<UncompressionDictReader>* uncompression_dict_reader);
-
-  Status GetOrReadUncompressionDictionary(
-      FilePrefetchBuffer* prefetch_buffer, const ReadOptions& ro,
-      GetContext* get_context, BlockCacheLookupContext* lookup_context,
-      CachableEntry<UncompressionDict>* uncompression_dict) const;
-
-  size_t ApproximateMemoryUsage() const;
-
- private:
-  UncompressionDictReader(const BlockBasedTable* t,
-                          CachableEntry<UncompressionDict>&& uncompression_dict)
-      : table_(t), uncompression_dict_(std::move(uncompression_dict)) {
-    assert(table_);
-  }
-
-  bool cache_dictionary_blocks() const;
-
-  static Status ReadUncompressionDictionary(
-      const BlockBasedTable* table, FilePrefetchBuffer* prefetch_buffer,
-      const ReadOptions& read_options, bool use_cache, GetContext* get_context,
-      BlockCacheLookupContext* lookup_context,
-      CachableEntry<UncompressionDict>* uncompression_dict);
-
-  const BlockBasedTable* table_;
-  CachableEntry<UncompressionDict> uncompression_dict_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE