rocksdb-native 2.2.0 → 2.3.1

package/vendor/librocksdb/vendor/rocksdb/utilities/write_batch_with_index/write_batch_with_index.cc

@@ -567,43 +567,62 @@ Status WriteBatchWithIndex::GetFromBatchAndDB(DB* db,
                            nullptr);
 }
 
-void WriteBatchWithIndex::MergeAcrossBatchAndDB(
+void WriteBatchWithIndex::MergeAcrossBatchAndDBImpl(
     ColumnFamilyHandle* column_family, const Slice& key,
     const PinnableWideColumns& existing, const MergeContext& merge_context,
-    PinnableSlice* value, Status* status) {
-  assert(value);
+    std::string* value, PinnableWideColumns* columns, Status* status) {
+  assert(value || columns);
+  assert(!value || !columns);
   assert(status);
-  assert(status->ok() || status->IsNotFound());
-
-  std::string result_value;
 
   if (status->ok()) {
     if (WideColumnsHelper::HasDefaultColumnOnly(existing.columns())) {
       *status = WriteBatchWithIndexInternal::MergeKeyWithBaseValue(
           column_family, key, MergeHelper::kPlainBaseValue,
           WideColumnsHelper::GetDefaultColumn(existing.columns()),
-          merge_context, &result_value,
-          static_cast<PinnableWideColumns*>(nullptr));
+          merge_context, value, columns);
     } else {
       *status = WriteBatchWithIndexInternal::MergeKeyWithBaseValue(
           column_family, key, MergeHelper::kWideBaseValue, existing.columns(),
-          merge_context, &result_value,
-          static_cast<PinnableWideColumns*>(nullptr));
+          merge_context, value, columns);
     }
   } else {
     assert(status->IsNotFound());
     *status = WriteBatchWithIndexInternal::MergeKeyWithNoBaseValue(
-        column_family, key, merge_context, &result_value,
-        static_cast<PinnableWideColumns*>(nullptr));
+        column_family, key, merge_context, value, columns);
   }
+}
+
+void WriteBatchWithIndex::MergeAcrossBatchAndDB(
+    ColumnFamilyHandle* column_family, const Slice& key,
+    const PinnableWideColumns& existing, const MergeContext& merge_context,
+    PinnableSlice* value, Status* status) {
+  assert(value);
+  assert(status);
+
+  std::string result_value;
+  constexpr PinnableWideColumns* result_entity = nullptr;
+  MergeAcrossBatchAndDBImpl(column_family, key, existing, merge_context,
+                            &result_value, result_entity, status);
 
   if (status->ok()) {
-    value->Reset();
     *value->GetSelf() = std::move(result_value);
     value->PinSelf();
   }
 }
 
