@nxtedition/rocksdb 10.1.4 → 10.1.6

package/deps/rocksdb/rocksdb/utilities/table_properties_collectors/compact_for_tiering_collector.cc

@@ -0,0 +1,144 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+//  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).
+
+#include "utilities/table_properties_collectors/compact_for_tiering_collector.h"
+
+#include <sstream>
+
+#include "db/seqno_to_time_mapping.h"
+#include "rocksdb/status.h"
+#include "rocksdb/types.h"
+#include "rocksdb/utilities/customizable_util.h"
+#include "rocksdb/utilities/object_registry.h"
+#include "rocksdb/utilities/options_type.h"
+#include "rocksdb/utilities/table_properties_collectors.h"
+#include "util/string_util.h"
+
+namespace ROCKSDB_NAMESPACE {
+const std::string
+    CompactForTieringCollector::kNumEligibleLastLevelEntriesPropertyName =
+        "rocksdb.eligible.last.level.entries";
+
+CompactForTieringCollector::CompactForTieringCollector(
+    SequenceNumber last_level_inclusive_max_seqno_threshold,
+    double compaction_trigger_ratio)
+    : last_level_inclusive_max_seqno_threshold_(
+          last_level_inclusive_max_seqno_threshold),
+      compaction_trigger_ratio_(compaction_trigger_ratio) {
+  assert(last_level_inclusive_max_seqno_threshold_ != kMaxSequenceNumber);
+}
+
+Status CompactForTieringCollector::AddUserKey(const Slice& /*key*/,
+                                              const Slice& value,
+                                              EntryType type,
+                                              SequenceNumber seq,
+                                              uint64_t /*file_size*/) {
+  SequenceNumber seq_for_check = seq;
+  if (type == kEntryTimedPut) {
+    seq_for_check = ParsePackedValueForSeqno(value);
+  }
+  if (seq_for_check < last_level_inclusive_max_seqno_threshold_) {
+    last_level_eligible_entries_counter_++;
+  }
+  total_entries_counter_ += 1;
+  return Status::OK();
+}
+
+Status CompactForTieringCollector::Finish(UserCollectedProperties* properties) {
+  assert(!finish_called_);
+  assert(compaction_trigger_ratio_ > 0);
+  if (last_level_eligible_entries_counter_ >=
+      compaction_trigger_ratio_ * total_entries_counter_) {
+    assert(compaction_trigger_ratio_ <= 1);
+    need_compaction_ = true;
+  }
+  if (last_level_eligible_entries_counter_ > 0) {
+    *properties = UserCollectedProperties{
+        {kNumEligibleLastLevelEntriesPropertyName,
+         std::to_string(last_level_eligible_entries_counter_)},
+    };
+  }
+  finish_called_ = true;
+  return Status::OK();
+}
+
+UserCollectedProperties CompactForTieringCollector::GetReadableProperties()
+    const {
+  return UserCollectedProperties{
+      {kNumEligibleLastLevelEntriesPropertyName,
+       std::to_string(last_level_eligible_entries_counter_)},
+  };
+}
+
+bool CompactForTieringCollector::NeedCompact() const {
+  return need_compaction_;
+}
+
+void CompactForTieringCollector::Reset() {
+  last_level_eligible_entries_counter_ = 0;
+  total_entries_counter_ = 0;
+  finish_called_ = false;
+  need_compaction_ = false;
+}
+
+TablePropertiesCollector*
+CompactForTieringCollectorFactory::CreateTablePropertiesCollector(
+    TablePropertiesCollectorFactory::Context context) {
+  double compaction_trigger_ratio = GetCompactionTriggerRatio();
+  if (compaction_trigger_ratio <= 0 ||
+      context.level_at_creation == context.num_levels - 1 ||
+      context.last_level_inclusive_max_seqno_threshold == kMaxSequenceNumber) {
+    return nullptr;
+  }
+  return new CompactForTieringCollector(
+      context.last_level_inclusive_max_seqno_threshold,
+      compaction_trigger_ratio);
+}
+
+static std::unordered_map<std::string, OptionTypeInfo>
+    on_compact_for_tiering_type_info = {
+        {"compaction_trigger_ratio",
+         {0, OptionType::kUnknown, OptionVerificationType::kNormal,
+          OptionTypeFlags::kCompareNever | OptionTypeFlags::kMutable,
+          [](const ConfigOptions&, const std::string&, const std::string& value,
+             void* addr) {
+            auto* factory =
+                static_cast<CompactForTieringCollectorFactory*>(addr);
+            factory->SetCompactionTriggerRatio(ParseDouble(value));
+            return Status::OK();
+          },
+          [](const ConfigOptions&, const std::string&, const void* addr,
+             std::string* value) {
+            const auto* factory =
+                static_cast<const CompactForTieringCollectorFactory*>(addr);
+            *value = std::to_string(factory->GetCompactionTriggerRatio());
+            return Status::OK();
+          },
+          nullptr}},
+
+};
+
+CompactForTieringCollectorFactory::CompactForTieringCollectorFactory(
+    double compaction_trigger_ratio)
+    : compaction_trigger_ratio_(compaction_trigger_ratio) {
+  RegisterOptions("", this, &on_compact_for_tiering_type_info);
+}
+
+std::string CompactForTieringCollectorFactory::ToString() const {
+  std::ostringstream cfg;
+  cfg << Name()
+      << ", compaction trigger ratio:" << compaction_trigger_ratio_.load()
+      << std::endl;
+  return cfg.str();
+}
+
+std::shared_ptr<CompactForTieringCollectorFactory>
+NewCompactForTieringCollectorFactory(double compaction_trigger_ratio) {
+  return std::make_shared<CompactForTieringCollectorFactory>(
+      compaction_trigger_ratio);
+}
+
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/table_properties_collectors/compact_for_tiering_collector.h

@@ -0,0 +1,45 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+//  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 "rocksdb/utilities/table_properties_collectors.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+// A user property collector that marks a SST file as need-compaction when for
+// the tiering use case. See documentation for
+// `CompactForTieringCollectorFactory`.
+class CompactForTieringCollector : public TablePropertiesCollector {
+ public:
+  static const std::string kNumEligibleLastLevelEntriesPropertyName;
+
+  CompactForTieringCollector(
+      SequenceNumber last_level_inclusive_max_seqno_threshold_,
+      double compaction_trigger_ratio);
+
+  Status AddUserKey(const Slice& key, const Slice& value, EntryType type,
+                    SequenceNumber seq, uint64_t file_size) override;
+
+  Status Finish(UserCollectedProperties* properties) override;
+
+  UserCollectedProperties GetReadableProperties() const override;
+
+  const char* Name() const override { return "CompactForTieringCollector"; }
+
+  bool NeedCompact() const override;
+
+ private:
+  void Reset();
+
+  SequenceNumber last_level_inclusive_max_seqno_threshold_;
+  double compaction_trigger_ratio_;
+  size_t last_level_eligible_entries_counter_ = 0;
+  size_t total_entries_counter_ = 0;
+  bool finish_called_ = false;
+  bool need_compaction_ = false;
+};
+}  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/utilities/table_properties_collectors/compact_for_tiering_collector_test.cc

