rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/include/rocksdb/secondary_cache.h

@@ -1,220 +0,0 @@
-// Copyright (c) 2021, 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 <stdint.h>
-
-#include <memory>
-#include <string>
-
-#include "rocksdb/advanced_cache.h"
-#include "rocksdb/customizable.h"
-#include "rocksdb/options.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/statistics.h"
-#include "rocksdb/status.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// A handle for lookup result. Immediately after SecondaryCache::Lookup() with
-// wait=false (and depending on the implementation), the handle could be in any
-// of the below states. It must not be destroyed while in the pending state.
-// * Pending state (IsReady() == false): result is not ready. Value() and Size()
-// must not be called.
-// * Ready + not found state (IsReady() == true, Value() == nullptr): the lookup
-// has completed, finding no match. Or an error occurred that prevented
-// normal completion of the Lookup.
-// * Ready + found state (IsReady() == false, Value() != nullptr): the lookup
-// has completed, finding an entry that has been loaded into an object that is
-// now owned by the caller.
-//
-// Wait() or SecondaryCache::WaitAll() may be skipped if IsReady() happens to
-// return true, but (depending on the implementation) IsReady() might never
-// return true without Wait() or SecondaryCache::WaitAll(). After the handle
-// is known ready, calling Value() is required to avoid a memory leak in case
-// of a cache hit.
-class SecondaryCacheResultHandle {
- public:
-  virtual ~SecondaryCacheResultHandle() = default;
-
-  // Returns whether the handle is ready or not
-  virtual bool IsReady() = 0;
-
-  // Block until handle becomes ready
-  virtual void Wait() = 0;
-
-  // Return the cache entry object (also known as value). If nullptr, it means
-  // the lookup was unsuccessful.
-  virtual Cache::ObjectPtr Value() = 0;
-
-  // Return the out_charge from the helper->create_cb used to construct the
-  // object.
-  // WART: potentially confusing name
-  virtual size_t Size() = 0;
-};
-
-// SecondaryCache
-//
-// Cache interface for caching blocks on a secondary tier (which can include
-// non-volatile media, or alternate forms of caching such as compressed data)
-//
-// Exceptions MUST NOT propagate out of overridden functions into RocksDB,
-// because RocksDB is not exception-safe. This could cause undefined behavior
-// including data loss, unreported corruption, deadlocks, and more.
-class SecondaryCache : public Customizable {
- public:
-  ~SecondaryCache() override = default;
-
-  static const char* Type() { return "SecondaryCache"; }
-  static Status CreateFromString(const ConfigOptions& config_options,
-                                 const std::string& id,
-                                 std::shared_ptr<SecondaryCache>* result);
-
-  // Suggest inserting an entry into this cache. The caller retains ownership
-  // of `obj` (also called the "value"), so is only used directly by the
-  // SecondaryCache during Insert(). When the cache chooses to perform the
-  // suggested insertion, it uses the size_cb and saveto_cb provided by
-  // `helper` to extract the persistable data (typically an uncompressed block)
-  // and writes it to this cache tier. OK may be returned even if the insertion
-  // is not made.
-  virtual Status Insert(const Slice& key, Cache::ObjectPtr obj,
-                        const Cache::CacheItemHelper* helper,
-                        bool force_insert) = 0;
-
-  // Insert a value from its saved/persistable data (typically uncompressed
-  // block), as if generated by SaveToCallback/SizeCallback. The data can be
-  // compressed, in which case the type argument should specify the
-  // compression algorithm used. Additionally, the source argument should
-  // be set to the appropriate tier that will be responsible for
-  // uncompressing the data.
-  //
-  // This method can be used in "warming up" the cache from some auxiliary
-  // source, and like Insert() may or may not write it to cache depending on
-  // the admission control policy, even if the return status is success.
-  virtual Status InsertSaved(
-      const Slice& key, const Slice& saved,
-      CompressionType type = CompressionType::kNoCompression,
-      CacheTier source = CacheTier::kVolatileTier) = 0;
-
-  // Lookup the data for the given key in this cache. The create_cb
-  // will be used to create the object. The handle returned may not be
-  // ready yet, unless wait=true, in which case Lookup() will block until
-  // the handle is ready.
-  //
-  // advise_erase is a hint from the primary cache indicating that the handle
-  // will be cached there, so the secondary cache is advised to drop it from
-  // the cache as an optimization. To use this feature, SupportForceErase()
-  // needs to return true.
-  // This hint can also be safely ignored.
-  //
-  // kept_in_sec_cache is to indicate whether the entry will be kept in the
-  // secondary cache after the Lookup (rather than erased because of Lookup)
-  virtual std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CacheItemHelper* helper,
-      Cache::CreateContext* create_context, bool wait, bool advise_erase,
-      Statistics* stats, bool& kept_in_sec_cache) = 0;
-
-  // Indicate whether a handle can be erased in this secondary cache.
-  [[nodiscard]] virtual bool SupportForceErase() const = 0;
-
-  // At the discretion of the implementation, erase the data associated
-  // with key.
-  virtual void Erase(const Slice& key) = 0;
-
-  // Wait for a collection of handles to become ready.
-  virtual void WaitAll(std::vector<SecondaryCacheResultHandle*> handles) = 0;
-
-  // Set the maximum configured capacity of the cache.
-  // When the new capacity is less than the old capacity and the existing usage
-  // is greater than new capacity, the implementation will do its best job to
-  // purge the released entries from the cache in order to lower the usage.
-  //
-  // The derived class can make this function no-op and return NotSupported().
-  virtual Status SetCapacity(size_t /* capacity */) {
-    return Status::NotSupported();
-  }
-
-  // The derived class can make this function no-op and return NotSupported().
-  virtual Status GetCapacity(size_t& /* capacity */) {
-    return Status::NotSupported();
-  }
-
-  // Temporarily decrease the cache capacity in RAM by the specified amount.
-  // The caller should call Inflate() to restore the cache capacity. This is
-  // intended to be lighter weight than SetCapacity(). The latter evenly
-  // distributes the new capacity across all shards and is meant for large
-  // changes in capacity, whereas the former is meant for relatively small
-  // changes and may be uneven by lowering capacity in a single shard.
-  virtual Status Deflate(size_t /*decrease*/) { return Status::NotSupported(); }
-
-  // Restore the capacity reduced by a prior call to Deflate().
-  virtual Status Inflate(size_t /*increase*/) { return Status::NotSupported(); }
-};
-
-// A wrapper around a SecondaryCache object. A derived class may selectively
-// override methods to implement a different behavior.
-class SecondaryCacheWrapper : public SecondaryCache {
- public:
-  explicit SecondaryCacheWrapper(std::shared_ptr<SecondaryCache> target)
-      : target_(std::move(target)) {}
-
-  Status Insert(const Slice& key, Cache::ObjectPtr obj,
-                const Cache::CacheItemHelper* helper,
-                bool force_insert) override {
-    return target()->Insert(key, obj, helper, force_insert);
-  }
-
-  Status InsertSaved(const Slice& key, const Slice& saved,
-                     CompressionType type = CompressionType::kNoCompression,
-                     CacheTier source = CacheTier::kVolatileTier) override {
-    return target()->InsertSaved(key, saved, type, source);
-  }
-
-  std::unique_ptr<SecondaryCacheResultHandle> Lookup(
-      const Slice& key, const Cache::CacheItemHelper* helper,
-      Cache::CreateContext* create_context, bool wait, bool advise_erase,
-      Statistics* stats, bool& kept_in_sec_cache) override {
-    return target()->Lookup(key, helper, create_context, wait, advise_erase,
-                            stats, kept_in_sec_cache);
-  }
-
-  bool SupportForceErase() const override {
-    return target()->SupportForceErase();
-  }
-
-  void Erase(const Slice& key) override { target()->Erase(key); }
-
-  void WaitAll(std::vector<SecondaryCacheResultHandle*> handles) override {
-    target()->WaitAll(handles);
-  }
-
-  Status SetCapacity(size_t capacity) override {
-    return target()->SetCapacity(capacity);
-  }
-
-  Status GetCapacity(size_t& capacity) override {
-    return target()->GetCapacity(capacity);
-  }
-
-  Status Deflate(size_t decrease) override {
-    return target()->Deflate(decrease);
-  }
-
-  Status Inflate(size_t increase) override {
-    return target()->Inflate(increase);
-  }
-
- protected:
-  SecondaryCache* target() const { return target_.get(); }
-
- private:
-  std::shared_ptr<SecondaryCache> target_;
-};
-
-// Useful for cache entries that just need to be copied into a
-// secondary cache, such as compressed blocks
-extern const Cache::CacheItemHelper kSliceCacheItemHelper;
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/include/rocksdb/slice.h

