rocksdb-native 2.6.2 → 2.6.4

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

@@ -1,231 +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 <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_; }
-
-  // Return what this Comparator considers as the maximum timestamp.
-  // The default implementation only works for when `timestamp_size_` is 0,
-  // subclasses for which this is not the case needs to override this function.
-  virtual Slice GetMaxTimestamp() const {
-    if (timestamp_size_ == 0) {
-      return Slice();
-    }
-    assert(false);
-    return Slice();
-  }
-
-  // Return what this Comparator considers as the min timestamp.
-  // The default implementation only works for when `timestamp_size_` is 0,
-  // subclasses for which this is not the case needs to override this function.
-  virtual Slice GetMinTimestamp() const {
-    if (timestamp_size_ == 0) {
-      return Slice();
-    }
-    assert(false);
-    return Slice();
-  }
-
-  // Return a human readable user-defined timestamp for debugging.
-  virtual std::string TimestampToString(const Slice& /*timestamp*/) const {
-    return "";
-  }
-
-  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.
-const Comparator* BytewiseComparator();
-
-// Return a builtin comparator that uses reverse lexicographic byte-wise
-// ordering.
-const Comparator* ReverseBytewiseComparator();
-
-// Returns a builtin comparator that enables user-defined timestamps (formatted
-// as uint64_t) while ordering the user key part without UDT with a
-// BytewiseComparator.
-// For the same user key with different timestamps, larger (newer) timestamp
-// comes first.
-const Comparator* BytewiseComparatorWithU64Ts();
-
-// Returns a builtin comparator that enables user-defined timestamps (formatted
-// as uint64_t) while ordering the user key part without UDT with a
-// ReverseBytewiseComparator.
-// For the same user key with different timestamps, larger (newer) timestamp
-// comes first.
-const Comparator* ReverseBytewiseComparatorWithU64Ts();
-
-// Decode a `U64Ts` timestamp returned by RocksDB to uint64_t.
-// When a column family enables user-defined timestamp feature
-// with `BytewiseComparatorWithU64Ts` or `ReverseBytewiseComparatorWithU64Ts`
-// comparator, the `Iterator::timestamp()` API returns timestamp in `Slice`
-// format. This util function helps to translate that `Slice` into an uint64_t
-// type.
-Status DecodeU64Ts(const Slice& ts, uint64_t* int_ts);
-
-// Encode an uint64_t timestamp into a U64Ts `Slice`, to be used as
-// `ReadOptions.timestamp` for a column family that enables user-defined
-// timestamp feature with `BytewiseComparatorWithU64Ts` or
-// `ReverseBytewiseComparatorWithU64Ts` comparator.
-// Be mindful that the returned `Slice` is backed by `ts_buf`. When `ts_buf`
-// is deconstructed, the returned `Slice` can no longer be used.
-Slice EncodeU64Ts(uint64_t ts, std::string* ts_buf);
-
-// Returns a `Slice` representing the maximum U64Ts timestamp.
-// The returned `Slice` is backed by some static storage, so it's valid until
-// program destruction.
-Slice MaxU64Ts();
-
-// Returns a `Slice` representing the minimum U64Ts timestamp.
-// The returned `Slice` is backed by some static storage, so it's valid until
-// program destruction.
-Slice MinU64Ts();
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,186 +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/rocksdb_namespace.h"
-#include "rocksdb/types.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,
-};
-
-// Compression options for different compression algorithms like Zlib
-struct CompressionOptions {
-  // ==> BEGIN options that can be set by deprecated configuration syntax, <==
-  // ==> e.g. compression_opts=5:6:7:8:9:10:true:11:false                  <==
-  // ==> Please use compression_opts={level=6;strategy=7;} form instead.   <==
-
-  // RocksDB's generic default compression level. Internally it'll be translated
-  // to the default compression level specific to the library being used (see
-  // comment above `ColumnFamilyOptions::compression`).
-  //
-  // The default value is the max 16-bit int as it'll be written out in OPTIONS
-  // file, which should be portable.
-  static constexpr int kDefaultCompressionLevel = 32767;
-
-  // zlib only: windowBits parameter. See https://www.zlib.net/manual.html
-  int window_bits = -14;
-
-  // Compression "level" applicable to zstd, zlib, LZ4, and LZ4HC. Except for
-  // kDefaultCompressionLevel (see above), the meaning of each value depends
-  // on the compression algorithm. Decreasing across non-
-  // `kDefaultCompressionLevel` values will either favor speed over
-  // compression ratio or have no effect.
-  //
-  // In LZ4 specifically, the absolute value of a negative `level` internally
-  // configures the `acceleration` parameter. For example, set `level=-10` for
-  // `acceleration=10`. This negation is necessary to ensure decreasing `level`
-  // values favor speed over compression ratio.
-  int level = kDefaultCompressionLevel;
-
-  // zlib only: strategy parameter. See https://www.zlib.net/manual.html
-  int strategy = 0;
-
-  // Maximum size of dictionaries used to prime the compression library.
-  // Enabling dictionary can improve compression ratios when there are
-  // repetitions across data blocks.
-  //
-  // The dictionary is created by sampling the SST file data. If
-  // `zstd_max_train_bytes` is nonzero, the samples are passed through zstd's
-  // dictionary generator (see comments for option `use_zstd_dict_trainer` for
-  // detail on dictionary generator). If `zstd_max_train_bytes` is zero, the
-  // random samples are used directly as the dictionary.
-  //
-  // When compression dictionary is disabled, we compress and write each block
-  // before buffering data for the next one. When compression dictionary is
-  // enabled, we buffer SST file data in-memory so we can sample it, as data
-  // can only be compressed and written after the dictionary has been finalized.
-  //
-  // The amount of data buffered can be limited by `max_dict_buffer_bytes`. This
-  // buffered memory is charged to the block cache when there is a block cache.
-  // If block cache insertion fails with `Status::MemoryLimit` (i.e., it is
-  // full), we finalize the dictionary with whatever data we have and then stop
-  // buffering.
-  uint32_t max_dict_bytes = 0;
-
-  // Maximum size of training data passed to zstd's dictionary trainer. Using
-  // zstd's dictionary trainer can achieve even better compression ratio
-  // improvements than using `max_dict_bytes` alone.
-  //
-  // The training data will be used to generate a dictionary of max_dict_bytes.
-  uint32_t zstd_max_train_bytes = 0;
-
-  // Number of threads for parallel compression.
-  // Parallel compression is enabled only if threads > 1.
-  // THE FEATURE IS STILL EXPERIMENTAL
-  //
-  // This option is valid only when BlockBasedTable is used.
-  //
-  // When parallel compression is enabled, SST size file sizes might be
-  // more inflated compared to the target size, because more data of unknown
-  // compressed size is in flight when compression is parallelized. To be
-  // reasonably accurate, this inflation is also estimated by using historical
-  // compression ratio and current bytes inflight.
-  uint32_t parallel_threads = 1;
-
-  // When the compression options are set by the user, it will be set to "true".
-  // For bottommost_compression_opts, to enable it, user must set enabled=true.
-  // Otherwise, bottommost compression will use compression_opts as default
-  // compression options.
-  //
-  // For compression_opts, if compression_opts.enabled=false, it is still
-  // used as compression options for compression process.
-  bool enabled = false;
-
-  // Limit on data buffering when gathering samples to build a dictionary. Zero
-  // means no limit. When dictionary is disabled (`max_dict_bytes == 0`),
-  // enabling this limit (`max_dict_buffer_bytes != 0`) has no effect.
-  //
-  // In compaction, the buffering is limited to the target file size (see
-  // `target_file_size_base` and `target_file_size_multiplier`) even if this
-  // setting permits more buffering. Since we cannot determine where the file
-  // should be cut until data blocks are compressed with dictionary, buffering
-  // more than the target file size could lead to selecting samples that belong
-  // to a later output SST.
-  //
-  // Limiting too strictly may harm dictionary effectiveness since it forces
-  // RocksDB to pick samples from the initial portion of the output SST, which
-  // may not be representative of the whole file. Configuring this limit below
-  // `zstd_max_train_bytes` (when enabled) can restrict how many samples we can
-  // pass to the dictionary trainer. Configuring it below `max_dict_bytes` can
-  // restrict the size of the final dictionary.
-  uint64_t max_dict_buffer_bytes = 0;
-
-  // Use zstd trainer to generate dictionaries. When this option is set to true,
-  // zstd_max_train_bytes of training data sampled from max_dict_buffer_bytes
-  // buffered data will be passed to zstd dictionary trainer to generate a
-  // dictionary of size max_dict_bytes.
-  //
-  // When this option is false, zstd's API ZDICT_finalizeDictionary() will be
-  // called to generate dictionaries. zstd_max_train_bytes of training sampled
-  // data will be passed to this API. Using this API should save CPU time on
-  // dictionary training, but the compression ratio may not be as good as using
-  // a dictionary trainer.
-  bool use_zstd_dict_trainer = true;
-
-  // ===> END options that can be set by deprecated configuration syntax <===
-  // ===> Use compression_opts={level=6;strategy=7;} form for below opts <===
-
-  // Essentially specifies a minimum acceptable compression ratio. A block is
-  // stored uncompressed if the compressed block does not achieve this ratio,
-  // because the downstream cost of decompression is not considered worth such
-  // a small savings (if any).
-  // However, the ratio is specified in a way that is efficient for checking.
-  // An integer from 1 to 1024 indicates the maximum allowable compressed bytes
-  // per 1KB of input, so the minimum acceptable ratio is 1024.0 / this value.
-  // For example, for a minimum ratio of 1.5:1, set to 683. See SetMinRatio().
-  // Default: abandon use of compression for a specific block or entry if
-  // compressed by less than 12.5% (minimum ratio of 1.143:1).
-  int max_compressed_bytes_per_kb = 1024 * 7 / 8;
-
-  // ZSTD only.
-  // Enable compression algorithm's checksum feature.
-  // (https://github.com/facebook/zstd/blob/d857369028d997c92ff1f1861a4d7f679a125464/lib/zstd.h#L428)
-  // Each compressed frame will have a 32-bit checksum attached. The checksum
-  // computed from the uncompressed data and can be verified during
-  // decompression.
-  bool checksum = false;
-
-  // A convenience function for setting max_compressed_bytes_per_kb based on a
-  // minimum acceptable compression ratio (uncompressed size over compressed
-  // size).
-  void SetMinRatio(double min_ratio) {
-    max_compressed_bytes_per_kb = static_cast<int>(1024.0 / min_ratio + 0.5);
-  }
-};
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,51 +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 <stdint.h>
-
-#include <string>
-
-#include "rocksdb/rocksdb_namespace.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// This is NOT an extensible interface but a public interface for result of
-// NewConcurrentTaskLimiter. Any derived classes must be RocksDB internal.
-class ConcurrentTaskLimiter {
- public:
-  virtual ~ConcurrentTaskLimiter() {}
-
-  // Returns a name that identifies this concurrent task limiter.
-  virtual const std::string& GetName() const = 0;
-
-  // Set max concurrent tasks.
-  // limit = 0 means no new task allowed.
-  // limit < 0 means no limitation.
-  virtual void SetMaxOutstandingTask(int32_t limit) = 0;
-
-  // Reset to unlimited max concurrent task.
-  virtual void ResetMaxOutstandingTask() = 0;
-
-  // Returns current outstanding task count.
-  virtual int32_t GetOutstandingTask() const = 0;
-};
-
-// Create a ConcurrentTaskLimiter that can be shared with multiple CFs
-// across RocksDB instances to control concurrent tasks.
-//
-// @param name: Name of the limiter.
-// @param limit: max concurrent tasks.
-//        limit = 0 means no new task allowed.
-//        limit < 0 means no limitation.
-ConcurrentTaskLimiter* NewConcurrentTaskLimiter(const std::string& name,
-                                                int32_t limit);
-
-}  // namespace ROCKSDB_NAMESPACE