@@ -0,0 +1,139 @@
+//  Copyright (c) Meta Platforms, Inc. and affiliates.
+//
+//  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).
+
+#include "utilities/table_properties_collectors/compact_for_tiering_collector.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <iostream>
+#include <vector>
+
+#include "db/seqno_to_time_mapping.h"
+#include "port/stack_trace.h"
+#include "rocksdb/table.h"
+#include "rocksdb/table_properties.h"
+#include "rocksdb/utilities/table_properties_collectors.h"
+#include "test_util/testharness.h"
+#include "util/random.h"
+
+namespace ROCKSDB_NAMESPACE {
+
+TEST(CompactForTieringCollector, NotEnabled) {
+  TablePropertiesCollectorFactory::Context context;
+  context.column_family_id = 1;
+  context.level_at_creation = 1;
+  context.num_levels = 6;
+  context.last_level_inclusive_max_seqno_threshold = 50;
+
+  // Set compaction trigger ratio to 0 to disable it. No collector created.
+  auto factory = NewCompactForTieringCollectorFactory(0);
+  std::unique_ptr<TablePropertiesCollector> collector(
+      factory->CreateTablePropertiesCollector(context));
+  ASSERT_EQ(nullptr, collector);
+}
+
+TEST(CompactForTieringCollector, TieringDisabled) {
+  TablePropertiesCollectorFactory::Context context;
+  context.column_family_id = 1;
+  context.level_at_creation = 1;
+  context.num_levels = 6;
+  context.last_level_inclusive_max_seqno_threshold = kMaxSequenceNumber;
+
+  // Tiering is disabled on the column family. No collector created.
+  {
+    for (double compaction_trigger_ratio : {0.0, 0.1, 1.0, 1.5}) {
+      auto factory =
+          NewCompactForTieringCollectorFactory(compaction_trigger_ratio);
+      std::unique_ptr<TablePropertiesCollector> collector(
+          factory->CreateTablePropertiesCollector(context));
+      ASSERT_EQ(nullptr, collector);
+    }
+  }
+}
+
+TEST(CompactForTieringCollector, LastLevelFile) {
+  TablePropertiesCollectorFactory::Context context;
+  context.column_family_id = 1;
+  context.level_at_creation = 5;
+  context.num_levels = 6;
+  context.last_level_inclusive_max_seqno_threshold = 50;
+
+  // No collector created for a file that is already on the last level.
+  {
+    for (double compaction_trigger_ratio : {0.0, 0.1, 1.0, 1.5}) {
+      auto factory =
+          NewCompactForTieringCollectorFactory(compaction_trigger_ratio);
+      std::unique_ptr<TablePropertiesCollector> collector(
+          factory->CreateTablePropertiesCollector(context));
+      ASSERT_EQ(nullptr, collector);
+    }
+  }
+}
+
+TEST(CompactForTieringCollector, CollectorEnabled) {
+  TablePropertiesCollectorFactory::Context context;
+  context.column_family_id = 1;
+  context.level_at_creation = 1;
+  context.num_levels = 6;
+  context.last_level_inclusive_max_seqno_threshold = 50;
+  const size_t kTotalEntries = 100;
+
+  {
+    for (double compaction_trigger_ratio : {0.1, 0.33333333, 0.5, 1.0, 1.5}) {
+      auto factory =
+          NewCompactForTieringCollectorFactory(compaction_trigger_ratio);
+      std::unique_ptr<TablePropertiesCollector> collector(
+          factory->CreateTablePropertiesCollector(context));
+      for (size_t i = 0; i < kTotalEntries; i++) {
+        ASSERT_OK(collector->AddUserKey("hello", "rocksdb", kEntryPut, i, 0));
+        ASSERT_FALSE(collector->NeedCompact());
+      }
+      UserCollectedProperties user_properties;
+      ASSERT_OK(collector->Finish(&user_properties));
+      ASSERT_EQ(user_properties[CompactForTieringCollector::
+                                    kNumEligibleLastLevelEntriesPropertyName],
+                std::to_string(50));
+      if (compaction_trigger_ratio > 0.5) {
+        ASSERT_FALSE(collector->NeedCompact());
+      } else {
+        ASSERT_TRUE(collector->NeedCompact());
+      }
+    }
+  }
+}
+
+TEST(CompactForTieringCollector, TimedPutEntries) {
+  TablePropertiesCollectorFactory::Context context;
+  context.column_family_id = 1;
+  context.level_at_creation = 1;
+  context.num_levels = 6;
+  context.last_level_inclusive_max_seqno_threshold = 50;
+  const size_t kTotalEntries = 100;
+
+  auto factory = NewCompactForTieringCollectorFactory(0.1);
+  std::unique_ptr<TablePropertiesCollector> collector(
+      factory->CreateTablePropertiesCollector(context));
+  for (size_t i = 0; i < kTotalEntries; i++) {
+    std::string value;
+    PackValueAndSeqno("rocksdb", i, &value);
+    ASSERT_OK(collector->AddUserKey("hello", value, kEntryTimedPut, 0, 0));
+    ASSERT_FALSE(collector->NeedCompact());
+  }
+  UserCollectedProperties user_properties;
+  ASSERT_OK(collector->Finish(&user_properties));
+  ASSERT_EQ(user_properties[CompactForTieringCollector::
+                                kNumEligibleLastLevelEntriesPropertyName],
+            std::to_string(50));
+  ASSERT_TRUE(collector->NeedCompact());
+}
+}  // namespace ROCKSDB_NAMESPACE
+
+int main(int argc, char** argv) {
+  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

package/deps/rocksdb/rocksdb/utilities/table_properties_collectors/compact_on_deletion_collector.cc

@@ -188,6 +188,7 @@ NewCompactOnDeletionCollectorFactory(size_t sliding_window_size,
       new CompactOnDeletionCollectorFactory(sliding_window_size,
                                             deletion_trigger, deletion_ratio));
 }