@@ -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.
-//
-// Slice is a simple structure containing a pointer into some external
-// storage and a size.  The user of a Slice must ensure that the slice
-// is not used after the corresponding external storage has been
-// deallocated.
-//
-// Multiple threads can invoke const methods on a Slice without
-// external synchronization, but if any of the threads may call a
-// non-const method, all threads accessing the same Slice must use
-// external synchronization.
-
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <string_view>  // RocksDB now requires C++17 support
-
-#include "rocksdb/cleanable.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Slice {
- public:
-  // Create an empty slice.
-  Slice() : data_(""), size_(0) {}
-
-  // Create a slice that refers to d[0,n-1].
-  Slice(const char* d, size_t n) : data_(d), size_(n) {}
-
-  // Create a slice that refers to the contents of "s"
-  /* implicit */
-  Slice(const std::string& s) : data_(s.data()), size_(s.size()) {}
-
-  // Create a slice that refers to the same contents as "sv"
-  /* implicit */
-  Slice(const std::string_view& sv) : data_(sv.data()), size_(sv.size()) {}
-
-  // Create a slice that refers to s[0,strlen(s)-1]
-  /* implicit */
-  Slice(const char* s) : data_(s) { size_ = (s == nullptr) ? 0 : strlen(s); }
-
-  // Create a single slice from SliceParts using buf as storage.
-  // buf must exist as long as the returned Slice exists.
-  Slice(const struct SliceParts& parts, std::string* buf);
-
-  // Return a pointer to the beginning of the referenced data
-  const char* data() const { return data_; }
-
-  // Return the length (in bytes) of the referenced data
-  size_t size() const { return size_; }
-
-  // Return true iff the length of the referenced data is zero
-  bool empty() const { return size_ == 0; }
-
-  // Return the ith byte in the referenced data.
-  // REQUIRES: n < size()
-  char operator[](size_t n) const {
-    assert(n < size());
-    return data_[n];
-  }
-
-  // Change this slice to refer to an empty array
-  void clear() {
-    data_ = "";
-    size_ = 0;
-  }
-
-  // Drop the first "n" bytes from this slice.
-  void remove_prefix(size_t n) {
-    assert(n <= size());
-    data_ += n;
-    size_ -= n;
-  }
-
-  void remove_suffix(size_t n) {
-    assert(n <= size());
-    size_ -= n;
-  }
-
-  // Return a string that contains the copy of the referenced data.
-  // when hex is true, returns a string of twice the length hex encoded (0-9A-F)
-  std::string ToString(bool hex = false) const;
-
-  // Return a string_view that references the same data as this slice.
-  std::string_view ToStringView() const {
-    return std::string_view(data_, size_);
-  }
-
-  // Decodes the current slice interpreted as an hexadecimal string into result,
-  // if successful returns true, if this isn't a valid hex string
-  // (e.g not coming from Slice::ToString(true)) DecodeHex returns false.
-  // This slice is expected to have an even number of 0-9A-F characters
-  // also accepts lowercase (a-f)
-  bool DecodeHex(std::string* result) const;
-
-  // Three-way comparison.  Returns value:
-  //   <  0 iff "*this" <  "b",
-  //   == 0 iff "*this" == "b",
-  //   >  0 iff "*this" >  "b"
-  int compare(const Slice& b) const;
-
-  // Return true iff "x" is a prefix of "*this"
-  bool starts_with(const Slice& x) const {
-    return ((size_ >= x.size_) && (memcmp(data_, x.data_, x.size_) == 0));
-  }
-
-  bool ends_with(const Slice& x) const {
-    return ((size_ >= x.size_) &&
-            (memcmp(data_ + size_ - x.size_, x.data_, x.size_) == 0));
-  }
-
-  // Compare two slices and returns the first byte where they differ
-  size_t difference_offset(const Slice& b) const;
-
-  // private: make these public for rocksdbjni access
-  const char* data_;
-  size_t size_;
-
-  // Intentionally copyable
-};
-
-/**
- * A Slice that can be pinned with some cleanup tasks, which will be run upon
- * ::Reset() or object destruction, whichever is invoked first. This can be used
- * to avoid memcpy by having the PinnableSlice object referring to the data
- * that is locked in the memory and release them after the data is consumed.
- */
-class PinnableSlice : public Slice, public Cleanable {
- public:
-  PinnableSlice() { buf_ = &self_space_; }
-  explicit PinnableSlice(std::string* buf) { buf_ = buf; }
-
-  PinnableSlice(PinnableSlice&& other);
-  PinnableSlice& operator=(PinnableSlice&& other);
-
-  // No copy constructor and copy assignment allowed.
-  PinnableSlice(PinnableSlice&) = delete;
-  PinnableSlice& operator=(PinnableSlice&) = delete;
-
-  inline void PinSlice(const Slice& s, CleanupFunction f, void* arg1,
-                       void* arg2) {
-    assert(!pinned_);
-    pinned_ = true;
-    data_ = s.data();
-    size_ = s.size();
-    RegisterCleanup(f, arg1, arg2);
-    assert(pinned_);
-  }
-
-  inline void PinSlice(const Slice& s, Cleanable* cleanable) {
-    assert(!pinned_);
-    pinned_ = true;
-    data_ = s.data();
-    size_ = s.size();
-    if (cleanable != nullptr) {
-      cleanable->DelegateCleanupsTo(this);
-    }
-    assert(pinned_);
-  }
-
-  inline void PinSelf(const Slice& slice) {
-    assert(!pinned_);
-    buf_->assign(slice.data(), slice.size());
-    data_ = buf_->data();
-    size_ = buf_->size();
-    assert(!pinned_);
-  }
-
-  inline void PinSelf() {
-    assert(!pinned_);
-    data_ = buf_->data();
-    size_ = buf_->size();
-    assert(!pinned_);
-  }
-
-  void remove_suffix(size_t n) {
-    assert(n <= size());
-    if (pinned_) {
-      size_ -= n;
-    } else {
-      buf_->erase(size() - n, n);
-      PinSelf();
-    }
-  }
-
-  void remove_prefix(size_t n) {
-    assert(n <= size());
-    if (pinned_) {
-      data_ += n;
-      size_ -= n;
-    } else {
-      buf_->erase(0, n);
-      PinSelf();
-    }
-  }
-
-  void Reset() {
-    Cleanable::Reset();
-    pinned_ = false;
-    size_ = 0;
-  }
-
-  inline std::string* GetSelf() { return buf_; }
-
-  inline bool IsPinned() const { return pinned_; }
-
- private:
-  friend class PinnableSlice4Test;
-  std::string self_space_;
-  std::string* buf_;
-  bool pinned_ = false;
-};
-
-// A set of Slices that are virtually concatenated together.  'parts' points
-// to an array of Slices.  The number of elements in the array is 'num_parts'.
-struct SliceParts {
-  SliceParts(const Slice* _parts, int _num_parts)
-      : parts(_parts), num_parts(_num_parts) {}
-  SliceParts() : parts(nullptr), num_parts(0) {}
-
-  const Slice* parts;
-  int num_parts;
-};
-
-inline bool operator==(const Slice& x, const Slice& y) {
-  return ((x.size() == y.size()) &&
-          (memcmp(x.data(), y.data(), x.size()) == 0));
-}
-
-inline bool operator!=(const Slice& x, const Slice& y) { return !(x == y); }
-
-inline int Slice::compare(const Slice& b) const {
-  assert(data_ != nullptr && b.data_ != nullptr);
-  const size_t min_len = (size_ < b.size_) ? size_ : b.size_;
-  int r = memcmp(data_, b.data_, min_len);
-  if (r == 0) {
-    if (size_ < b.size_)
-      r = -1;
-    else if (size_ > b.size_)
-      r = +1;
-  }
-  return r;
-}
-
-inline size_t Slice::difference_offset(const Slice& b) const {
-  size_t off = 0;
-  const size_t len = (size_ < b.size_) ? size_ : b.size_;
-  for (; off < len; off++) {
-    if (data_[off] != b.data_[off]) break;
-  }
-  return off;
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/include/rocksdb/slice_transform.h

@@ -1,135 +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) 2012 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.
-//
-// Class for specifying user-defined functions which perform a
-// transformation on a slice.  It is not required that every slice
-// belong to the domain and/or range of a function.  Subclasses should
-// define InDomain and InRange to determine which slices are in either
-// of these sets respectively.
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "rocksdb/customizable.h"
-#include "rocksdb/rocksdb_namespace.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Slice;
-struct ConfigOptions;
-
-// A SliceTransform is a generic pluggable way of transforming one string
-// to another. Its primary use-case is in configuring RocksDB prefix Bloom
-// filters, by setting prefix_extractor in ColumnFamilyOptions.
-//
-// Exceptions MUST NOT propagate out of overridden functions into RocksDB,
-// because RocksDB is not exception-safe. This could cause undefined behavior
-// including data loss, unreported corruption, deadlocks, and more.
-class SliceTransform : public Customizable {
- public:
-  virtual ~SliceTransform(){}
-
-  // Return the name of this transformation.
-  const char* Name() const override = 0;
-  static const char* Type() { return "SliceTransform"; }
-
-  // Creates and configures a new SliceTransform from the input options and id.
-  static Status CreateFromString(const ConfigOptions& config_options,
-                                 const std::string& id,
-                                 std::shared_ptr<const SliceTransform>* result);
-
-  // Returns a string representation of this SliceTransform, representing the ID
-  // and any additional properties.
-  std::string AsString() const;
-
-  // Extract a prefix from a specified key, partial key, iterator upper bound,
-  // etc. This is normally used for building and checking prefix Bloom filters
-  // but should accept any string for which InDomain() returns true.
-  // See ColumnFamilyOptions::prefix_extractor for specific properties that
-  // must be satisfied by prefix extractors.
-  virtual Slice Transform(const Slice& key) const = 0;
-
-  // Determine whether the specified key is compatible with the logic
-  // specified in the Transform method. Keys for which InDomain returns
-  // false will not be added to or queried against prefix Bloom filters.
-  //
-  // For example, if the Transform method returns a fixed length
-  // prefix of size 4, then an invocation to InDomain("abc") returns
-  // false because the specified key length(3) is shorter than the
-  // prefix size of 4.
-  //
-  // Wiki documentation here:
-  // https://github.com/facebook/rocksdb/wiki/Prefix-Seek
-  //
-  virtual bool InDomain(const Slice& key) const = 0;
-
-  // DEPRECATED: This is currently not used and remains here for backward
-  // compatibility.
-  virtual bool InRange(const Slice& /*dst*/) const { return false; }
-
-  // Returns information on maximum prefix length, if there is one.
-  // If Transform(x).size() == n for some keys and otherwise < n,
-  // should return true and set *len = n. Returning false is safe but
-  // currently disables some auto_prefix_mode filtering.
-  // Specifically, if the iterate_upper_bound is the immediate successor (see
-  // Comparator::IsSameLengthImmediateSuccessor) of the seek key's prefix,
-  // we require this function return true and iterate_upper_bound.size() == n
-  // to recognize and optimize the prefix seek.
-  // Otherwise (including FullLengthEnabled returns false, or prefix length is
-  // less than maximum), Seek with auto_prefix_mode is only optimized if the
-  // iterate_upper_bound and seek key have the same prefix.
-  // BUG: Despite all these conditions and even with the extra condition on
-  // IsSameLengthImmediateSuccessor (see it's "BUG" section), it is not
-  // sufficient to ensure auto_prefix_mode returns all entries that
-  // total_order_seek would return. See auto_prefix_mode "BUG" section.
-  virtual bool FullLengthEnabled(size_t* /*len*/) const { return false; }
-
-  // Transform(s)=Transform(`prefix`) for any s with `prefix` as a prefix.
-  //
-  // This function is not used by RocksDB, but for users. If users pass
-  // Options by string to RocksDB, they might not know what prefix extractor
-  // they are using. This function is to help users can determine:
-  //   if they want to iterate all keys prefixing `prefix`, whether it is
-  //   safe to use prefix bloom filter and seek to key `prefix`.
-  // If this function returns true, this means a user can Seek() to a prefix
-  // using the bloom filter. Otherwise, user needs to skip the bloom filter
-  // by setting ReadOptions.total_order_seek = true.
-  //
-  // Here is an example: Suppose we implement a slice transform that returns
-  // the first part of the string up to and including first ",":
-  // 1. SameResultWhenAppended("abc,") should return true. If applying prefix
-  //    bloom filter using it, all slices matching "abc,.*" will be extracted
-  //    to "abc,", so any SST file or memtable containing any of those key
-  //    will not be filtered out.
-  // 2. SameResultWhenAppended("abc") should return false. A user will not be
-  //    guaranteed to see all the keys matching "abc.*" if a user prefix
-  //    seeks to "abc" against a DB with the same setting. If one SST file
-  //    only contains "abcd,e", the file can be filtered out and the key will
-  //    be invisible, because the prefix according to the configured extractor
-  //    is "abcd,".
-  //
-  // i.e., an implementation always returning false is safe.
-  virtual bool SameResultWhenAppended(const Slice& /*prefix*/) const {
-    return false;
-  }
-};
-
-// The prefix is the first `prefix_len` bytes of the key, and keys shorter
-// then `prefix_len` are not InDomain.
-const SliceTransform* NewFixedPrefixTransform(size_t prefix_len);
-
-// The prefix is the first min(length(key),`cap_len`) bytes of the key, and
-// all keys are InDomain.
-const SliceTransform* NewCappedPrefixTransform(size_t cap_len);
-
-// Prefix is equal to key. All keys are InDomain.
-const SliceTransform* NewNoopTransform();
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/include/rocksdb/snapshot.h

