rocksdb-native 0.0.0

package/vendor/rocksdb/include/rocksdb/compaction_filter.h

@@ -0,0 +1,363 @@
+// 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) 2013 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 <cassert>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "rocksdb/customizable.h"
+#include "rocksdb/rocksdb_namespace.h"
+#include "rocksdb/types.h"
+#include "rocksdb/wide_columns.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class Slice;
+class SliceTransform;
+
+// CompactionFilter allows an application to modify/delete a key-value during
+// table file creation.
+//
+// Some general notes:
+//
+// * RocksDB snapshots do not guarantee to preserve the state of the DB in the
+// presence of CompactionFilter. Data seen from a snapshot might disappear after
+// a table file created with a `CompactionFilter` is installed. If you use
+// snapshots, think twice about whether you want to use `CompactionFilter` and
+// whether you are using it in a safe way.
+//
+// * If multithreaded compaction is being used *and* a single CompactionFilter
+// instance was supplied via Options::compaction_filter, CompactionFilter
+// methods may be called from different threads concurrently.  The application
+// must ensure that such calls are thread-safe. If the CompactionFilter was
+// created by a factory, then it will only ever be used by a single thread that
+// is doing the table file creation, and this call does not need to be
+// thread-safe.  However, multiple filters may be in existence and operating
+// concurrently.
+//
+// * The key passed to the filtering methods includes the timestamp if
+// user-defined timestamps are enabled.
+//
+// * 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 CompactionFilter : public Customizable {
+ public:
+  // Value type of the key-value passed to the compaction filter's FilterV2/V3
+  // methods.
+  enum ValueType {
+    // Plain key-value
+    kValue,
+    // Merge operand
+    kMergeOperand,
+    // Used internally by the old stacked BlobDB implementation; this value type
+    // is never passed to application code. Note that when using the new
+    // integrated BlobDB, values stored separately as blobs are retrieved and
+    // presented to FilterV2/V3 with the type kValue above.
+    kBlobIndex,
+    // Wide-column entity
+    kWideColumnEntity,
+  };
+
+  // Potential decisions that can be returned by the compaction filter's
+  // FilterV2/V3 and FilterBlobByKey methods. See decision-specific caveats and
+  // constraints below.
+  enum class Decision {
+    // Keep the current key-value as-is.
+    kKeep,
+
+    // Remove the current key-value. Note that the semantics of removal are
+    // dependent on the value type. If the current key-value is a plain
+    // key-value or a wide-column entity, it is converted to a tombstone
+    // (Delete), resulting in the deletion of any earlier versions of the key.
+    // If it is a merge operand, it is simply dropped. Note: if you are using
+    // a TransactionDB, it is not recommended to filter out merge operands.
+    // If a Merge operation is filtered out, TransactionDB may not realize there
+    // is a write conflict and may allow a Transaction that should have failed
+    // to Commit. Instead, it is better to implement any Merge filtering inside
+    // the MergeOperator.
+    kRemove,
+
+    // Change the value of the current key-value. If the current key-value is a
+    // plain key-value or a merge operand, its value is updated but its value
+    // type remains the same. If the current key-value is a wide-column entity,
+    // it is converted to a plain key-value with the new value specified.
+    kChangeValue,
+
+    // Remove all key-values with key in [key, *skip_until). This range of keys
+    // will be skipped in a way that potentially avoids some IO operations
+    // compared to removing the keys one by one. Note that removal in this case
+    // means dropping the key-value regardless of value type; in other words, in
+    // contrast with kRemove, plain values and entities are not converted to
+    // tombstones.
+    //
+    // *skip_until <= key is treated the same as Decision::kKeep (since the
+    // range [key, *skip_until) is empty).
+    //
+    // Caveats:
+    // * The keys are skipped even if there are snapshots containing them,
+    //   i.e. values removed by kRemoveAndSkipUntil can disappear from a
+    //   snapshot - beware if you're using TransactionDB or DB::GetSnapshot().
+    // * If value for a key was overwritten or merged into (multiple Put()s
+    //   or Merge()s), and `CompactionFilter` skips this key with
+    //   kRemoveAndSkipUntil, it's possible that it will remove only
+    //   the new value, exposing the old value that was supposed to be
+    //   overwritten.
+    // * Doesn't work with PlainTableFactory in prefix mode.
+    // * If you use kRemoveAndSkipUntil for table files created by compaction,
+    //   consider also reducing compaction_readahead_size option.
+    kRemoveAndSkipUntil,
+
+    // Used internally by the old stacked BlobDB implementation. Returning this
+    // decision from application code is not supported.
+    kChangeBlobIndex,
+
+    // Used internally by the old stacked BlobDB implementation. Returning this
+    // decision from application code is not supported.
+    kIOError,
+
+    // Remove the current key-value by converting it to a SingleDelete-type
+    // tombstone. Only supported for plain-key values and wide-column entities;
+    // not supported for merge operands. All the caveats related to
+    // SingleDeletes apply.
+    kPurge,
+
+    // Change the current key-value to the wide-column entity specified. If the
+    // current key-value is already a wide-column entity, only its columns are
+    // updated; if it is a plain key-value, it is converted to a wide-column
+    // entity with the specified columns. Not supported for merge operands.
+    // Only applicable to FilterV3.
+    kChangeWideColumnEntity,
+
+    // When using the integrated BlobDB implementation, it may be possible for
+    // applications to make a filtering decision for a given blob based on
+    // the key only without actually reading the blob value, which saves some
+    // I/O; see the FilterBlobByKey method below. Returning kUndetermined from
+    // FilterBlobByKey signals that making a decision solely based on the
+    // key is not possible; in this case, RocksDB reads the blob value and
+    // passes the key-value to the regular filtering method. Only applicable to
+    // FilterBlobByKey; returning this value from FilterV2/V3 is not supported.
+    kUndetermined,
+  };
+
+  // Used internally by the old stacked BlobDB implementation.
+  enum class BlobDecision { kKeep, kChangeValue, kCorruption, kIOError };
+
+  // Context information for a table file creation.
+  struct Context {
+    // Whether this table file is created as part of a compaction including all
+    // table files.
+    bool is_full_compaction;
+    // Whether this table file is created as part of a compaction requested by
+    // the client.
+    bool is_manual_compaction;
+    // The column family that will contain the created table file.
+    uint32_t column_family_id;
+    // Reason this table file is being created.
+    TableFileCreationReason reason;
+  };
+
+  virtual ~CompactionFilter() {}
+  static const char* Type() { return "CompactionFilter"; }
+  static Status CreateFromString(const ConfigOptions& config_options,
+                                 const std::string& name,
+                                 const CompactionFilter** result);
+
+  // The table file creation process invokes this method before adding a kv to
+  // the table file. A return value of false indicates that the kv should be
+  // preserved in the new table file and a return value of true indicates
+  // that this key-value should be removed (that is, converted to a tombstone).
+  // The application can inspect the existing value of the key and make decision
+  // based on it.
+  //
+  // Key-Values that are results of merge operation during table file creation
+  // are not passed into this function. Currently, when you have a mix of Put()s
+  // and Merge()s on a same key, we only guarantee to process the merge operands
+  // through the `CompactionFilter`s. Put()s might be processed, or might not.
+  //
+  // When the value is to be preserved, the application has the option
+  // to modify the existing_value and pass it back through new_value.
+  // value_changed needs to be set to true in this case.
+  virtual bool Filter(int /*level*/, const Slice& /*key*/,
+                      const Slice& /*existing_value*/,
+                      std::string* /*new_value*/,
+                      bool* /*value_changed*/) const {
+    return false;
+  }
+
+  // The table file creation process invokes this method on every merge operand.
+  // If this method returns true, the merge operand will be ignored and not
+  // written out in the new table file.
+  //
+  // Note: If you are using a TransactionDB, it is not recommended to implement
+  // FilterMergeOperand().  If a Merge operation is filtered out, TransactionDB
+  // may not realize there is a write conflict and may allow a Transaction to
+  // Commit that should have failed.  Instead, it is better to implement any
+  // Merge filtering inside the MergeOperator.
+  virtual bool FilterMergeOperand(int /*level*/, const Slice& /*key*/,
+                                  const Slice& /*operand*/) const {
+    return false;
+  }
+
+  // A unified API for plain values and merge operands that may
+  // return a variety of decisions (see Decision above). The `value_type`
+  // parameter indicates the type of the key-value and the `existing_value`
+  // contains the current value or merge operand. The `new_value` output
+  // parameter can be used to set the updated value or merge operand when the
+  // kChangeValue decision is made by the filter. See the description of
+  // kRemoveAndSkipUntil above for the semantics of the `skip_until` output
+  // parameter, and see Decision above for more information on the semantics of
+  // the potential return values.
+  //
+  // The default implementation uses Filter() and FilterMergeOperand().
+  // If you're overriding this method, no need to override the other two.
+  virtual Decision FilterV2(int level, const Slice& key, ValueType value_type,
+                            const Slice& existing_value, std::string* new_value,
+                            std::string* /*skip_until*/) const {
+    switch (value_type) {
+      case ValueType::kValue: {
+        bool value_changed = false;
+        bool rv = Filter(level, key, existing_value, new_value, &value_changed);
+        if (rv) {
+          return Decision::kRemove;
+        }
+        return value_changed ? Decision::kChangeValue : Decision::kKeep;
+      }
+
+      case ValueType::kMergeOperand: {
+        bool rv = FilterMergeOperand(level, key, existing_value);
+        return rv ? Decision::kRemove : Decision::kKeep;
+      }
+
+      case ValueType::kBlobIndex:
+        return Decision::kKeep;
+
+      default:
+        assert(false);
+        return Decision::kKeep;
+    }
+  }
+
+  // Wide column aware unified API. Called for plain values, merge operands, and
+  // wide-column entities; the `value_type` parameter indicates the type of the
+  // key-value. When the key-value is a plain value or a merge operand, the
+  // `existing_value` parameter contains the existing value and the
+  // `existing_columns` parameter is invalid (nullptr). When the key-value is a
+  // wide-column entity, the `existing_columns` parameter contains the wide
+  // columns of the existing entity and the `existing_value` parameter is
+  // invalid (nullptr). The `new_value` output parameter can be used to set the
+  // updated value or merge operand when the kChangeValue decision is made by
+  // the filter. The `new_columns` output parameter can be used to specify
+  // the pairs of column names and column values when the
+  // kChangeWideColumnEntity decision is returned. See the description of
+  // kRemoveAndSkipUntil above for the semantics of the `skip_until` output
+  // parameter, and see Decision above for more information on the semantics of
+  // the potential return values.
+  //
+  // For compatibility, the default implementation keeps all wide-column
+  // entities, and falls back to FilterV2 for plain values and merge operands.
+  // If you override this method, there is no need to override FilterV2 (or
+  // Filter/FilterMergeOperand).
+  virtual Decision FilterV3(
+      int level, const Slice& key, ValueType value_type,
+      const Slice* existing_value, const WideColumns* existing_columns,
+      std::string* new_value,
+      std::vector<std::pair<std::string, std::string>>* /* new_columns */,
+      std::string* skip_until) const {
+#ifdef NDEBUG
+    (void)existing_columns;
+#endif
+
+    assert(!existing_value || !existing_columns);
+    assert(value_type == ValueType::kWideColumnEntity || existing_value);
+    assert(value_type != ValueType::kWideColumnEntity || existing_columns);
+
+    if (value_type == ValueType::kWideColumnEntity) {
+      return Decision::kKeep;
+    }
+
+    return FilterV2(level, key, value_type, *existing_value, new_value,
+                    skip_until);
+  }
+
+  // Internal (BlobDB) use only. Do not override in application code.
+  virtual BlobDecision PrepareBlobOutput(const Slice& /* key */,
+                                         const Slice& /* existing_value */,
+                                         std::string* /* new_value */) const {
+    return BlobDecision::kKeep;
+  }
+
+  // This function is deprecated. Snapshots will always be ignored for
+  // `CompactionFilter`s, because we realized that not ignoring snapshots
+  // doesn't provide the guarantee we initially thought it would provide.
+  // Repeatable reads will not be guaranteed anyway. If you override the
+  // function and returns false, we will fail the table file creation.
+  virtual bool IgnoreSnapshots() const { return true; }
+
+  // Returns a name that identifies this `CompactionFilter`.
+  // The name will be printed to LOG file on start up for diagnosis.
+  const char* Name() const override = 0;
+
+  // Internal (BlobDB) use only. Do not override in application code.
+  virtual bool IsStackedBlobDbInternalCompactionFilter() const { return false; }
+
+  // In the case of BlobDB, it may be possible to reach a decision with only
+  // the key without reading the actual value, saving some I/O operations.
+  // Keys where the value is stored separately in a blob file will be
+  // passed to this method. If the method returns a supported decision other
+  // than kUndetermined, it will be considered final and performed without
+  // reading the existing value. Returning kUndetermined will cause FilterV3()
+  // to be called to make a decision as usual. The output parameters
+  // `new_value` and `skip_until` are applicable to the decisions kChangeValue
+  // and kRemoveAndSkipUntil respectively, and have the same semantics as
+  // the corresponding parameters of FilterV2/V3.
+  virtual Decision FilterBlobByKey(int /*level*/, const Slice& /*key*/,
+                                   std::string* /*new_value*/,
+                                   std::string* /*skip_until*/) const {
+    return Decision::kUndetermined;
+  }
+};
+
+// Each thread of work involving creating table files will create a new
+// `CompactionFilter` according to `ShouldFilterTableFileCreation()`. This
+// allows the application to know about the different ongoing threads of work
+// and makes it unnecessary for `CompactionFilter` to provide thread-safety.
+//
+// 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 CompactionFilterFactory : public Customizable {
+ public:
+  virtual ~CompactionFilterFactory() {}
+  static const char* Type() { return "CompactionFilterFactory"; }
+  static Status CreateFromString(
+      const ConfigOptions& config_options, const std::string& name,
+      std::shared_ptr<CompactionFilterFactory>* result);
+
+  // Returns whether a thread creating table files for the specified `reason`
+  // should invoke `CreateCompactionFilter()` and pass KVs through the returned
+  // filter.
+  virtual bool ShouldFilterTableFileCreation(
+      TableFileCreationReason reason) const {
+    // For backward compatibility, default implementation only applies
+    // `CompactionFilter` to files generated by compaction.
+    return reason == TableFileCreationReason::kCompaction;
+  }
+
+  virtual std::unique_ptr<CompactionFilter> CreateCompactionFilter(
+      const CompactionFilter::Context& context) = 0;
+
+  // Returns a name that identifies this `CompactionFilter` factory.
+  virtual const char* Name() const override = 0;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/vendor/rocksdb/include/rocksdb/compaction_job_stats.h