+
 namespace {
 static int RegisterTablePropertiesCollectorFactories(
     ObjectLibrary& library, const std::string& /*arg*/) {
@@ -202,6 +203,17 @@ static int RegisterTablePropertiesCollectorFactories(
         guard->reset(new CompactOnDeletionCollectorFactory(0, 0, 0));
         return guard->get();
       });
+  library.AddFactory<TablePropertiesCollectorFactory>(
+      CompactForTieringCollectorFactory::kClassName(),
+      [](const std::string& /*uri*/,
+         std::unique_ptr<TablePropertiesCollectorFactory>* guard,
+         std::string* /* errmsg */) {
+        // By default, create a `CompactForTieringCollectorFactory` that is
+        // disabled. Users will need to call corresponding setters to enable
+        // the factory.
+        guard->reset(new CompactForTieringCollectorFactory(0));
+        return guard->get();
+      });
   return 1;
 }
 }  // namespace

package/deps/rocksdb/rocksdb/utilities/table_properties_collectors/compact_on_deletion_collector_test.cc

@@ -14,6 +14,7 @@
 #include <cstdio>
 #include <vector>
 
+#include "db/dbformat.h"
 #include "port/stack_trace.h"
 #include "rocksdb/table.h"
 #include "rocksdb/table_properties.h"
