rocksdb-native 2.6.2 → 2.6.4

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

@@ -1,318 +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 <string>
-#include <vector>
-
-#include "db/merge_context.h"
-#include "db/range_del_aggregator.h"
-#include "db/snapshot_checker.h"
-#include "db/wide/wide_column_serialization.h"
-#include "rocksdb/compaction_filter.h"
-#include "rocksdb/env.h"
-#include "rocksdb/merge_operator.h"
-#include "rocksdb/slice.h"
-#include "rocksdb/wide_columns.h"
-#include "util/stop_watch.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-class Comparator;
-class Iterator;
-class Logger;
-class MergeOperator;
-class Statistics;
-class SystemClock;
-class BlobFetcher;
-class PrefetchBufferCollection;
-struct CompactionIterationStats;
-
-class MergeHelper {
- public:
-  MergeHelper(Env* env, const Comparator* user_comparator,
-              const MergeOperator* user_merge_operator,
-              const CompactionFilter* compaction_filter, Logger* logger,
-              bool assert_valid_internal_key, SequenceNumber latest_snapshot,
-              const SnapshotChecker* snapshot_checker = nullptr, int level = 0,
-              Statistics* stats = nullptr,
-              const std::atomic<bool>* shutting_down = nullptr);
-
-  // Wrappers around MergeOperator::FullMergeV3() that record perf statistics.
-  // Set `update_num_ops_stats` to true if it is from a user read so that
-  // the corresponding statistics are updated.
-  // Returns one of the following statuses:
-  // - OK: Entries were successfully merged.
-  // - Corruption: Merge operator reported unsuccessful merge. The scope of the
-  //   damage will be stored in `*op_failure_scope` when `op_failure_scope` is
-  //   not nullptr
-
-  // Empty tag types to disambiguate overloads
-  struct NoBaseValueTag {};
-  static constexpr NoBaseValueTag kNoBaseValue{};
-
-  struct PlainBaseValueTag {};
-  static constexpr PlainBaseValueTag kPlainBaseValue{};
-
-  struct WideBaseValueTag {};
-  static constexpr WideBaseValueTag kWideBaseValue{};
-
-  template <typename... ResultTs>
-  static Status TimedFullMerge(const MergeOperator* merge_operator,
-                               const Slice& key, NoBaseValueTag,
-                               const std::vector<Slice>& operands,
-                               Logger* logger, Statistics* statistics,
-                               SystemClock* clock, bool update_num_ops_stats,
-                               MergeOperator::OpFailureScope* op_failure_scope,
-                               ResultTs... results) {
-    MergeOperator::MergeOperationInputV3::ExistingValue existing_value;
-
-    return TimedFullMergeImpl(
-        merge_operator, key, std::move(existing_value), operands, logger,
-        statistics, clock, update_num_ops_stats, op_failure_scope, results...);
-  }
-
-  template <typename... ResultTs>
-  static Status TimedFullMerge(
-      const MergeOperator* merge_operator, const Slice& key, PlainBaseValueTag,
-      const Slice& value, const std::vector<Slice>& operands, Logger* logger,
-      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
-      MergeOperator::OpFailureScope* op_failure_scope, ResultTs... results) {
-    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(value);
-
-    return TimedFullMergeImpl(
-        merge_operator, key, std::move(existing_value), operands, logger,
-        statistics, clock, update_num_ops_stats, op_failure_scope, results...);
-  }
-
-  template <typename... ResultTs>
-  static Status TimedFullMerge(
-      const MergeOperator* merge_operator, const Slice& key, WideBaseValueTag,
-      const Slice& entity, const std::vector<Slice>& operands, Logger* logger,
-      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
-      MergeOperator::OpFailureScope* op_failure_scope, ResultTs... results) {
-    MergeOperator::MergeOperationInputV3::ExistingValue existing_value;
-
-    Slice entity_copy(entity);
-    WideColumns existing_columns;
-
-    const Status s =
-        WideColumnSerialization::Deserialize(entity_copy, existing_columns);
-    if (!s.ok()) {
-      return s;
-    }
-
-    existing_value = std::move(existing_columns);
-
-    return TimedFullMergeImpl(
-        merge_operator, key, std::move(existing_value), operands, logger,
-        statistics, clock, update_num_ops_stats, op_failure_scope, results...);
-  }
-
-  template <typename... ResultTs>
-  static Status TimedFullMerge(const MergeOperator* merge_operator,
-                               const Slice& key, WideBaseValueTag,
-                               const WideColumns& columns,
-                               const std::vector<Slice>& operands,
-                               Logger* logger, Statistics* statistics,
-                               SystemClock* clock, bool update_num_ops_stats,
-                               MergeOperator::OpFailureScope* op_failure_scope,
-                               ResultTs... results) {
-    MergeOperator::MergeOperationInputV3::ExistingValue existing_value(columns);
-
-    return TimedFullMergeImpl(
-        merge_operator, key, std::move(existing_value), operands, logger,
-        statistics, clock, update_num_ops_stats, op_failure_scope, results...);
-  }
-
-  // During compaction, merge entries until we hit
-  //     - a corrupted key
-  //     - a Put/Delete,
-  //     - a different user key,
-  //     - a specific sequence number (snapshot boundary),
-  //     - REMOVE_AND_SKIP_UNTIL returned from compaction filter,
-  //  or - the end of iteration
-  //
-  // The result(s) of the merge can be accessed in `MergeHelper::keys()` and
-  // `MergeHelper::values()`, which are invalidated the next time `MergeUntil()`
-  // is called. `MergeOutputIterator` is specially designed to iterate the
-  // results of a `MergeHelper`'s most recent `MergeUntil()`.
-  //
-  // iter: (IN)  points to the first merge type entry
-  //       (OUT) points to the first entry not included in the merge process
-  // range_del_agg: (IN) filters merge operands covered by range tombstones.
-  // stop_before: (IN) a sequence number that merge should not cross.
-  //                   0 means no restriction
-  // at_bottom:   (IN) true if the iterator covers the bottem level, which means
-  //                   we could reach the start of the history of this user key.
-  // allow_data_in_errors: (IN) if true, data details will be displayed in
-  //                   error/log messages.
-  // blob_fetcher: (IN) blob fetcher object for the compaction's input version.
-  // prefetch_buffers: (IN/OUT) a collection of blob file prefetch buffers
-  //                            used for compaction readahead.
-  // c_iter_stats: (OUT) compaction iteration statistics.
-  //
-  // Returns one of the following statuses:
-  // - OK: Entries were successfully merged.
-  // - MergeInProgress: Output consists of merge operands only.
-  // - Corruption: Merge operator reported unsuccessful merge or a corrupted
-  //   key has been encountered and not expected (applies only when compiling
-  //   with asserts removed).
-  // - ShutdownInProgress: interrupted by shutdown (*shutting_down == true).
-  //
-  // REQUIRED: The first key in the input is not corrupted.
-  Status MergeUntil(InternalIterator* iter,
-                    CompactionRangeDelAggregator* range_del_agg,
-                    const SequenceNumber stop_before, const bool at_bottom,
-                    const bool allow_data_in_errors,
-                    const BlobFetcher* blob_fetcher,
-                    const std::string* const full_history_ts_low,
-                    PrefetchBufferCollection* prefetch_buffers,
-                    CompactionIterationStats* c_iter_stats);
-
-  // Filters a merge operand using the compaction filter specified
-  // in the constructor. Returns the decision that the filter made.
-  // Uses compaction_filter_value_ and compaction_filter_skip_until_ for the
-  // optional outputs of compaction filter.
-  // user_key includes timestamp if user-defined timestamp is enabled.
-  CompactionFilter::Decision FilterMerge(const Slice& user_key,
-                                         const Slice& value_slice);
-
-  // Query the merge result
-  // These are valid until the next MergeUntil call
-  // If the merging was successful:
-  //   - keys() contains a single element with the latest sequence number of
-  //     the merges. The type will be Put or Merge. See IMPORTANT 1 note, below.
-  //   - values() contains a single element with the result of merging all the
-  //     operands together
-  //
-  //   IMPORTANT 1: the key type could change after the MergeUntil call.
-  //        Put/Delete + Merge + ... + Merge => Put
-  //        Merge + ... + Merge => Merge
-  //
-  // If the merge operator is not associative, and if a Put/Delete is not found
-  // then the merging will be unsuccessful. In this case:
-  //   - keys() contains the list of internal keys seen in order of iteration.
-  //   - values() contains the list of values (merges) seen in the same order.
-  //              values() is parallel to keys() so that the first entry in
-  //              keys() is the key associated with the first entry in values()
-  //              and so on. These lists will be the same length.
-  //              All of these pairs will be merges over the same user key.
-  //              See IMPORTANT 2 note below.
-  //
-  //   IMPORTANT 2: The entries were traversed in order from BACK to FRONT.
-  //                So keys().back() was the first key seen by iterator.
-  // TODO: Re-style this comment to be like the first one
-  const std::deque<std::string>& keys() const { return keys_; }
-  const std::vector<Slice>& values() const {
-    return merge_context_.GetOperands();
-  }
-  uint64_t TotalFilterTime() const { return total_filter_time_; }
-  bool HasOperator() const { return user_merge_operator_ != nullptr; }
-
-  // If compaction filter returned REMOVE_AND_SKIP_UNTIL, this method will
-  // return true and fill *until with the key to which we should skip.
-  // If true, keys() and values() are empty.
-  bool FilteredUntil(Slice* skip_until) const {
-    if (!has_compaction_filter_skip_until_) {
-      return false;
-    }
-    assert(compaction_filter_ != nullptr);
-    assert(skip_until != nullptr);
-    assert(compaction_filter_skip_until_.Valid());
-    *skip_until = compaction_filter_skip_until_.Encode();
-    return true;
-  }
-
- private:
-  Env* env_;
-  SystemClock* clock_;
-  const Comparator* user_comparator_;
-  const MergeOperator* user_merge_operator_;
-  const CompactionFilter* compaction_filter_;
-  const std::atomic<bool>* shutting_down_;
-  Logger* logger_;
-  bool assert_valid_internal_key_;  // enforce no internal key corruption?
-  bool allow_single_operand_;
-  SequenceNumber latest_snapshot_;
-  const SnapshotChecker* const snapshot_checker_;
-  int level_;
-
-  // the scratch area that holds the result of MergeUntil
-  // valid up to the next MergeUntil call
-
-  // Keeps track of the sequence of keys seen
-  std::deque<std::string> keys_;
-  // Parallel with keys_; stores the operands
-  mutable MergeContext merge_context_;
-
-  StopWatchNano filter_timer_;
-  uint64_t total_filter_time_;
-  Statistics* stats_;
-
-  bool has_compaction_filter_skip_until_ = false;
-  std::string compaction_filter_value_;
-  InternalKey compaction_filter_skip_until_;
-
-  bool IsShuttingDown() {
-    // This is a best-effort facility, so memory_order_relaxed is sufficient.
-    return shutting_down_ && shutting_down_->load(std::memory_order_relaxed);
-  }
-
-  template <typename Visitor>
-  static Status TimedFullMergeCommonImpl(
-      const MergeOperator* merge_operator, const Slice& key,
-      MergeOperator::MergeOperationInputV3::ExistingValue&& existing_value,
-      const std::vector<Slice>& operands, Logger* logger,
-      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
-      MergeOperator::OpFailureScope* op_failure_scope, Visitor&& visitor);
-
-  // Variant that exposes the merge result directly (in serialized form for wide
-  // columns) as well as its value type. Used by iterator and compaction.
-  static Status TimedFullMergeImpl(
-      const MergeOperator* merge_operator, const Slice& key,
-      MergeOperator::MergeOperationInputV3::ExistingValue&& existing_value,
-      const std::vector<Slice>& operands, Logger* logger,
-      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
-      MergeOperator::OpFailureScope* op_failure_scope, std::string* result,
-      Slice* result_operand, ValueType* result_type);
-
-  // Variant that exposes the merge result translated into the form requested by
-  // the client. (For example, if the result is a wide-column structure but the
-  // client requested the results in plain-value form, the value of the default
-  // column is returned.) Used by point lookups.
-  static Status TimedFullMergeImpl(
-      const MergeOperator* merge_operator, const Slice& key,
-      MergeOperator::MergeOperationInputV3::ExistingValue&& existing_value,
-      const std::vector<Slice>& operands, Logger* logger,
-      Statistics* statistics, SystemClock* clock, bool update_num_ops_stats,
-      MergeOperator::OpFailureScope* op_failure_scope,
-      std::string* result_value, PinnableWideColumns* result_entity);
-};
-
-// MergeOutputIterator can be used to iterate over the result of a merge.
-class MergeOutputIterator {
- public:
-  // The MergeOutputIterator is bound to a MergeHelper instance.
-  explicit MergeOutputIterator(const MergeHelper* merge_helper);
-
-  // Seeks to the first record in the output.
-  void SeekToFirst();
-  // Advances to the next record in the output.
-  void Next();
-
-  Slice key() { return Slice(*it_keys_); }
-  Slice value() { return Slice(*it_values_); }
-  bool Valid() { return it_keys_ != merge_helper_->keys().rend(); }
-
- private:
-  const MergeHelper* merge_helper_;
-  std::deque<std::string>::const_reverse_iterator it_keys_;
-  std::vector<Slice>::const_reverse_iterator it_values_;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

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

@@ -1,167 +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).
-//
-/**
- * Back-end implementation details specific to the Merge Operator.
- */
-
-#include "rocksdb/merge_operator.h"
-
-#include <type_traits>
-
-#include "db/wide/wide_columns_helper.h"
-#include "util/overload.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-bool MergeOperator::FullMergeV2(const MergeOperationInput& merge_in,
-                                MergeOperationOutput* merge_out) const {
-  // If FullMergeV2 is not implemented, we convert the operand_list to
-  // std::deque<std::string> and pass it to FullMerge
-  std::deque<std::string> operand_list_str;
-  for (auto& op : merge_in.operand_list) {
-    operand_list_str.emplace_back(op.data(), op.size());
-  }
-  return FullMerge(merge_in.key, merge_in.existing_value, operand_list_str,
-                   &merge_out->new_value, merge_in.logger);
-}
-
-bool MergeOperator::FullMergeV3(const MergeOperationInputV3& merge_in,
-                                MergeOperationOutputV3* merge_out) const {
-  assert(merge_out);
-
-  MergeOperationInput in_v2(merge_in.key, nullptr, merge_in.operand_list,
-                            merge_in.logger);
-
-  std::string new_value;
-  Slice existing_operand(nullptr, 0);
-  MergeOperationOutput out_v2(new_value, existing_operand);
-
-  return std::visit(
-      overload{
-          [&](const auto& existing) -> bool {
-            using T = std::decay_t<decltype(existing)>;
-
-            if constexpr (std::is_same_v<T, Slice>) {
-              in_v2.existing_value = &existing;
-            }
-
-            const bool result = FullMergeV2(in_v2, &out_v2);
-            if (!result) {
-              merge_out->op_failure_scope = out_v2.op_failure_scope;
-              return false;
-            }
-
-            if (existing_operand.data()) {
-              merge_out->new_value = existing_operand;
-            } else {
-              merge_out->new_value = std::move(new_value);
-            }
-
-            return true;
-          },
-          [&](const WideColumns& existing_columns) -> bool {
-            const bool has_default_column =
-                WideColumnsHelper::HasDefaultColumn(existing_columns);
-
-            Slice value_of_default;
-            if (has_default_column) {
-              value_of_default = existing_columns.front().value();
-            }
-
-            in_v2.existing_value = &value_of_default;
-
-            const bool result = FullMergeV2(in_v2, &out_v2);
-            if (!result) {
-              merge_out->op_failure_scope = out_v2.op_failure_scope;
-              return false;
-            }
-
-            merge_out->new_value = MergeOperationOutputV3::NewColumns();
-            auto& new_columns = std::get<MergeOperationOutputV3::NewColumns>(
-                merge_out->new_value);
-            new_columns.reserve(has_default_column
-                                    ? existing_columns.size()
-                                    : (existing_columns.size() + 1));
-
-            if (existing_operand.data()) {
-              new_columns.emplace_back(kDefaultWideColumnName.ToString(),
-                                       existing_operand.ToString());
-            } else {
-              new_columns.emplace_back(kDefaultWideColumnName.ToString(),
-                                       std::move(new_value));
-            }
-
-            for (size_t i = has_default_column ? 1 : 0;
-                 i < existing_columns.size(); ++i) {
-              new_columns.emplace_back(existing_columns[i].name().ToString(),
-                                       existing_columns[i].value().ToString());
-            }
-
-            return true;
-          }},
-      merge_in.existing_value);
-}
-
-// The default implementation of PartialMergeMulti, which invokes
-// PartialMerge multiple times internally and merges two operands at
-// a time.
-bool MergeOperator::PartialMergeMulti(const Slice& key,
-                                      const std::deque<Slice>& operand_list,
-                                      std::string* new_value,
-                                      Logger* logger) const {
-  assert(operand_list.size() >= 2);
-  // Simply loop through the operands
-  Slice temp_slice(operand_list[0]);
-
-  for (size_t i = 1; i < operand_list.size(); ++i) {
-    auto& operand = operand_list[i];
-    std::string temp_value;
-    if (!PartialMerge(key, temp_slice, operand, &temp_value, logger)) {
-      return false;
-    }
-    swap(temp_value, *new_value);
-    temp_slice = Slice(*new_value);
-  }
-
-  // The result will be in *new_value. All merges succeeded.
-  return true;
-}
-
-// Given a "real" merge from the library, call the user's
-// associative merge function one-by-one on each of the operands.
-// NOTE: It is assumed that the client's merge-operator will handle any errors.
-bool AssociativeMergeOperator::FullMergeV2(
-    const MergeOperationInput& merge_in,
-    MergeOperationOutput* merge_out) const {
-  // Simply loop through the operands
-  Slice temp_existing;
-  const Slice* existing_value = merge_in.existing_value;
-  for (const auto& operand : merge_in.operand_list) {
-    std::string temp_value;
-    if (!Merge(merge_in.key, existing_value, operand, &temp_value,
-               merge_in.logger)) {
-      return false;
-    }
-    swap(temp_value, merge_out->new_value);
-    temp_existing = Slice(merge_out->new_value);
-    existing_value = &temp_existing;
-  }
-
-  // The result will be in *new_value. All merges succeeded.
-  return true;
-}
-
-// Call the user defined simple merge on the operands;
-// NOTE: It is assumed that the client's merge-operator will handle any errors.
-bool AssociativeMergeOperator::PartialMerge(const Slice& key,
-                                            const Slice& left_operand,
-                                            const Slice& right_operand,
-                                            std::string* new_value,
-                                            Logger* logger) const {
-  return Merge(key, &left_operand, right_operand, new_value, logger);
-}
-
-}  // namespace ROCKSDB_NAMESPACE