+void WriteBatchWithIndex::MergeAcrossBatchAndDB(
+    ColumnFamilyHandle* column_family, const Slice& key,
+    const PinnableWideColumns& existing, const MergeContext& merge_context,
+    PinnableWideColumns* columns, Status* status) {
+  assert(columns);
+  assert(status);
+
+  constexpr std::string* value = nullptr;
+  MergeAcrossBatchAndDBImpl(column_family, key, existing, merge_context, value,
+                            columns, status);
+}
+
 Status WriteBatchWithIndex::GetFromBatchAndDB(
     DB* db, const ReadOptions& read_options, ColumnFamilyHandle* column_family,
     const Slice& key, PinnableSlice* pinnable_val, ReadCallback* callback) {
@@ -620,6 +639,8 @@ Status WriteBatchWithIndex::GetFromBatchAndDB(
     return Status::InvalidArgument("Must specify timestamp");
   }
 
+  pinnable_val->Reset();
+
   // Since the lifetime of the WriteBatch is the same as that of the transaction
   // we cannot pin it as otherwise the returned value will not be available
   // after the transaction finishes.
@@ -634,7 +655,8 @@ Status WriteBatchWithIndex::GetFromBatchAndDB(
     return s;
   }
 
-  if (!s.ok() || result == WBWIIteratorImpl::kError) {
+  assert(!s.ok() == (result == WBWIIteratorImpl::kError));
+  if (result == WBWIIteratorImpl::kError) {
     return s;
   }
 
@@ -800,6 +822,283 @@ void WriteBatchWithIndex::MultiGetFromBatchAndDB(
   }
 }
 
+Status WriteBatchWithIndex::GetEntityFromBatchAndDB(
+    DB* db, const ReadOptions& _read_options, ColumnFamilyHandle* column_family,
+    const Slice& key, PinnableWideColumns* columns, ReadCallback* callback) {
+  if (!db) {
+    return Status::InvalidArgument(
+        "Cannot call GetEntityFromBatchAndDB without a DB object");
+  }
+
+  if (_read_options.io_activity != Env::IOActivity::kUnknown &&
+      _read_options.io_activity != Env::IOActivity::kGetEntity) {
+    return Status::InvalidArgument(
+        "Can only call GetEntityFromBatchAndDB with `ReadOptions::io_activity` "
+        "set to `Env::IOActivity::kUnknown` or `Env::IOActivity::kGetEntity`");
+  }
+
+  ReadOptions read_options(_read_options);
+  if (read_options.io_activity == Env::IOActivity::kUnknown) {
+    read_options.io_activity = Env::IOActivity::kGetEntity;
+  }
+
+  if (!column_family) {
+    return Status::InvalidArgument(
+        "Cannot call GetEntityFromBatchAndDB without a column family handle");
+  }
+
+  const Comparator* const ucmp = rep->comparator.GetComparator(column_family);
+  size_t ts_sz = ucmp ? ucmp->timestamp_size() : 0;
+  if (ts_sz > 0) {
+    if (!read_options.timestamp) {
+      return Status::InvalidArgument("Must specify timestamp");
+    }
+
+    if (read_options.timestamp->size() != ts_sz) {
+      return Status::InvalidArgument(
+          "Timestamp size does not match the timestamp size of the "
+          "column family");
+    }
+  } else {
+    if (read_options.timestamp) {
+      return Status::InvalidArgument(
+          "Cannot specify timestamp since the column family does not have "
+          "timestamps enabled");
+    }
+  }
+
+  if (!columns) {
+    return Status::InvalidArgument(
+        "Cannot call GetEntityFromBatchAndDB without a PinnableWideColumns "
+        "object");
+  }
+
+  columns->Reset();
+
+  MergeContext merge_context;
+  Status s;
+
+  auto result = WriteBatchWithIndexInternal::GetEntityFromBatch(
+      this, column_family, key, &merge_context, columns, &s);
+
+  assert(!s.ok() == (result == WBWIIteratorImpl::kError));
+
+  if (result == WBWIIteratorImpl::kFound ||
+      result == WBWIIteratorImpl::kError) {
+    return s;
+  }
+
+  if (result == WBWIIteratorImpl::kDeleted) {
+    return Status::NotFound();
+  }
+
+  assert(result == WBWIIteratorImpl::kMergeInProgress ||
+         result == WBWIIteratorImpl::kNotFound);
+
+  PinnableWideColumns existing;
+
+  DBImpl::GetImplOptions get_impl_options;
+  get_impl_options.column_family = column_family;
+  get_impl_options.columns =
+      (result == WBWIIteratorImpl::kMergeInProgress) ? &existing : columns;
+  get_impl_options.callback = callback;
+
+  s = static_cast_with_check<DBImpl>(db->GetRootDB())
+          ->GetImpl(read_options, key, get_impl_options);
+
+  if (result == WBWIIteratorImpl::kMergeInProgress) {
+    if (s.ok() || s.IsNotFound()) {  // DB lookup succeeded
+      MergeAcrossBatchAndDB(column_family, key, existing, merge_context,
+                            columns, &s);
+    }
+  }
+
+  return s;
+}
+
+void WriteBatchWithIndex::MultiGetEntityFromBatchAndDB(
+    DB* db, const ReadOptions& _read_options, ColumnFamilyHandle* column_family,
+    size_t num_keys, const Slice* keys, PinnableWideColumns* results,
+    Status* statuses, bool sorted_input, ReadCallback* callback) {
+  assert(statuses);
+
+  if (!db) {
+    const Status s = Status::InvalidArgument(
+        "Cannot call MultiGetEntityFromBatchAndDB without a DB object");
+    for (size_t i = 0; i < num_keys; ++i) {
+      statuses[i] = s;
+    }
+    return;
+  }
+
+  if (_read_options.io_activity != Env::IOActivity::kUnknown &&
+      _read_options.io_activity != Env::IOActivity::kMultiGetEntity) {
+    const Status s = Status::InvalidArgument(
+        "Can only call MultiGetEntityFromBatchAndDB with "
+        "`ReadOptions::io_activity` set to `Env::IOActivity::kUnknown` or "
+        "`Env::IOActivity::kMultiGetEntity`");
+    for (size_t i = 0; i < num_keys; ++i) {
+      if (statuses[i].ok()) {
+        statuses[i] = s;
+      }
+    }
+    return;
+  }
+
+  ReadOptions read_options(_read_options);
+  if (read_options.io_activity == Env::IOActivity::kUnknown) {
+    read_options.io_activity = Env::IOActivity::kMultiGetEntity;
+  }
+
+  if (!column_family) {
+    const Status s = Status::InvalidArgument(
+        "Cannot call MultiGetEntityFromBatchAndDB without a column family "
+        "handle");
+    for (size_t i = 0; i < num_keys; ++i) {
+      statuses[i] = s;
+    }
+    return;
+  }
+
+  const Comparator* const ucmp = rep->comparator.GetComparator(column_family);
+  const size_t ts_sz = ucmp ? ucmp->timestamp_size() : 0;
+  if (ts_sz > 0) {
+    if (!read_options.timestamp) {
+      const Status s = Status::InvalidArgument("Must specify timestamp");
+      for (size_t i = 0; i < num_keys; ++i) {
+        statuses[i] = s;
+      }
+      return;
+    }
+
+    if (read_options.timestamp->size() != ts_sz) {
+      const Status s = Status::InvalidArgument(
+          "Timestamp size does not match the timestamp size of the "
+          "column family");
+      for (size_t i = 0; i < num_keys; ++i) {
+        statuses[i] = s;
+      }
+      return;
+    }
+  } else {
+    if (read_options.timestamp) {
+      const Status s = Status::InvalidArgument(
+          "Cannot specify timestamp since the column family does not have "
+          "timestamps enabled");
+      for (size_t i = 0; i < num_keys; ++i) {
+        statuses[i] = s;
+      }
+      return;
+    }
+  }
+
+  if (!keys) {
+    const Status s = Status::InvalidArgument(
+        "Cannot call MultiGetEntityFromBatchAndDB without keys");
+    for (size_t i = 0; i < num_keys; ++i) {
+      statuses[i] = s;
+    }
+    return;
+  }
+
+  if (!results) {
+    const Status s = Status::InvalidArgument(
+        "Cannot call MultiGetEntityFromBatchAndDB without "
+        "PinnableWideColumns objects");
+    for (size_t i = 0; i < num_keys; ++i) {
+      statuses[i] = s;
+    }
+    return;
+  }
+
+  struct MergeTuple {
+    MergeTuple(const Slice& _key, Status* _s, MergeContext&& _merge_context,
+               PinnableWideColumns* _columns)
+        : key(_key),
+          s(_s),
+          merge_context(std::move(_merge_context)),
+          columns(_columns) {
+      assert(s);
+      assert(columns);
+    }
+
+    Slice key;
+    Status* s;
+    PinnableWideColumns existing;
+    MergeContext merge_context;
+    PinnableWideColumns* columns;
+  };
+
+  autovector<MergeTuple, MultiGetContext::MAX_BATCH_SIZE> merges;
+
+  autovector<KeyContext, MultiGetContext::MAX_BATCH_SIZE> key_contexts;
+
+  for (size_t i = 0; i < num_keys; ++i) {
+    const Slice& key = keys[i];
+    MergeContext merge_context;
+    PinnableWideColumns* const columns = &results[i];
+    Status* const s = &statuses[i];
+
+    columns->Reset();
+
+    auto result = WriteBatchWithIndexInternal::GetEntityFromBatch(
+        this, column_family, key, &merge_context, columns, s);
+
+    if (result == WBWIIteratorImpl::kFound ||
+        result == WBWIIteratorImpl::kError) {
+      continue;
+    }
+
+    if (result == WBWIIteratorImpl::kDeleted) {
+      *s = Status::NotFound();
+      continue;
+    }
+
+    if (result == WBWIIteratorImpl::kMergeInProgress) {
+      merges.emplace_back(key, s, std::move(merge_context), columns);
+
+      // The columns field will be populated by the loop below to prevent issues
+      // with dangling pointers.
+      key_contexts.emplace_back(column_family, key, /* value */ nullptr,
+                                /* columns */ nullptr, /* timestamp */ nullptr,
+                                s);
+      continue;
+    }
+
+    assert(result == WBWIIteratorImpl::kNotFound);
+    key_contexts.emplace_back(column_family, key, /* value */ nullptr, columns,
+                              /* timestamp */ nullptr, s);
+  }
+
+  autovector<KeyContext*, MultiGetContext::MAX_BATCH_SIZE> sorted_keys;
+  sorted_keys.reserve(key_contexts.size());
+
+  size_t merges_idx = 0;
+  for (KeyContext& key_context : key_contexts) {
+    if (!key_context.columns) {
+      assert(*key_context.key == merges[merges_idx].key);
+
+      key_context.columns = &merges[merges_idx].existing;
+      ++merges_idx;
+    }
+
+    sorted_keys.emplace_back(&key_context);
+  }
+
+  static_cast_with_check<DBImpl>(db->GetRootDB())
+      ->PrepareMultiGetKeys(sorted_keys.size(), sorted_input, &sorted_keys);
+  static_cast_with_check<DBImpl>(db->GetRootDB())
+      ->MultiGetEntityWithCallback(read_options, column_family, callback,
+                                   &sorted_keys);
+
+  for (const auto& merge : merges) {
+    if (merge.s->ok() || merge.s->IsNotFound()) {  // DB lookup succeeded
+      MergeAcrossBatchAndDB(column_family, merge.key, merge.existing,
+                            merge.merge_context, merge.columns, merge.s);
+    }
+  }
+}
+
 void WriteBatchWithIndex::SetSavePoint() { rep->write_batch.SetSavePoint(); }
 
 Status WriteBatchWithIndex::RollbackToSavePoint() {

package/vendor/librocksdb/vendor/rocksdb/utilities/write_batch_with_index/write_batch_with_index_internal.cc

@@ -36,6 +36,8 @@ BaseDeltaIterator::BaseDeltaIterator(ColumnFamilyHandle* column_family,
   assert(comparator_);
 }
 
+BaseDeltaIterator::~BaseDeltaIterator() = default;
+
 bool BaseDeltaIterator::Valid() const {
   return status_.ok() ? (current_at_base_ ? BaseValid() : DeltaValid()) : false;
 }
@@ -281,6 +283,7 @@ void BaseDeltaIterator::SetValueAndColumnsFromDelta() {
 
       status_ = WideColumnSerialization::Deserialize(value_copy, columns_);
       if (!status_.ok()) {
+        columns_.clear();
         return;
       }
 
@@ -340,6 +343,7 @@ void BaseDeltaIterator::SetValueAndColumnsFromDelta() {
 
     status_ = WideColumnSerialization::Deserialize(entity, columns_);
     if (!status_.ok()) {
+      columns_.clear();
       return;
     }
 
@@ -838,6 +842,9 @@ WBWIIteratorImpl::Result WriteBatchWithIndexInternal::GetFromBatchImpl(
         Traits::ClearOutput(output);
         result = WBWIIteratorImpl::Result::kError;
       }
+    } else {
+      Traits::ClearOutput(output);
+      *s = Status::OK();
     }
 
     return result;

package/vendor/librocksdb/vendor/rocksdb/utilities/write_batch_with_index/write_batch_with_index_internal.h

@@ -38,7 +38,7 @@ class BaseDeltaIterator : public Iterator {
                     WBWIIteratorImpl* delta_iterator,
                     const Comparator* comparator);
 
-  ~BaseDeltaIterator() override {}
+  ~BaseDeltaIterator() override;
 
   bool Valid() const override;
   void SeekToFirst() override;

package/vendor/librocksdb/vendor/rocksdb/db/multi_cf_iterator.cc

@@ -1,102 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  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 "db/multi_cf_iterator.h"
-
-#include <cassert>
-
-namespace ROCKSDB_NAMESPACE {
-
-template <typename BinaryHeap, typename ChildSeekFuncType>
-void MultiCfIterator::SeekCommon(BinaryHeap& heap,
-                                 ChildSeekFuncType child_seek_func) {
-  heap.clear();
-  int i = 0;
-  for (auto& cfh_iter_pair : cfh_iter_pairs_) {
-    auto& cfh = cfh_iter_pair.first;
-    auto& iter = cfh_iter_pair.second;
-    child_seek_func(iter.get());
-    if (iter->Valid()) {
-      assert(iter->status().ok());
-      heap.push(MultiCfIteratorInfo{iter.get(), cfh, i});
-    } else {
-      considerStatus(iter->status());
-    }
-    ++i;
-  }
-}
-
-template <typename BinaryHeap, typename AdvanceFuncType>
-void MultiCfIterator::AdvanceIterator(BinaryHeap& heap,
-                                      AdvanceFuncType advance_func) {
-  // 1. Keep the top iterator (by popping it from the heap)
-  // 2. Make sure all others have iterated past the top iterator key slice
-  // 3. Advance the top iterator, and add it back to the heap if valid
-  auto top = heap.top();
-  heap.pop();
-  if (!heap.empty()) {
-    auto* current = heap.top().iterator;
-    while (current->Valid() &&
-           comparator_->Compare(top.iterator->key(), current->key()) == 0) {
-      assert(current->status().ok());
-      advance_func(current);
-      if (current->Valid()) {
-        heap.replace_top(heap.top());
-      } else {
-        considerStatus(current->status());
-        heap.pop();
-      }
-      if (!heap.empty()) {
-        current = heap.top().iterator;
-      }
-    }
-  }
-  advance_func(top.iterator);
-  if (top.iterator->Valid()) {
-    assert(top.iterator->status().ok());
-    heap.push(top);
-  } else {
-    considerStatus(top.iterator->status());
-  }
-}
-
-void MultiCfIterator::SeekToFirst() {
-  auto& min_heap = GetHeap<MultiCfMinHeap>([this]() { InitMinHeap(); });
-  SeekCommon(min_heap, [](Iterator* iter) { iter->SeekToFirst(); });
-}
-void MultiCfIterator::Seek(const Slice& target) {
-  auto& min_heap = GetHeap<MultiCfMinHeap>([this]() { InitMinHeap(); });
-  SeekCommon(min_heap, [&target](Iterator* iter) { iter->Seek(target); });
-}
-void MultiCfIterator::SeekToLast() {
-  auto& max_heap = GetHeap<MultiCfMaxHeap>([this]() { InitMaxHeap(); });
-  SeekCommon(max_heap, [](Iterator* iter) { iter->SeekToLast(); });
-}
-void MultiCfIterator::SeekForPrev(const Slice& target) {
-  auto& max_heap = GetHeap<MultiCfMaxHeap>([this]() { InitMaxHeap(); });
-  SeekCommon(max_heap,
-             [&target](Iterator* iter) { iter->SeekForPrev(target); });
-}
-
-void MultiCfIterator::Next() {
-  assert(Valid());
-  auto& min_heap = GetHeap<MultiCfMinHeap>([this]() {
-    Slice target = key();
-    InitMinHeap();
-    Seek(target);
-  });
-  AdvanceIterator(min_heap, [](Iterator* iter) { iter->Next(); });
-}
-void MultiCfIterator::Prev() {
-  assert(Valid());
-  auto& max_heap = GetHeap<MultiCfMaxHeap>([this]() {
-    Slice target = key();
-    InitMaxHeap();
-    SeekForPrev(target);
-  });
-  AdvanceIterator(max_heap, [](Iterator* iter) { iter->Prev(); });
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/multi_cf_iterator.h

@@ -1,159 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  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 <variant>
-
-#include "rocksdb/comparator.h"
-#include "rocksdb/iterator.h"
-#include "rocksdb/options.h"
-#include "util/heap.h"
-#include "util/overload.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// UNDER CONSTRUCTION - DO NOT USE
-// A cross-column-family iterator from a consistent database state.
-// When the same key exists in more than one column families, the iterator
-// selects the value from the first column family containing the key, in the
-// order provided in the `column_families` parameter.
-class MultiCfIterator : public Iterator {
- public:
-  MultiCfIterator(const Comparator* comparator,
-                  const std::vector<ColumnFamilyHandle*>& column_families,
-                  const std::vector<Iterator*>& child_iterators)
-      : comparator_(comparator),
-        heap_(MultiCfMinHeap(
-            MultiCfHeapItemComparator<std::greater<int>>(comparator_))) {
-    assert(column_families.size() > 0 &&
-           column_families.size() == child_iterators.size());
-    cfh_iter_pairs_.reserve(column_families.size());
-    for (size_t i = 0; i < column_families.size(); ++i) {
-      cfh_iter_pairs_.emplace_back(
-          column_families[i], std::unique_ptr<Iterator>(child_iterators[i]));
-    }
-  }
-  ~MultiCfIterator() override { status_.PermitUncheckedError(); }
-
-  // No copy allowed
-  MultiCfIterator(const MultiCfIterator&) = delete;
-  MultiCfIterator& operator=(const MultiCfIterator&) = delete;
-
- private:
-  std::vector<std::pair<ColumnFamilyHandle*, std::unique_ptr<Iterator>>>
-      cfh_iter_pairs_;
-  ReadOptions read_options_;
-  Status status_;
-
-  AttributeGroups attribute_groups_;
-
-  struct MultiCfIteratorInfo {
-    Iterator* iterator;
-    ColumnFamilyHandle* cfh;
-    int order;
-  };
-
-  template <typename CompareOp>
-  class MultiCfHeapItemComparator {
-   public:
-    explicit MultiCfHeapItemComparator(const Comparator* comparator)
-        : comparator_(comparator) {}
-    bool operator()(const MultiCfIteratorInfo& a,
-                    const MultiCfIteratorInfo& b) const {
-      assert(a.iterator);
-      assert(b.iterator);
-      assert(a.iterator->Valid());
-      assert(b.iterator->Valid());
-      int c = comparator_->Compare(a.iterator->key(), b.iterator->key());
-      assert(c != 0 || a.order != b.order);
-      return c == 0 ? a.order - b.order > 0 : CompareOp()(c, 0);
-    }
-
-   private:
-    const Comparator* comparator_;
-  };
-  const Comparator* comparator_;
-  using MultiCfMinHeap =
-      BinaryHeap<MultiCfIteratorInfo,
-                 MultiCfHeapItemComparator<std::greater<int>>>;
-  using MultiCfMaxHeap = BinaryHeap<MultiCfIteratorInfo,
-                                    MultiCfHeapItemComparator<std::less<int>>>;
-
-  using MultiCfIterHeap = std::variant<MultiCfMinHeap, MultiCfMaxHeap>;
-
-  MultiCfIterHeap heap_;
-
-  // TODO: Lower and Upper bounds
-
-  Iterator* current() const {
-    if (std::holds_alternative<MultiCfMaxHeap>(heap_)) {
-      auto& max_heap = std::get<MultiCfMaxHeap>(heap_);
-      return max_heap.top().iterator;
-    }
-    auto& min_heap = std::get<MultiCfMinHeap>(heap_);
-    return min_heap.top().iterator;
-  }
-
-  Slice key() const override {
-    assert(Valid());
-    return current()->key();
-  }
-  Slice value() const override {
-    assert(Valid());
-    return current()->value();
-  }
-  const WideColumns& columns() const override {
-    assert(Valid());
-    return current()->columns();
-  }
-
-  bool Valid() const override {
-    if (std::holds_alternative<MultiCfMaxHeap>(heap_)) {
-      auto& max_heap = std::get<MultiCfMaxHeap>(heap_);
-      return !max_heap.empty() && status_.ok();
-    }
-    auto& min_heap = std::get<MultiCfMinHeap>(heap_);
-    return !min_heap.empty() && status_.ok();
-  }
-
-  Status status() const override { return status_; }
-  void considerStatus(Status s) {
-    if (!s.ok() && status_.ok()) {
-      status_ = std::move(s);
-    }
-  }
-
-  template <typename HeapType, typename InitFunc>
-  HeapType& GetHeap(InitFunc initFunc) {
-    if (!std::holds_alternative<HeapType>(heap_)) {
-      initFunc();
-    }
-    return std::get<HeapType>(heap_);
-  }
-
-  void InitMinHeap() {
-    heap_.emplace<MultiCfMinHeap>(
-        MultiCfHeapItemComparator<std::greater<int>>(comparator_));
-  }
-  void InitMaxHeap() {
-    heap_.emplace<MultiCfMaxHeap>(
-        MultiCfHeapItemComparator<std::less<int>>(comparator_));
-  }
-
-  template <typename BinaryHeap, typename ChildSeekFuncType>
-  void SeekCommon(BinaryHeap& heap, ChildSeekFuncType child_seek_func);
-  template <typename BinaryHeap, typename AdvanceFuncType>
-  void AdvanceIterator(BinaryHeap& heap, AdvanceFuncType advance_func);
-
-  void SeekToFirst() override;
-  void SeekToLast() override;
-  void Seek(const Slice& /*target*/) override;
-  void SeekForPrev(const Slice& /*target*/) override;
-  void Next() override;
-  void Prev() override;
-};
-
-}  // namespace ROCKSDB_NAMESPACE