rocksdb-native 2.6.2 → 2.6.4

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

@@ -1,337 +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 <deque>
-#include <memory>
-#include <string>
-#include <utility>
-#include <variant>
-#include <vector>
-
-#include "rocksdb/customizable.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/wide_columns.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Slice;
-class Logger;
-
-// The Merge Operator
-//
-// Essentially, a MergeOperator specifies the SEMANTICS of a merge, which only
-// client knows. It could be numeric addition, list append, string
-// concatenation, edit data structure, ... , anything.
-// The library, on the other hand, is concerned with the exercise of this
-// interface, at the right time (during get, iteration, compaction...)
-//
-// To use merge, the client needs to provide an object implementing one of
-// the following interfaces:
-//  a) AssociativeMergeOperator - for most simple semantics (always take
-//    two values, and merge them into one value, which is then put back
-//    into rocksdb); numeric addition and string concatenation are examples;
-//
-//  b) MergeOperator - the generic class for all the more abstract / complex
-//    operations; one method (FullMergeV3) to merge a Put/Delete value with a
-//    merge operand; and another method (PartialMerge) that merges multiple
-//    operands together. this is especially useful if your key values have
-//    complex structures but you would still like to support client-specific
-//    incremental updates.
-//
-// AssociativeMergeOperator is simpler to implement. MergeOperator is simply
-// more powerful.
-//
-// Refer to rocksdb-merge wiki for more details and example implementations.
-//
-// 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 MergeOperator : public Customizable {
- public:
-  virtual ~MergeOperator() {}
-  static const char* Type() { return "MergeOperator"; }
-  static Status CreateFromString(const ConfigOptions& opts,
-                                 const std::string& id,
-                                 std::shared_ptr<MergeOperator>* result);
-
-  // Gives the client a way to express the read -> modify -> write semantics
-  // key:      (IN)    The key that's associated with this merge operation.
-  //                   Client could multiplex the merge operator based on it
-  //                   if the key space is partitioned and different subspaces
-  //                   refer to different types of data which have different
-  //                   merge operation semantics
-  // existing: (IN)    null indicates that the key does not exist before this op
-  // operand_list:(IN) the sequence of merge operations to apply, front() first.
-  // new_value:(OUT)   Client is responsible for filling the merge result here.
-  // The string that new_value is pointing to will be empty.
-  // logger:   (IN)    Client could use this to log errors during merge.
-  //
-  // Return true on success.
-  // All values passed in will be client-specific values. So if this method
-  // returns false, it is because client specified bad data or there was
-  // internal corruption. This will be treated as an error by the library.
-  //
-  // Also make use of the *logger for error messages.
-  virtual bool FullMerge(const Slice& /*key*/, const Slice* /*existing_value*/,
-                         const std::deque<std::string>& /*operand_list*/,
-                         std::string* /*new_value*/, Logger* /*logger*/) const {
-    // deprecated, please use FullMergeV2()
-    assert(false);
-    return false;
-  }
-
-  struct MergeOperationInput {
-    // If user-defined timestamp is enabled, `_key` includes timestamp.
-    explicit MergeOperationInput(const Slice& _key,
-                                 const Slice* _existing_value,
-                                 const std::vector<Slice>& _operand_list,
-                                 Logger* _logger)
-        : key(_key),
-          existing_value(_existing_value),
-          operand_list(_operand_list),
-          logger(_logger) {}
-
-    // The key associated with the merge operation.
-    const Slice& key;
-    // The existing value of the current key, nullptr means that the
-    // value doesn't exist.
-    const Slice* existing_value;
-    // A list of operands to apply.
-    const std::vector<Slice>& operand_list;
-    // Logger could be used by client to log any errors that happen during
-    // the merge operation.
-    Logger* logger;
-  };
-
-  enum class OpFailureScope {
-    kDefault,
-    kTryMerge,
-    kMustMerge,
-    kOpFailureScopeMax,
-  };
-
-  struct MergeOperationOutput {
-    explicit MergeOperationOutput(std::string& _new_value,
-                                  Slice& _existing_operand)
-        : new_value(_new_value), existing_operand(_existing_operand) {}
-
-    // Client is responsible for filling the merge result here.
-    std::string& new_value;
-    // If the merge result is one of the existing operands (or existing_value),
-    // client can set this field to the operand (or existing_value) instead of
-    // using new_value.
-    Slice& existing_operand;
-    // Indicates the blast radius of the failure. It is only meaningful to
-    // provide a failure scope when returning `false` from the API populating
-    // the `MergeOperationOutput`. Currently RocksDB operations handle these
-    // values as follows:
-    //
-    // - `OpFailureScope::kDefault`: fallback to default
-    //   (`OpFailureScope::kTryMerge`)
-    // - `OpFailureScope::kTryMerge`: operations that try to merge that key will
-    //   fail. This includes flush and compaction, which puts the DB in
-    //   read-only mode.
-    // - `OpFailureScope::kMustMerge`: operations that must merge that key will
-    //   fail (e.g., `Get()`, `MultiGet()`, iteration). Flushes/compactions can
-    //   still proceed by copying the original input operands to the output.
-    OpFailureScope op_failure_scope = OpFailureScope::kDefault;
-  };
-
-  // This function applies a stack of merge operands in chronological order
-  // on top of an existing value. There are two ways in which this method is
-  // being used:
-  // a) During Get() operation, it used to calculate the final value of a key
-  // b) During compaction, in order to collapse some operands with the based
-  //    value.
-  //
-  // Note: The name of the method is somewhat misleading, as both in the cases
-  // of Get() or compaction it may be called on a subset of operands:
-  // K:    0    +1    +2    +7    +4     +5      2     +1     +2
-  //                              ^
-  //                              |
-  //                          snapshot
-  // In the example above, Get(K) operation will call FullMerge with a base
-  // value of 2 and operands [+1, +2]. Compaction process might decide to
-  // collapse the beginning of the history up to the snapshot by performing
-  // full Merge with base value of 0 and operands [+1, +2, +7, +4].
-  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
-                           MergeOperationOutput* merge_out) const;
-
-  struct MergeOperationInputV3 {
-    using ExistingValue = std::variant<std::monostate, Slice, WideColumns>;
-    using OperandList = std::vector<Slice>;
-
-    explicit MergeOperationInputV3(const Slice& _key,
-                                   ExistingValue&& _existing_value,
-                                   const OperandList& _operand_list,
-                                   Logger* _logger)
-        : key(_key),
-          existing_value(std::move(_existing_value)),
-          operand_list(_operand_list),
-          logger(_logger) {}
-
-    // The user key, including the user-defined timestamp if applicable.
-    const Slice& key;
-    // The base value of the merge operation. Can be one of three things (see
-    // the ExistingValue variant above): no existing value, plain existing
-    // value, or wide-column existing value.
-    ExistingValue existing_value;
-    // The list of operands to apply.
-    const OperandList& operand_list;
-    // The logger to use in case a failure happens during the merge operation.
-    Logger* logger;
-  };
-
-  struct MergeOperationOutputV3 {
-    using NewColumns = std::vector<std::pair<std::string, std::string>>;
-    using NewValue = std::variant<std::string, NewColumns, Slice>;
-
-    // The result of the merge operation. Can be one of three things (see the
-    // NewValue variant above): a new plain value, a new wide-column value, or
-    // an existing merge operand.
-    NewValue new_value;
-    // The scope of the failure if applicable. See above for more details.
-    OpFailureScope op_failure_scope = OpFailureScope::kDefault;
-  };
-
-  // An extended version of FullMergeV2() that supports wide columns on both the
-  // input and the output side, enabling the application to perform general
-  // transformations during merges. For backward compatibility, the default
-  // implementation calls FullMergeV2(). Specifically, if there is no base value
-  // or the base value is a plain key-value, the default implementation falls
-  // back to FullMergeV2(). If the base value is a wide-column entity, the
-  // default implementation invokes FullMergeV2() to perform the merge on the
-  // default column, and leaves any other columns unchanged.
-  virtual bool FullMergeV3(const MergeOperationInputV3& merge_in,
-                           MergeOperationOutputV3* merge_out) const;
-
-  // This function performs merge(left_op, right_op)
-  // when both the operands are themselves merge operation types
-  // that you would have passed to a DB::Merge() call in the same order
-  // (i.e.: DB::Merge(key,left_op), followed by DB::Merge(key,right_op)).
-  //
-  // PartialMerge should combine them into a single merge operation that is
-  // saved into *new_value, and then it should return true.
-  // *new_value should be constructed such that a call to
-  // DB::Merge(key, *new_value) would yield the same result as a call
-  // to DB::Merge(key, left_op) followed by DB::Merge(key, right_op).
-  //
-  // The string that new_value is pointing to will be empty.
-  //
-  // The default implementation of PartialMergeMulti will use this function
-  // as a helper, for backward compatibility.  Any successor class of
-  // MergeOperator should either implement PartialMerge or PartialMergeMulti,
-  // although implementing PartialMergeMulti is suggested as it is in general
-  // more effective to merge multiple operands at a time instead of two
-  // operands at a time.
-  //
-  // If it is impossible or infeasible to combine the two operations,
-  // leave new_value unchanged and return false. The library will
-  // internally keep track of the operations, and apply them in the
-  // correct order once a base-value (a Put/Delete/End-of-Database) is seen.
-  //
-  // TODO: Presently there is no way to differentiate between error/corruption
-  // and simply "return false". For now, the client should simply return
-  // false in any case it cannot perform partial-merge, regardless of reason.
-  // If there is corruption in the data, handle it in the FullMergeV3() function
-  // and return false there.  The default implementation of PartialMerge will
-  // always return false.
-  virtual bool PartialMerge(const Slice& /*key*/, const Slice& /*left_operand*/,
-                            const Slice& /*right_operand*/,
-                            std::string* /*new_value*/,
-                            Logger* /*logger*/) const {
-    return false;
-  }
-
-  // This function performs merge when all the operands are themselves merge
-  // operation types that you would have passed to a DB::Merge() call in the
-  // same order (front() first)
-  // (i.e. DB::Merge(key, operand_list[0]), followed by
-  //  DB::Merge(key, operand_list[1]), ...)
-  //
-  // PartialMergeMulti should combine them into a single merge operation that is
-  // saved into *new_value, and then it should return true.  *new_value should
-  // be constructed such that a call to DB::Merge(key, *new_value) would yield
-  // the same result as sequential individual calls to DB::Merge(key, operand)
-  // for each operand in operand_list from front() to back().
-  //
-  // The string that new_value is pointing to will be empty.
-  //
-  // The PartialMergeMulti function will be called when there are at least two
-  // operands.
-  //
-  // In the default implementation, PartialMergeMulti will invoke PartialMerge
-  // multiple times, where each time it only merges two operands.  Developers
-  // should either implement PartialMergeMulti, or implement PartialMerge which
-  // is served as the helper function of the default PartialMergeMulti.
-  virtual bool PartialMergeMulti(const Slice& key,
-                                 const std::deque<Slice>& operand_list,
-                                 std::string* new_value, Logger* logger) const;
-
-  // The name of the MergeOperator. Used to check for MergeOperator
-  // mismatches (i.e., a DB created with one MergeOperator is
-  // accessed using a different MergeOperator)
-  // TODO: the name is currently not stored persistently and thus
-  //       no checking is enforced. Client is responsible for providing
-  //       consistent MergeOperator between DB opens.
-  const char* Name() const override = 0;
-
-  // Determines whether the PartialMerge can be called with just a single
-  // merge operand.
-  // Override and return true for allowing a single operand. PartialMerge
-  // and PartialMergeMulti should be overridden and implemented
-  // correctly to properly handle a single operand.
-  virtual bool AllowSingleOperand() const { return false; }
-
-  // Allows to control when to invoke a full merge during Get.
-  // This could be used to limit the number of merge operands that are looked at
-  // during a point lookup, thereby helping in limiting the number of levels to
-  // read from.
-  // Doesn't help with iterators.
-  //
-  // Note: the merge operands are passed to this function in the reversed order
-  // relative to how they were merged (passed to
-  // FullMerge/FullMergeV2/FullMergeV3) for performance reasons, see also:
-  // https://github.com/facebook/rocksdb/issues/3865
-  virtual bool ShouldMerge(const std::vector<Slice>& /*operands*/) const {
-    return false;
-  }
-};
-
-// The simpler, associative merge operator.
-class AssociativeMergeOperator : public MergeOperator {
- public:
-  ~AssociativeMergeOperator() override {}
-
-  // Gives the client a way to express the read -> modify -> write semantics
-  // key:           (IN) The key that's associated with this merge operation.
-  // existing_value:(IN) null indicates the key does not exist before this op
-  // value:         (IN) the value to update/merge the existing_value with
-  // new_value:    (OUT) Client is responsible for filling the merge result
-  // here. The string that new_value is pointing to will be empty.
-  // logger:        (IN) Client could use this to log errors during merge.
-  //
-  // Return true on success.
-  // All values passed in will be client-specific values. So if this method
-  // returns false, it is because client specified bad data or there was
-  // internal corruption. The client should assume that this will be treated
-  // as an error by the library.
-  virtual bool Merge(const Slice& key, const Slice* existing_value,
-                     const Slice& value, std::string* new_value,
-                     Logger* logger) const = 0;
-
- private:
-  // Default implementations of the MergeOperator functions
-  bool FullMergeV2(const MergeOperationInput& merge_in,
-                   MergeOperationOutput* merge_out) const override;
-
-  bool PartialMerge(const Slice& key, const Slice& left_operand,
-                    const Slice& right_operand, std::string* new_value,
-                    Logger* logger) const override;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,258 +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 <cstdint>
-#include <limits>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "rocksdb/options.h"
-#include "rocksdb/types.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// Basic identifiers and metadata for a file in a DB. This only includes
-// information considered relevant for taking backups, checkpoints, or other
-// services relating to DB file storage.
-// This is only appropriate for immutable files, such as SST files or all
-// files in a backup. See also LiveFileStorageInfo.
-struct FileStorageInfo {
-  // The name of the file within its directory (e.g. "123456.sst")
-  std::string relative_filename;
-  // The directory containing the file, without a trailing '/'. This could be
-  // a DB path, wal_dir, etc.
-  std::string directory;
-
-  // The id of the file within a single DB. Set to 0 if the file does not have
-  // a number (e.g. CURRENT)
-  uint64_t file_number = 0;
-  // The type of the file as part of a DB.
-  FileType file_type = kTempFile;
-
-  // File size in bytes. See also `trim_to_size`.
-  uint64_t size = 0;
-
-  // This feature is experimental and subject to change.
-  Temperature temperature = Temperature::kUnknown;
-
-  // The checksum of a SST file, the value is decided by the file content and
-  // the checksum algorithm used for this SST file. The checksum function is
-  // identified by the file_checksum_func_name. If the checksum function is
-  // not specified, file_checksum is "0" by default.
-  std::string file_checksum;
-
-  // The name of the checksum function used to generate the file checksum
-  // value. If file checksum is not enabled (e.g., sst_file_checksum_func is
-  // null), file_checksum_func_name is UnknownFileChecksumFuncName, which is
-  // "Unknown".
-  std::string file_checksum_func_name;
-};
-
-// Adds to FileStorageInfo the ability to capture the state of files that
-// might change in a running DB.
-struct LiveFileStorageInfo : public FileStorageInfo {
-  // If non-empty, this string represents the "saved" contents of the file
-  // for the current context. (This field is used for checkpointing CURRENT
-  // file.) In that case, size == replacement_contents.size() and file on disk
-  // should be ignored. If empty string, the file on disk should still have
-  // "saved" contents. (See trim_to_size.)
-  std::string replacement_contents;
-
-  // If true, the file on disk is allowed to be larger than `size` but only
-  // the first `size` bytes should be used for the current context. If false,
-  // the file is corrupt if size on disk does not equal `size`.
-  bool trim_to_size = false;
-};
-
-// The metadata that describes an SST file. (Does not need to extend
-// LiveFileStorageInfo because SST files are always immutable.)
-struct SstFileMetaData : public FileStorageInfo {
-  SstFileMetaData() { file_type = kTableFile; }
-
-  SstFileMetaData(const std::string& _file_name, uint64_t _file_number,
-                  const std::string& _directory, uint64_t _size,
-                  SequenceNumber _smallest_seqno, SequenceNumber _largest_seqno,
-                  const std::string& _smallestkey,
-                  const std::string& _largestkey, uint64_t _num_reads_sampled,
-                  bool _being_compacted, Temperature _temperature,
-                  uint64_t _oldest_blob_file_number,
-                  uint64_t _oldest_ancester_time, uint64_t _file_creation_time,
-                  uint64_t _epoch_number, std::string& _file_checksum,
-                  std::string& _file_checksum_func_name)
-      : smallest_seqno(_smallest_seqno),
-        largest_seqno(_largest_seqno),
-        smallestkey(_smallestkey),
-        largestkey(_largestkey),
-        num_reads_sampled(_num_reads_sampled),
-        being_compacted(_being_compacted),
-        num_entries(0),
-        num_deletions(0),
-        oldest_blob_file_number(_oldest_blob_file_number),
-        oldest_ancester_time(_oldest_ancester_time),
-        file_creation_time(_file_creation_time),
-        epoch_number(_epoch_number) {
-    if (!_file_name.empty()) {
-      if (_file_name[0] == '/') {
-        relative_filename = _file_name.substr(1);
-        name = _file_name;  // Deprecated field
-      } else {
-        relative_filename = _file_name;
-        name = std::string("/") + _file_name;  // Deprecated field
-      }
-      assert(relative_filename.size() + 1 == name.size());
-      assert(relative_filename[0] != '/');
-      assert(name[0] == '/');
-    }
-    directory = _directory;
-    db_path = _directory;  // Deprecated field
-    file_number = _file_number;
-    file_type = kTableFile;
-    size = _size;
-    temperature = _temperature;
-    file_checksum = _file_checksum;
-    file_checksum_func_name = _file_checksum_func_name;
-  }
-
-  SequenceNumber smallest_seqno = 0;  // Smallest sequence number in file.
-  SequenceNumber largest_seqno = 0;   // Largest sequence number in file.
-  std::string smallestkey;            // Smallest user defined key in the file.
-  std::string largestkey;             // Largest user defined key in the file.
-  uint64_t num_reads_sampled = 0;     // How many times the file is read.
-  bool being_compacted =
-      false;  // true if the file is currently being compacted.
-
-  uint64_t num_entries = 0;
-  uint64_t num_deletions = 0;
-
-  uint64_t oldest_blob_file_number = 0;  // The id of the oldest blob file
-                                         // referenced by the file.
-  // An SST file may be generated by compactions whose input files may
-  // in turn be generated by earlier compactions. The creation time of the
-  // oldest SST file that is the compaction ancestor of this file.
-  // The timestamp is provided SystemClock::GetCurrentTime().
-  // 0 if the information is not available.
-  //
-  // Note: for TTL blob files, it contains the start of the expiration range.
-  uint64_t oldest_ancester_time = 0;
-  // Timestamp when the SST file is created, provided by
-  // SystemClock::GetCurrentTime(). 0 if the information is not available.
-  uint64_t file_creation_time = 0;
-  // The order of a file being flushed or ingested/imported.
-  // Compaction output file will be assigned with the minimum `epoch_number`
-  // among input files'.
-  // For L0, larger `epoch_number` indicates newer L0 file.
-  // 0 if the information is not available.
-  uint64_t epoch_number = 0;
-
-  // These bounds define the effective key range for range tombstones
-  // in this file.
-  // Currently only used by CreateColumnFamilyWithImport().
-  std::string smallest{};  // Smallest internal key served by table
-  std::string largest{};   // Largest internal key served by table
-
-  // DEPRECATED: The name of the file within its directory with a
-  // leading slash (e.g. "/123456.sst"). Use relative_filename from base struct
-  // instead.
-  std::string name;
-
-  // DEPRECATED: replaced by `directory` in base struct
-  std::string db_path;
-};
-
-// The full set of metadata associated with each SST file.
-struct LiveFileMetaData : SstFileMetaData {
-  std::string column_family_name;  // Name of the column family
-  int level;                       // Level at which this file resides.
-  LiveFileMetaData() : column_family_name(), level(0) {}
-};
-
-// The MetaData that describes a Blob file
-struct BlobMetaData {
-  BlobMetaData()
-      : blob_file_number(0),
-        blob_file_size(0),
-        total_blob_count(0),
-        total_blob_bytes(0),
-        garbage_blob_count(0),
-        garbage_blob_bytes(0) {}
-
-  BlobMetaData(uint64_t _file_number, const std::string& _file_name,
-               const std::string& _file_path, uint64_t _file_size,
-               uint64_t _total_blob_count, uint64_t _total_blob_bytes,
-               uint64_t _garbage_blob_count, uint64_t _garbage_blob_bytes,
-               const std::string& _file_checksum,
-               const std::string& _file_checksum_func_name)
-      : blob_file_number(_file_number),
-        blob_file_name(_file_name),
-        blob_file_path(_file_path),
-        blob_file_size(_file_size),
-        total_blob_count(_total_blob_count),
-        total_blob_bytes(_total_blob_bytes),
-        garbage_blob_count(_garbage_blob_count),
-        garbage_blob_bytes(_garbage_blob_bytes),
-        checksum_method(_file_checksum),
-        checksum_value(_file_checksum_func_name) {}
-  uint64_t blob_file_number;
-  std::string blob_file_name;
-  std::string blob_file_path;
-  uint64_t blob_file_size;
-  uint64_t total_blob_count;
-  uint64_t total_blob_bytes;
-  uint64_t garbage_blob_count;
-  uint64_t garbage_blob_bytes;
-  std::string checksum_method;
-  std::string checksum_value;
-};
-
-// The metadata that describes a level.
-struct LevelMetaData {
-  LevelMetaData(int _level, uint64_t _size,
-                const std::vector<SstFileMetaData>&& _files)
-      : level(_level), size(_size), files(_files) {}
-
-  // The level which this meta data describes.
-  const int level;
-  // The size of this level in bytes, which is equal to the sum of
-  // the file size of its "files".
-  const uint64_t size;
-  // The metadata of all sst files in this level.
-  const std::vector<SstFileMetaData> files;
-};
-
-// The metadata that describes a column family.
-struct ColumnFamilyMetaData {
-  ColumnFamilyMetaData() : size(0), file_count(0), name("") {}
-  ColumnFamilyMetaData(const std::string& _name, uint64_t _size,
-                       const std::vector<LevelMetaData>&& _levels)
-      : size(_size), name(_name), levels(_levels) {}
-
-  // The size of this column family in bytes, which is equal to the sum of
-  // the file size of its "levels".
-  uint64_t size;
-  // The number of files in this column family.
-  size_t file_count;
-  // The name of the column family.
-  std::string name;
-  // The metadata of all levels in this column family.
-  std::vector<LevelMetaData> levels;
-
-  // The total size of all blob files
-  uint64_t blob_file_size = 0;
-  // The number of blob files in this column family.
-  size_t blob_file_count = 0;
-  // The metadata of the blobs in this column family.
-  std::vector<BlobMetaData> blob_files;
-};
-
-// Metadata returned as output from ExportColumnFamily() and used as input to
-// CreateColumnFamiliesWithImport().
-struct ExportImportFilesMetaData {
-  std::string db_comparator_name;       // Used to safety check at import.
-  std::vector<LiveFileMetaData> files;  // Vector of file metadata.
-};
-}  // namespace ROCKSDB_NAMESPACE