@nxtedition/rocksdb 8.1.3 → 8.1.5

package/deps/rocksdb/rocksdb/db/merge_helper.cc

@@ -56,13 +56,12 @@ MergeHelper::MergeHelper(Env* env, const Comparator* user_comparator,
   }
 }
 
-Status MergeHelper::TimedFullMerge(const MergeOperator* merge_operator,
-                                   const Slice& key, const Slice* value,
-                                   const std::vector<Slice>& operands,
-                                   std::string* result, Logger* logger,
-                                   Statistics* statistics, SystemClock* clock,
-                                   Slice* result_operand,
-                                   bool update_num_ops_stats) {
+Status MergeHelper::TimedFullMerge(
+    const MergeOperator* merge_operator, const Slice& key, const Slice* value,
+    const std::vector<Slice>& operands, std::string* result, Logger* logger,
+    Statistics* statistics, SystemClock* clock, Slice* result_operand,
+    bool update_num_ops_stats,
+    MergeOperator::OpFailureScope* op_failure_scope) {
   assert(merge_operator != nullptr);
 
   if (operands.empty()) {
@@ -104,6 +103,14 @@ Status MergeHelper::TimedFullMerge(const MergeOperator* merge_operator,
                statistics ? timer.ElapsedNanos() : 0);
   }
 
+  if (op_failure_scope != nullptr) {
+    *op_failure_scope = merge_out.op_failure_scope;
+    // Apply default per merge_operator.h
+    if (*op_failure_scope == MergeOperator::OpFailureScope::kDefault) {
+      *op_failure_scope = MergeOperator::OpFailureScope::kTryMerge;
+    }
+  }
+
   if (!success) {
     RecordTick(statistics, NUMBER_MERGE_FAILURES);
     return Status::Corruption("Error: Could not perform merge.");
@@ -115,7 +122,8 @@ Status MergeHelper::TimedFullMerge(const MergeOperator* merge_operator,
 Status MergeHelper::TimedFullMergeWithEntity(
     const MergeOperator* merge_operator, const Slice& key, Slice base_entity,
     const std::vector<Slice>& operands, std::string* result, Logger* logger,
-    Statistics* statistics, SystemClock* clock, bool update_num_ops_stats) {
+    Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+    MergeOperator::OpFailureScope* op_failure_scope) {
   WideColumns base_columns;
 
   {
@@ -137,11 +145,10 @@ Status MergeHelper::TimedFullMergeWithEntity(
   std::string merge_result;
 
   {
-    constexpr Slice* result_operand = nullptr;
-
-    const Status s = TimedFullMerge(
-        merge_operator, key, &value_of_default, operands, &merge_result, logger,
-        statistics, clock, result_operand, update_num_ops_stats);
+    const Status s = TimedFullMerge(merge_operator, key, &value_of_default,
+                                    operands, &merge_result, logger, statistics,
+                                    clock, nullptr /* result_operand */,
+                                    update_num_ops_stats, op_failure_scope);
     if (!s.ok()) {
       return s;
     }
@@ -224,10 +231,6 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       s = Status::ShutdownInProgress();
       return s;
     }
-    // Skip range tombstones emitted by the compaction iterator.
-    if (iter->IsDeleteRangeSentinelKey()) {
-      continue;
-    }
 
     ParsedInternalKey ikey;
     assert(keys_.size() == merge_context_.GetNumOperands());
@@ -290,11 +293,10 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
         return s;
       }
 
-      // TODO(noetzli) If the merge operator returns false, we are currently
-      // (almost) silently dropping the put/delete. That's probably not what we
-      // want. Also if we're in compaction and it's a put, it would be nice to
-      // run compaction filter on it.
+      // TODO: if we're in compaction and it's a put, it would be nice to run
+      // compaction filter on it.
       std::string merge_result;
+      MergeOperator::OpFailureScope op_failure_scope;
 
       if (range_del_agg &&
           range_del_agg->ShouldDelete(
@@ -303,7 +305,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
                            merge_context_.GetOperands(), &merge_result, logger_,
                            stats_, clock_,
                            /* result_operand */ nullptr,
-                           /* update_num_ops_stats */ false);
+                           /* update_num_ops_stats */ false, &op_failure_scope);
       } else if (ikey.type == kTypeValue) {
         const Slice val = iter->value();
 
@@ -311,7 +313,7 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
                            merge_context_.GetOperands(), &merge_result, logger_,
                            stats_, clock_,
                            /* result_operand */ nullptr,
-                           /* update_num_ops_stats */ false);
+                           /* update_num_ops_stats */ false, &op_failure_scope);
       } else if (ikey.type == kTypeBlobIndex) {
         BlobIndex blob_index;
 
@@ -345,18 +347,18 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
                            merge_context_.GetOperands(), &merge_result, logger_,
                            stats_, clock_,
                            /* result_operand */ nullptr,
-                           /* update_num_ops_stats */ false);
+                           /* update_num_ops_stats */ false, &op_failure_scope);
       } else if (ikey.type == kTypeWideColumnEntity) {
         s = TimedFullMergeWithEntity(
             user_merge_operator_, ikey.user_key, iter->value(),
             merge_context_.GetOperands(), &merge_result, logger_, stats_,
-            clock_, /* update_num_ops_stats */ false);
+            clock_, /* update_num_ops_stats */ false, &op_failure_scope);
       } else {
         s = TimedFullMerge(user_merge_operator_, ikey.user_key, nullptr,
                            merge_context_.GetOperands(), &merge_result, logger_,
                            stats_, clock_,
                            /* result_operand */ nullptr,
-                           /* update_num_ops_stats */ false);
+                           /* update_num_ops_stats */ false, &op_failure_scope);
       }
 
       // We store the result in keys_.back() and operands_.back()
