@nxtedition/rocksdb 8.2.8 → 9.0.1

package/deps/rocksdb/rocksdb/util/udt_util.h

@@ -1,15 +1,22 @@
-//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
+//  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 <memory>
+#include <optional>
 #include <sstream>
+#include <unordered_map>
 #include <vector>
 
+#include "db/write_batch_internal.h"
 #include "rocksdb/slice.h"
 #include "rocksdb/status.h"
+#include "rocksdb/write_batch.h"
 #include "util/coding.h"
+#include "util/hash_containers.h"
 
 namespace ROCKSDB_NAMESPACE {
 
@@ -74,4 +81,188 @@ class UserDefinedTimestampSizeRecord {
   std::vector<std::pair<uint32_t, size_t>> cf_to_ts_sz_;
 };
 
+// This handler is used to recover a WriteBatch read from WAL logs during
+// recovery. It does a best-effort recovery if the column families contained in
+// the WriteBatch have inconsistency between the recorded timestamp size and the
+// running timestamp size. And creates a new WriteBatch that are consistent with
+// the running timestamp size with entries from the original WriteBatch.
+//
+// Note that for a WriteBatch with no inconsistency, a new WriteBatch is created
+// nonetheless, and it should be exactly the same as the original WriteBatch.
+//
+// To access the new WriteBatch, invoke `TransferNewBatch` after calling
+// `Iterate`. The handler becomes invalid afterwards.
+//
+// For the user key in each entry, the best effort recovery means:
+// 1) If recorded timestamp size is 0, running timestamp size is > 0, a min
+// timestamp of length running timestamp size is padded to the user key.
+// 2) If recorded timestamp size is > 0, running timestamp size is 0, the last
+// bytes of length recorded timestamp size is stripped from user key.
+// 3) If recorded timestamp size is the same as running timestamp size, no-op.
+// 4) If recorded timestamp size and running timestamp size are both non-zero
+// but not equal, return Status::InvalidArgument.
+class TimestampRecoveryHandler : public WriteBatch::Handler {
+ public:
+  TimestampRecoveryHandler(const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+                           const UnorderedMap<uint32_t, size_t>& record_ts_sz);
+
+  ~TimestampRecoveryHandler() override {}
+
+  // No copy or move.
+  TimestampRecoveryHandler(const TimestampRecoveryHandler&) = delete;
+  TimestampRecoveryHandler(TimestampRecoveryHandler&&) = delete;
+  TimestampRecoveryHandler& operator=(const TimestampRecoveryHandler&) = delete;
+  TimestampRecoveryHandler& operator=(TimestampRecoveryHandler&&) = delete;
+
+  Status PutCF(uint32_t cf, const Slice& key, const Slice& value) override;
+
+  Status DeleteCF(uint32_t cf, const Slice& key) override;
+
+  Status SingleDeleteCF(uint32_t cf, const Slice& key) override;
+
+  Status DeleteRangeCF(uint32_t cf, const Slice& begin_key,
+                       const Slice& end_key) override;
+
+  Status MergeCF(uint32_t cf, const Slice& key, const Slice& value) override;
+
+  Status PutBlobIndexCF(uint32_t cf, const Slice& key,
+                        const Slice& value) override;
+
+  Status MarkBeginPrepare(bool) override { return Status::OK(); }
+
+  Status MarkEndPrepare(const Slice&) override { return Status::OK(); }
+
+  Status MarkCommit(const Slice&) override { return Status::OK(); }
+
+  Status MarkCommitWithTimestamp(const Slice&, const Slice&) override {
+    return Status::OK();
+  }
+
+  Status MarkRollback(const Slice&) override { return Status::OK(); }
+
+  Status MarkNoop(bool /*empty_batch*/) override { return Status::OK(); }
+
+  std::unique_ptr<WriteBatch>&& TransferNewBatch() {
+    assert(new_batch_diff_from_orig_batch_);
+    handler_valid_ = false;
+    return std::move(new_batch_);
+  }
+
+ private:
+  Status ReconcileTimestampDiscrepancy(uint32_t cf, const Slice& key,
+                                       std::string* new_key_buf,
+                                       Slice* new_key);
+
+  // Mapping from column family id to user-defined timestamp size for all
+  // running column families including the ones with zero timestamp size.
+  const UnorderedMap<uint32_t, size_t>& running_ts_sz_;
+
+  // Mapping from column family id to user-defined timestamp size as recorded
+  // in the WAL. This only contains non-zero user-defined timestamp size.
+  const UnorderedMap<uint32_t, size_t>& record_ts_sz_;
+
+  std::unique_ptr<WriteBatch> new_batch_;
+  // Handler is valid upon creation and becomes invalid after its `new_batch_`
+  // is transferred.
+  bool handler_valid_;
+
+  // False upon creation, and become true if at least one user key from the
+  // original batch is updated when creating the new batch.
+  bool new_batch_diff_from_orig_batch_;
+};
+
+// Mode for checking and handling timestamp size inconsistency encountered in a
+// WriteBatch read from WAL log.
+enum class TimestampSizeConsistencyMode {
+  // Verified that the recorded user-defined timestamp size is consistent with
+  // the running one for all the column families involved in a WriteBatch.
+  // Column families referred to in the WriteBatch but are dropped are ignored.
+  kVerifyConsistency,
+  // Verified that if any inconsistency exists in a WriteBatch, it's all
+  // tolerable by a best-effort reconciliation. And optionally creates a new
+  // WriteBatch from the original WriteBatch that is consistent with the running
+  // timestamp size. Column families referred to in the WriteBatch but are
+  // dropped are ignored. If a new WriteBatch is created, such entries are
+  // copied over as is.
+  kReconcileInconsistency,
+};
+
+// Handles the inconsistency between recorded timestamp sizes and running
+// timestamp sizes for a WriteBatch. A non-OK `status` indicates there are
+// intolerable inconsistency with the specified `check_mode`.
+//
+// If `check_mode` is `kVerifyConsistency`, intolerable inconsistency means any
+// running column family has an inconsistent user-defined timestamp size.
+//
+// If `check_mode` is `kReconcileInconsistency`, intolerable inconsistency means
+// any running column family has an inconsistent user-defined timestamp size
+// that cannot be reconciled with a best-effort recovery. Check
+// `TimestampRecoveryHandler` for what a best-effort recovery is capable of. In
+// this mode, output argument `new_batch` should be set, a new WriteBatch is
+// created on the heap and transferred to `new_batch` if there is tolerable
+// inconsistency.
+//
+// An invariant that WAL logging ensures is that all timestamp size info
+// is logged prior to a WriteBatch that needed this info. And zero timestamp
+// size is skipped. So `record_ts_sz` only contains column family with non-zero
+// timestamp size and a column family id absent from `record_ts_sz` will be
+// interpreted as that column family has zero timestamp size. On the other hand,
+// `running_ts_sz` should contain the timestamp size for all running column
+// families including the ones with zero timestamp size.
+Status HandleWriteBatchTimestampSizeDifference(
+    const WriteBatch* batch,
+    const UnorderedMap<uint32_t, size_t>& running_ts_sz,
+    const UnorderedMap<uint32_t, size_t>& record_ts_sz,
+    TimestampSizeConsistencyMode check_mode,
+    std::unique_ptr<WriteBatch>* new_batch = nullptr);
+
+// This util function is used when opening an existing column family and
+// processing its VersionEdit. It does a sanity check for the column family's
+// old user comparator and the persist_user_defined_timestamps flag as recorded
+// in the VersionEdit, against its new settings from the column family's
+// ImmutableCFOptions.
+//
+// Valid settings change include:
+// 1) no user comparator change and no effective persist_user_defined_timestamp
+// flag change.
+// 2) switch user comparator to enable user-defined timestamps feature provided
+// the immediately effective persist_user_defined_timestamps flag is false.
+// 3) switch user comparator to disable user-defined timestamps feature provided
+// that the before-change persist_user_defined_timestamps is already false.
+//
+// Switch user comparator to disable/enable UDT is only sanity checked by a user
+// comparator name comparison. The full check includes enforcing the new user
+// comparator ranks user keys exactly the same as the old user comparator and
+// only add / remove the user-defined timestamp comparison. We don't have ways
+// to strictly enforce this so currently only the RocksDB builtin comparator
+// wrapper `ComparatorWithU64TsImpl` is  supported to enable / disable
+// user-defined timestamps. It formats user-defined timestamps as uint64_t.
+//
+// When the settings indicate a legit change to enable user-defined timestamps
+// feature on a column family, `mark_sst_files_has_no_udt` will be set to true
+// to indicate marking all existing SST files has no user-defined timestamps
+// when re-writing the manifest.
+Status ValidateUserDefinedTimestampsOptions(
+    const Comparator* new_comparator, const std::string& old_comparator_name,
+    bool new_persist_udt, bool old_persist_udt,
+    bool* mark_sst_files_has_no_udt);
+
+// Given a cutoff user-defined timestamp formatted as uint64_t, get the
+// effective `full_history_ts_low` timestamp, which is the next immediately
+// bigger timestamp. Used by the UDT in memtable only feature when flushing
+// memtables and remove timestamps. This process collapses history and increase
+// the effective `full_history_ts_low`.
+void GetFullHistoryTsLowFromU64CutoffTs(Slice* cutoff_ts,
+                                        std::string* full_history_ts_low);
+
+// `start` is the inclusive lower user key bound without user-defined timestamp.
+// `end` is the upper user key bound without user-defined timestamp.
+// By default, `end` is treated as being exclusive. If `exclusive_end` is set to
+// false, it's treated as an inclusive upper bound.
+// If any of these two bounds is nullptr, an empty std::optional<Slice> is
+// returned for that bound.
+std::tuple<std::optional<Slice>, std::optional<Slice>>
+MaybeAddTimestampsToRange(const Slice* start, const Slice* end, size_t ts_sz,
+                          std::string* start_with_ts, std::string* end_with_ts,
+                          bool exclusive_end = true);
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/util/udt_util_test.cc

@@ -0,0 +1,461 @@
+//  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 "util/udt_util.h"
+
+#include <gtest/gtest.h>
+
+#include "db/dbformat.h"
+#include "test_util/testharness.h"
+#include "test_util/testutil.h"
+
+namespace ROCKSDB_NAMESPACE {
+namespace {
+static const std::string kTestKeyWithoutTs = "key";
+static const std::string kValuePlaceHolder = "value";
+}  // namespace
+
+class HandleTimestampSizeDifferenceTest : public testing::Test {
+ public:
+  HandleTimestampSizeDifferenceTest() {}
+
+  // Test handler used to collect the column family id and user keys contained
+  // in a WriteBatch for test verification. And verifies the value part stays
+  // the same if it's available.
+  class KeyCollector : public WriteBatch::Handler {
+   public:
+    explicit KeyCollector() {}
+
+    ~KeyCollector() override {}
+
+    Status PutCF(uint32_t cf, const Slice& key, const Slice& value) override {
+      if (value.compare(kValuePlaceHolder) != 0) {
+        return Status::InvalidArgument();
+      }
+      return AddKey(cf, key);
+    }
+
+    Status DeleteCF(uint32_t cf, const Slice& key) override {
+      return AddKey(cf, key);
+    }
+
+    Status SingleDeleteCF(uint32_t cf, const Slice& key) override {
+      return AddKey(cf, key);
+    }
+
+    Status DeleteRangeCF(uint32_t cf, const Slice& begin_key,
+                         const Slice& end_key) override {
+      Status status = AddKey(cf, begin_key);
+      if (!status.ok()) {
+        return status;
+      }
+      return AddKey(cf, end_key);
+    }
+
+    Status MergeCF(uint32_t cf, const Slice& key, const Slice& value) override {
+      if (value.compare(kValuePlaceHolder) != 0) {
+        return Status::InvalidArgument();
+      }
+      return AddKey(cf, key);
+    }
+
+    Status PutBlobIndexCF(uint32_t cf, const Slice& key,
+                          const Slice& value) override {
+      if (value.compare(kValuePlaceHolder) != 0) {
+        return Status::InvalidArgument();
+      }
+      return AddKey(cf, key);
+    }
+
+    Status MarkBeginPrepare(bool) override { return Status::OK(); }
+
+    Status MarkEndPrepare(const Slice&) override { return Status::OK(); }
+
+    Status MarkRollback(const Slice&) override { return Status::OK(); }
+
+    Status MarkCommit(const Slice&) override { return Status::OK(); }
+
+    Status MarkCommitWithTimestamp(const Slice&, const Slice&) override {
+      return Status::OK();
+    }
+
+    Status MarkNoop(bool) override { return Status::OK(); }
+
+    const std::vector<std::pair<uint32_t, const Slice>>& GetKeys() const {
+      return keys_;
+    }
+
+   private:
+    Status AddKey(uint32_t cf, const Slice& key) {
+      keys_.push_back(std::make_pair(cf, key));
+      return Status::OK();
+    }
+    std::vector<std::pair<uint32_t, const Slice>> keys_;
+  };
+
+  void CreateKey(std::string* key_buf, size_t ts_sz) {
+    if (ts_sz > 0) {
+      AppendKeyWithMinTimestamp(key_buf, kTestKeyWithoutTs, ts_sz);
+    } else {
+      key_buf->assign(kTestKeyWithoutTs);
+    }
+  }
+
+  void CreateWriteBatch(const UnorderedMap<uint32_t, size_t>& ts_sz_for_batch,
+                        WriteBatch* batch) {
+    for (const auto& [cf_id, ts_sz] : ts_sz_for_batch) {
+      std::string key;
+      CreateKey(&key, ts_sz);
+      ASSERT_OK(WriteBatchInternal::Put(batch, cf_id, key, kValuePlaceHolder));
+      ASSERT_OK(WriteBatchInternal::Delete(batch, cf_id, key));
+      ASSERT_OK(WriteBatchInternal::SingleDelete(batch, cf_id, key));
+      ASSERT_OK(WriteBatchInternal::DeleteRange(batch, cf_id, key, key));
+      ASSERT_OK(
+          WriteBatchInternal::Merge(batch, cf_id, key, kValuePlaceHolder));
+      ASSERT_OK(WriteBatchInternal::PutBlobIndex(batch, cf_id, key,
+                                                 kValuePlaceHolder));
+    }
+  }
+
+  void CheckSequenceEqual(const WriteBatch& orig_batch,
+                          const WriteBatch& new_batch) {
+    ASSERT_EQ(WriteBatchInternal::Sequence(&orig_batch),
+              WriteBatchInternal::Sequence(&new_batch));
+  }
+  void CheckCountEqual(const WriteBatch& orig_batch,
+                       const WriteBatch& new_batch) {
+    ASSERT_EQ(WriteBatchInternal::Count(&orig_batch),
+              WriteBatchInternal::Count(&new_batch));
+  }
+
+  void VerifyKeys(
+      const std::vector<std::pair<uint32_t, const Slice>>& keys_with_ts,
+      const std::vector<std::pair<uint32_t, const Slice>>& keys_without_ts,
+      size_t ts_sz, std::optional<uint32_t> dropped_cf) {
+    ASSERT_EQ(keys_with_ts.size(), keys_without_ts.size());
+    const std::string kTsMin(ts_sz, static_cast<unsigned char>(0));
+    for (size_t i = 0; i < keys_with_ts.size(); i++) {
+      // TimestampRecoveryHandler ignores dropped column family and copy it over
+      // as is. Check the keys stay the same.
+      if (dropped_cf.has_value() &&
+          keys_with_ts[i].first == dropped_cf.value()) {
+        ASSERT_EQ(keys_with_ts[i].first, keys_without_ts[i].first);
+        ASSERT_EQ(keys_with_ts[i].second, keys_without_ts[i].second);
+        continue;
+      }
+      const Slice& key_with_ts = keys_with_ts[i].second;
+      const Slice& key_without_ts = keys_without_ts[i].second;
+      ASSERT_TRUE(key_with_ts.starts_with(key_without_ts));
+      ASSERT_EQ(key_with_ts.size() - key_without_ts.size(), ts_sz);
+      ASSERT_TRUE(key_with_ts.ends_with(kTsMin));
+    }
+  }
+
+  void CheckContentsWithTimestampStripping(const WriteBatch& orig_batch,
+                                           const WriteBatch& new_batch,
+                                           size_t ts_sz,
+                                           std::optional<uint32_t> dropped_cf) {
+    CheckSequenceEqual(orig_batch, new_batch);
+    CheckCountEqual(orig_batch, new_batch);
+    KeyCollector collector_for_orig_batch;
+    ASSERT_OK(orig_batch.Iterate(&collector_for_orig_batch));
+    KeyCollector collector_for_new_batch;
+    ASSERT_OK(new_batch.Iterate(&collector_for_new_batch));
+    VerifyKeys(collector_for_orig_batch.GetKeys(),
+               collector_for_new_batch.GetKeys(), ts_sz, dropped_cf);
+  }
+
+  void CheckContentsWithTimestampPadding(const WriteBatch& orig_batch,
+                                         const WriteBatch& new_batch,
+                                         size_t ts_sz) {
+    CheckSequenceEqual(orig_batch, new_batch);
+    CheckCountEqual(orig_batch, new_batch);
+    KeyCollector collector_for_orig_batch;
+    ASSERT_OK(orig_batch.Iterate(&collector_for_orig_batch));
+    KeyCollector collector_for_new_batch;
+    ASSERT_OK(new_batch.Iterate(&collector_for_new_batch));
+    VerifyKeys(collector_for_new_batch.GetKeys(),
+               collector_for_orig_batch.GetKeys(), ts_sz,
+               std::nullopt /* dropped_cf */);
+  }
+};
+
+TEST_F(HandleTimestampSizeDifferenceTest, AllColumnFamiliesConsistent) {
+  UnorderedMap<uint32_t, size_t> running_ts_sz = {{1, sizeof(uint64_t)},
+                                                  {2, 0}};
+  UnorderedMap<uint32_t, size_t> record_ts_sz = {{1, sizeof(uint64_t)}};
+  WriteBatch batch;
+  CreateWriteBatch(running_ts_sz, &batch);
+
+  // All `check_mode` pass with OK status and `batch` not checked or updated.
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kVerifyConsistency));
+  std::unique_ptr<WriteBatch> new_batch(nullptr);
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+  ASSERT_TRUE(new_batch.get() == nullptr);
+}
+
+TEST_F(HandleTimestampSizeDifferenceTest,
+       AllInconsistentColumnFamiliesDropped) {
+  UnorderedMap<uint32_t, size_t> running_ts_sz = {{2, 0}};
+  UnorderedMap<uint32_t, size_t> record_ts_sz = {{1, sizeof(uint64_t)},
+                                                 {3, sizeof(char)}};
+  WriteBatch batch;
+  CreateWriteBatch(record_ts_sz, &batch);
+
+  // All `check_mode` pass with OK status and `batch` not checked or updated.
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kVerifyConsistency));
+  std::unique_ptr<WriteBatch> new_batch(nullptr);
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+  ASSERT_TRUE(new_batch.get() == nullptr);
+}
+
+TEST_F(HandleTimestampSizeDifferenceTest, InvolvedColumnFamiliesConsistent) {
+  UnorderedMap<uint32_t, size_t> running_ts_sz = {{1, sizeof(uint64_t)},
+                                                  {2, sizeof(char)}};
+  UnorderedMap<uint32_t, size_t> record_ts_sz = {{1, sizeof(uint64_t)}};
+  WriteBatch batch;
+  CreateWriteBatch(record_ts_sz, &batch);
+
+  // All `check_mode` pass with OK status and `batch` not updated.
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kVerifyConsistency));
+  std::unique_ptr<WriteBatch> new_batch(nullptr);
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+  ASSERT_TRUE(new_batch.get() == nullptr);
+}
+
+TEST_F(HandleTimestampSizeDifferenceTest,
+       InconsistentColumnFamilyNeedsTimestampStripping) {
+  UnorderedMap<uint32_t, size_t> running_ts_sz = {{1, 0}, {2, sizeof(char)}};
+  UnorderedMap<uint32_t, size_t> record_ts_sz = {{1, sizeof(uint64_t)}};
+  WriteBatch batch;
+  CreateWriteBatch(record_ts_sz, &batch);
+
+  // kVerifyConsistency doesn't tolerate inconsistency for running column
+  // families.
+  ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
+                  &batch, running_ts_sz, record_ts_sz,
+                  TimestampSizeConsistencyMode::kVerifyConsistency)
+                  .IsInvalidArgument());
+
+  std::unique_ptr<WriteBatch> new_batch(nullptr);
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+  ASSERT_TRUE(new_batch.get() != nullptr);
+  CheckContentsWithTimestampStripping(batch, *new_batch, sizeof(uint64_t),
+                                      std::nullopt /* dropped_cf */);
+}
+
+TEST_F(HandleTimestampSizeDifferenceTest,
+       InconsistentColumnFamilyNeedsTimestampPadding) {
+  UnorderedMap<uint32_t, size_t> running_ts_sz = {{1, sizeof(uint64_t)}};
+  // Make `record_ts_sz` not contain zero timestamp size entries to follow the
+  // behavior of actual WAL log timestamp size record.
+  UnorderedMap<uint32_t, size_t> record_ts_sz;
+  WriteBatch batch;
+  CreateWriteBatch({{1, 0}}, &batch);
+
+  // kVerifyConsistency doesn't tolerate inconsistency for running column
+  // families.
+  ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
+                  &batch, running_ts_sz, record_ts_sz,
+                  TimestampSizeConsistencyMode::kVerifyConsistency)
+                  .IsInvalidArgument());
+
+  std::unique_ptr<WriteBatch> new_batch(nullptr);
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+  ASSERT_TRUE(new_batch.get() != nullptr);
+  CheckContentsWithTimestampPadding(batch, *new_batch, sizeof(uint64_t));
+}
+
+TEST_F(HandleTimestampSizeDifferenceTest,
+       InconsistencyReconcileCopyOverDroppedColumnFamily) {
+  UnorderedMap<uint32_t, size_t> running_ts_sz = {{1, 0}};
+  UnorderedMap<uint32_t, size_t> record_ts_sz = {{1, sizeof(uint64_t)},
+                                                 {2, sizeof(char)}};
+  WriteBatch batch;
+  CreateWriteBatch(record_ts_sz, &batch);
+  std::unique_ptr<WriteBatch> new_batch(nullptr);
+
+  // kReconcileInconsistency tolerate inconsistency for dropped column family
+  // and all related entries copied over to the new WriteBatch.
+  ASSERT_OK(HandleWriteBatchTimestampSizeDifference(
+      &batch, running_ts_sz, record_ts_sz,
+      TimestampSizeConsistencyMode::kReconcileInconsistency, &new_batch));
+
+  ASSERT_TRUE(new_batch.get() != nullptr);
+  CheckContentsWithTimestampStripping(batch, *new_batch, sizeof(uint64_t),
+                                      std::optional<uint32_t>(2));
+}
+
+TEST_F(HandleTimestampSizeDifferenceTest, UnrecoverableInconsistency) {
+  UnorderedMap<uint32_t, size_t> running_ts_sz = {{1, sizeof(char)}};
+  UnorderedMap<uint32_t, size_t> record_ts_sz = {{1, sizeof(uint64_t)}};
+  WriteBatch batch;
+  CreateWriteBatch(record_ts_sz, &batch);
+
+  ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
+                  &batch, running_ts_sz, record_ts_sz,
+                  TimestampSizeConsistencyMode::kVerifyConsistency)
+                  .IsInvalidArgument());
+
+  ASSERT_TRUE(HandleWriteBatchTimestampSizeDifference(
+                  &batch, running_ts_sz, record_ts_sz,
+                  TimestampSizeConsistencyMode::kReconcileInconsistency)
+                  .IsInvalidArgument());
+}
+
+TEST(ValidateUserDefinedTimestampsOptionsTest, EnableUserDefinedTimestamps) {
+  bool mark_sst_files = false;
+  const Comparator* new_comparator = test::BytewiseComparatorWithU64TsWrapper();
+  const Comparator* old_comparator = BytewiseComparator();
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      new_comparator, std::string(old_comparator->Name()),
+      false /*new_persist_udt*/, true /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_TRUE(mark_sst_files);
+
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      new_comparator, std::string(old_comparator->Name()),
+      false /*new_persist_udt*/, false /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_TRUE(mark_sst_files);
+}
+
+TEST(ValidateUserDefinedTimestampsOptionsTest,
+     EnableUserDefinedTimestampsNewPersistUDTFlagIncorrect) {
+  bool mark_sst_files = false;
+  const Comparator* new_comparator = test::BytewiseComparatorWithU64TsWrapper();
+  const Comparator* old_comparator = BytewiseComparator();
+  ASSERT_TRUE(ValidateUserDefinedTimestampsOptions(
+                  new_comparator, std::string(old_comparator->Name()),
+                  true /*new_persist_udt*/, true /*old_persist_udt*/,
+                  &mark_sst_files)
+                  .IsInvalidArgument());
+  ASSERT_TRUE(ValidateUserDefinedTimestampsOptions(
+                  new_comparator, std::string(old_comparator->Name()),
+                  true /*new_persist_udt*/, false /*old_persist_udt*/,
+                  &mark_sst_files)
+                  .IsInvalidArgument());
+}
+
+TEST(ValidateUserDefinedTimestampsOptionsTest, DisableUserDefinedTimestamps) {
+  bool mark_sst_files = false;
+  const Comparator* new_comparator = ReverseBytewiseComparator();
+  const Comparator* old_comparator =
+      test::ReverseBytewiseComparatorWithU64TsWrapper();
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      new_comparator, std::string(old_comparator->Name()),
+      false /*new_persist_udt*/, false /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      new_comparator, std::string(old_comparator->Name()),
+      true /*new_persist_udt*/, false /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+}
+
+TEST(ValidateUserDefinedTimestampsOptionsTest,
+     DisableUserDefinedTimestampsOldPersistUDTFlagIncorrect) {
+  bool mark_sst_files = false;
+  const Comparator* new_comparator = BytewiseComparator();
+  const Comparator* old_comparator = test::BytewiseComparatorWithU64TsWrapper();
+  ASSERT_TRUE(ValidateUserDefinedTimestampsOptions(
+                  new_comparator, std::string(old_comparator->Name()),
+                  false /*new_persist_udt*/, true /*old_persist_udt*/,
+                  &mark_sst_files)
+                  .IsInvalidArgument());
+  ASSERT_TRUE(ValidateUserDefinedTimestampsOptions(
+                  new_comparator, std::string(old_comparator->Name()),
+                  true /*new_persist_udt*/, true /*old_persist_udt*/,
+                  &mark_sst_files)
+                  .IsInvalidArgument());
+}
+
+TEST(ValidateUserDefinedTimestampsOptionsTest, UserComparatorUnchanged) {
+  bool mark_sst_files = false;
+  const Comparator* ucmp_without_ts = BytewiseComparator();
+  const Comparator* ucmp_with_ts = test::BytewiseComparatorWithU64TsWrapper();
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      ucmp_without_ts, std::string(ucmp_without_ts->Name()),
+      false /*new_persist_udt*/, false /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      ucmp_without_ts, std::string(ucmp_without_ts->Name()),
+      true /*new_persist_udt*/, true /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      ucmp_without_ts, std::string(ucmp_without_ts->Name()),
+      true /*new_persist_udt*/, false /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      ucmp_without_ts, std::string(ucmp_without_ts->Name()),
+      false /*new_persist_udt*/, true /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      ucmp_with_ts, std::string(ucmp_with_ts->Name()), true /*new_persist_udt*/,
+      true /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+  ASSERT_OK(ValidateUserDefinedTimestampsOptions(
+      ucmp_with_ts, std::string(ucmp_with_ts->Name()),
+      false /*new_persist_udt*/, false /*old_persist_udt*/, &mark_sst_files));
+  ASSERT_FALSE(mark_sst_files);
+  ASSERT_TRUE(ValidateUserDefinedTimestampsOptions(
+                  ucmp_with_ts, std::string(ucmp_with_ts->Name()),
+                  true /*new_persist_udt*/, false /*old_persist_udt*/,
+                  &mark_sst_files)
+                  .IsInvalidArgument());
+  ASSERT_TRUE(ValidateUserDefinedTimestampsOptions(
+                  ucmp_with_ts, std::string(ucmp_with_ts->Name()),
+                  false /*new_persist_udt*/, true /*old_persist_udt*/,
+                  &mark_sst_files)
+                  .IsInvalidArgument());
+}
+
+TEST(ValidateUserDefinedTimestampsOptionsTest, InvalidUserComparatorChange) {
+  bool mark_sst_files = false;
+  const Comparator* new_comparator = BytewiseComparator();
+  const Comparator* old_comparator = ReverseBytewiseComparator();
+  ASSERT_TRUE(ValidateUserDefinedTimestampsOptions(
+                  new_comparator, std::string(old_comparator->Name()),
+                  false /*new_persist_udt*/, true /*old_persist_udt*/,
+                  &mark_sst_files)
+                  .IsInvalidArgument());
+}
+
+TEST(GetFullHistoryTsLowFromU64CutoffTsTest, Success) {
+  std::string cutoff_ts;
+  uint64_t cutoff_ts_int = 3;
+  PutFixed64(&cutoff_ts, 3);
+  Slice cutoff_ts_slice = cutoff_ts;
+  std::string actual_full_history_ts_low;
+  GetFullHistoryTsLowFromU64CutoffTs(&cutoff_ts_slice,
+                                     &actual_full_history_ts_low);
+
+  std::string expected_ts_low;
+  PutFixed64(&expected_ts_low, cutoff_ts_int + 1);
+  ASSERT_EQ(expected_ts_low, actual_full_history_ts_low);
+}
+}  // namespace ROCKSDB_NAMESPACE
+
+int main(int argc, char** argv) {
+  ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}