@nxtedition/rocksdb 8.1.6 → 8.1.8

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_compaction_filter.cc

@@ -17,7 +17,6 @@ namespace ROCKSDB_NAMESPACE {
 namespace cassandra {
 static std::unordered_map<std::string, OptionTypeInfo>
     cassandra_filter_type_info = {
-#ifndef ROCKSDB_LITE
         {"purge_ttl_on_expiration",
          {offsetof(struct CassandraOptions, purge_ttl_on_expiration),
           OptionType::kBoolean, OptionVerificationType::kNormal,
@@ -26,7 +25,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
          {offsetof(struct CassandraOptions, gc_grace_period_in_seconds),
           OptionType::kUInt32T, OptionVerificationType::kNormal,
           OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 
 CassandraCompactionFilter::CassandraCompactionFilter(
@@ -77,7 +75,6 @@ CassandraCompactionFilterFactory::CreateCompactionFilter(
   return result;
 }
 
-#ifndef ROCKSDB_LITE
 int RegisterCassandraObjects(ObjectLibrary& library,
                              const std::string& /*arg*/) {
   library.AddFactory<MergeOperator>(
@@ -105,6 +102,5 @@ int RegisterCassandraObjects(ObjectLibrary& library,
   size_t num_types;
   return static_cast<int>(library.GetFactoryCount(&num_types));
 }
-#endif  // ROCKSDB_LITE
 }  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_functional_test.cc

@@ -343,7 +343,6 @@ TEST_F(CassandraFunctionalTest, CompactionShouldRemoveTombstoneFromPut) {
   ASSERT_FALSE(std::get<0>(store.Get("k1")));
 }
 
-#ifndef ROCKSDB_LITE
 TEST_F(CassandraFunctionalTest, LoadMergeOperator) {
   ConfigOptions config_options;
   std::shared_ptr<MergeOperator> mo;
@@ -434,7 +433,6 @@ TEST_F(CassandraFunctionalTest, LoadCompactionFilterFactory) {
   ASSERT_EQ(opts->gc_grace_period_in_seconds, 42);
   ASSERT_TRUE(opts->purge_ttl_on_expiration);
 }
-#endif  // ROCKSDB_LITE
 
 }  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/cassandra/cassandra_options.h

@@ -34,10 +34,8 @@ struct CassandraOptions {
   // data back.
   bool purge_ttl_on_expiration;
 };
-#ifndef ROCKSDB_LITE
 extern "C" {
 int RegisterCassandraObjects(ObjectLibrary& library, const std::string& arg);
 }  // extern "C"
-#endif  // ROCKSDB_LITE
 }  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/cassandra/merge_operator.cc

@@ -19,7 +19,6 @@ namespace ROCKSDB_NAMESPACE {
 namespace cassandra {
 static std::unordered_map<std::string, OptionTypeInfo>
     merge_operator_options_info = {
-#ifndef ROCKSDB_LITE
         {"gc_grace_period_in_seconds",
          {offsetof(struct CassandraOptions, gc_grace_period_in_seconds),
           OptionType::kUInt32T, OptionVerificationType::kNormal,
@@ -27,7 +26,6 @@ static std::unordered_map<std::string, OptionTypeInfo>
         {"operands_limit",
          {offsetof(struct CassandraOptions, operands_limit), OptionType::kSizeT,
           OptionVerificationType::kNormal, OptionTypeFlags::kNone}},
-#endif  // ROCKSDB_LITE
 };
 
 CassandraValueMergeOperator::CassandraValueMergeOperator(

package/deps/rocksdb/rocksdb/utilities/checkpoint/checkpoint_impl.cc

@@ -7,7 +7,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ROCKSDB_LITE
 
 #include "utilities/checkpoint/checkpoint_impl.h"
 
@@ -467,4 +466,3 @@ Status CheckpointImpl::ExportFilesInMetaData(
 }
 }  // namespace ROCKSDB_NAMESPACE
 
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/checkpoint/checkpoint_impl.h

@@ -4,7 +4,6 @@
 //  (found in the LICENSE.Apache file in the root directory).
 
 #pragma once
-#ifndef ROCKSDB_LITE
 
 #include <string>
 
@@ -63,4 +62,3 @@ class CheckpointImpl : public Checkpoint {
 
 }  // namespace ROCKSDB_NAMESPACE
 
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/checkpoint/checkpoint_test.cc

@@ -8,7 +8,6 @@
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 // Syncpoint prevents us building and running tests in release
-#ifndef ROCKSDB_LITE
 #include "rocksdb/utilities/checkpoint.h"
 
 #ifndef OS_WIN
@@ -855,6 +854,30 @@ TEST_F(CheckpointTest, CheckpointReadOnlyDB) {
   delete snapshot_db;
 }
 
+TEST_F(CheckpointTest, CheckpointWithLockWAL) {
+  Options options = CurrentOptions();
+  ASSERT_OK(Put("foo", "foo_value"));
+
+  ASSERT_OK(db_->LockWAL());
+
+  Checkpoint* checkpoint = nullptr;
+  ASSERT_OK(Checkpoint::Create(db_, &checkpoint));
+  ASSERT_OK(checkpoint->CreateCheckpoint(snapshot_name_));
+  delete checkpoint;
+  checkpoint = nullptr;
+
+  ASSERT_OK(db_->UnlockWAL());
+  Close();
+
+  DB* snapshot_db = nullptr;
+  ASSERT_OK(DB::Open(options, snapshot_name_, &snapshot_db));
+  ReadOptions read_opts;
+  std::string get_result;
+  ASSERT_OK(snapshot_db->Get(read_opts, "foo", &get_result));
+  ASSERT_EQ("foo_value", get_result);
+  delete snapshot_db;
+}
+
 TEST_F(CheckpointTest, CheckpointReadOnlyDBWithMultipleColumnFamilies) {
   Options options = CurrentOptions();
   CreateAndReopenWithCF({"pikachu", "eevee"}, options);
@@ -963,12 +986,3 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-#else
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED as Checkpoint is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/compaction_filters/remove_emptyvalue_compactionfilter.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "utilities/compaction_filters/remove_emptyvalue_compactionfilter.h"
 
@@ -23,4 +22,3 @@ bool RemoveEmptyValueCompactionFilter::Filter(int /*level*/,
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/compaction_filters/remove_emptyvalue_compactionfilter.h

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #pragma once
 
@@ -25,4 +24,3 @@ class RemoveEmptyValueCompactionFilter : public CompactionFilter {
 };
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/compaction_filters.cc

@@ -13,7 +13,6 @@
 #include "utilities/compaction_filters/remove_emptyvalue_compactionfilter.h"
 
 namespace ROCKSDB_NAMESPACE {
-#ifndef ROCKSDB_LITE
 static int RegisterBuiltinCompactionFilters(ObjectLibrary& library,
                                             const std::string& /*arg*/) {
   library.AddFactory<CompactionFilter>(
@@ -25,19 +24,16 @@ static int RegisterBuiltinCompactionFilters(ObjectLibrary& library,
       });
   return 1;
 }
-#endif  // ROCKSDB_LITE
 Status CompactionFilter::CreateFromString(const ConfigOptions& config_options,
                                           const std::string& value,
                                           const CompactionFilter** result) {
-#ifndef ROCKSDB_LITE
   static std::once_flag once;
   std::call_once(once, [&]() {
     RegisterBuiltinCompactionFilters(*(ObjectLibrary::Default().get()), "");
   });
-#endif  // ROCKSDB_LITE
   CompactionFilter* filter = const_cast<CompactionFilter*>(*result);
-  Status status = LoadStaticObject<CompactionFilter>(config_options, value,
-                                                     nullptr, &filter);
+  Status status =
+      LoadStaticObject<CompactionFilter>(config_options, value, &filter);
   if (status.ok()) {
     *result = const_cast<CompactionFilter*>(filter);
   }
@@ -49,8 +45,8 @@ Status CompactionFilterFactory::CreateFromString(
     std::shared_ptr<CompactionFilterFactory>* result) {
   // Currently there are no builtin CompactionFilterFactories.
   // If any are introduced, they need to be registered here.
-  Status status = LoadSharedObject<CompactionFilterFactory>(
-      config_options, value, nullptr, result);
+  Status status =
+      LoadSharedObject<CompactionFilterFactory>(config_options, value, result);
   return status;
 }
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/debug.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/debug.h"
 
@@ -117,4 +116,3 @@ Status GetAllKeyVersions(DB* db, ColumnFamilyHandle* cfh, Slice begin_key,
 
 }  // namespace ROCKSDB_NAMESPACE
 
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/env_mirror.cc

@@ -7,7 +7,6 @@
 // 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.
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/env_mirror.h"
 
@@ -272,4 +271,3 @@ Status EnvMirror::ReuseWritableFile(const std::string& fname,
 }
 
 }  // namespace ROCKSDB_NAMESPACE
-#endif

package/deps/rocksdb/rocksdb/utilities/env_mirror_test.cc

@@ -4,7 +4,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/env_mirror.h"
 
@@ -215,12 +214,3 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-#else
-#include <stdio.h>
-
-int main(int argc, char** argv) {
-  fprintf(stderr, "SKIPPED as EnvMirror is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/env_timed.cc

@@ -12,7 +12,6 @@
 
 namespace ROCKSDB_NAMESPACE {
 
-#ifndef ROCKSDB_LITE
 TimedFileSystem::TimedFileSystem(const std::shared_ptr<FileSystem>& base)
     : FileSystemWrapper(base) {}
 IOStatus TimedFileSystem::NewSequentialFile(
@@ -178,10 +177,5 @@ Env* NewTimedEnv(Env* base_env) {
   return new CompositeEnvWrapper(base_env, timed_fs);
 }
 
-#else  // ROCKSDB_LITE
-
-Env* NewTimedEnv(Env* /*base_env*/) { return nullptr; }
-
-#endif  // !ROCKSDB_LITE
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/env_timed.h

@@ -7,7 +7,6 @@
 #pragma once
 #include "rocksdb/file_system.h"
 namespace ROCKSDB_NAMESPACE {
-#ifndef ROCKSDB_LITE
 class TimedFileSystem : public FileSystemWrapper {
  public:
   explicit TimedFileSystem(const std::shared_ptr<FileSystem>& base);
@@ -93,5 +92,4 @@ class TimedFileSystem : public FileSystemWrapper {
                      IODebugContext* dbg) override;
 };
 
-#endif  // ROCKSDB_LITE
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/env_timed_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/env.h"
 #include "rocksdb/perf_context.h"
@@ -33,12 +32,3 @@ int main(int argc, char** argv) {
   return RUN_ALL_TESTS();
 }
 
-#else  // ROCKSDB_LITE
-#include <stdio.h>
-
-int main(int /*argc*/, char** /*argv*/) {
-  fprintf(stderr, "SKIPPED as TimedEnv is not supported in ROCKSDB_LITE\n");
-  return 0;
-}
-
-#endif  // ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/leveldb_options/leveldb_options.cc

@@ -9,7 +9,7 @@
 
 #include "rocksdb/utilities/leveldb_options.h"
 
-#include "rocksdb/cache.h"
+#include "rocksdb/advanced_cache.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/env.h"
 #include "rocksdb/filter_policy.h"

package/deps/rocksdb/rocksdb/utilities/memory/memory_test.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "db/db_impl/db_impl.h"
 #include "rocksdb/cache.h"
@@ -41,7 +40,6 @@ class MemoryTest : public testing::Test {
     const auto bbto = factory->GetOptions<BlockBasedTableOptions>();
     if (bbto != nullptr) {
       cache_set->insert(bbto->block_cache.get());
-      cache_set->insert(bbto->block_cache_compressed.get());
     }
   }
 
@@ -269,11 +267,3 @@ int main(int argc, char** argv) {
 #endif
 }
 
-#else
-#include <cstdio>
-
-int main(int /*argc*/, char** /*argv*/) {
-  printf("Skipped in RocksDBLite as utilities are not supported.\n");
-  return 0;
-}
-#endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/memory/memory_util.cc

@@ -3,7 +3,6 @@
 //  COPYING file in the root directory) and Apache 2.0 License
 //  (found in the LICENSE.Apache file in the root directory).
 
-#ifndef ROCKSDB_LITE
 
 #include "rocksdb/utilities/memory_util.h"
 
@@ -49,4 +48,3 @@ Status MemoryUtil::GetApproximateMemoryUsageByType(
   return Status::OK();
 }
 }  // namespace ROCKSDB_NAMESPACE
-#endif  // !ROCKSDB_LITE

package/deps/rocksdb/rocksdb/utilities/merge_operators/max.cc

@@ -8,71 +8,55 @@
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/slice.h"
 #include "utilities/merge_operators.h"
+#include "utilities/merge_operators/max_operator.h"
 
-using ROCKSDB_NAMESPACE::Logger;
-using ROCKSDB_NAMESPACE::MergeOperator;
-using ROCKSDB_NAMESPACE::Slice;
-
-namespace {  // anonymous namespace
-
-// Merge operator that picks the maximum operand, Comparison is based on
-// Slice::compare
-class MaxOperator : public MergeOperator {
- public:
-  bool FullMergeV2(const MergeOperationInput& merge_in,
-                   MergeOperationOutput* merge_out) const override {
-    Slice& max = merge_out->existing_operand;
-    if (merge_in.existing_value) {
-      max = Slice(merge_in.existing_value->data(),
-                  merge_in.existing_value->size());
-    } else if (max.data() == nullptr) {
-      max = Slice();
-    }
-
-    for (const auto& op : merge_in.operand_list) {
-      if (max.compare(op) < 0) {
-        max = op;
-      }
-    }
+namespace ROCKSDB_NAMESPACE {
 
-    return true;
+bool MaxOperator::FullMergeV2(const MergeOperationInput& merge_in,
+                              MergeOperationOutput* merge_out) const {
+  Slice& max = merge_out->existing_operand;
+  if (merge_in.existing_value) {
+    max =
+        Slice(merge_in.existing_value->data(), merge_in.existing_value->size());
+  } else if (max.data() == nullptr) {
+    max = Slice();
   }
 
-  bool PartialMerge(const Slice& /*key*/, const Slice& left_operand,
-                    const Slice& right_operand, std::string* new_value,
-                    Logger* /*logger*/) const override {
-    if (left_operand.compare(right_operand) >= 0) {
-      new_value->assign(left_operand.data(), left_operand.size());
-    } else {
-      new_value->assign(right_operand.data(), right_operand.size());
+  for (const auto& op : merge_in.operand_list) {
+    if (max.compare(op) < 0) {
+      max = op;
     }
-    return true;
   }
 
-  bool PartialMergeMulti(const Slice& /*key*/,
-                         const std::deque<Slice>& operand_list,
-                         std::string* new_value,
-                         Logger* /*logger*/) const override {
-    Slice max;
-    for (const auto& operand : operand_list) {
-      if (max.compare(operand) < 0) {
-        max = operand;
-      }
-    }
+  return true;
+}
 
-    new_value->assign(max.data(), max.size());
-    return true;
+bool MaxOperator::PartialMerge(const Slice& /*key*/, const Slice& left_operand,
+                               const Slice& right_operand,
+                               std::string* new_value,
+                               Logger* /*logger*/) const {
+  if (left_operand.compare(right_operand) >= 0) {
+    new_value->assign(left_operand.data(), left_operand.size());
+  } else {
+    new_value->assign(right_operand.data(), right_operand.size());
   }
+  return true;
+}
 
-  static const char* kClassName() { return "MaxOperator"; }
-  static const char* kNickName() { return "max"; }
-  const char* Name() const override { return kClassName(); }
-  const char* NickName() const override { return kNickName(); }
-};
-
-}  // end of anonymous namespace
+bool MaxOperator::PartialMergeMulti(const Slice& /*key*/,
+                                    const std::deque<Slice>& operand_list,
+                                    std::string* new_value,
+                                    Logger* /*logger*/) const {
+  Slice max;
+  for (const auto& operand : operand_list) {
+    if (max.compare(operand) < 0) {
+      max = operand;
+    }
+  }
 
-namespace ROCKSDB_NAMESPACE {
+  new_value->assign(max.data(), max.size());
+  return true;
+}
 
 std::shared_ptr<MergeOperator> MergeOperators::CreateMaxOperator() {
   return std::make_shared<MaxOperator>();

package/deps/rocksdb/rocksdb/utilities/merge_operators/max_operator.h

@@ -0,0 +1,35 @@
+//  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).
+//
+// Merge operator that picks the maximum operand, Comparison is based on
+// Slice::compare
+
+#pragma once
+
+#include "rocksdb/merge_operator.h"
+
+namespace ROCKSDB_NAMESPACE {
+class Logger;
+class Slice;
+
+class MaxOperator : public MergeOperator {
+ public:
+  static const char* kClassName() { return "MaxOperator"; }
+  static const char* kNickName() { return "max"; }
+  const char* Name() const override { return kClassName(); }
+  const char* NickName() const override { return kNickName(); }
+
+  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;
+  bool PartialMergeMulti(const Slice& /*key*/,
+                         const std::deque<Slice>& operand_list,
+                         std::string* new_value,
+                         Logger* /*logger*/) const override;
+};
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/merge_operators/put.cc

@@ -8,12 +8,9 @@
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/slice.h"
 #include "utilities/merge_operators.h"
+#include "utilities/merge_operators/put_operator.h"
 
-namespace {  // anonymous namespace
-
-using ROCKSDB_NAMESPACE::Logger;
-using ROCKSDB_NAMESPACE::MergeOperator;
-using ROCKSDB_NAMESPACE::Slice;
+namespace ROCKSDB_NAMESPACE {
 
 // A merge operator that mimics Put semantics
 // Since this merge-operator will not be used in production,
@@ -23,64 +20,49 @@ using ROCKSDB_NAMESPACE::Slice;
 // which would be simpler in this case).
 //
 // From the client-perspective, semantics are the same.
-class PutOperator : public MergeOperator {
- public:
-  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;
-  }
-
-  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.data(), right_operand.size());
-    return true;
-  }
-
-  using MergeOperator::PartialMergeMulti;
-  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().data(), operand_list.back().size());
-    return true;
-  }
-
-  static const char* kClassName() { return "PutOperator"; }
-  static const char* kNickName() { return "put_v1"; }
-  const char* Name() const override { return kClassName(); }
-  const char* NickName() const override { return kNickName(); }
-};
-
-class PutOperatorV2 : public PutOperator {
-  bool FullMerge(const Slice& /*key*/, const Slice* /*existing_value*/,
-                 const std::deque<std::string>& /*operand_sequence*/,
-                 std::string* /*new_value*/,
-                 Logger* /*logger*/) const override {
-    assert(false);
-    return false;
-  }
+bool PutOperator::FullMerge(const Slice& /*key*/,
+                            const Slice* /*existing_value*/,
+                            const std::deque<std::string>& operand_sequence,
+                            std::string* new_value, Logger* /*logger*/) const {
+  // 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;
+}
 
-  bool FullMergeV2(const MergeOperationInput& merge_in,
-                   MergeOperationOutput* merge_out) const override {
-    // Put basically only looks at the current/latest value
-    assert(!merge_in.operand_list.empty());
-    merge_out->existing_operand = merge_in.operand_list.back();
-    return true;
-  }
+bool PutOperator::PartialMerge(const Slice& /*key*/,
+                               const Slice& /*left_operand*/,
+                               const Slice& right_operand,
+                               std::string* new_value,
+                               Logger* /*logger*/) const {
+  new_value->assign(right_operand.data(), right_operand.size());
+  return true;
+}
 
-  static const char* kNickName() { return "put"; }
-  const char* NickName() const override { return kNickName(); }
-};
+bool PutOperator::PartialMergeMulti(const Slice& /*key*/,
+                                    const std::deque<Slice>& operand_list,
+                                    std::string* new_value,
+                                    Logger* /*logger*/) const {
+  new_value->assign(operand_list.back().data(), operand_list.back().size());
+  return true;
+}
 
-}  // end of anonymous namespace
+bool PutOperatorV2::FullMerge(
+    const Slice& /*key*/, const Slice* /*existing_value*/,
+    const std::deque<std::string>& /*operand_sequence*/,
+    std::string* /*new_value*/, Logger* /*logger*/) const {
+  assert(false);
+  return false;
+}
 
-namespace ROCKSDB_NAMESPACE {
+bool PutOperatorV2::FullMergeV2(const MergeOperationInput& merge_in,
+                                MergeOperationOutput* merge_out) const {
+  // Put basically only looks at the current/latest value
+  assert(!merge_in.operand_list.empty());
+  merge_out->existing_operand = merge_in.operand_list.back();
+  return true;
+}
 
 std::shared_ptr<MergeOperator> MergeOperators::CreateDeprecatedPutOperator() {
   return std::make_shared<PutOperator>();