@@ -1,53 +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 {
-
-class DB;
-
-// Abstract handle to particular state of a DB.
-// A Snapshot is an immutable object and can therefore be safely
-// accessed from multiple threads without any external synchronization.
-//
-// To Create a Snapshot, call DB::GetSnapshot().
-// To Destroy a Snapshot, call DB::ReleaseSnapshot(snapshot).
-class Snapshot {
- public:
-  virtual SequenceNumber GetSequenceNumber() const = 0;
-
-  // Returns unix time i.e. the number of seconds since the Epoch, 1970-01-01
-  // 00:00:00 (UTC).
-  virtual int64_t GetUnixTime() const = 0;
-
-  virtual uint64_t GetTimestamp() const = 0;
-
- protected:
-  virtual ~Snapshot();
-};
-
-// Simple RAII wrapper class for Snapshot.
-// Constructing this object will create a snapshot.  Destructing will
-// release the snapshot.
-class ManagedSnapshot {
- public:
-  explicit ManagedSnapshot(DB* db);
-
-  // Instead of creating a snapshot, take ownership of the input snapshot.
-  ManagedSnapshot(DB* db, const Snapshot* _snapshot);
-
-  ~ManagedSnapshot();
-
-  const Snapshot* snapshot();
-
- private:
-  DB* db_;
-  const Snapshot* snapshot_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/include/rocksdb/sst_dump_tool.h

@@ -1,17 +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/options.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class SSTDumpTool {
- public:
-  int Run(int argc, char const* const* argv, Options options = Options());
-};
-
-}  // namespace ROCKSDB_NAMESPACE
-