@@ -0,0 +1,109 @@
+// 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 <stddef.h>
+#include <stdint.h>
+
+#include <string>
+
+#include "rocksdb/rocksdb_namespace.h"
+
+namespace ROCKSDB_NAMESPACE {
+struct CompactionJobStats {
+  CompactionJobStats() { Reset(); }
+  void Reset();
+  // Aggregate the CompactionJobStats from another instance with this one
+  void Add(const CompactionJobStats& stats);
+
+  // the elapsed time of this compaction in microseconds.
+  uint64_t elapsed_micros;
+
+  // the elapsed CPU time of this compaction in microseconds.
+  uint64_t cpu_micros;
+
+  // the number of compaction input records.
+  uint64_t num_input_records;
+  // the number of blobs read from blob files
+  uint64_t num_blobs_read;
+  // the number of compaction input files (table files)
+  size_t num_input_files;
+  // the number of compaction input files at the output level (table files)
+  size_t num_input_files_at_output_level;
+
+  // the number of compaction output records.
+  uint64_t num_output_records;
+  // the number of compaction output files (table files)
+  size_t num_output_files;
+  // the number of compaction output files (blob files)
+  size_t num_output_files_blob;
+
+  // true if the compaction is a full compaction (all live SST files input)
+  bool is_full_compaction;
+  // true if the compaction is a manual compaction
+  bool is_manual_compaction;
+
+  // the total size of table files in the compaction input
+  uint64_t total_input_bytes;
+  // the total size of blobs read from blob files
+  uint64_t total_blob_bytes_read;
+  // the total size of table files in the compaction output
+  uint64_t total_output_bytes;
+  // the total size of blob files in the compaction output
+  uint64_t total_output_bytes_blob;
+
+  // number of records being replaced by newer record associated with same key.
+  // this could be a new value or a deletion entry for that key so this field
+  // sums up all updated and deleted keys
+  uint64_t num_records_replaced;
+
+  // the sum of the uncompressed input keys in bytes.
+  uint64_t total_input_raw_key_bytes;
+  // the sum of the uncompressed input values in bytes.
+  uint64_t total_input_raw_value_bytes;
+
+  // the number of deletion entries before compaction. Deletion entries
+  // can disappear after compaction because they expired
+  uint64_t num_input_deletion_records;
+  // number of deletion records that were found obsolete and discarded
+  // because it is not possible to delete any more keys with this entry
+  // (i.e. all possible deletions resulting from it have been completed)
+  uint64_t num_expired_deletion_records;
+
+  // number of corrupt keys (ParseInternalKey returned false when applied to
+  // the key) encountered and written out.
+  uint64_t num_corrupt_keys;
+
+  // Following counters are only populated if
+  // options.report_bg_io_stats = true;
+
+  // Time spent on file's Append() call.
+  uint64_t file_write_nanos;
+
+  // Time spent on sync file range.
+  uint64_t file_range_sync_nanos;
+
+  // Time spent on file fsync.
+  uint64_t file_fsync_nanos;
+
+  // Time spent on preparing file write (fallocate, etc)
+  uint64_t file_prepare_write_nanos;
+
+  // 0-terminated strings storing the first 8 bytes of the smallest and
+  // largest key in the output.
+  static const size_t kMaxPrefixLength = 8;
+
+  std::string smallest_output_key_prefix;
+  std::string largest_output_key_prefix;
+
+  // number of single-deletes which do not meet a put
+  uint64_t num_single_del_fallthru;
+
+  // number of single-deletes which meet something other than a put
+  uint64_t num_single_del_mismatch;
+
+  // TODO: Add output_to_penultimate_level output information
+};
+}  // namespace ROCKSDB_NAMESPACE

