YugabyteDB (2.13.1.0-b60, 21121d69985fbf76aa6958d8f04a9bfa936293b5)

//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.

//  This source code is licensed under the BSD-style license found in the

//  LICENSE file in the root directory of this source tree. An additional grant

//  of patent rights can be found in the PATENTS file in the same directory.

//

// The following only applies to changes made to this file as part of YugaByte development.

//

// Portions Copyright (c) YugaByte, Inc.

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except

// in compliance with the License.  You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software distributed under the License

// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

// or implied.  See the License for the specific language governing permissions and limitations

// under the License.

//

#include <memory>

#include "yb/util/slice.h"

#include "yb/rocksdb/merge_operator.h"

#include "yb/rocksdb/utilities/merge_operators.h"

namespace rocksdb {

namespace { // anonymous namespace

// A merge operator that mimics Put semantics

// Since this merge-operator will not be used in production,

// it is implemented as a non-associative merge operator to illustrate the

// new interface and for testing purposes. (That is, we inherit from

// the MergeOperator class rather than the AssociativeMergeOperator

// which would be simpler in this case).

//

// From the client-perspective, semantics are the same.

class PutOperator : public MergeOperator {

 public:

  virtual bool FullMerge(const Slice& key,

                         const Slice* existing_value,

                         const std::deque<std::string>& operand_sequence,

                         std::string* new_value,

                         Logger* logger) const override {

    // Put basically only looks at the current/latest value

    assert(!operand_sequence.empty());

    assert(new_value != nullptr);

    new_value->assign(operand_sequence.back());

    return true;

  }

  virtual bool PartialMerge(const Slice& key,

                            const Slice& left_operand,

                            const Slice& right_operand,

                            std::string* new_value,

                            Logger* logger) const override {

    new_value->assign(right_operand.cdata(), right_operand.size());

    return true;

  }

  using MergeOperator::PartialMergeMulti;

  virtual bool PartialMergeMulti(const Slice& key,

                                 const std::deque<Slice>& operand_list,

                                 std::string* new_value,

                                 Logger* logger) const override {

    new_value->assign(operand_list.back().cdata(), operand_list.back().size());

    return true;

  }

  const char* Name() const override {

    return "PutOperator";

  }

};

} // end of anonymous namespace

std::shared_ptr<MergeOperator> MergeOperators::CreatePutOperator() {

  return std::make_shared<PutOperator>();

}

} // namespace rocksdb