@nxtedition/rocksdb 15.4.0 → 15.5.0

package/deps/rocksdb/rocksdb/db/c_test.c

@@ -3596,6 +3596,14 @@ int main(int argc, char** argv) {
         100000 ==
         rocksdb_fifo_compaction_options_get_max_table_files_size(fco));
 
+    rocksdb_fifo_compaction_options_set_max_data_files_size(fco, 200000);
+    CheckCondition(
+        200000 == rocksdb_fifo_compaction_options_get_max_data_files_size(fco));
+
+    rocksdb_fifo_compaction_options_set_use_kv_ratio_compaction(fco, 1);
+    CheckCondition(
+        1 == rocksdb_fifo_compaction_options_get_use_kv_ratio_compaction(fco));
+
     rocksdb_fifo_compaction_options_destroy(fco);
   }
 
@@ -4447,7 +4455,7 @@ int main(int argc, char** argv) {
 
   StartPhase("statistics");
   {
-    const uint32_t BYTES_WRITTEN_TICKER = 60;
+    const uint32_t BYTES_WRITTEN_TICKER = 61;
     const uint32_t DB_WRITE_HIST = 1;
 
     rocksdb_statistics_histogram_data_t* hist =
@@ -4717,9 +4725,86 @@ int main(int argc, char** argv) {
     rocksdb_compaction_service_options_override_set_comparator(override_opts,
                                                                cmp);
 
+    // Test file checksum gen factory
+    rocksdb_file_checksum_gen_factory_t* checksum_factory =
+        rocksdb_file_checksum_gen_crc32c_factory_create();
+    CheckCondition(checksum_factory != NULL);
+    rocksdb_compaction_service_options_override_set_file_checksum_gen_factory(
+        override_opts, checksum_factory);
+
+    // Test SST partitioner factory
+    rocksdb_sst_partitioner_factory_t* partitioner_factory =
+        rocksdb_sst_partitioner_fixed_prefix_factory_create(4);
+    CheckCondition(partitioner_factory != NULL);
+    rocksdb_compaction_service_options_override_set_sst_partitioner_factory(
+        override_opts, partitioner_factory);
+
+    // Test merge operator
+    rocksdb_compaction_service_options_override_set_merge_operator(
+        override_opts, NULL);
+
+    // Test compaction filter
+    rocksdb_compaction_service_options_override_set_compaction_filter(
+        override_opts, NULL);
+
+    // Test prefix extractor
+    rocksdb_compaction_service_options_override_set_prefix_extractor(
+        override_opts, NULL);
+
+    // Test table factory - block based
+    rocksdb_block_based_table_options_t* table_opts =
+        rocksdb_block_based_options_create();
+    rocksdb_compaction_service_options_override_set_block_based_table_factory(
+        override_opts, table_opts);
+    rocksdb_block_based_options_destroy(table_opts);
+
+    // Test statistics via options
+    rocksdb_options_t* stats_opts = rocksdb_options_create();
+    rocksdb_options_enable_statistics(stats_opts);
+    rocksdb_compaction_service_options_override_set_statistics(override_opts,
+                                                               stats_opts);
+    rocksdb_options_destroy(stats_opts);
+
+    // Test info log
+    rocksdb_logger_t* logger =
+        rocksdb_logger_create_stderr_logger(1, "test_prefix");
+    rocksdb_compaction_service_options_override_set_info_log(override_opts,
+                                                             logger);
+    rocksdb_logger_destroy(logger);
+
+    // Test options map
+    rocksdb_compaction_service_options_override_set_option(
+        override_opts, "max_bytes_for_level_base", "67108864");
+
+    // Cleanup
+    rocksdb_file_checksum_gen_factory_destroy(checksum_factory);
+    rocksdb_sst_partitioner_factory_destroy(partitioner_factory);
     rocksdb_compaction_service_options_override_destroy(override_opts);
   }
 
+  StartPhase("factory_options_on_regular_options");
+  {
+    // Test that the new factory types work with regular rocksdb_options_t
+    rocksdb_options_t* test_opts = rocksdb_options_create();
+
+    // Test file checksum gen factory on regular options
+    rocksdb_file_checksum_gen_factory_t* checksum_factory =
+        rocksdb_file_checksum_gen_crc32c_factory_create();
+    CheckCondition(checksum_factory != NULL);
+    rocksdb_options_set_file_checksum_gen_factory(test_opts, checksum_factory);
+
+    // Test SST partitioner factory on regular options
+    rocksdb_sst_partitioner_factory_t* partitioner_factory =
+        rocksdb_sst_partitioner_fixed_prefix_factory_create(8);
+    CheckCondition(partitioner_factory != NULL);
+    rocksdb_options_set_sst_partitioner_factory(test_opts, partitioner_factory);
+
+    // Cleanup
+    rocksdb_file_checksum_gen_factory_destroy(checksum_factory);
+    rocksdb_sst_partitioner_factory_destroy(partitioner_factory);
+    rocksdb_options_destroy(test_opts);
+  }
+
   StartPhase("remote_compaction_null_callback_handling");
   {
     // Test that NULL callback returns are handled gracefully
@@ -4795,6 +4880,21 @@ int main(int argc, char** argv) {
     rocksdb_sst_file_manager_destroy(sst_file_manager);
   }
 
+  StartPhase("create_column_family_error_returns_null");
+  {
+    // Creating a column family with a name that already exists should fail
+    // and return NULL. Without the fix, the handle is leaked and a non-NULL
+    // pointer with an indeterminate rep field is returned.
+    char* cf_err = NULL;
+    rocksdb_column_family_handle_t* cf_handle =
+        rocksdb_create_column_family(db, options, "default", &cf_err);
+    // Should have an error since "default" already exists
+    CheckCondition(cf_err != NULL);
+    // The handle should be NULL on error (this is the bug fix)
+    CheckCondition(cf_handle == NULL);
+    free(cf_err);
+  }
+
   StartPhase("cancel_all_background_work");
   rocksdb_cancel_all_background_work(db, 1);
 

package/deps/rocksdb/rocksdb/db/column_family.cc

@@ -401,7 +401,13 @@ ColumnFamilyOptions SanitizeCfOptions(const ImmutableDBOptions& db_options,
   }
 
   if (result.max_compaction_bytes == 0) {
-    result.max_compaction_bytes = result.target_file_size_base * 25;
+    // For FIFO with use_kv_ratio_compaction, leave max_compaction_bytes as 0
+    // to signal "auto-calculate target from capacity and SST/blob ratio."
+    // When explicitly set by the user, it overrides the auto-calculated target.
+    if (result.compaction_style != kCompactionStyleFIFO ||
+        !result.compaction_options_fifo.use_kv_ratio_compaction) {
+      result.max_compaction_bytes = result.target_file_size_base * 25;
+    }
   }
 
   bool is_block_based_table = (result.table_factory->IsInstanceOf(
@@ -1248,7 +1254,7 @@ Compaction* ColumnFamilyData::PickCompaction(
   auto* result = compaction_picker_->PickCompaction(
       GetName(), mutable_options, mutable_db_options, existing_snapshots,
       snapshot_checker, current_->storage_info(), log_buffer,
-      require_max_output_level);
+      GetFullHistoryTsLow(), require_max_output_level);
   if (result != nullptr) {
     result->FinalizeInputInfo(current_);
   }
@@ -1336,7 +1342,7 @@ Compaction* ColumnFamilyData::CompactRange(
       GetName(), mutable_cf_options, mutable_db_options,
       current_->storage_info(), input_level, output_level,
       compact_range_options, begin, end, compaction_end, conflict,
-      max_file_num_to_ignore, trim_ts);
+      max_file_num_to_ignore, trim_ts, GetFullHistoryTsLow());
   if (result != nullptr) {
     result->FinalizeInputInfo(current_);
   }
@@ -1563,6 +1569,28 @@ Status ColumnFamilyData::ValidateOptions(
         "FIFO compaction only supported with max_open_files = -1.");
   }
 
+  if (db_options.open_files_async) {
+    // FIFO TTL picker relies on reading the files table properties inside a
+    // DB mutex. This can be slow if files are opened asynchronously, so we
+    // disable it.
+    //
+    // TODO: consider blocking fifo compaction until async file open task
+    // completes.
+    if (cf_options.compaction_style == kCompactionStyleFIFO) {
+      return Status::NotSupported(
+          "FIFO compaction is not supported with open_files_async = true.");
+    }
+    // Open files async is not useful if skip_stats_update_on_db_open=true
+    // because DB open will still block on IO.
+    //
+    // TODO: consider moving stats update inside async file open background
+    // task.
+    if (!db_options.skip_stats_update_on_db_open) {
+      return Status::InvalidArgument(
+          "open_files_async requires skip_stats_update_on_db_open = true.");
+    }
+  }
+
   std::vector<uint32_t> supported{0, 1, 2, 4, 8};
   if (std::find(supported.begin(), supported.end(),
                 cf_options.memtable_protection_bytes_per_key) ==

package/deps/rocksdb/rocksdb/db/column_family_test.cc

@@ -118,8 +118,7 @@ class ColumnFamilyTestBase : public testing::Test {
 
     for (int i = 0; i < n; i++) {
       if (flush_every != 0 && i != 0 && i % flush_every == 0) {
-        DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-        dbi->TEST_FlushMemTable();
+        dbfull()->TEST_FlushMemTable();
       }
 
       int keyi = base + i;
@@ -177,8 +176,7 @@ class ColumnFamilyTestBase : public testing::Test {
     }
     handles_.clear();
     names_.clear();
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
   }
 
   Status TryOpen(std::vector<std::string> cf,
@@ -218,7 +216,7 @@ class ColumnFamilyTestBase : public testing::Test {
 
   void Open() { Open({"default"}); }
 
-  DBImpl* dbfull() { return static_cast_with_check<DBImpl>(db_); }
+  DBImpl* dbfull() { return static_cast_with_check<DBImpl>(db_.get()); }
 
   int GetProperty(int cf, std::string property) {
     std::string value;
@@ -500,7 +498,7 @@ class ColumnFamilyTestBase : public testing::Test {
   ColumnFamilyOptions column_family_options_;
   DBOptions db_options_;
   std::string dbname_;
-  DB* db_ = nullptr;
+  std::unique_ptr<DB> db_;
   EnvCounter* env_;
   std::shared_ptr<Env> env_guard_;
   Random rnd_;
@@ -517,7 +515,7 @@ class ColumnFamilyTest
 INSTANTIATE_TEST_CASE_P(FormatDef, ColumnFamilyTest,
                         testing::Values(test::kDefaultFormatVersion));
 INSTANTIATE_TEST_CASE_P(FormatLatest, ColumnFamilyTest,
-                        testing::Values(kLatestFormatVersion));
+                        testing::Values(kLatestBbtFormatVersion));
 
 TEST_P(ColumnFamilyTest, DontReuseColumnFamilyID) {
   for (int iter = 0; iter < 3; ++iter) {
@@ -707,8 +705,8 @@ INSTANTIATE_TEST_CASE_P(
                     std::make_tuple(test::kDefaultFormatVersion, false)));
 INSTANTIATE_TEST_CASE_P(
     FormatLatest, FlushEmptyCFTestWithParam,
-    testing::Values(std::make_tuple(kLatestFormatVersion, true),
-                    std::make_tuple(kLatestFormatVersion, false)));
+    testing::Values(std::make_tuple(kLatestBbtFormatVersion, true),
+                    std::make_tuple(kLatestBbtFormatVersion, false)));
 
 TEST_P(ColumnFamilyTest, AddDrop) {
   Open();
@@ -3542,11 +3540,10 @@ TEST_P(ColumnFamilyTest, MultipleCFPathsTest) {
 
   // Re-open and verify the keys.
   Reopen({ColumnFamilyOptions(), cf_opt1, cf_opt2});
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
   for (int cf = 1; cf != 3; ++cf) {
     ReadOptions read_options;
     read_options.readahead_size = 0;
-    auto it = dbi->NewIterator(read_options, handles_[cf]);
+    auto it = db_->NewIterator(read_options, handles_[cf]);
     for (it->SeekToFirst(); it->Valid(); it->Next()) {
       ASSERT_OK(it->status());
       Slice key(it->key());
@@ -3636,7 +3633,7 @@ TEST(ColumnFamilyTest, ValidateMemtableKVChecksumOption) {
 // the behavior of manual flush is that it skips retaining UDTs.
 class ColumnFamilyRetainUDTTest : public ColumnFamilyTestBase {
  public:
-  ColumnFamilyRetainUDTTest() : ColumnFamilyTestBase(kLatestFormatVersion) {}
+  ColumnFamilyRetainUDTTest() : ColumnFamilyTestBase(kLatestBbtFormatVersion) {}
 
   void SetUp() override {
     db_options_.allow_concurrent_memtable_write = false;
@@ -3886,7 +3883,7 @@ TEST_F(ManualFlushSkipRetainUDTTest, FlushRemovesStaleEntries) {
       static_cast_with_check<ColumnFamilyHandleImpl>(cfh)->cfd();
   for (int version = 0; version < 100; version++) {
     if (version == 50) {
-      ASSERT_OK(static_cast_with_check<DBImpl>(db_)->TEST_SwitchMemtable(cfd));
+      ASSERT_OK(dbfull()->TEST_SwitchMemtable(cfd));
     }
     ASSERT_OK(
         Put(0, "foo", EncodeAsUint64(version), "v" + std::to_string(version)));

package/deps/rocksdb/rocksdb/db/compact_files_test.cc

@@ -75,10 +75,9 @@ TEST_F(CompactFilesTest, L0ConflictsFiles) {
   options.level0_file_num_compaction_trigger = kLevel0Trigger;
   options.compression = kNoCompression;
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
-  Status s = DB::Open(options, db_name_, &db);
-  assert(s.ok());
+  ASSERT_OK(DB::Open(options, db_name_, &db));
   assert(db);
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency({
@@ -114,7 +113,6 @@ TEST_F(CompactFilesTest, L0ConflictsFiles) {
     }
   }
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  delete db;
 }
 
 TEST_F(CompactFilesTest, MultipleLevel) {
@@ -128,11 +126,11 @@ TEST_F(CompactFilesTest, MultipleLevel) {
   FlushedFileCollector* collector = new FlushedFileCollector();
   options.listeners.emplace_back(collector);
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
-  ASSERT_NE(db, nullptr);
+  ASSERT_NE(db.get(), nullptr);
 
   // create couple files in L0, L3, L4 and L5
   for (int i = 5; i > 2; --i) {
@@ -141,7 +139,8 @@ TEST_F(CompactFilesTest, MultipleLevel) {
     ASSERT_OK(db->Flush(FlushOptions()));
     // Ensure background work is fully finished including listener callbacks
     // before accessing listener state.
-    ASSERT_OK(static_cast_with_check<DBImpl>(db)->TEST_WaitForBackgroundWork());
+    ASSERT_OK(
+        static_cast_with_check<DBImpl>(db.get())->TEST_WaitForBackgroundWork());
     auto l0_files = collector->GetFlushedFiles();
     ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files, i));
 
@@ -191,8 +190,6 @@ TEST_F(CompactFilesTest, MultipleLevel) {
   ASSERT_OK(db->CompactFiles(CompactionOptions(), files, 5));
   SyncPoint::GetInstance()->DisableProcessing();
   thread.join();
-
-  delete db;
 }
 
 TEST_F(CompactFilesTest, ObsoleteFiles) {
@@ -212,11 +209,11 @@ TEST_F(CompactFilesTest, ObsoleteFiles) {
   FlushedFileCollector* collector = new FlushedFileCollector();
   options.listeners.emplace_back(collector);
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
-  ASSERT_NE(db, nullptr);
+  ASSERT_NE(db.get(), nullptr);
 
   // create couple files
   for (int i = 1000; i < 2000; ++i) {
@@ -226,13 +223,12 @@ TEST_F(CompactFilesTest, ObsoleteFiles) {
 
   auto l0_files = collector->GetFlushedFiles();
   ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files, 1));
-  ASSERT_OK(static_cast_with_check<DBImpl>(db)->TEST_WaitForCompact());
+  ASSERT_OK(static_cast_with_check<DBImpl>(db.get())->TEST_WaitForCompact());
 
   // verify all compaction input files are deleted
   for (const auto& fname : l0_files) {
     ASSERT_EQ(Status::NotFound(), env_->FileExists(fname));
   }
-  delete db;
 }
 
 TEST_F(CompactFilesTest, NotCutOutputOnLevel0) {
@@ -251,10 +247,9 @@ TEST_F(CompactFilesTest, NotCutOutputOnLevel0) {
   FlushedFileCollector* collector = new FlushedFileCollector();
   options.listeners.emplace_back(collector);
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
-  Status s = DB::Open(options, db_name_, &db);
-  assert(s.ok());
+  ASSERT_OK(DB::Open(options, db_name_, &db));
   assert(db);
 
   // create couple files
@@ -262,19 +257,20 @@ TEST_F(CompactFilesTest, NotCutOutputOnLevel0) {
     ASSERT_OK(db->Put(WriteOptions(), std::to_string(i),
                       std::string(1000, 'a' + (i % 26))));
   }
-  ASSERT_OK(static_cast_with_check<DBImpl>(db)->TEST_WaitForFlushMemTable());
+  ASSERT_OK(
+      static_cast_with_check<DBImpl>(db.get())->TEST_WaitForFlushMemTable());
   auto l0_files_1 = collector->GetFlushedFiles();
   collector->ClearFlushedFiles();
   for (int i = 0; i < 500; ++i) {
     ASSERT_OK(db->Put(WriteOptions(), std::to_string(i),
                       std::string(1000, 'a' + (i % 26))));
   }
-  ASSERT_OK(static_cast_with_check<DBImpl>(db)->TEST_WaitForFlushMemTable());
+  ASSERT_OK(
+      static_cast_with_check<DBImpl>(db.get())->TEST_WaitForFlushMemTable());
   auto l0_files_2 = collector->GetFlushedFiles();
   ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files_1, 0));
   ASSERT_OK(db->CompactFiles(CompactionOptions(), l0_files_2, 0));
   // no assertion failure
-  delete db;
 }
 
 TEST_F(CompactFilesTest, CapturingPendingFiles) {
@@ -289,7 +285,7 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) {
   FlushedFileCollector* collector = new FlushedFileCollector();
   options.listeners.emplace_back(collector);
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
@@ -303,7 +299,8 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) {
 
   // Ensure background work is fully finished including listener callbacks
   // before accessing listener state.
-  ASSERT_OK(static_cast_with_check<DBImpl>(db)->TEST_WaitForBackgroundWork());
+  ASSERT_OK(
+      static_cast_with_check<DBImpl>(db.get())->TEST_WaitForBackgroundWork());
   auto l0_files = collector->GetFlushedFiles();
   EXPECT_EQ(5, l0_files.size());
 
@@ -327,13 +324,12 @@ TEST_F(CompactFilesTest, CapturingPendingFiles) {
 
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
 
-  delete db;
+  db.reset();
 
   // Make sure we can reopen the DB.
   s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
   assert(db);
-  delete db;
 }
 
 TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
@@ -365,12 +361,12 @@ TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
   options.create_if_missing = true;
   options.compaction_filter = cf.get();
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
 
-  cf->SetDB(db);
+  cf->SetDB(db.get());
 
   // Write one L0 file
   ASSERT_OK(db->Put(WriteOptions(), "K1", "V1"));
@@ -384,8 +380,6 @@ TEST_F(CompactFilesTest, CompactionFilterWithGetSv) {
     ASSERT_OK(
         db->CompactFiles(ROCKSDB_NAMESPACE::CompactionOptions(), {fname}, 0));
   }
-
-  delete db;
 }
 
 TEST_F(CompactFilesTest, SentinelCompressionType) {
@@ -413,7 +407,7 @@ TEST_F(CompactFilesTest, SentinelCompressionType) {
     options.create_if_missing = true;
     FlushedFileCollector* collector = new FlushedFileCollector();
     options.listeners.emplace_back(collector);
-    DB* db = nullptr;
+    std::unique_ptr<DB> db;
     ASSERT_OK(DB::Open(options, db_name_, &db));
 
     ASSERT_OK(db->Put(WriteOptions(), "key", "val"));
@@ -421,7 +415,8 @@ TEST_F(CompactFilesTest, SentinelCompressionType) {
 
     // Ensure background work is fully finished including listener callbacks
     // before accessing listener state.
-    ASSERT_OK(static_cast_with_check<DBImpl>(db)->TEST_WaitForBackgroundWork());
+    ASSERT_OK(
+        static_cast_with_check<DBImpl>(db.get())->TEST_WaitForBackgroundWork());
     auto l0_files = collector->GetFlushedFiles();
     ASSERT_EQ(1, l0_files.size());
 
@@ -433,10 +428,10 @@ TEST_F(CompactFilesTest, SentinelCompressionType) {
     ROCKSDB_NAMESPACE::TablePropertiesCollection all_tables_props;
     ASSERT_OK(db->GetPropertiesOfAllTables(&all_tables_props));
     for (const auto& name_and_table_props : all_tables_props) {
-      ASSERT_EQ(CompressionTypeToString(CompressionType::kZlibCompression),
-                name_and_table_props.second->compression_name);
+      // As of format_version 7, more elaborate information is encoded into the
+      // compression_name property
+      ASSERT_EQ("BuiltinV2;02;", name_and_table_props.second->compression_name);
     }
-    delete db;
   }
 }
 
@@ -461,11 +456,7 @@ TEST_F(CompactFilesTest, CompressionWithBlockAlign) {
   }
 
   std::unique_ptr<DB> db;
-  {
-    DB* _db = nullptr;
-    ASSERT_OK(DB::Open(options, db_name_, &_db));
-    db.reset(_db);
-  }
+  ASSERT_OK(DB::Open(options, db_name_, &db));
 
   ASSERT_OK(db->Put(WriteOptions(), "key", "val"));
   ASSERT_OK(db->Flush(FlushOptions()));
@@ -504,7 +495,7 @@ TEST_F(CompactFilesTest, GetCompactionJobInfo) {
   FlushedFileCollector* collector = new FlushedFileCollector();
   options.listeners.emplace_back(collector);
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
@@ -515,7 +506,8 @@ TEST_F(CompactFilesTest, GetCompactionJobInfo) {
     ASSERT_OK(db->Put(WriteOptions(), std::to_string(i),
                       std::string(1000, 'a' + (i % 26))));
   }
-  ASSERT_OK(static_cast_with_check<DBImpl>(db)->TEST_WaitForFlushMemTable());
+  ASSERT_OK(
+      static_cast_with_check<DBImpl>(db.get())->TEST_WaitForFlushMemTable());
   auto l0_files_1 = collector->GetFlushedFiles();
   CompactionOptions co;
   co.compression = CompressionType::kLZ4Compression;
@@ -531,7 +523,6 @@ TEST_F(CompactFilesTest, GetCompactionJobInfo) {
   ASSERT_EQ(compaction_job_info.output_level, 0);
   ASSERT_OK(compaction_job_info.status);
   // no assertion failure
-  delete db;
 }
 
 // Helper function to generate zero-padded keys
@@ -547,11 +538,11 @@ TEST_F(CompactFilesTest, TrivialMoveNonOverlappingFiles) {
   options.compression = kNoCompression;
   options.level_compaction_dynamic_level_bytes = false;
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
-  ASSERT_NE(db, nullptr);
+  ASSERT_NE(db.get(), nullptr);
 
   // Create 3 non-overlapping files in L0
   // File 1: keys [a00-a99]
@@ -664,8 +655,6 @@ TEST_F(CompactFilesTest, TrivialMoveNonOverlappingFiles) {
     ASSERT_OK(db->Get(ReadOptions(), key, &value));
     ASSERT_EQ(value, "value_" + key);
   }
-
-  delete db;
 }
 
 TEST_F(CompactFilesTest, TrivialMoveBlockedByOverlap) {
@@ -676,11 +665,11 @@ TEST_F(CompactFilesTest, TrivialMoveBlockedByOverlap) {
   options.level_compaction_dynamic_level_bytes = false;
   options.num_levels = 7;
 
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DestroyDB(db_name_, options));
   Status s = DB::Open(options, db_name_, &db);
   ASSERT_OK(s);
-  ASSERT_NE(db, nullptr);
+  ASSERT_NE(db.get(), nullptr);
 
   // Create a file in L6 with keys [m00-m99] (wide range)
   for (int i = 0; i < 100; i++) {
@@ -756,8 +745,6 @@ TEST_F(CompactFilesTest, TrivialMoveBlockedByOverlap) {
     ASSERT_OK(db->Get(ReadOptions(), key, &value));
     ASSERT_EQ(value, "updated_value_" + key);
   }
-
-  delete db;
 }
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/compaction/compaction_iterator.cc

@@ -1310,14 +1310,14 @@ void CompactionIterator::PrepareOutput() {
             validity_info_.rep);
         assert(false);
       }
-      ikey_.sequence = 0;
-      last_key_seq_zeroed_ = true;
-      TEST_SYNC_POINT_CALLBACK("CompactionIterator::PrepareOutput:ZeroingSeq",
-                               &ikey_);
+
+      bool zeroed_seqno = false;
       if (!timestamp_size_) {
         current_key_.UpdateInternalKey(0, ikey_.type);
+        zeroed_seqno = true;
       } else if (full_history_ts_low_ && cmp_with_history_ts_low_ < 0) {
-        // We can also zero out timestamp for better compression.
+        // For UDT, the seqno and timestamp could only be zeroed out after the
+        // key is below history_ts_low_.
         // For the same user key (excluding timestamp), the timestamp-based
         // history can be collapsed to save some space if the timestamp is
         // older than *full_history_ts_low_.
@@ -1325,6 +1325,14 @@ void CompactionIterator::PrepareOutput() {
         const Slice ts_slice = kTsMin;
         ikey_.SetTimestamp(ts_slice);
         current_key_.UpdateInternalKey(0, ikey_.type, &ts_slice);
+        zeroed_seqno = true;
+      }
+
+      if (zeroed_seqno) {
+        ikey_.sequence = 0;
+        last_key_seq_zeroed_ = true;
+        TEST_SYNC_POINT_CALLBACK("CompactionIterator::PrepareOutput:ZeroingSeq",
+                                 &ikey_);
       }
     }
   }