package/vendor/rocksdb/include/rocksdb/comparator.h

@@ -0,0 +1,164 @@
+// 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 <string>
+
+#include "rocksdb/customizable.h"
+#include "rocksdb/rocksdb_namespace.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+class Slice;
+
+// The general interface for comparing two Slices are defined for both of
+// Comparator and some internal data structures.
+class CompareInterface {
+ public:
+  virtual ~CompareInterface() {}
+
+  // Three-way comparison.  Returns value:
+  //   < 0 iff "a" < "b",
+  //   == 0 iff "a" == "b",
+  //   > 0 iff "a" > "b"
+  // Note that Compare(a, b) also compares timestamp if timestamp size is
+  // non-zero. For the same user key with different timestamps, larger (newer)
+  // timestamp comes first.
+  virtual int Compare(const Slice& a, const Slice& b) const = 0;
+};
+
+// A Comparator object provides a total order across slices that are
+// used as keys in an sstable or a database.  A Comparator implementation
+// must be thread-safe since rocksdb may invoke its methods concurrently
+// from multiple threads.
+//
+// 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 Comparator : public Customizable, public CompareInterface {
+ public:
+  Comparator() : timestamp_size_(0) {}
+
+  Comparator(size_t ts_sz) : timestamp_size_(ts_sz) {}
+
+  Comparator(const Comparator& orig) : timestamp_size_(orig.timestamp_size_) {}
+
+  Comparator& operator=(const Comparator& rhs) {
+    if (this != &rhs) {
+      timestamp_size_ = rhs.timestamp_size_;
+    }
+    return *this;
+  }
+
+  ~Comparator() override {}
+
+  static Status CreateFromString(const ConfigOptions& opts,
+                                 const std::string& id,
+                                 const Comparator** comp);
+  static const char* Type() { return "Comparator"; }
+
+  // The name of the comparator.  Used to check for comparator
+  // mismatches (i.e., a DB created with one comparator is
+  // accessed using a different comparator.
+  //
+  // The client of this package should switch to a new name whenever
+  // the comparator implementation changes in a way that will cause
+  // the relative ordering of any two keys to change.
+  //
+  // Names starting with "rocksdb." are reserved and should not be used
+  // by any clients of this package.
+  const char* Name() const override = 0;
+
+  // Compares two slices for equality. The following invariant should always
+  // hold (and is the default implementation):
+  //   Equal(a, b) iff Compare(a, b) == 0
+  // Overwrite only if equality comparisons can be done more efficiently than
+  // three-way comparisons.
+  virtual bool Equal(const Slice& a, const Slice& b) const {
+    return Compare(a, b) == 0;
+  }
+
+  // Advanced functions: these are used to reduce the space requirements
+  // for internal data structures like index blocks.
+
+  // If *start < limit, changes *start to a short string in [start,limit).
+  // Simple comparator implementations may return with *start unchanged,
+  // i.e., an implementation of this method that does nothing is correct.
+  virtual void FindShortestSeparator(std::string* start,
+                                     const Slice& limit) const = 0;
+
+  // Changes *key to a short string >= *key.
+  // Simple comparator implementations may return with *key unchanged,
+  // i.e., an implementation of this method that does nothing is correct.
+  virtual void FindShortSuccessor(std::string* key) const = 0;
+
+  // given two keys, determine if t is the successor of s
+  // BUG: only return true if no other keys starting with `t` are ordered
+  // before `t`. Otherwise, the auto_prefix_mode can omit entries within
+  // iterator bounds that have same prefix as upper bound but different
+  // prefix from seek key.
+  virtual bool IsSameLengthImmediateSuccessor(const Slice& /*s*/,
+                                              const Slice& /*t*/) const {
+    return false;
+  }
+
+  // return true if two keys with different byte sequences can be regarded
+  // as equal by this comparator.
+  // The major use case is to determine if DataBlockHashIndex is compatible
+  // with the customized comparator.
+  virtual bool CanKeysWithDifferentByteContentsBeEqual() const { return true; }
+
+  // if it is a wrapped comparator, may return the root one.
+  // return itself it is not wrapped.
+  virtual const Comparator* GetRootComparator() const { return this; }
+
+  inline size_t timestamp_size() const { return timestamp_size_; }
+
+  int CompareWithoutTimestamp(const Slice& a, const Slice& b) const {
+    return CompareWithoutTimestamp(a, /*a_has_ts=*/true, b, /*b_has_ts=*/true);
+  }
+
+  // For two events e1 and e2 whose timestamps are t1 and t2 respectively,
+  // Returns value:
+  // < 0  iff t1 < t2
+  // == 0 iff t1 == t2
+  // > 0  iff t1 > t2
+  // Note that an all-zero byte array will be the smallest (oldest) timestamp
+  // of the same length, and a byte array with all bits 1 will be the largest.
+  // In the future, we can extend Comparator so that subclasses can specify
+  // both largest and smallest timestamps.
+  virtual int CompareTimestamp(const Slice& /*ts1*/,
+                               const Slice& /*ts2*/) const {
+    return 0;
+  }
+
+  virtual int CompareWithoutTimestamp(const Slice& a, bool /*a_has_ts*/,
+                                      const Slice& b, bool /*b_has_ts*/) const {
+    return Compare(a, b);
+  }
+
+  virtual bool EqualWithoutTimestamp(const Slice& a, const Slice& b) const {
+    return 0 ==
+           CompareWithoutTimestamp(a, /*a_has_ts=*/true, b, /*b_has_ts=*/true);
+  }
+
+ private:
+  size_t timestamp_size_;
+};
+
+// Return a builtin comparator that uses lexicographic byte-wise
+// ordering.  The result remains the property of this module and
+// must not be deleted.
+extern const Comparator* BytewiseComparator();
+
+// Return a builtin comparator that uses reverse lexicographic byte-wise
+// ordering.
+extern const Comparator* ReverseBytewiseComparator();
+
+}  // namespace ROCKSDB_NAMESPACE

