rocksdb-native 2.6.2 → 2.6.4

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

@@ -1,307 +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 <algorithm>
-#include <cinttypes>
-#include <cstdint>
-#include <deque>
-#include <functional>
-#include <iterator>
-#include <string>
-
-#include "db/dbformat.h"
-#include "rocksdb/status.h"
-#include "rocksdb/types.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-constexpr uint64_t kUnknownTimeBeforeAll = 0;
-constexpr SequenceNumber kUnknownSeqnoBeforeAll = 0;
-
-// Maximum number of entries can be encoded into SST. The data is delta encode
-// so the maximum data usage for each SST is < 0.3K
-constexpr uint64_t kMaxSeqnoTimePairsPerSST = 100;
-
-// Maximum number of entries per CF. If there's only CF with this feature on,
-// the max span divided by this number, so for example, if
-// preclude_last_level_data_seconds = 100000 (~1day), then it will sample the
-// seqno -> time every 1000 seconds (~17minutes). Then the maximum entry it
-// needs is 100.
-// When there are multiple CFs having this feature on, the sampling cadence is
-// determined by the smallest setting, the capacity is determined the largest
-// setting, also it's caped by kMaxSeqnoTimePairsPerCF * 10.
-constexpr uint64_t kMaxSeqnoTimePairsPerCF = 100;
-
-constexpr uint64_t kMaxSeqnoToTimeEntries = kMaxSeqnoTimePairsPerCF * 10;
-
-// SeqnoToTimeMapping stores a sampled mapping from sequence numbers to
-// unix times (seconds since epoch). This information provides rough bounds
-// between sequence numbers and their write times, but is primarily designed
-// for getting a best lower bound on the sequence number of data written no
-// later than a specified time.
-//
-// For ease of sampling, it is assumed that the recorded time in each pair
-// comes at or after the sequence number and before the next sequence number,
-// so this example:
-//
-// Seqno: 10,       11, ... 20,       21, ... 30,       31, ...
-// Time:  ...  500      ...      600      ...      700      ...
-//
-// would be represented as
-//   10 -> 500
-//   20 -> 600
-//   30 -> 700
-//
-// In typical operation, the list is in "enforced" operation to maintain
-// invariants on sortedness, capacity, and time span of entries. However, some
-// operations will put the object into "unenforced" mode where those invariants
-// are relaxed until explicitly or implicitly re-enforced (which will sort and
-// filter the data).
-//
-// NOT thread safe - requires external synchronization, except a const
-// object allows concurrent reads.
-class SeqnoToTimeMapping {
- public:
-  // A simple struct for sequence number to time pair
-  struct SeqnoTimePair {
-    SequenceNumber seqno = 0;
-    uint64_t time = 0;
-
-    SeqnoTimePair() = default;
-    SeqnoTimePair(SequenceNumber _seqno, uint64_t _time)
-        : seqno(_seqno), time(_time) {}
-
-    // Encode to dest string
-    void Encode(std::string& dest) const;
-
-    // Decode the value from input Slice and remove it from the input
-    Status Decode(Slice& input);
-
-    // For delta encoding
-    SeqnoTimePair ComputeDelta(const SeqnoTimePair& base) const {
-      return {seqno - base.seqno, time - base.time};
-    }
-
-    // For delta decoding
-    void ApplyDelta(const SeqnoTimePair& delta_or_base) {
-      seqno += delta_or_base.seqno;
-      time += delta_or_base.time;
-    }
-
-    // If another pair can be combined into this one (for optimizing
-    // normal SeqnoToTimeMapping behavior), then this mapping is modified
-    // and true is returned, indicating the other mapping can be discarded.
-    // Otherwise false is returned and nothing is changed.
-    bool Merge(const SeqnoTimePair& other);
-
-    // Ordering used for Sort()
-    bool operator<(const SeqnoTimePair& other) const {
-      return std::tie(seqno, time) < std::tie(other.seqno, other.time);
-    }
-
-    bool operator==(const SeqnoTimePair& other) const {
-      return std::tie(seqno, time) == std::tie(other.seqno, other.time);
-    }
-
-    static bool SeqnoLess(const SeqnoTimePair& a, const SeqnoTimePair& b) {
-      return a.seqno < b.seqno;
-    }
-
-    static bool TimeLess(const SeqnoTimePair& a, const SeqnoTimePair& b) {
-      return a.time < b.time;
-    }
-  };
-
-  // Construct an empty SeqnoToTimeMapping with no limits.
-  SeqnoToTimeMapping() {}
-
-  // ==== Configuration for enforced state ==== //
-  // Set a time span beyond which old entries can be deleted. Specifically,
-  // under enforcement mode, the structure will maintian only one entry older
-  // than the newest entry time minus max_time_span, so that
-  // GetProximalSeqnoBeforeTime queries back to that time return a good result.
-  // UINT64_MAX == unlimited. 0 == retain just one latest entry. Returns *this.
-  SeqnoToTimeMapping& SetMaxTimeSpan(uint64_t max_time_span);
-
-  // Set the nominal capacity under enforcement mode. The structure is allowed
-  // to grow some reasonable fraction larger but will automatically compact
-  // down to this size. UINT64_MAX == unlimited. 0 == retain nothing.
-  // Returns *this.
-  SeqnoToTimeMapping& SetCapacity(uint64_t capacity);
-
-  // ==== Modifiers, enforced ==== //
-  // Adds a series of mappings interpolating from from_seqno->from_time to
-  // to_seqno->to_time. This can only be called on an empty object and both
-  // seqno range and time range are inclusive.
-  bool PrePopulate(SequenceNumber from_seqno, SequenceNumber to_seqno,
-                   uint64_t from_time, uint64_t to_time);
-
-  // Append a new entry to the list. The `seqno` should be >= all previous
-  // entries. This operation maintains enforced mode invariants, and will
-  // automatically (re-)enter enforced mode if not already in that state.
-  // Returns false if the entry was merged into the most recent entry
-  // rather than creating a new entry.
-  bool Append(SequenceNumber seqno, uint64_t time);
-
-  // Clear all entries and (re-)enter enforced mode if not already in that
-  // state. Enforced limits are unchanged.
-  void Clear() {
-    pairs_.clear();
-    enforced_ = true;
-  }
-
-  // Enters the "enforced" state if not already in that state, which is
-  // useful before copying or querying. This will
-  //  * Sort the entries
-  //  * Discard any obsolete entries, which is aided if the caller specifies
-  // the `now` time so that entries older than now minus the max time span can
-  // be discarded.
-  //  * Compact the entries to the configured capacity.
-  // Returns *this.
-  SeqnoToTimeMapping& Enforce(uint64_t now = 0);
-
-  // ==== Modifiers, unenforced ==== //
-  // Add a new random entry and enter "unenforced" state. Unlike Append(), it
-  // can be any historical data.
-  void AddUnenforced(SequenceNumber seqno, uint64_t time);
-
-  // Decode and add the entries to this mapping object. Unless starting from
-  // an empty mapping with no configured enforcement limits, this operation
-  // enters the unenforced state.
-  Status DecodeFrom(const std::string& pairs_str);
-
-  // Copies entries from the src mapping object to this one, limited to entries
-  // needed to answer GetProximalTimeBeforeSeqno() queries for the given
-  // *inclusive* seqno range. The source structure must be in enforced
-  // state as a precondition. Unless starting with this object as empty mapping
-  // with no configured enforcement limits, this object enters the unenforced
-  // state.
-  void CopyFromSeqnoRange(const SeqnoToTimeMapping& src,
-                          SequenceNumber from_seqno,
-                          SequenceNumber to_seqno = kMaxSequenceNumber);
-  void CopyFrom(const SeqnoToTimeMapping& src) {
-    CopyFromSeqnoRange(src, kUnknownSeqnoBeforeAll, kMaxSequenceNumber);
-  }
-
-  // ==== Accessors ==== //
-  // Given a sequence number, return the best (largest / newest) known time
-  // that is no later than the write time of that given sequence number.
-  // If no such specific time is known, returns kUnknownTimeBeforeAll.
-  // Using the example in the class comment above,
-  //  GetProximalTimeBeforeSeqno(10) -> kUnknownTimeBeforeAll
-  //  GetProximalTimeBeforeSeqno(11) -> 500
-  //  GetProximalTimeBeforeSeqno(20) -> 500
-  //  GetProximalTimeBeforeSeqno(21) -> 600
-  // Because this is a const operation depending on sortedness, the structure
-  // must be in enforced state as a precondition.
-  uint64_t GetProximalTimeBeforeSeqno(SequenceNumber seqno) const;
-
-  // Given a time, return the best (largest) sequence number whose write time
-  // is no later than that given time. If no such specific sequence number is
-  // known, returns kUnknownSeqnoBeforeAll. Using the example in the class
-  // comment above,
-  //  GetProximalSeqnoBeforeTime(499) -> kUnknownSeqnoBeforeAll
-  //  GetProximalSeqnoBeforeTime(500) -> 10
-  //  GetProximalSeqnoBeforeTime(599) -> 10
-  //  GetProximalSeqnoBeforeTime(600) -> 20
-  // Because this is a const operation depending on sortedness, the structure
-  // must be in enforced state as a precondition.
-  SequenceNumber GetProximalSeqnoBeforeTime(uint64_t time) const;
-
-  // Given current time, the configured `preserve_internal_time_seconds`, and
-  // `preclude_last_level_data_seconds`, find the relevant cutoff sequence
-  // numbers for tiering.
-  void GetCurrentTieringCutoffSeqnos(
-      uint64_t current_time, uint64_t preserve_internal_time_seconds,
-      uint64_t preclude_last_level_data_seconds,
-      SequenceNumber* preserve_time_min_seqno,
-      SequenceNumber* preclude_last_level_min_seqno) const;
-
-  // Encode to a binary string by appending to `dest`.
-  // Because this is a const operation depending on sortedness, the structure
-  // must be in enforced state as a precondition.
-  void EncodeTo(std::string& dest) const;
-
-  // Return the number of entries
-  size_t Size() const { return pairs_.size(); }
-
-  uint64_t GetCapacity() const { return capacity_; }
-
-  // If the internal list is empty
-  bool Empty() const { return pairs_.empty(); }
-
-  // return the string for user message
-  // Note: Not efficient, okay for print
-  std::string ToHumanString() const;
-
-#ifndef NDEBUG
-  const SeqnoTimePair& TEST_GetLastEntry() const { return pairs_.back(); }
-  const std::deque<SeqnoTimePair>& TEST_GetInternalMapping() const {
-    return pairs_;
-  }
-  bool TEST_IsEnforced() const { return enforced_; }
-#endif
-
- private:
-  uint64_t max_time_span_ = UINT64_MAX;
-  uint64_t capacity_ = UINT64_MAX;
-
-  std::deque<SeqnoTimePair> pairs_;
-
-  // Whether this object is in the "enforced" state. Between calls to public
-  // functions, enforced_==true means that
-  // * `pairs_` is sorted
-  // * The capacity limit (non-strict) is met
-  // * The time span limit is met
-  // However, some places within the implementation (Append()) will temporarily
-  // violate those last two conditions while enforced_==true. See also the
-  // Enforce*() and Sort*() private functions below.
-  bool enforced_ = true;
-
-  void EnforceMaxTimeSpan(uint64_t now = 0);
-  void EnforceCapacity(bool strict);
-  void SortAndMerge();
-
-  using pair_const_iterator =
-      std::deque<SeqnoToTimeMapping::SeqnoTimePair>::const_iterator;
-  pair_const_iterator FindGreaterTime(uint64_t time) const;
-  pair_const_iterator FindGreaterSeqno(SequenceNumber seqno) const;
-  pair_const_iterator FindGreaterEqSeqno(SequenceNumber seqno) const;
-};
-
-// === Utility methods used for TimedPut === //
-
-// Pack a value Slice and a unix write time into buffer `buf` and return a Slice
-// for the packed value backed by `buf`.
-Slice PackValueAndWriteTime(const Slice& value, uint64_t unix_write_time,
-                            std::string* buf);
-
-// Pack a value Slice and a sequence number into buffer `buf` and return a Slice
-// for the packed value backed by `buf`.
-Slice PackValueAndSeqno(const Slice& value, SequenceNumber seqno,
-                        std::string* buf);
-
-// Parse a packed value to get the write time.
-uint64_t ParsePackedValueForWriteTime(const Slice& value);
-
-// Parse a packed value to get the value and the write time. The unpacked value
-// Slice is backed up by the same memory backing up `value`.
-std::tuple<Slice, uint64_t> ParsePackedValueWithWriteTime(const Slice& value);
-
-// Parse a packed value to get the sequence number.
-SequenceNumber ParsePackedValueForSeqno(const Slice& value);
-
-// Parse a packed value to get the value and the sequence number. The unpacked
-// value Slice is backed up by the same memory backing up `value`.
-std::tuple<Slice, SequenceNumber> ParsePackedValueWithSeqno(const Slice& value);
-
-// Parse a packed value to get the value. The unpacked value Slice is backed up
-// by the same memory backing up `value`.
-Slice ParsePackedValueForValue(const Slice& value);
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/db/snapshot_checker.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).
-
-#pragma once
-#include "rocksdb/types.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-enum class SnapshotCheckerResult : int {
-  kInSnapshot = 0,
-  kNotInSnapshot = 1,
-  // In case snapshot is released and the checker has no clue whether
-  // the given sequence is visible to the snapshot.
-  kSnapshotReleased = 2,
-};
-
-// Callback class that control GC of duplicate keys in flush/compaction.
-class SnapshotChecker {
- public:
-  virtual ~SnapshotChecker() {}
-  virtual SnapshotCheckerResult CheckInSnapshot(
-      SequenceNumber sequence, SequenceNumber snapshot_sequence) const = 0;
-};
-
-class DisableGCSnapshotChecker : public SnapshotChecker {
- public:
-  virtual ~DisableGCSnapshotChecker() {}
-  SnapshotCheckerResult CheckInSnapshot(
-      SequenceNumber /*sequence*/,
-      SequenceNumber /*snapshot_sequence*/) const override {
-    // By returning kNotInSnapshot, we prevent all the values from being GCed
-    return SnapshotCheckerResult::kNotInSnapshot;
-  }
-  static DisableGCSnapshotChecker* Instance();
-
- protected:
-  explicit DisableGCSnapshotChecker() {}
-};
-
-class WritePreparedTxnDB;
-
-// Callback class created by WritePreparedTxnDB to check if a key
-// is visible by a snapshot.
-class WritePreparedSnapshotChecker : public SnapshotChecker {
- public:
-  explicit WritePreparedSnapshotChecker(WritePreparedTxnDB* txn_db);
-  virtual ~WritePreparedSnapshotChecker() {}
-
-  SnapshotCheckerResult CheckInSnapshot(
-      SequenceNumber sequence, SequenceNumber snapshot_sequence) const override;
-
- private:
-  const WritePreparedTxnDB* const txn_db_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,25 +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 "rocksdb/db.h"
-#include "rocksdb/snapshot.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-ManagedSnapshot::ManagedSnapshot(DB* db)
-    : db_(db), snapshot_(db->GetSnapshot()) {}
-
-ManagedSnapshot::ManagedSnapshot(DB* db, const Snapshot* _snapshot)
-    : db_(db), snapshot_(_snapshot) {}
-
-ManagedSnapshot::~ManagedSnapshot() {
-  if (snapshot_) {
-    db_->ReleaseSnapshot(snapshot_);
-  }
-}
-
-const Snapshot* ManagedSnapshot::snapshot() { return snapshot_; }
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,239 +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 <vector>
-
-#include "db/dbformat.h"
-#include "rocksdb/db.h"
-#include "util/autovector.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class SnapshotList;
-
-// Snapshots are kept in a doubly-linked list in the DB.
-// Each SnapshotImpl corresponds to a particular sequence number.
-class SnapshotImpl : public Snapshot {
- public:
-  SequenceNumber number_;  // const after creation
-  // It indicates the smallest uncommitted data at the time the snapshot was
-  // taken. This is currently used by WritePrepared transactions to limit the
-  // scope of queries to IsInSnapshot.
-  SequenceNumber min_uncommitted_ = kMinUnCommittedSeq;
-
-  SequenceNumber GetSequenceNumber() const override { return number_; }
-
-  int64_t GetUnixTime() const override { return unix_time_; }
-
-  uint64_t GetTimestamp() const override { return timestamp_; }
-
- private:
-  friend class SnapshotList;
-
-  // SnapshotImpl is kept in a doubly-linked circular list
-  SnapshotImpl* prev_;
-  SnapshotImpl* next_;
-
-  SnapshotList* list_;  // just for sanity checks
-
-  int64_t unix_time_;
-
-  uint64_t timestamp_;
-
-  // Will this snapshot be used by a Transaction to do write-conflict checking?
-  bool is_write_conflict_boundary_;
-};
-
-class SnapshotList {
- public:
-  SnapshotList() {
-    list_.prev_ = &list_;
-    list_.next_ = &list_;
-    list_.number_ = 0xFFFFFFFFL;  // placeholder marker, for debugging
-    // Set all the variables to make UBSAN happy.
-    list_.list_ = nullptr;
-    list_.unix_time_ = 0;
-    list_.timestamp_ = 0;
-    list_.is_write_conflict_boundary_ = false;
-    count_ = 0;
-  }
-
-  // No copy-construct.
-  SnapshotList(const SnapshotList&) = delete;
-
-  bool empty() const {
-    assert(list_.next_ != &list_ || 0 == count_);
-    return list_.next_ == &list_;
-  }
-  SnapshotImpl* oldest() const {
-    assert(!empty());
-    return list_.next_;
-  }
-  SnapshotImpl* newest() const {
-    assert(!empty());
-    return list_.prev_;
-  }
-
-  SnapshotImpl* New(SnapshotImpl* s, SequenceNumber seq, uint64_t unix_time,
-                    bool is_write_conflict_boundary,
-                    uint64_t ts = std::numeric_limits<uint64_t>::max()) {
-    s->number_ = seq;
-    s->unix_time_ = unix_time;
-    s->timestamp_ = ts;
-    s->is_write_conflict_boundary_ = is_write_conflict_boundary;
-    s->list_ = this;
-    s->next_ = &list_;
-    s->prev_ = list_.prev_;
-    s->prev_->next_ = s;
-    s->next_->prev_ = s;
-    count_++;
-    return s;
-  }
-
-  // Do not responsible to free the object.
-  void Delete(const SnapshotImpl* s) {
-    assert(s->list_ == this);
-    s->prev_->next_ = s->next_;
-    s->next_->prev_ = s->prev_;
-    count_--;
-  }
-
-  // retrieve all snapshot numbers up until max_seq. They are sorted in
-  // ascending order (with no duplicates).
-  std::vector<SequenceNumber> GetAll(
-      SequenceNumber* oldest_write_conflict_snapshot = nullptr,
-      const SequenceNumber& max_seq = kMaxSequenceNumber) const {
-    std::vector<SequenceNumber> ret;
-    GetAll(&ret, oldest_write_conflict_snapshot, max_seq);
-    return ret;
-  }
-
-  void GetAll(std::vector<SequenceNumber>* snap_vector,
-              SequenceNumber* oldest_write_conflict_snapshot = nullptr,
-              const SequenceNumber& max_seq = kMaxSequenceNumber) const {
-    std::vector<SequenceNumber>& ret = *snap_vector;
-    // So far we have no use case that would pass a non-empty vector
-    assert(ret.size() == 0);
-
-    if (oldest_write_conflict_snapshot != nullptr) {
-      *oldest_write_conflict_snapshot = kMaxSequenceNumber;
-    }
-
-    if (empty()) {
-      return;
-    }
-    const SnapshotImpl* s = &list_;
-    while (s->next_ != &list_) {
-      if (s->next_->number_ > max_seq) {
-        break;
-      }
-      // Avoid duplicates
-      if (ret.empty() || ret.back() != s->next_->number_) {
-        ret.push_back(s->next_->number_);
-      }
-
-      if (oldest_write_conflict_snapshot != nullptr &&
-          *oldest_write_conflict_snapshot == kMaxSequenceNumber &&
-          s->next_->is_write_conflict_boundary_) {
-        // If this is the first write-conflict boundary snapshot in the list,
-        // it is the oldest
-        *oldest_write_conflict_snapshot = s->next_->number_;
-      }
-
-      s = s->next_;
-    }
-    return;
-  }
-
-  // get the sequence number of the most recent snapshot
-  SequenceNumber GetNewest() {
-    if (empty()) {
-      return 0;
-    }
-    return newest()->number_;
-  }
-
-  int64_t GetOldestSnapshotTime() const {
-    if (empty()) {
-      return 0;
-    } else {
-      return oldest()->unix_time_;
-    }
-  }
-
-  int64_t GetOldestSnapshotSequence() const {
-    if (empty()) {
-      return 0;
-    } else {
-      return oldest()->GetSequenceNumber();
-    }
-  }
-
-  uint64_t count() const { return count_; }
-
- private:
-  // Dummy head of doubly-linked list of snapshots
-  SnapshotImpl list_;
-  uint64_t count_;
-};
-
-// All operations on TimestampedSnapshotList must be protected by db mutex.
-class TimestampedSnapshotList {
- public:
-  explicit TimestampedSnapshotList() = default;
-
-  std::shared_ptr<const SnapshotImpl> GetSnapshot(uint64_t ts) const {
-    if (ts == std::numeric_limits<uint64_t>::max() && !snapshots_.empty()) {
-      auto it = snapshots_.rbegin();
-      assert(it != snapshots_.rend());
-      return it->second;
-    }
-    auto it = snapshots_.find(ts);
-    if (it == snapshots_.end()) {
-      return std::shared_ptr<const SnapshotImpl>();
-    }
-    return it->second;
-  }
-
-  void GetSnapshots(
-      uint64_t ts_lb, uint64_t ts_ub,
-      std::vector<std::shared_ptr<const Snapshot>>& snapshots) const {
-    assert(ts_lb < ts_ub);
-    auto it_low = snapshots_.lower_bound(ts_lb);
-    auto it_high = snapshots_.lower_bound(ts_ub);
-    for (auto it = it_low; it != it_high; ++it) {
-      snapshots.emplace_back(it->second);
-    }
-  }
-
-  void AddSnapshot(const std::shared_ptr<const SnapshotImpl>& snapshot) {
-    assert(snapshot);
-    snapshots_.try_emplace(snapshot->GetTimestamp(), snapshot);
-  }
-
-  // snapshots_to_release: the container to where the timestamped snapshots will
-  // be moved so that it retains the last reference to the snapshots and the
-  // snapshots won't be actually released which requires db mutex. The
-  // snapshots will be released by caller of ReleaseSnapshotsOlderThan().
-  void ReleaseSnapshotsOlderThan(
-      uint64_t ts,
-      autovector<std::shared_ptr<const SnapshotImpl>>& snapshots_to_release) {
-    auto ub = snapshots_.lower_bound(ts);
-    for (auto it = snapshots_.begin(); it != ub; ++it) {
-      snapshots_to_release.emplace_back(it->second);
-    }
-    snapshots_.erase(snapshots_.begin(), ub);
-  }
-
- private:
-  std::map<uint64_t, std::shared_ptr<const SnapshotImpl>> snapshots_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE