@nxtedition/rocksdb 7.1.30 → 7.1.31

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

@@ -6,46 +6,39 @@
 #include "test_util/testharness.h"
 #include "utilities/cassandra/serialize.h"
 
-
 namespace ROCKSDB_NAMESPACE {
 namespace cassandra {
 
 TEST(SerializeTest, SerializeI64) {
   std::string dest;
   Serialize<int64_t>(0, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'}),
-      dest);
+  EXPECT_EQ(std::string({'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
+                         '\x00'}),
+            dest);
 
   dest.clear();
   Serialize<int64_t>(1, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x01'}),
-      dest);
-
+  EXPECT_EQ(std::string({'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
+                         '\x01'}),
+            dest);
 
   dest.clear();
   Serialize<int64_t>(-1, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\xff', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff'}),
-      dest);
+  EXPECT_EQ(std::string({'\xff', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff',
+                         '\xff'}),
+            dest);
 
   dest.clear();
   Serialize<int64_t>(9223372036854775807, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x7f', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff'}),
-      dest);
+  EXPECT_EQ(std::string({'\x7f', '\xff', '\xff', '\xff', '\xff', '\xff', '\xff',
+                         '\xff'}),
+            dest);
 
   dest.clear();
   Serialize<int64_t>(-9223372036854775807, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x80', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x01'}),
