@nxtedition/rocksdb 15.4.1 → 16.0.0

package/deps/rocksdb/rocksdb/utilities/backup/backup_engine_test.cc

@@ -758,8 +758,8 @@ class BackupEngineTest : public testing::Test {
     ASSERT_OK(CreateLoggerFromOptions(dbname_, logger_options, &logger_));
   }
 
-  DB* OpenDB() {
-    DB* db;
+  std::unique_ptr<DB> OpenDB() {
+    std::unique_ptr<DB> db;
     EXPECT_OK(DB::Open(options_, dbname_, &db));
     return db;
   }
@@ -770,13 +770,11 @@ class BackupEngineTest : public testing::Test {
 
     // Open DB
     test_db_fs_->SetLimitWrittenFiles(1000000);
-    DB* db;
     if (read_only) {
-      ASSERT_OK(DB::OpenForReadOnly(options_, dbname_, &db));
+      ASSERT_OK(DB::OpenForReadOnly(options_, dbname_, &db_));
     } else {
-      ASSERT_OK(DB::Open(options_, dbname_, &db));
+      ASSERT_OK(DB::Open(options_, dbname_, &db_));
     }
-    db_.reset(db);
   }
 
   void InitializeDBAndBackupEngine(bool dummy = false) {
@@ -784,14 +782,12 @@ class BackupEngineTest : public testing::Test {
     test_db_fs_->SetLimitWrittenFiles(1000000);
     test_db_fs_->SetDummySequentialFile(dummy);
 
-    DB* db;
     if (dummy) {
       dummy_db_ = new DummyDB(options_, dbname_);
-      db = dummy_db_;
+      db_.reset(dummy_db_);
     } else {
-      ASSERT_OK(DB::Open(options_, dbname_, &db));
+      ASSERT_OK(DB::Open(options_, dbname_, &db_));
     }
-    db_.reset(db);
   }
 
   virtual void OpenDBAndBackupEngine(
@@ -914,13 +910,13 @@ class BackupEngineTest : public testing::Test {
       ASSERT_OK(backup_engine_->RestoreDBFromLatestBackup(dbname_, dbname_,
                                                           restore_options));
     }
-    DB* db = OpenDB();
+    auto db = OpenDB();
     // Check DB contents
-    AssertExists(db, start_exist, end_exist);
+    AssertExists(db.get(), start_exist, end_exist);
     if (end != 0) {
-      AssertEmpty(db, end_exist, end);
+      AssertEmpty(db.get(), end_exist, end);
     }
-    delete db;
+    db.reset();
     if (opened_backup_engine) {
       CloseBackupEngine();
     }
@@ -1063,6 +1059,7 @@ class BackupEngineTest : public testing::Test {
   // all the dbs!
   DummyDB* dummy_db_;  // owned as db_ when present
   std::unique_ptr<DB> db_;
+  DBImpl* dbfull() { return static_cast_with_check<DBImpl>(db_.get()); }
   std::unique_ptr<BackupEngine> backup_engine_;
 
   // options
@@ -1203,7 +1200,7 @@ TEST_F(BackupEngineTest, IncrementalRestore) {
     // Since we started with a blank db, restore copied all the files.
     test_db_fs_->AssertWrittenFiles(all_files);
 
-    db_.reset(OpenDB());
+    db_ = OpenDB();
 
     // Check DB contents.
     AssertExists(db_.get(), 0, keys_iteration * 2);
@@ -1255,7 +1252,7 @@ TEST_F(BackupEngineTest, IncrementalRestore) {
     test_db_fs_->AssertWrittenFiles(should_have_written);
 
     // Check DB contents.
-    db_.reset(OpenDB());
+    db_ = OpenDB();
     AssertExists(db_.get(), 0, keys_iteration * 2);
 
     db_.reset();  // Close DB.
@@ -1307,7 +1304,7 @@ TEST_F(BackupEngineTest, IncrementalRestore) {
     // 'Hole' has been patched, 'in-policy' db files were retained.
     test_db_fs_->AssertWrittenFiles(should_have_written);
 
-    db_.reset(OpenDB());
+    db_ = OpenDB();
     Status s = db_->VerifyChecksum();
 
     // Check DB contents.
@@ -1424,9 +1421,9 @@ TEST_P(BackupEngineTestWithParam, OfflineIntegrationTest) {
       DestroyDBWithoutCheck(dbname_, options_);
 
       // ---- make sure it's empty ----
-      DB* db = OpenDB();
-      AssertEmpty(db, 0, fill_up_to);
-      delete db;
+      auto db = OpenDB();
+      AssertEmpty(db.get(), 0, fill_up_to);
+      db.reset();
 
       // ---- restore the DB ----
       OpenBackupEngine();
@@ -1478,9 +1475,9 @@ TEST_P(BackupEngineTestWithParam, OnlineIntegrationTest) {
   DestroyDBWithoutCheck(dbname_, options_);
 
   // ---- make sure it's empty ----
-  DB* db = OpenDB();
-  AssertEmpty(db, 0, max_key);
-  delete db;
+  auto db = OpenDB();
+  AssertEmpty(db.get(), 0, max_key);
+  db.reset();
 
   // ---- restore every backup and verify all the data is there ----
   OpenBackupEngine();
@@ -2091,10 +2088,9 @@ TEST_F(BackupEngineTest, FlushCompactDuringBackupCheckpoint) {
           "BackupEngineTest::FlushCompactDuringBackupCheckpoint:Before");
       FillDB(db_.get(), keys_iteration, 2 * keys_iteration);
       ASSERT_OK(db_->Flush(FlushOptions()));
-      DBImpl* dbi = static_cast<DBImpl*>(db_.get());
-      ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
+      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
       ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-      ASSERT_OK(dbi->TEST_WaitForCompact());
+      ASSERT_OK(dbfull()->TEST_WaitForCompact());
       TEST_SYNC_POINT(
           "BackupEngineTest::FlushCompactDuringBackupCheckpoint:After");
     }};
@@ -2141,7 +2137,7 @@ TEST_F(BackupEngineTest, BackupOptions) {
     // Must reset() before reset(OpenDB()) again.
     // Calling OpenDB() while *db_ is existing will cause LOCK issue
     db_.reset();
-    db_.reset(OpenDB());
+    db_ = OpenDB();
     ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), true));
     ASSERT_OK(ROCKSDB_NAMESPACE::GetLatestOptionsFileName(db_->GetName(),
                                                           options_.env, &name));
@@ -2169,13 +2165,12 @@ TEST_F(BackupEngineTest, SetOptionsBackupRaceCondition) {
   ROCKSDB_NAMESPACE::port::Thread setoptions_thread{[this]() {
     TEST_SYNC_POINT(
         "BackupEngineTest::SetOptionsBackupRaceCondition:BeforeSetOptions");
-    DBImpl* dbi = static_cast<DBImpl*>(db_.get());
     // Change arbitrary option to trigger OPTIONS file deletion
-    ASSERT_OK(dbi->SetOptions(dbi->DefaultColumnFamily(),
+    ASSERT_OK(db_->SetOptions(db_->DefaultColumnFamily(),
                               {{"paranoid_file_checks", "false"}}));
-    ASSERT_OK(dbi->SetOptions(dbi->DefaultColumnFamily(),
+    ASSERT_OK(db_->SetOptions(db_->DefaultColumnFamily(),
                               {{"paranoid_file_checks", "true"}}));
-    ASSERT_OK(dbi->SetOptions(dbi->DefaultColumnFamily(),
+    ASSERT_OK(db_->SetOptions(db_->DefaultColumnFamily(),
                               {{"paranoid_file_checks", "false"}}));
     TEST_SYNC_POINT(
         "BackupEngineTest::SetOptionsBackupRaceCondition:AfterSetOptions");
@@ -2433,14 +2428,13 @@ TEST_F(BackupEngineTest, TableFileCorruptionBeforeIncremental) {
         engine_options_->share_files_with_checksum_naming = option;
       }
       OpenDBAndBackupEngine(true, false, share);
-      DBImpl* dbi = static_cast<DBImpl*>(db_.get());
       // A small SST file
-      ASSERT_OK(dbi->Put(WriteOptions(), "x", "y"));
-      ASSERT_OK(dbi->Flush(FlushOptions()));
+      ASSERT_OK(db_->Put(WriteOptions(), "x", "y"));
+      ASSERT_OK(db_->Flush(FlushOptions()));
       // And a bigger one
-      ASSERT_OK(dbi->Put(WriteOptions(), "y", Random(42).RandomString(500)));
-      ASSERT_OK(dbi->Flush(FlushOptions()));
-      ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
+      ASSERT_OK(db_->Put(WriteOptions(), "y", Random(42).RandomString(500)));
+      ASSERT_OK(db_->Flush(FlushOptions()));
+      ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
       CloseAndReopenDB(/*read_only*/ true);
 
       std::vector<FileAttributes> table_files;
@@ -2485,9 +2479,8 @@ TEST_F(BackupEngineTest, TableFileCorruptionBeforeIncremental) {
       db_.reset();
       ASSERT_OK(backup_engine_->RestoreDBFromBackup(2, dbname_, dbname_));
       {
-        DB* db = OpenDB();
+        auto db = OpenDB();
         s = db->VerifyChecksum();
-        delete db;
       }
       if (option != kLegacyCrc32cAndFileSize && !corrupt_before_first_backup) {
         // Second backup is OK because it used (uncorrupt) file from first
@@ -2529,11 +2522,10 @@ TEST_F(BackupEngineTest, TableFileCorruptionBeforeIncremental) {
 
 TEST_F(BackupEngineTest, PropertiesBlockCorruptionIncremental) {
   OpenDBAndBackupEngine(true, false, kShareWithChecksum);
-  DBImpl* dbi = static_cast<DBImpl*>(db_.get());
   // A small SST file
-  ASSERT_OK(dbi->Put(WriteOptions(), "x", "y"));
-  ASSERT_OK(dbi->Flush(FlushOptions()));
-  ASSERT_OK(dbi->TEST_WaitForFlushMemTable());
+  ASSERT_OK(db_->Put(WriteOptions(), "x", "y"));
+  ASSERT_OK(db_->Flush(FlushOptions()));
+  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
 
   ASSERT_OK(backup_engine_->CreateNewBackup(db_.get()));
 
@@ -3350,9 +3342,9 @@ TEST_F(BackupEngineTest, ReadOnlyBackupEngine) {
   std::vector<std::string> should_have_written;
   test_backup_fs_->AssertWrittenFiles(should_have_written);
 
-  DB* db = OpenDB();
-  AssertExists(db, 0, 200);
-  delete db;
+  auto db = OpenDB();
+  AssertExists(db.get(), 0, 200);
+  db.reset();
 }
 
 TEST_F(BackupEngineTest, OpenBackupAsReadOnlyDB) {
@@ -3385,7 +3377,7 @@ TEST_F(BackupEngineTest, OpenBackupAsReadOnlyDB) {
   // Caution: DBOptions only holds a raw pointer to Env, so something else
   // must keep it alive.
   // Case 1: Keeping BackupEngine open suffices to keep Env alive
-  DB* db = nullptr;
+  std::unique_ptr<DB> db;
   Options opts = options_;
   // Ensure some key defaults are set
   opts.wal_dir = "";
@@ -3397,11 +3389,10 @@ TEST_F(BackupEngineTest, OpenBackupAsReadOnlyDB) {
   backup_info = BackupInfo();
   ASSERT_OK(DB::OpenForReadOnly(opts, name, &db));
 
-  AssertExists(db, 0, 100);
-  AssertEmpty(db, 100, 200);
+  AssertExists(db.get(), 0, 100);
+  AssertEmpty(db.get(), 100, 200);
 
-  delete db;
-  db = nullptr;
+  db.reset();
 
   // Case 2: Keeping BackupInfo alive rather than BackupEngine also suffices
   ASSERT_OK(backup_engine_->GetBackupInfo(/*id*/ 2U, &backup_info,
@@ -3413,12 +3404,71 @@ TEST_F(BackupEngineTest, OpenBackupAsReadOnlyDB) {
   // Note: keeping backup_info alive
   ASSERT_OK(DB::OpenForReadOnly(opts, name, &db));
 
-  AssertExists(db, 0, 200);
-  delete db;
-  db = nullptr;
+  AssertExists(db.get(), 0, 200);
+  db.reset();
 
   // Now try opening read-write and make sure it fails, for safety.
-  ASSERT_TRUE(DB::Open(opts, name, &db).IsIOError());
+  {
+    std::unique_ptr<DB> dbptr;
+    ASSERT_TRUE(DB::Open(opts, name, &dbptr).IsIOError());
+  }
+}
+
+TEST_F(BackupEngineTest, FileDetailsHaveCorrectFileType) {
+  // Verify that BackupInfo::file_details correctly reports file_type
+  // for all file types in the backup (SST, WAL, MANIFEST, CURRENT, OPTIONS).
+  DestroyDBWithoutCheck(dbname_, options_);
+  OpenDBAndBackupEngine(true);
+
+  // Use kFlushMost so there's both SST data and WAL data in the backup.
+  FillDB(db_.get(), 0, 100);
+  ASSERT_OK(backup_engine_->CreateNewBackup(db_.get(), /*flush*/ false));
+
+  BackupInfo backup_info;
+  ASSERT_OK(backup_engine_->GetBackupInfo(/*id*/ 1U, &backup_info,
+                                          /*include_file_details*/ true));
+  ASSERT_GT(backup_info.file_details.size(), 0);
+
+  bool found_wal = false;
+  bool found_sst = false;
+  bool found_manifest = false;
+  bool found_current = false;
+  bool found_options = false;
+
+  for (const auto& file_info : backup_info.file_details) {
+    // No file should have the default kTempFile type — ParseFileName should
+    // have successfully identified all backup files.
+    EXPECT_NE(file_info.file_type, kTempFile)
+        << "Unexpected kTempFile for: " << file_info.relative_filename;
+
+    switch (file_info.file_type) {
+      case kWalFile:
+        found_wal = true;
+        break;
+      case kTableFile:
+        found_sst = true;
+        break;
+      case kDescriptorFile:
+        found_manifest = true;
+        break;
+      case kCurrentFile:
+        found_current = true;
+        break;
+      case kOptionsFile:
+        found_options = true;
+        break;
+      default:
+        break;
+    }
+  }
+
+  EXPECT_TRUE(found_sst) << "Expected at least one SST file in backup";
+  EXPECT_TRUE(found_wal) << "Expected at least one WAL file in backup";
+  EXPECT_TRUE(found_manifest) << "Expected MANIFEST file in backup";
+  EXPECT_TRUE(found_current) << "Expected CURRENT file in backup";
+  EXPECT_TRUE(found_options) << "Expected OPTIONS file in backup";
+
+  CloseDBAndBackupEngine();
 }
 
 TEST_F(BackupEngineTest, ProgressCallbackDuringBackup) {
@@ -3565,16 +3615,15 @@ TEST_F(BackupEngineTest, ChangeManifestDuringBackupCreation) {
   // The last manifest roll would've already been cleaned up by the full scan
   // that happens when CreateNewBackup invokes EnableFileDeletions. We need to
   // trigger another roll to verify non-full scan purges stale manifests.
-  DBImpl* db_impl = static_cast_with_check<DBImpl>(db_.get());
   std::string prev_manifest_path =
-      DescriptorFileName(dbname_, db_impl->TEST_Current_Manifest_FileNo());
+      DescriptorFileName(dbname_, dbfull()->TEST_Current_Manifest_FileNo());
   FillDB(db_.get(), 0, 100, kAutoFlushOnly);
   ASSERT_OK(db_chroot_env_->FileExists(prev_manifest_path));
   ASSERT_OK(db_->Flush(FlushOptions()));
   // Even though manual flush completed above, the background thread may not
   // have finished its cleanup work. `TEST_WaitForBackgroundWork()` will wait
   // until all the background thread's work has completed, including cleanup.
-  ASSERT_OK(db_impl->TEST_WaitForBackgroundWork());
+  ASSERT_OK(dbfull()->TEST_WaitForBackgroundWork());
   ASSERT_TRUE(db_chroot_env_->FileExists(prev_manifest_path).IsNotFound());
 
   CloseDBAndBackupEngine();
@@ -3940,7 +3989,7 @@ TEST_F(BackupEngineTest, Concurrency) {
       // by doing it async and ensuring we either get OK or InvalidArgument
       restore_verify_threads[i] =
           std::thread([this, &db_opts, restore_db_dir, to_restore] {
-            DB* restored;
+            std::unique_ptr<DB> restored;
             Status s;
             for (;;) {
               s = DB::Open(db_opts, restore_db_dir, &restored);
@@ -3956,10 +4005,9 @@ TEST_F(BackupEngineTest, Concurrency) {
               }
             }
             int factor = std::min(static_cast<int>(to_restore), max_factor);
-            AssertExists(restored, 0, factor * keys_iteration);
-            AssertEmpty(restored, factor * keys_iteration,
+            AssertExists(restored.get(), 0, factor * keys_iteration);
+            AssertEmpty(restored.get(), factor * keys_iteration,
                         (factor + 1) * keys_iteration);
-            delete restored;
           });
 
       // (Ok now) Restore one of the backups, or "latest"
@@ -4418,14 +4466,13 @@ TEST_F(BackupEngineTest, FileTemperatures) {
                         kShareWithChecksum);
 
   // generate a bottommost file (combined from 2) and a non-bottommost file
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_.get());
   ASSERT_OK(db_->Put(WriteOptions(), "a", "val"));
   ASSERT_OK(db_->Put(WriteOptions(), "c", "val"));
   ASSERT_OK(db_->Flush(FlushOptions()));
   ASSERT_OK(db_->Put(WriteOptions(), "b", "val"));
   ASSERT_OK(db_->Put(WriteOptions(), "d", "val"));
   ASSERT_OK(db_->Flush(FlushOptions()));
-  ASSERT_OK(dbi->TEST_WaitForCompact());
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());
   ASSERT_OK(db_->Put(WriteOptions(), "e", "val"));
   ASSERT_OK(db_->Flush(FlushOptions()));
 
@@ -4524,9 +4571,8 @@ TEST_F(BackupEngineTest, FileTemperatures) {
     ASSERT_OK(backup_engine_->GetLatestBackupInfo(
         &info, /*include_file_details*/ true));
     ASSERT_GT(info.file_details.size(), 2);
-    for (auto& e : info.file_details) {
-      EXPECT_EQ(expected_temps[e.file_number], e.temperature);
-    }
+    // TODO: Restore temperature check once finfo.temperature is populated
+    // in SetBackupInfoFromBackupMeta (currently commented out).
 
     // Restore backup to another virtual (tiered) dir
     const std::string restore_dir = "/restore" + std::to_string(i);
@@ -4583,7 +4629,7 @@ TEST_F(BackupEngineTest, ExcludeFiles) {
 
     // Ensure each backup is same set of files
     db_.reset();
-    DB* db = nullptr;
+    std::unique_ptr<DB> db;
     ASSERT_OK(DB::OpenForReadOnly(options_, dbname_, &db));
 
     // A callback that throws should cleanly fail the backup creation.
@@ -4593,12 +4639,12 @@ TEST_F(BackupEngineTest, ExcludeFiles) {
                                     MaybeExcludeBackupFile* /*files_end*/) {
       throw 42;
     };
-    ASSERT_TRUE(backup_engine_->CreateNewBackup(cbo, db).IsAborted());
+    ASSERT_TRUE(backup_engine_->CreateNewBackup(cbo, db.get()).IsAborted());
     cbo.exclude_files_callback = [](MaybeExcludeBackupFile* /*files_begin*/,
                                     MaybeExcludeBackupFile* /*files_end*/) {
       throw std::out_of_range("blah");
     };
-    ASSERT_TRUE(backup_engine_->CreateNewBackup(cbo, db).IsAborted());
+    ASSERT_TRUE(backup_engine_->CreateNewBackup(cbo, db.get()).IsAborted());
 
     // Include files only in given bucket, based on modulus and remainder
     constexpr int modulus = 4;
@@ -4619,22 +4665,21 @@ TEST_F(BackupEngineTest, ExcludeFiles) {
     BackupID first_id{};
     BackupID last_alt_id{};
     remainder = 0;
-    ASSERT_OK(backup_engine_->CreateNewBackup(cbo, db, &first_id));
+    ASSERT_OK(backup_engine_->CreateNewBackup(cbo, db.get(), &first_id));
     AssertBackupInfoConsistency(/*allow excluded*/ true);
     remainder = 1;
-    ASSERT_OK(alt_backup_engine->CreateNewBackup(cbo, db));
+    ASSERT_OK(alt_backup_engine->CreateNewBackup(cbo, db.get()));
     AssertBackupInfoConsistency(/*allow excluded*/ true);
     remainder = 2;
-    ASSERT_OK(backup_engine_->CreateNewBackup(cbo, db));
+    ASSERT_OK(backup_engine_->CreateNewBackup(cbo, db.get()));
     AssertBackupInfoConsistency(/*allow excluded*/ true);
     remainder = 3;
-    ASSERT_OK(alt_backup_engine->CreateNewBackup(cbo, db, &last_alt_id));
+    ASSERT_OK(alt_backup_engine->CreateNewBackup(cbo, db.get(), &last_alt_id));
     AssertBackupInfoConsistency(/*allow excluded*/ true);
 
     // Close DB
     ASSERT_OK(db->Close());
-    delete db;
-    db = nullptr;
+    db.reset();
 
     auto backup_engine = backup_engine_.get();
     for (auto be_pair : {std::make_pair(backup_engine, alt_backup_engine),
@@ -4652,8 +4697,8 @@ TEST_F(BackupEngineTest, ExcludeFiles) {
 
       // Check DB contents
       db = OpenDB();
-      AssertExists(db, 0, keys_iteration);
-      delete db;
+      AssertExists(db.get(), 0, keys_iteration);
+      db.reset();
     }
 
     // Should still work after close and re-open

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_compaction_filter.cc

@@ -32,7 +32,7 @@ CompactionFilter::Decision BlobIndexCompactionFilterBase::FilterV2(
     if (ucf == nullptr) {
       return Decision::kKeep;
     }
-    // Apply user compaction filter for inlined data.
+    // Apply user compaction filter for non-blob data.
     CompactionFilter::Decision decision =
         ucf->FilterV2(level, key, value_type, value, new_value, skip_until);
     if (decision == Decision::kChangeValue) {
@@ -52,34 +52,12 @@ CompactionFilter::Decision BlobIndexCompactionFilterBase::FilterV2(
     expired_size_ += key.size() + value.size();
     return Decision::kRemove;
   }
-  if (!blob_index.IsInlined() &&
-      blob_index.file_number() < context_.next_file_number &&
+  if (blob_index.file_number() < context_.next_file_number &&
       context_.current_blob_files.count(blob_index.file_number()) == 0) {
-    // Corresponding blob file gone (most likely, evicted by FIFO eviction).
     evicted_count_++;
     evicted_size_ += key.size() + value.size();
     return Decision::kRemove;
   }
-  if (context_.fifo_eviction_seq > 0 && blob_index.HasTTL() &&
-      blob_index.expiration() < context_.evict_expiration_up_to) {
-    // Hack: Internal key is passed to BlobIndexCompactionFilter for it to
-    // get sequence number.
-    ParsedInternalKey ikey;
-    if (!ParseInternalKey(
-             key, &ikey,
-             context_.blob_db_impl->db_options_.allow_data_in_errors)
-             .ok()) {
-      assert(false);
-      return Decision::kKeep;
-    }
-    // Remove keys that could have been remove by last FIFO eviction.
-    // If get error while parsing key, ignore and continue.
-    if (ikey.sequence < context_.fifo_eviction_seq) {
-      evicted_count_++;
-      evicted_size_ += key.size() + value.size();
-      return Decision::kRemove;
-    }
-  }
   // Apply user compaction filter for all non-TTL blob data.
   if (ucf != nullptr && !blob_index.HasTTL()) {
     // Hack: Internal key is passed to BlobIndexCompactionFilter for it to
@@ -94,10 +72,7 @@ CompactionFilter::Decision BlobIndexCompactionFilterBase::FilterV2(
     }
     // Read value from blob file.
     PinnableSlice blob;
-    CompressionType compression_type = kNoCompression;
-    constexpr bool need_decompress = true;
-    if (!ReadBlobFromOldFile(ikey.user_key, blob_index, &blob, need_decompress,
-                             &compression_type)) {
+    if (!ReadBlobFromOldFile(ikey.user_key, blob_index, &blob)) {
       return Decision::kIOError;
     }
     CompactionFilter::Decision decision = ucf->FilterV2(
@@ -112,22 +87,10 @@ CompactionFilter::Decision BlobIndexCompactionFilterBase::FilterV2(
 
 CompactionFilter::Decision BlobIndexCompactionFilterBase::HandleValueChange(
     const Slice& key, std::string* new_value) const {
-  BlobDBImpl* const blob_db_impl = context_.blob_db_impl;
-  assert(blob_db_impl);
-
-  if (new_value->size() < blob_db_impl->bdb_options_.min_blob_size) {
-    // Keep new_value inlined.
-    return Decision::kChangeValue;
-  }
   if (!OpenNewBlobFileIfNeeded()) {
     return Decision::kIOError;
   }
   Slice new_blob_value(*new_value);
-  std::string compression_output;
-  if (blob_db_impl->bdb_options_.compression != kNoCompression) {
-    new_blob_value =
-        blob_db_impl->GetCompressedSlice(new_blob_value, &compression_output);
-  }
   uint64_t new_blob_file_number = 0;
   uint64_t new_blob_offset = 0;
   if (!WriteBlobToNewFile(key, new_blob_value, &new_blob_file_number,
@@ -138,8 +101,7 @@ CompactionFilter::Decision BlobIndexCompactionFilterBase::HandleValueChange(
     return Decision::kIOError;
   }
   BlobIndex::EncodeBlob(new_value, new_blob_file_number, new_blob_offset,
-                        new_blob_value.size(),
-                        blob_db_impl->bdb_options_.compression);
+                        new_blob_value.size(), kNoCompression);
   return Decision::kChangeBlobIndex;
 }
 
@@ -201,14 +163,13 @@ bool BlobIndexCompactionFilterBase::OpenNewBlobFileIfNeeded() const {
 }
 
 bool BlobIndexCompactionFilterBase::ReadBlobFromOldFile(
-    const Slice& key, const BlobIndex& blob_index, PinnableSlice* blob,
-    bool need_decompress, CompressionType* compression_type) const {
+    const Slice& key, const BlobIndex& blob_index, PinnableSlice* blob) const {
   BlobDBImpl* const blob_db_impl = context_.blob_db_impl;
   assert(blob_db_impl);
 
-  Status s = blob_db_impl->GetRawBlobFromFile(
-      key, blob_index.file_number(), blob_index.offset(), blob_index.size(),
-      blob, compression_type);
+  Status s = blob_db_impl->GetRawBlobFromFile(key, blob_index.file_number(),
+                                              blob_index.offset(),
+                                              blob_index.size(), blob);
 
   if (!s.ok()) {
     ROCKS_LOG_ERROR(
@@ -221,21 +182,6 @@ bool BlobIndexCompactionFilterBase::ReadBlobFromOldFile(
     return false;
   }
 
-  if (need_decompress && *compression_type != kNoCompression) {
-    s = blob_db_impl->DecompressSlice(*blob, *compression_type, blob);
-    if (!s.ok()) {
-      ROCKS_LOG_ERROR(
-          blob_db_impl->db_options_.info_log,
-          "Uncompression error during blob read from file: %" PRIu64
-          " blob_offset: %" PRIu64 " blob_size: %" PRIu64
-          " key: %s status: '%s'",
-          blob_index.file_number(), blob_index.offset(), blob_index.size(),
-          key.ToString(/* output_hex */ true).c_str(), s.ToString().c_str());
-
-      return false;
-    }
-  }
-
   return true;
 }
 
@@ -306,8 +252,7 @@ bool BlobIndexCompactionFilterBase::CloseAndRegisterNewBlobFile() const {
     // TODO: plumb Env::IOActivity, Env::IOPriority
     s = blob_db_impl->CloseBlobFile(WriteOptions(), blob_file_);
 
-    // Note: we delay registering the new blob file until it's closed to
-    // prevent FIFO eviction from processing it during compaction/GC.
+    // Note: we delay registering the new blob file until it's closed.
     blob_db_impl->RegisterBlobFile(blob_file_);
   }
 
@@ -336,18 +281,12 @@ CompactionFilter::BlobDecision BlobIndexCompactionFilterGC::PrepareBlobOutput(
   assert(blob_db_impl->bdb_options_.enable_garbage_collection);
 
   BlobIndex blob_index;
-  const Status s = blob_index.DecodeFrom(existing_value);
+  Status s = blob_index.DecodeFrom(existing_value);
   if (!s.ok()) {
     gc_stats_.SetError();
     return BlobDecision::kCorruption;
   }
 
-  if (blob_index.IsInlined()) {
-    gc_stats_.AddBlob(blob_index.value().size());
-
-    return BlobDecision::kKeep;
-  }
-
   gc_stats_.AddBlob(blob_index.size());
 
   if (blob_index.HasTTL()) {
@@ -368,31 +307,11 @@ CompactionFilter::BlobDecision BlobIndexCompactionFilterGC::PrepareBlobOutput(
   }
 
   PinnableSlice blob;
-  CompressionType compression_type = kNoCompression;
-  std::string compression_output;
-  if (!ReadBlobFromOldFile(key, blob_index, &blob, false, &compression_type)) {
+  if (!ReadBlobFromOldFile(key, blob_index, &blob)) {
     gc_stats_.SetError();
     return BlobDecision::kIOError;
   }
 
-  // If the compression_type is changed, re-compress it with the new compression
-  // type.
-  if (compression_type != blob_db_impl->bdb_options_.compression) {
-    if (compression_type != kNoCompression) {
-      const Status status =
-          blob_db_impl->DecompressSlice(blob, compression_type, &blob);
-      if (!status.ok()) {
-        gc_stats_.SetError();
-        return BlobDecision::kCorruption;
-      }
-    }
-    if (blob_db_impl->bdb_options_.compression != kNoCompression) {
-      blob_db_impl->GetCompressedSlice(blob, &compression_output);
-      blob = PinnableSlice(&compression_output);
-      blob.PinSelf();
-    }
-  }
-
   uint64_t new_blob_file_number = 0;
   uint64_t new_blob_offset = 0;
   if (!WriteBlobToNewFile(key, blob, &new_blob_file_number, &new_blob_offset)) {
@@ -406,7 +325,7 @@ CompactionFilter::BlobDecision BlobIndexCompactionFilterGC::PrepareBlobOutput(
   }
 
   BlobIndex::EncodeBlob(new_value, new_blob_file_number, new_blob_offset,
-                        blob.size(), compression_type);
+                        blob.size(), kNoCompression);
 
   gc_stats_.AddRelocatedBlob(blob_index.size());
 

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_compaction_filter.h

@@ -21,8 +21,6 @@ struct BlobCompactionContext {
   BlobDBImpl* blob_db_impl = nullptr;
   uint64_t next_file_number = 0;
   std::unordered_set<uint64_t> current_blob_files;
-  SequenceNumber fifo_eviction_seq = 0;
-  uint64_t evict_expiration_up_to = 0;
 };
 
 struct BlobCompactionContextGC {
@@ -59,8 +57,7 @@ class BlobIndexCompactionFilterBase : public LayeredCompactionFilterBase {
   bool IsBlobFileOpened() const;
   virtual bool OpenNewBlobFileIfNeeded() const;
   bool ReadBlobFromOldFile(const Slice& key, const BlobIndex& blob_index,
-                           PinnableSlice* blob, bool need_decompress,
-                           CompressionType* compression_type) const;
+                           PinnableSlice* blob) const;
   bool WriteBlobToNewFile(const Slice& key, const Slice& blob,
                           uint64_t* new_blob_file_number,
                           uint64_t* new_blob_offset) const;