@@ -27,6 +28,7 @@ TEST(CompactOnDeletionCollector, DeletionRatio) {
   TablePropertiesCollectorFactory::Context context;
   context.column_family_id =
       TablePropertiesCollectorFactory::Context::kUnknownColumnFamily;
+  context.last_level_inclusive_max_seqno_threshold = kMaxSequenceNumber;
   const size_t kTotalEntries = 100;
 
   {
@@ -86,6 +88,7 @@ TEST(CompactOnDeletionCollector, SlidingWindow) {
   TablePropertiesCollectorFactory::Context context;
   context.column_family_id =
       TablePropertiesCollectorFactory::Context::kUnknownColumnFamily;
+  context.last_level_inclusive_max_seqno_threshold = kMaxSequenceNumber;
 
   std::vector<int> window_sizes;
   std::vector<int> deletion_triggers;

package/deps/rocksdb/rocksdb/utilities/transactions/optimistic_transaction_test.cc

@@ -1719,9 +1719,10 @@ TEST_P(OptimisticTransactionTest, PutEntitySuccess) {
     }
 
     {
-      PinnableSlice value;
-      ASSERT_OK(txn->GetForUpdate(ReadOptions(), foo, &value));
-      ASSERT_EQ(value, foo_columns[0].value());
+      PinnableWideColumns columns;
+      ASSERT_OK(txn->GetEntityForUpdate(
+          ReadOptions(), txn_db->DefaultColumnFamily(), foo, &columns));
+      ASSERT_EQ(columns.columns(), foo_columns);
     }
 
     ASSERT_OK(
@@ -1737,9 +1738,10 @@ TEST_P(OptimisticTransactionTest, PutEntitySuccess) {
     }
 
     {
-      PinnableSlice value;
-      ASSERT_OK(txn->GetForUpdate(ReadOptions(), foo, &value));
-      ASSERT_EQ(value, foo_new_columns[0].value());
+      PinnableWideColumns columns;
+      ASSERT_OK(txn->GetEntityForUpdate(
+          ReadOptions(), txn_db->DefaultColumnFamily(), foo, &columns));
+      ASSERT_EQ(columns.columns(), foo_new_columns);
     }
 
     ASSERT_OK(txn->Commit());
@@ -2034,6 +2036,60 @@ TEST_P(OptimisticTransactionTest, PutEntityWriteConflictTxnTxn) {
   }
 }
 
+TEST_P(OptimisticTransactionTest, PutEntityReadConflict) {
+  constexpr char foo[] = "foo";
+  const WideColumns foo_columns{
+      {kDefaultWideColumnName, "bar"}, {"col1", "val1"}, {"col2", "val2"}};
+
+  ASSERT_OK(txn_db->PutEntity(WriteOptions(), txn_db->DefaultColumnFamily(),
+                              foo, foo_columns));
+
+  std::unique_ptr<Transaction> txn(txn_db->BeginTransaction(WriteOptions()));
+  ASSERT_NE(txn, nullptr);
+
+  txn->SetSnapshot();
+
+  ReadOptions snapshot_read_options;
+  snapshot_read_options.snapshot = txn->GetSnapshot();
+
+  {
+    PinnableWideColumns columns;
+    ASSERT_OK(txn->GetEntityForUpdate(
+        snapshot_read_options, txn_db->DefaultColumnFamily(), foo, &columns));
+    ASSERT_EQ(columns.columns(), foo_columns);
+  }
+
+  // This PutEntity outside of a transaction will conflict with the previous
+  // write
+  const WideColumns foo_conflict_columns{{kDefaultWideColumnName, "X"},
+                                         {"conflicting", "write"}};
+  ASSERT_OK(txn_db->PutEntity(WriteOptions(), txn_db->DefaultColumnFamily(),
+                              foo, foo_conflict_columns));
+
+  {
+    PinnableWideColumns columns;
+    ASSERT_OK(txn_db->GetEntity(ReadOptions(), txn_db->DefaultColumnFamily(),
+                                foo, &columns));
+    ASSERT_EQ(columns.columns(), foo_conflict_columns);
+  }
+
+  {
+    PinnableWideColumns columns;
+    ASSERT_OK(txn->GetEntity(ReadOptions(), txn_db->DefaultColumnFamily(), foo,
+                             &columns));
+    ASSERT_EQ(columns.columns(), foo_conflict_columns);
+  }
+
+  ASSERT_TRUE(txn->Commit().IsBusy());  // Txn should not commit
+
+  {
+    PinnableWideColumns columns;
+    ASSERT_OK(txn_db->GetEntity(ReadOptions(), txn_db->DefaultColumnFamily(),
+                                foo, &columns));
+    ASSERT_EQ(columns.columns(), foo_conflict_columns);
+  }
+}
+
 TEST_P(OptimisticTransactionTest, EntityReadSanityChecks) {
   constexpr char foo[] = "foo";
   constexpr char bar[] = "bar";
@@ -2121,6 +2177,49 @@ TEST_P(OptimisticTransactionTest, EntityReadSanityChecks) {
     ASSERT_TRUE(statuses[0].IsInvalidArgument());
     ASSERT_TRUE(statuses[1].IsInvalidArgument());
   }
+
+  {
+    constexpr ColumnFamilyHandle* column_family = nullptr;
+    PinnableWideColumns columns;
+    ASSERT_TRUE(
+        txn->GetEntityForUpdate(ReadOptions(), column_family, foo, &columns)
+            .IsInvalidArgument());
+  }
+
+  {
+    constexpr PinnableWideColumns* columns = nullptr;
+    ASSERT_TRUE(txn->GetEntityForUpdate(ReadOptions(),
+                                        txn_db->DefaultColumnFamily(), foo,
+                                        columns)
+                    .IsInvalidArgument());
+  }
+
+  {
+    ReadOptions read_options;
+    read_options.io_activity = Env::IOActivity::kGet;
+
+    PinnableWideColumns columns;
+    ASSERT_TRUE(txn->GetEntityForUpdate(read_options,
+                                        txn_db->DefaultColumnFamily(), foo,
+                                        &columns)
+                    .IsInvalidArgument());
+  }
+
+  {
+    txn->SetSnapshot();
+
+    ReadOptions read_options;
+    read_options.snapshot = txn->GetSnapshot();
+
+    PinnableWideColumns columns;
+    constexpr bool exclusive = true;
+    constexpr bool do_validate = false;
+
+    ASSERT_TRUE(txn->GetEntityForUpdate(read_options,
+                                        txn_db->DefaultColumnFamily(), foo,
+                                        &columns, exclusive, do_validate)
+                    .IsInvalidArgument());
+  }
 }
 
 INSTANTIATE_TEST_CASE_P(

package/deps/rocksdb/rocksdb/utilities/transactions/pessimistic_transaction.cc

@@ -217,6 +217,60 @@ inline Status WriteCommittedTxn::GetForUpdateImpl(
                                            value, exclusive, do_validate);
 }
 
+Status WriteCommittedTxn::GetEntityForUpdate(const ReadOptions& read_options,
+                                             ColumnFamilyHandle* column_family,
+                                             const Slice& key,
+                                             PinnableWideColumns* columns,
+                                             bool exclusive, bool do_validate) {
+  if (!column_family) {
+    return Status::InvalidArgument(
+        "Cannot call GetEntityForUpdate without a column family handle");
+  }
+
+  const Comparator* const ucmp = column_family->GetComparator();
+  assert(ucmp);
+  const size_t ts_sz = ucmp->timestamp_size();
+
+  if (ts_sz == 0) {
+    return TransactionBaseImpl::GetEntityForUpdate(
+        read_options, column_family, key, columns, exclusive, do_validate);
+  }
+
+  assert(ts_sz > 0);
+
+  if (!do_validate) {
+    if (read_timestamp_ != kMaxTxnTimestamp) {
+      return Status::InvalidArgument(
+          "Read timestamp must not be set if validation is disabled");
+    }
+  } else {
+    if (read_timestamp_ == kMaxTxnTimestamp) {
+      return Status::InvalidArgument(
+          "Read timestamp must be set for validation");
+    }
+  }
+
+  std::string ts_buf;
+  PutFixed64(&ts_buf, read_timestamp_);
+  Slice ts(ts_buf);
+
+  if (!read_options.timestamp) {
+    ReadOptions read_options_copy = read_options;
+    read_options_copy.timestamp = &ts;
+
+    return TransactionBaseImpl::GetEntityForUpdate(
+        read_options_copy, column_family, key, columns, exclusive, do_validate);
+  }
+
+  assert(read_options.timestamp);
+  if (*read_options.timestamp != ts) {
+    return Status::InvalidArgument("Must read from the same read timestamp");
+  }
+
+  return TransactionBaseImpl::GetEntityForUpdate(
+      read_options, column_family, key, columns, exclusive, do_validate);
+}
+
 Status WriteCommittedTxn::PutEntityImpl(ColumnFamilyHandle* column_family,
                                         const Slice& key,
                                         const WideColumns& columns,
@@ -584,9 +638,9 @@ Status WriteCommittedTxn::PrepareInternal() {
   SequenceNumber* const KIgnoreSeqUsed = nullptr;
   const size_t kNoBatchCount = 0;
   s = db_impl_->WriteImpl(write_options, GetWriteBatch()->GetWriteBatch(),
-                          kNoWriteCallback, &log_number_, kRefNoLog,
-                          kDisableMemtable, KIgnoreSeqUsed, kNoBatchCount,
-                          &mark_log_callback);
+                          kNoWriteCallback, /*user_write_cb=*/nullptr,
+                          &log_number_, kRefNoLog, kDisableMemtable,
+                          KIgnoreSeqUsed, kNoBatchCount, &mark_log_callback);
   return s;
 }
 
@@ -719,11 +773,11 @@ Status WriteCommittedTxn::CommitWithoutPrepareInternal() {
       post_mem_cb = &snapshot_creation_cb;
     }
   }
-  auto s = db_impl_->WriteImpl(write_options_, wb,
-                               /*callback*/ nullptr, /*log_used*/ nullptr,
-                               /*log_ref*/ 0, /*disable_memtable*/ false,
-                               &seq_used, /*batch_cnt=*/0,
-                               /*pre_release_callback=*/nullptr, post_mem_cb);
+  auto s = db_impl_->WriteImpl(
+      write_options_, wb,
+      /*callback*/ nullptr, /*user_write_cb=*/nullptr, /*log_used*/ nullptr,
+      /*log_ref*/ 0, /*disable_memtable*/ false, &seq_used, /*batch_cnt=*/0,
+      /*pre_release_callback=*/nullptr, post_mem_cb);
   assert(!s.ok() || seq_used != kMaxSequenceNumber);
   if (s.ok()) {
     SetId(seq_used);
@@ -734,6 +788,7 @@ Status WriteCommittedTxn::CommitWithoutPrepareInternal() {
 Status WriteCommittedTxn::CommitBatchInternal(WriteBatch* batch, size_t) {
   uint64_t seq_used = kMaxSequenceNumber;
   auto s = db_impl_->WriteImpl(write_options_, batch, /*callback*/ nullptr,
+                               /*user_write_cb=*/nullptr,
                                /*log_used*/ nullptr, /*log_ref*/ 0,
                                /*disable_memtable*/ false, &seq_used);
   assert(!s.ok() || seq_used != kMaxSequenceNumber);
@@ -807,6 +862,7 @@ Status WriteCommittedTxn::CommitInternal() {
     }
   }
   s = db_impl_->WriteImpl(write_options_, working_batch, /*callback*/ nullptr,
+                          /*user_write_cb=*/nullptr,
                           /*log_used*/ nullptr, /*log_ref*/ log_number_,
                           /*disable_memtable*/ false, &seq_used,
                           /*batch_cnt=*/0, /*pre_release_callback=*/nullptr,

package/deps/rocksdb/rocksdb/utilities/transactions/pessimistic_transaction.h

@@ -234,6 +234,11 @@ class WriteCommittedTxn : public PessimisticTransaction {
                       PinnableSlice* pinnable_val, bool exclusive,
                       const bool do_validate) override;
 
+  Status GetEntityForUpdate(const ReadOptions& read_options,
+                            ColumnFamilyHandle* column_family, const Slice& key,
+                            PinnableWideColumns* columns, bool exclusive,
+                            bool do_validate) override;
+
   using TransactionBaseImpl::Put;
   // `key` does NOT include timestamp even when it's enabled.
   Status Put(ColumnFamilyHandle* column_family, const Slice& key,