@@ -372,10 +374,16 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
         merge_context_.Clear();
         keys_.emplace_front(std::move(original_key));
         merge_context_.PushOperand(merge_result);
-      }
 
-      // move iter to the next entry
-      iter->Next();
+        // move iter to the next entry
+        iter->Next();
+      } else if (op_failure_scope ==
+                 MergeOperator::OpFailureScope::kMustMerge) {
+        // Change to `Status::MergeInProgress()` to denote output consists of
+        // merge operands only. Leave `iter` at the non-merge entry so it will
+        // be output after.
+        s = Status::MergeInProgress();
+      }
       return s;
     } else {
       // hit a merge
@@ -486,10 +494,12 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
     assert(merge_context_.GetNumOperands() >= 1);
     assert(merge_context_.GetNumOperands() == keys_.size());
     std::string merge_result;
-    s = TimedFullMerge(
-        user_merge_operator_, orig_ikey.user_key, nullptr,
-        merge_context_.GetOperands(), &merge_result, logger_, stats_, clock_,
-        /* result_operand */ nullptr, /* update_num_ops_stats */ false);
+    MergeOperator::OpFailureScope op_failure_scope;
+    s = TimedFullMerge(user_merge_operator_, orig_ikey.user_key, nullptr,
+                       merge_context_.GetOperands(), &merge_result, logger_,
+                       stats_, clock_,
+                       /* result_operand */ nullptr,
+                       /* update_num_ops_stats */ false, &op_failure_scope);
     if (s.ok()) {
       // The original key encountered
       // We are certain that keys_ is not empty here (see assertions couple of
@@ -501,6 +511,10 @@ Status MergeHelper::MergeUntil(InternalIterator* iter,
       merge_context_.Clear();
       keys_.emplace_front(std::move(original_key));
       merge_context_.PushOperand(merge_result);
+    } else if (op_failure_scope == MergeOperator::OpFailureScope::kMustMerge) {
+      // Change to `Status::MergeInProgress()` to denote output consists of
+      // merge operands only.
+      s = Status::MergeInProgress();
     }
   } else {
     // We haven't seen the beginning of the key nor a Put/Delete.

package/deps/rocksdb/rocksdb/db/merge_helper.h

@@ -48,19 +48,22 @@ class MergeHelper {
   // the latency is sensitive.
   // Returns one of the following statuses:
   // - OK: Entries were successfully merged.
-  // - Corruption: Merge operator reported unsuccessful merge.
+  // - Corruption: Merge operator reported unsuccessful merge. The scope of the
+  //   damage will be stored in `*op_failure_scope` when `op_failure_scope` is
+  //   not nullptr
   static Status TimedFullMerge(const MergeOperator* merge_operator,
                                const Slice& key, const Slice* value,
                                const std::vector<Slice>& operands,
                                std::string* result, Logger* logger,
                                Statistics* statistics, SystemClock* clock,
-                               Slice* result_operand,
-                               bool update_num_ops_stats);
+                               Slice* result_operand, bool update_num_ops_stats,
+                               MergeOperator::OpFailureScope* op_failure_scope);
 
   static Status TimedFullMergeWithEntity(
       const MergeOperator* merge_operator, const Slice& key, Slice base_entity,
       const std::vector<Slice>& operands, std::string* result, Logger* logger,
-      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats);
+      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
+      MergeOperator::OpFailureScope* op_failure_scope);
 
   // During compaction, merge entries until we hit
   //     - a corrupted key
@@ -69,6 +72,12 @@ class MergeHelper {
   //     - a specific sequence number (snapshot boundary),
   //     - REMOVE_AND_SKIP_UNTIL returned from compaction filter,
   //  or - the end of iteration
+  //
+  // The result(s) of the merge can be accessed in `MergeHelper::keys()` and
+  // `MergeHelper::values()`, which are invalidated the next time `MergeUntil()`
+  // is called. `MergeOutputIterator` is specially designed to iterate the
+  // results of a `MergeHelper`'s most recent `MergeUntil()`.
+  //
   // iter: (IN)  points to the first merge type entry
   //       (OUT) points to the first entry not included in the merge process
   // range_del_agg: (IN) filters merge operands covered by range tombstones.
@@ -85,8 +94,7 @@ class MergeHelper {
   //
   // Returns one of the following statuses:
   // - OK: Entries were successfully merged.
-  // - MergeInProgress: Put/Delete not encountered, and didn't reach the start
-  //   of key's history. Output consists of merge operands only.
+  // - MergeInProgress: Output consists of merge operands only.
   // - Corruption: Merge operator reported unsuccessful merge or a corrupted
   //   key has been encountered and not expected (applies only when compiling
   //   with asserts removed).

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

@@ -31,16 +31,6 @@
 #include "util/coding.h"
 #include "util/stop_watch.h"
 
-namespace ROCKSDB_NAMESPACE {
-namespace {
-template <class T>
-static void DeleteEntry(const Slice& /*key*/, void* value) {
-  T* typed_value = reinterpret_cast<T*>(value);
-  delete typed_value;
-}
-}  // anonymous namespace
-}  // namespace ROCKSDB_NAMESPACE
-
 // Generate the regular and coroutine versions of some methods by
 // including table_cache_sync_and_async.h twice
 // Macros in the header will expand differently based on whether
@@ -58,12 +48,6 @@ namespace ROCKSDB_NAMESPACE {
 
 namespace {
 
-static void UnrefEntry(void* arg1, void* arg2) {
-  Cache* cache = reinterpret_cast<Cache*>(arg1);
-  Cache::Handle* h = reinterpret_cast<Cache::Handle*>(arg2);
-  cache->Release(h);
-}
-
 static Slice GetSliceForFileNumber(const uint64_t* file_number) {
   return Slice(reinterpret_cast<const char*>(file_number),
                sizeof(*file_number));
@@ -105,14 +89,6 @@ TableCache::TableCache(const ImmutableOptions& ioptions,
 
 TableCache::~TableCache() {}
 
-TableReader* TableCache::GetTableReaderFromHandle(Cache::Handle* handle) {
-  return reinterpret_cast<TableReader*>(cache_->Value(handle));
-}
-
-void TableCache::ReleaseHandle(Cache::Handle* handle) {
-  cache_->Release(handle);
-}
-
 Status TableCache::GetTableReader(
     const ReadOptions& ro, const FileOptions& file_options,
     const InternalKeyComparator& internal_comparator,
@@ -178,17 +154,10 @@ Status TableCache::GetTableReader(
   return s;
 }
 
-void TableCache::EraseHandle(const FileDescriptor& fd, Cache::Handle* handle) {
-  ReleaseHandle(handle);
-  uint64_t number = fd.GetNumber();
-  Slice key = GetSliceForFileNumber(&number);
-  cache_->Erase(key);
-}
-
 Status TableCache::FindTable(
     const ReadOptions& ro, const FileOptions& file_options,
     const InternalKeyComparator& internal_comparator,
-    const FileMetaData& file_meta, Cache::Handle** handle,
+    const FileMetaData& file_meta, TypedHandle** 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,
@@ -196,7 +165,7 @@ Status TableCache::FindTable(
   PERF_TIMER_GUARD_WITH_CLOCK(find_table_nanos, ioptions_.clock);
   uint64_t number = file_meta.fd.GetNumber();
   Slice key = GetSliceForFileNumber(&number);
-  *handle = cache_->Lookup(key);
+  *handle = cache_.Lookup(key);
   TEST_SYNC_POINT_CALLBACK("TableCache::FindTable:0",
                            const_cast<bool*>(&no_io));
 
@@ -206,7 +175,7 @@ Status TableCache::FindTable(
     }
     MutexLock load_lock(loader_mutex_.get(key));
     // We check the cache again under loading mutex
-    *handle = cache_->Lookup(key);
+    *handle = cache_.Lookup(key);
     if (*handle != nullptr) {
       return Status::OK();
     }
@@ -224,8 +193,7 @@ Status TableCache::FindTable(
       // We do not cache error results so that if the error is transient,
       // or somebody repairs the file, we recover automatically.
     } else {
-      s = cache_->Insert(key, table_reader.get(), 1, &DeleteEntry<TableReader>,
-                         handle);
+      s = cache_.Insert(key, table_reader.get(), 1, handle);
       if (s.ok()) {
         // Release ownership of table reader.
         table_reader.release();
@@ -251,7 +219,7 @@ InternalIterator* TableCache::NewIterator(
 
   Status s;
   TableReader* table_reader = nullptr;
-  Cache::Handle* handle = nullptr;
+  TypedHandle* handle = nullptr;
   if (table_reader_ptr != nullptr) {
     *table_reader_ptr = nullptr;
   }
@@ -266,7 +234,7 @@ InternalIterator* TableCache::NewIterator(
         level, true /* prefetch_index_and_filter_in_cache */,
         max_file_size_for_l0_meta_pin, file_meta.temperature);
     if (s.ok()) {
-      table_reader = GetTableReaderFromHandle(handle);
+      table_reader = cache_.Value(handle);
     }
   }
   InternalIterator* result = nullptr;
@@ -280,7 +248,7 @@ InternalIterator* TableCache::NewIterator(
           file_options.compaction_readahead_size, allow_unprepared_value);
     }
     if (handle != nullptr) {
-      result->RegisterCleanup(&UnrefEntry, cache_, handle);
+      cache_.RegisterReleaseAsCleanup(handle, *result);
       handle = nullptr;  // prevent from releasing below
     }
 
@@ -330,7 +298,7 @@ InternalIterator* TableCache::NewIterator(
   }
 
   if (handle != nullptr) {
-    ReleaseHandle(handle);
+    cache_.Release(handle);
   }
   if (!s.ok()) {
     assert(result == nullptr);
@@ -348,12 +316,12 @@ Status TableCache::GetRangeTombstoneIterator(
   const FileDescriptor& fd = file_meta.fd;
   Status s;
   TableReader* t = fd.table_reader;
-  Cache::Handle* handle = nullptr;
+  TypedHandle* handle = nullptr;
   if (t == nullptr) {
     s = FindTable(options, file_options_, internal_comparator, file_meta,
                   &handle);
     if (s.ok()) {
-      t = GetTableReaderFromHandle(handle);
+      t = cache_.Value(handle);
     }
   }
   if (s.ok()) {
@@ -362,9 +330,9 @@ Status TableCache::GetRangeTombstoneIterator(
   }
   if (handle) {
     if (*out_iter) {
-      (*out_iter)->RegisterCleanup(&UnrefEntry, cache_, handle);
+      cache_.RegisterReleaseAsCleanup(handle, **out_iter);
     } else {
-      ReleaseHandle(handle);
+      cache_.Release(handle);
     }
   }
   return s;
@@ -411,16 +379,10 @@ bool TableCache::GetFromRowCache(const Slice& user_key, IterKey& row_cache_key,
   bool found = false;
 
   row_cache_key.TrimAppend(prefix_size, user_key.data(), user_key.size());
-  if (auto row_handle =
-          ioptions_.row_cache->Lookup(row_cache_key.GetUserKey())) {
+  RowCacheInterface row_cache{ioptions_.row_cache.get()};
+  if (auto row_handle = row_cache.Lookup(row_cache_key.GetUserKey())) {
     // Cleanable routine to release the cache entry
     Cleanable value_pinner;
-    auto release_cache_entry_func = [](void* cache_to_clean,
-                                       void* cache_handle) {
-      ((Cache*)cache_to_clean)->Release((Cache::Handle*)cache_handle);
-    };
-    auto found_row_cache_entry =
-        static_cast<const std::string*>(ioptions_.row_cache->Value(row_handle));
     // If it comes here value is located on the cache.
     // found_row_cache_entry points to the value on cache,
     // and value_pinner has cleanup procedure for the cached entry.
@@ -429,9 +391,8 @@ bool TableCache::GetFromRowCache(const Slice& user_key, IterKey& row_cache_key,
     // cleanup routine under value_pinner will be delegated to
     // get_context.pinnable_slice_. Cache entry is released when
     // get_context.pinnable_slice_ is reset.
-    value_pinner.RegisterCleanup(release_cache_entry_func,
-                                 ioptions_.row_cache.get(), row_handle);
-    replayGetContextLog(*found_row_cache_entry, user_key, get_context,
+    row_cache.RegisterReleaseAsCleanup(row_handle, value_pinner);
+    replayGetContextLog(*row_cache.Value(row_handle), user_key, get_context,
                         &value_pinner);
     RecordTick(ioptions_.stats, ROW_CACHE_HIT);
     found = true;
@@ -470,7 +431,7 @@ Status TableCache::Get(
 #endif  // ROCKSDB_LITE
   Status s;
   TableReader* t = fd.table_reader;
-  Cache::Handle* handle = nullptr;
+  TypedHandle* handle = nullptr;
   if (!done) {
     assert(s.ok());
     if (t == nullptr) {
@@ -481,7 +442,7 @@ Status TableCache::Get(
                     level, true /* prefetch_index_and_filter_in_cache */,
                     max_file_size_for_l0_meta_pin, file_meta.temperature);
       if (s.ok()) {
-        t = GetTableReaderFromHandle(handle);
+        t = cache_.Value(handle);
       }
     }
     SequenceNumber* max_covering_tombstone_seq =
@@ -517,18 +478,17 @@ Status TableCache::Get(
 #ifndef ROCKSDB_LITE
   // Put the replay log in row cache only if something was found.
   if (!done && s.ok() && row_cache_entry && !row_cache_entry->empty()) {
+    RowCacheInterface row_cache{ioptions_.row_cache.get()};
     size_t charge = row_cache_entry->capacity() + sizeof(std::string);
-    void* row_ptr = new std::string(std::move(*row_cache_entry));
+    auto row_ptr = new std::string(std::move(*row_cache_entry));
     // If row cache is full, it's OK to continue.
-    ioptions_.row_cache
-        ->Insert(row_cache_key.GetUserKey(), row_ptr, charge,
-                 &DeleteEntry<std::string>)
+    row_cache.Insert(row_cache_key.GetUserKey(), row_ptr, charge)
         .PermitUncheckedError();
   }
 #endif  // ROCKSDB_LITE
 
   if (handle != nullptr) {
-    ReleaseHandle(handle);
+    cache_.Release(handle);
   }
   return s;
 }
@@ -561,7 +521,7 @@ Status TableCache::MultiGetFilter(
     const FileMetaData& file_meta,
     const std::shared_ptr<const SliceTransform>& prefix_extractor,
     HistogramImpl* file_read_hist, int level,
-    MultiGetContext::Range* mget_range, Cache::Handle** table_handle) {
+    MultiGetContext::Range* mget_range, TypedHandle** table_handle) {
   auto& fd = file_meta.fd;
 #ifndef ROCKSDB_LITE
   IterKey row_cache_key;
@@ -577,7 +537,7 @@ Status TableCache::MultiGetFilter(
 #endif  // ROCKSDB_LITE
   Status s;
   TableReader* t = fd.table_reader;
-  Cache::Handle* handle = nullptr;
+  TypedHandle* handle = nullptr;
   MultiGetContext::Range tombstone_range(*mget_range, mget_range->begin(),
                                          mget_range->end());
   if (t == nullptr) {
@@ -588,7 +548,7 @@ Status TableCache::MultiGetFilter(
         level, true /* prefetch_index_and_filter_in_cache */,
         /*max_file_size_for_l0_meta_pin=*/0, file_meta.temperature);
     if (s.ok()) {
-      t = GetTableReaderFromHandle(handle);
+      t = cache_.Value(handle);
     }
     *table_handle = handle;
   }
@@ -602,7 +562,7 @@ Status TableCache::MultiGetFilter(
     UpdateRangeTombstoneSeqnums(options, t, tombstone_range);
   }
   if (mget_range->empty() && handle) {
-    ReleaseHandle(handle);
+    cache_.Release(handle);
     *table_handle = nullptr;
   }
 
@@ -623,16 +583,16 @@ Status TableCache::GetTableProperties(
     return Status::OK();
   }
 
-  Cache::Handle* table_handle = nullptr;
+  TypedHandle* table_handle = nullptr;
   Status s = FindTable(ReadOptions(), file_options, internal_comparator,
                        file_meta, &table_handle, prefix_extractor, no_io);
   if (!s.ok()) {
     return s;
   }
   assert(table_handle);
-  auto table = GetTableReaderFromHandle(table_handle);
+  auto table = cache_.Value(table_handle);
   *properties = table->GetTableProperties();
-  ReleaseHandle(table_handle);
+  cache_.Release(table_handle);
   return s;
 }
 
@@ -641,18 +601,18 @@ Status TableCache::ApproximateKeyAnchors(
     const FileMetaData& file_meta, std::vector<TableReader::Anchor>& anchors) {
   Status s;
   TableReader* t = file_meta.fd.table_reader;
-  Cache::Handle* handle = nullptr;
+  TypedHandle* handle = nullptr;
   if (t == nullptr) {
     s = FindTable(ro, file_options_, internal_comparator, file_meta, &handle);
     if (s.ok()) {
-      t = GetTableReaderFromHandle(handle);
+      t = cache_.Value(handle);
     }
   }
   if (s.ok() && t != nullptr) {
     s = t->ApproximateKeyAnchors(ro, anchors);
   }
   if (handle != nullptr) {
-    ReleaseHandle(handle);
+    cache_.Release(handle);
   }
   return s;
 }
@@ -668,29 +628,19 @@ size_t TableCache::GetMemoryUsageByTableReader(
     return table_reader->ApproximateMemoryUsage();
   }
 
-  Cache::Handle* table_handle = nullptr;
+  TypedHandle* table_handle = nullptr;
   Status s = FindTable(ReadOptions(), file_options, internal_comparator,
                        file_meta, &table_handle, prefix_extractor, true);
   if (!s.ok()) {
     return 0;
   }
   assert(table_handle);
-  auto table = GetTableReaderFromHandle(table_handle);
+  auto table = cache_.Value(table_handle);
   auto ret = table->ApproximateMemoryUsage();
-  ReleaseHandle(table_handle);
+  cache_.Release(table_handle);
   return ret;
 }
 
-bool TableCache::HasEntry(Cache* cache, uint64_t file_number) {
-  Cache::Handle* handle = cache->Lookup(GetSliceForFileNumber(&file_number));
-  if (handle) {
-    cache->Release(handle);
-    return true;
-  } else {
-    return false;
-  }
-}
-
 void TableCache::Evict(Cache* cache, uint64_t file_number) {
   cache->Erase(GetSliceForFileNumber(&file_number));
 }
@@ -701,7 +651,7 @@ uint64_t TableCache::ApproximateOffsetOf(
     const std::shared_ptr<const SliceTransform>& prefix_extractor) {
   uint64_t result = 0;
   TableReader* table_reader = file_meta.fd.table_reader;
-  Cache::Handle* table_handle = nullptr;
+  TypedHandle* table_handle = nullptr;
   if (table_reader == nullptr) {
     const bool for_compaction = (caller == TableReaderCaller::kCompaction);
     Status s =
@@ -709,7 +659,7 @@ uint64_t TableCache::ApproximateOffsetOf(
                   &table_handle, prefix_extractor, false /* no_io */,
                   !for_compaction /* record_read_stats */);
     if (s.ok()) {
-      table_reader = GetTableReaderFromHandle(table_handle);
+      table_reader = cache_.Value(table_handle);
     }
   }
 
@@ -717,7 +667,7 @@ uint64_t TableCache::ApproximateOffsetOf(
     result = table_reader->ApproximateOffsetOf(key, caller);
   }
   if (table_handle != nullptr) {
-    ReleaseHandle(table_handle);
+    cache_.Release(table_handle);
   }
 
   return result;
@@ -729,7 +679,7 @@ uint64_t TableCache::ApproximateSize(
     const std::shared_ptr<const SliceTransform>& prefix_extractor) {
   uint64_t result = 0;
   TableReader* table_reader = file_meta.fd.table_reader;
-  Cache::Handle* table_handle = nullptr;
+  TypedHandle* table_handle = nullptr;
   if (table_reader == nullptr) {
     const bool for_compaction = (caller == TableReaderCaller::kCompaction);
     Status s =
@@ -737,7 +687,7 @@ uint64_t TableCache::ApproximateSize(
                   &table_handle, prefix_extractor, false /* no_io */,
                   !for_compaction /* record_read_stats */);
     if (s.ok()) {
-      table_reader = GetTableReaderFromHandle(table_handle);
+      table_reader = cache_.Value(table_handle);
     }
   }
 
@@ -745,7 +695,7 @@ uint64_t TableCache::ApproximateSize(
     result = table_reader->ApproximateSize(start, end, caller);
   }
   if (table_handle != nullptr) {
-    ReleaseHandle(table_handle);
+    cache_.Release(table_handle);
   }
 
   return result;