-      dest);
+  EXPECT_EQ(std::string({'\x80', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
+                         '\x01'}),
+            dest);
 }
 
 TEST(SerializeTest, DeserializeI64) {
@@ -74,39 +67,23 @@ TEST(SerializeTest, DeserializeI64) {
 TEST(SerializeTest, SerializeI32) {
   std::string dest;
   Serialize<int32_t>(0, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x00', '\x00', '\x00', '\x00'}),
-      dest);
+  EXPECT_EQ(std::string({'\x00', '\x00', '\x00', '\x00'}), dest);
 
   dest.clear();
   Serialize<int32_t>(1, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x00', '\x00', '\x00', '\x01'}),
-      dest);
-
+  EXPECT_EQ(std::string({'\x00', '\x00', '\x00', '\x01'}), dest);
 
   dest.clear();
   Serialize<int32_t>(-1, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\xff', '\xff', '\xff', '\xff'}),
-      dest);
+  EXPECT_EQ(std::string({'\xff', '\xff', '\xff', '\xff'}), dest);
 
   dest.clear();
   Serialize<int32_t>(2147483647, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x7f', '\xff', '\xff', '\xff'}),
-      dest);
+  EXPECT_EQ(std::string({'\x7f', '\xff', '\xff', '\xff'}), dest);
 
   dest.clear();
   Serialize<int32_t>(-2147483648LL, &dest);
-  EXPECT_EQ(
-      std::string(
-          {'\x80', '\x00', '\x00', '\x00'}),
-      dest);
+  EXPECT_EQ(std::string({'\x80', '\x00', '\x00', '\x00'}), dest);
 }
 
 TEST(SerializeTest, DeserializeI32) {
@@ -141,7 +118,6 @@ TEST(SerializeTest, SerializeI8) {
   Serialize<int8_t>(1, &dest);
   EXPECT_EQ(std::string({'\x01'}), dest);
 
-
   dest.clear();
   Serialize<int8_t>(-1, &dest);
   EXPECT_EQ(std::string({'\xff'}), dest);
@@ -178,7 +154,7 @@ TEST(SerializeTest, DeserializeI8) {
   EXPECT_EQ(-128, Deserialize<int8_t>(dest.c_str(), offset));
 }
 
-} // namespace cassandra
+}  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

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

@@ -14,26 +14,18 @@
 namespace ROCKSDB_NAMESPACE {
 namespace cassandra {
 namespace {
-const int32_t kDefaultLocalDeletionTime =
-  std::numeric_limits<int32_t>::max();
-const int64_t kDefaultMarkedForDeleteAt =
-  std::numeric_limits<int64_t>::min();
-}
+const int32_t kDefaultLocalDeletionTime = std::numeric_limits<int32_t>::max();
+const int64_t kDefaultMarkedForDeleteAt = std::numeric_limits<int64_t>::min();
+}  // namespace
 
 ColumnBase::ColumnBase(int8_t mask, int8_t index)
-  : mask_(mask), index_(index) {}
+    : mask_(mask), index_(index) {}
 
-std::size_t ColumnBase::Size() const {
-  return sizeof(mask_) + sizeof(index_);
-}
+std::size_t ColumnBase::Size() const { return sizeof(mask_) + sizeof(index_); }
 
-int8_t ColumnBase::Mask() const {
-  return mask_;
-}
+int8_t ColumnBase::Mask() const { return mask_; }
 
-int8_t ColumnBase::Index() const {
-  return index_;
-}
+int8_t ColumnBase::Index() const { return index_; }
 
 void ColumnBase::Serialize(std::string* dest) const {
   ROCKSDB_NAMESPACE::cassandra::Serialize<int8_t>(mask_, dest);
@@ -52,22 +44,18 @@ std::shared_ptr<ColumnBase> ColumnBase::Deserialize(const char* src,
   }
 }
 
-Column::Column(
-  int8_t mask,
-  int8_t index,
-  int64_t timestamp,
-  int32_t value_size,
-  const char* value
-) : ColumnBase(mask, index), timestamp_(timestamp),
-  value_size_(value_size), value_(value) {}
-
-int64_t Column::Timestamp() const {
-  return timestamp_;
-}
+Column::Column(int8_t mask, int8_t index, int64_t timestamp, int32_t value_size,
+               const char* value)
+    : ColumnBase(mask, index),
+      timestamp_(timestamp),
+      value_size_(value_size),
+      value_(value) {}
+
+int64_t Column::Timestamp() const { return timestamp_; }
 
 std::size_t Column::Size() const {
-  return ColumnBase::Size() + sizeof(timestamp_) + sizeof(value_size_)
-    + value_size_;
+  return ColumnBase::Size() + sizeof(timestamp_) + sizeof(value_size_) +
+         value_size_;
 }
 
 void Column::Serialize(std::string* dest) const {
@@ -77,7 +65,7 @@ void Column::Serialize(std::string* dest) const {
   dest->append(value_, value_size_);
 }
 
-std::shared_ptr<Column> Column::Deserialize(const char *src,
+std::shared_ptr<Column> Column::Deserialize(const char* src,
                                             std::size_t offset) {
   int8_t mask = ROCKSDB_NAMESPACE::cassandra::Deserialize<int8_t>(src, offset);
   offset += sizeof(mask);
@@ -89,19 +77,14 @@ std::shared_ptr<Column> Column::Deserialize(const char *src,
   int32_t value_size =
       ROCKSDB_NAMESPACE::cassandra::Deserialize<int32_t>(src, offset);
   offset += sizeof(value_size);
-  return std::make_shared<Column>(
-    mask, index, timestamp, value_size, src + offset);
+  return std::make_shared<Column>(mask, index, timestamp, value_size,
+                                  src + offset);
 }
 
-ExpiringColumn::ExpiringColumn(
-  int8_t mask,
-  int8_t index,
-  int64_t timestamp,
-  int32_t value_size,
-  const char* value,
-  int32_t ttl
-) : Column(mask, index, timestamp, value_size, value),
-  ttl_(ttl) {}
+ExpiringColumn::ExpiringColumn(int8_t mask, int8_t index, int64_t timestamp,
+                               int32_t value_size, const char* value,
+                               int32_t ttl)
+    : Column(mask, index, timestamp, value_size, value), ttl_(ttl) {}
 
 std::size_t ExpiringColumn::Size() const {
   return Column::Size() + sizeof(ttl_);
@@ -112,8 +95,10 @@ void ExpiringColumn::Serialize(std::string* dest) const {
   ROCKSDB_NAMESPACE::cassandra::Serialize<int32_t>(ttl_, dest);
 }
 
-std::chrono::time_point<std::chrono::system_clock> ExpiringColumn::TimePoint() const {
-  return std::chrono::time_point<std::chrono::system_clock>(std::chrono::microseconds(Timestamp()));
+std::chrono::time_point<std::chrono::system_clock> ExpiringColumn::TimePoint()
+    const {
+  return std::chrono::time_point<std::chrono::system_clock>(
+      std::chrono::microseconds(Timestamp()));
 }
 
 std::chrono::seconds ExpiringColumn::Ttl() const {
@@ -127,19 +112,16 @@ bool ExpiringColumn::Expired() const {
 std::shared_ptr<Tombstone> ExpiringColumn::ToTombstone() const {
   auto expired_at = (TimePoint() + Ttl()).time_since_epoch();
   int32_t local_deletion_time = static_cast<int32_t>(
-    std::chrono::duration_cast<std::chrono::seconds>(expired_at).count());
+      std::chrono::duration_cast<std::chrono::seconds>(expired_at).count());
   int64_t marked_for_delete_at =
-    std::chrono::duration_cast<std::chrono::microseconds>(expired_at).count();
+      std::chrono::duration_cast<std::chrono::microseconds>(expired_at).count();
   return std::make_shared<Tombstone>(
-    static_cast<int8_t>(ColumnTypeMask::DELETION_MASK),
-    Index(),
-    local_deletion_time,
-    marked_for_delete_at);
+      static_cast<int8_t>(ColumnTypeMask::DELETION_MASK), Index(),
+      local_deletion_time, marked_for_delete_at);
 }
 
 std::shared_ptr<ExpiringColumn> ExpiringColumn::Deserialize(
-    const char *src,
-    std::size_t offset) {
+    const char* src, std::size_t offset) {
   int8_t mask = ROCKSDB_NAMESPACE::cassandra::Deserialize<int8_t>(src, offset);
   offset += sizeof(mask);
   int8_t index = ROCKSDB_NAMESPACE::cassandra::Deserialize<int8_t>(src, offset);
@@ -153,25 +135,21 @@ std::shared_ptr<ExpiringColumn> ExpiringColumn::Deserialize(
   const char* value = src + offset;
   offset += value_size;
   int32_t ttl = ROCKSDB_NAMESPACE::cassandra::Deserialize<int32_t>(src, offset);
-  return std::make_shared<ExpiringColumn>(
-    mask, index, timestamp, value_size, value, ttl);
+  return std::make_shared<ExpiringColumn>(mask, index, timestamp, value_size,
+                                          value, ttl);
 }
 
-Tombstone::Tombstone(
-  int8_t mask,
-  int8_t index,
-  int32_t local_deletion_time,
-  int64_t marked_for_delete_at
-) : ColumnBase(mask, index), local_deletion_time_(local_deletion_time),
-  marked_for_delete_at_(marked_for_delete_at) {}
+Tombstone::Tombstone(int8_t mask, int8_t index, int32_t local_deletion_time,
+                     int64_t marked_for_delete_at)
+    : ColumnBase(mask, index),
+      local_deletion_time_(local_deletion_time),
+      marked_for_delete_at_(marked_for_delete_at) {}
 
-int64_t Tombstone::Timestamp() const {
-  return marked_for_delete_at_;
-}
+int64_t Tombstone::Timestamp() const { return marked_for_delete_at_; }
 
 std::size_t Tombstone::Size() const {
-  return ColumnBase::Size() + sizeof(local_deletion_time_)
-    + sizeof(marked_for_delete_at_);
+  return ColumnBase::Size() + sizeof(local_deletion_time_) +
+         sizeof(marked_for_delete_at_);
 }
 
 void Tombstone::Serialize(std::string* dest) const {
@@ -187,7 +165,7 @@ bool Tombstone::Collectable(int32_t gc_grace_period_in_seconds) const {
   return local_deleted_at + gc_grace_period < std::chrono::system_clock::now();
 }
 
-std::shared_ptr<Tombstone> Tombstone::Deserialize(const char *src,
+std::shared_ptr<Tombstone> Tombstone::Deserialize(const char* src,
                                                   std::size_t offset) {
   int8_t mask = ROCKSDB_NAMESPACE::cassandra::Deserialize<int8_t>(src, offset);
   offset += sizeof(mask);
@@ -198,26 +176,27 @@ std::shared_ptr<Tombstone> Tombstone::Deserialize(const char *src,
   offset += sizeof(int32_t);
   int64_t marked_for_delete_at =
       ROCKSDB_NAMESPACE::cassandra::Deserialize<int64_t>(src, offset);
-  return std::make_shared<Tombstone>(
-    mask, index, local_deletion_time, marked_for_delete_at);
+  return std::make_shared<Tombstone>(mask, index, local_deletion_time,
+                                     marked_for_delete_at);
 }
 
 RowValue::RowValue(int32_t local_deletion_time, int64_t marked_for_delete_at)
-  : local_deletion_time_(local_deletion_time),
-  marked_for_delete_at_(marked_for_delete_at), columns_(),
-  last_modified_time_(0) {}
+    : local_deletion_time_(local_deletion_time),
+      marked_for_delete_at_(marked_for_delete_at),
+      columns_(),
+      last_modified_time_(0) {}
 
-RowValue::RowValue(Columns columns,
-                  int64_t last_modified_time)
-  : local_deletion_time_(kDefaultLocalDeletionTime),
-  marked_for_delete_at_(kDefaultMarkedForDeleteAt),
-  columns_(std::move(columns)), last_modified_time_(last_modified_time) {}
+RowValue::RowValue(Columns columns, int64_t last_modified_time)
+    : local_deletion_time_(kDefaultLocalDeletionTime),
+      marked_for_delete_at_(kDefaultMarkedForDeleteAt),
+      columns_(std::move(columns)),
+      last_modified_time_(last_modified_time) {}
 
 std::size_t RowValue::Size() const {
-  std::size_t size = sizeof(local_deletion_time_)
-    + sizeof(marked_for_delete_at_);
+  std::size_t size =
+      sizeof(local_deletion_time_) + sizeof(marked_for_delete_at_);
   for (const auto& column : columns_) {
-    size += column -> Size();
+    size += column->Size();
   }
   return size;
 }
@@ -238,7 +217,7 @@ void RowValue::Serialize(std::string* dest) const {
   ROCKSDB_NAMESPACE::cassandra::Serialize<int32_t>(local_deletion_time_, dest);
   ROCKSDB_NAMESPACE::cassandra::Serialize<int64_t>(marked_for_delete_at_, dest);
   for (const auto& column : columns_) {
-    column -> Serialize(dest);
+    column->Serialize(dest);
   }
 }
 
@@ -246,11 +225,11 @@ RowValue RowValue::RemoveExpiredColumns(bool* changed) const {
   *changed = false;
   Columns new_columns;
   for (auto& column : columns_) {
-    if(column->Mask() == ColumnTypeMask::EXPIRATION_MASK) {
+    if (column->Mask() == ColumnTypeMask::EXPIRATION_MASK) {
       std::shared_ptr<ExpiringColumn> expiring_column =
-        std::static_pointer_cast<ExpiringColumn>(column);
+          std::static_pointer_cast<ExpiringColumn>(column);
 
-      if(expiring_column->Expired()){
+      if (expiring_column->Expired()) {
         *changed = true;
         continue;
       }
@@ -265,11 +244,11 @@ RowValue RowValue::ConvertExpiredColumnsToTombstones(bool* changed) const {
   *changed = false;
   Columns new_columns;
   for (auto& column : columns_) {
-    if(column->Mask() == ColumnTypeMask::EXPIRATION_MASK) {
+    if (column->Mask() == ColumnTypeMask::EXPIRATION_MASK) {
       std::shared_ptr<ExpiringColumn> expiring_column =
-        std::static_pointer_cast<ExpiringColumn>(column);
+          std::static_pointer_cast<ExpiringColumn>(column);
 
-      if(expiring_column->Expired()) {
+      if (expiring_column->Expired()) {
         std::shared_ptr<Tombstone> tombstone = expiring_column->ToTombstone();
         new_columns.push_back(tombstone);
         *changed = true;
@@ -298,11 +277,9 @@ RowValue RowValue::RemoveTombstones(int32_t gc_grace_period) const {
   return RowValue(std::move(new_columns), last_modified_time_);
 }
 
-bool RowValue::Empty() const {
-  return columns_.empty();
-}
+bool RowValue::Empty() const { return columns_.empty(); }
 
-RowValue RowValue::Deserialize(const char *src, std::size_t size) {
+RowValue RowValue::Deserialize(const char* src, std::size_t size) {
   std::size_t offset = 0;
   assert(size >= sizeof(local_deletion_time_) + sizeof(marked_for_delete_at_));
   int32_t local_deletion_time =
@@ -321,9 +298,9 @@ RowValue RowValue::Deserialize(const char *src, std::size_t size) {
   int64_t last_modified_time = 0;
   while (offset < size) {
     auto c = ColumnBase::Deserialize(src, offset);
-    offset += c -> Size();
+    offset += c->Size();
     assert(offset <= size);
-    last_modified_time = std::max(last_modified_time, c -> Timestamp());
+    last_modified_time = std::max(last_modified_time, c->Timestamp());
     columns.push_back(std::move(c));
   }
 
@@ -344,9 +321,9 @@ RowValue RowValue::Merge(std::vector<RowValue>&& values) {
   // Merge columns by their last modified time, and skip once we hit
   // a row tombstone.
   std::sort(values.begin(), values.end(),
-    [](const RowValue& r1, const RowValue& r2) {
-      return r1.LastModifiedTime() > r2.LastModifiedTime();
-    });
+            [](const RowValue& r1, const RowValue& r2) {
+              return r1.LastModifiedTime() > r2.LastModifiedTime();
+            });
 
   std::map<int8_t, std::shared_ptr<ColumnBase>> merged_columns;
   int64_t tombstone_timestamp = 0;
@@ -373,7 +350,7 @@ RowValue RowValue::Merge(std::vector<RowValue>&& values) {
 
   int64_t last_modified_time = 0;
   Columns columns;
-  for (auto& pair: merged_columns) {
+  for (auto& pair : merged_columns) {
     // For some row, its last_modified_time > row tombstone_timestamp, but
     // it might have rows whose timestamp is ealier than tombstone, so we
     // ned to filter these rows.
@@ -386,5 +363,5 @@ RowValue RowValue::Merge(std::vector<RowValue>&& values) {
   return RowValue(std::move(columns), last_modified_time);
 }
 
-} // namepsace cassandrda
+}  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -58,6 +58,7 @@
 #include <chrono>
 #include <memory>
 #include <vector>
+
 #include "rocksdb/merge_operator.h"
 #include "rocksdb/slice.h"
 
@@ -70,9 +71,8 @@ enum ColumnTypeMask {
   EXPIRATION_MASK = 0x02,
 };
 
-
 class ColumnBase {
-public:
+ public:
   ColumnBase(int8_t mask, int8_t index);
   virtual ~ColumnBase() = default;
 
@@ -84,15 +84,15 @@ public:
   static std::shared_ptr<ColumnBase> Deserialize(const char* src,
                                                  std::size_t offset);
 
-private:
+ private:
   int8_t mask_;
   int8_t index_;
 };
 
 class Column : public ColumnBase {
-public:
-  Column(int8_t mask, int8_t index, int64_t timestamp,
-    int32_t value_size, const char* value);
+ public:
+  Column(int8_t mask, int8_t index, int64_t timestamp, int32_t value_size,
+         const char* value);
 
   virtual int64_t Timestamp() const override;
   virtual std::size_t Size() const override;
@@ -100,16 +100,16 @@ public:
   static std::shared_ptr<Column> Deserialize(const char* src,
                                              std::size_t offset);
 
-private:
+ private:
   int64_t timestamp_;
   int32_t value_size_;
   const char* value_;
 };
 
 class Tombstone : public ColumnBase {
-public:
-  Tombstone(int8_t mask, int8_t index,
-    int32_t local_deletion_time, int64_t marked_for_delete_at);
+ public:
+  Tombstone(int8_t mask, int8_t index, int32_t local_deletion_time,
+            int64_t marked_for_delete_at);
 
   virtual int64_t Timestamp() const override;
   virtual std::size_t Size() const override;
@@ -118,15 +118,15 @@ public:
   static std::shared_ptr<Tombstone> Deserialize(const char* src,
                                                 std::size_t offset);
 
-private:
+ private:
   int32_t local_deletion_time_;
   int64_t marked_for_delete_at_;
 };
 
 class ExpiringColumn : public Column {
-public:
+ public:
   ExpiringColumn(int8_t mask, int8_t index, int64_t timestamp,
-    int32_t value_size, const char* value, int32_t ttl);
+                 int32_t value_size, const char* value, int32_t ttl);
 
   virtual std::size_t Size() const override;
   virtual void Serialize(std::string* dest) const override;
@@ -136,7 +136,7 @@ public:
   static std::shared_ptr<ExpiringColumn> Deserialize(const char* src,
                                                      std::size_t offset);
 
-private:
+ private:
   int32_t ttl_;
   std::chrono::time_point<std::chrono::system_clock> TimePoint() const;
   std::chrono::seconds Ttl() const;
@@ -145,12 +145,11 @@ private:
 using Columns = std::vector<std::shared_ptr<ColumnBase>>;
 
 class RowValue {
-public:
+ public:
   // Create a Row Tombstone.
   RowValue(int32_t local_deletion_time, int64_t marked_for_delete_at);
   // Create a Row containing columns.
-  RowValue(Columns columns,
-           int64_t last_modified_time);
+  RowValue(Columns columns, int64_t last_modified_time);
   RowValue(const RowValue& /*that*/) = delete;
   RowValue(RowValue&& /*that*/) noexcept = default;
   RowValue& operator=(const RowValue& /*that*/) = delete;
@@ -180,5 +179,5 @@ public:
   int64_t last_modified_time_;
 };
 
-} // namepsace cassandrda
+}  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -44,9 +44,8 @@ bool CassandraValueMergeOperator::FullMergeV2(
   merge_out->new_value.clear();
   std::vector<RowValue> row_values;
   if (merge_in.existing_value) {
-    row_values.push_back(
-      RowValue::Deserialize(merge_in.existing_value->data(),
-                            merge_in.existing_value->size()));
+    row_values.push_back(RowValue::Deserialize(
+        merge_in.existing_value->data(), merge_in.existing_value->size()));
   }
 
   for (auto& operand : merge_in.operand_list) {
@@ -78,6 +77,6 @@ bool CassandraValueMergeOperator::PartialMergeMulti(
   return true;
 }
 
-} // namespace cassandra
+}  // namespace cassandra
 
 }  // namespace ROCKSDB_NAMESPACE

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

@@ -15,30 +15,30 @@ namespace cassandra {
  * A MergeOperator for rocksdb that implements Cassandra row value merge.
  */
 class CassandraValueMergeOperator : public MergeOperator {
-public:
- explicit CassandraValueMergeOperator(int32_t gc_grace_period_in_seconds,
-                                      size_t operands_limit = 0);
+ public:
+  explicit CassandraValueMergeOperator(int32_t gc_grace_period_in_seconds,
+                                       size_t operands_limit = 0);
 
- virtual bool FullMergeV2(const MergeOperationInput& merge_in,
-                          MergeOperationOutput* merge_out) const override;
+  virtual bool FullMergeV2(const MergeOperationInput& merge_in,
+                           MergeOperationOutput* merge_out) const override;
 
- virtual bool PartialMergeMulti(const Slice& key,
-                                const std::deque<Slice>& operand_list,
-                                std::string* new_value,
-                                Logger* logger) const override;
+  virtual bool PartialMergeMulti(const Slice& key,
+                                 const std::deque<Slice>& operand_list,
+                                 std::string* new_value,
+                                 Logger* logger) const override;
 
- const char* Name() const override { return kClassName(); }
- static const char* kClassName() { return "CassandraValueMergeOperator"; }
+  const char* Name() const override { return kClassName(); }
+  static const char* kClassName() { return "CassandraValueMergeOperator"; }
 
- virtual bool AllowSingleOperand() const override { return true; }
+  virtual bool AllowSingleOperand() const override { return true; }
 
- virtual bool ShouldMerge(const std::vector<Slice>& operands) const override {
-   return options_.operands_limit > 0 &&
-          operands.size() >= options_.operands_limit;
- }
+  virtual bool ShouldMerge(const std::vector<Slice>& operands) const override {
+    return options_.operands_limit > 0 &&
+           operands.size() >= options_.operands_limit;
+  }
 
-private:
- CassandraOptions options_;
+ private:
+  CassandraOptions options_;
 };
-} // namespace cassandra
+}  // namespace cassandra
 }  // namespace ROCKSDB_NAMESPACE