package/vendor/rocksdb/include/rocksdb/compression_type.h

@@ -0,0 +1,40 @@
+// 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/rocksdb_namespace.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// DB contents are stored in a set of blocks, each of which holds a
+// sequence of key,value pairs.  Each block may be compressed before
+// being stored in a file.  The following enum describes which
+// compression method (if any) is used to compress a block.
+
+enum CompressionType : unsigned char {
+  // NOTE: do not change the values of existing entries, as these are
+  // part of the persistent format on disk.
+  kNoCompression = 0x0,
+  kSnappyCompression = 0x1,
+  kZlibCompression = 0x2,
+  kBZip2Compression = 0x3,
+  kLZ4Compression = 0x4,
+  kLZ4HCCompression = 0x5,
+  kXpressCompression = 0x6,
+  kZSTD = 0x7,
+
+  // Only use kZSTDNotFinalCompression if you have to use ZSTD lib older than
+  // 0.8.0 or consider a possibility of downgrading the service or copying
+  // the database files to another service running with an older version of
+  // RocksDB that doesn't have kZSTD. Otherwise, you should use kZSTD. We will
+  // eventually remove the option from the public API.
+  kZSTDNotFinalCompression = 0x40,
+
+  // kDisableCompressionOption is used to disable some compression options.
+  kDisableCompressionOption = 0xff,
+};
+
+}  // namespace ROCKSDB_NAMESPACE