@nxtedition/rocksdb 15.4.1 → 15.5.0

package/deps/rocksdb/rocksdb/db/compaction/subcompaction_state.h

@@ -95,6 +95,14 @@ class SubcompactionState {
     proximal_level_outputs_.RemoveLastEmptyOutput();
   }
 
+  // Cleanup output builders for abandoning in-progress files.
+  void CleanupOutputs() {
+    compaction_outputs_.Cleanup();
+    if (compaction->SupportsPerKeyPlacement()) {
+      proximal_level_outputs_.Cleanup();
+    }
+  }
+
   void BuildSubcompactionJobInfo(
       SubcompactionJobInfo& subcompaction_job_info) const {
     const Compaction* c = compaction;
@@ -162,7 +170,7 @@ class SubcompactionState {
     }
   }
 
-  void Cleanup(Cache* cache);
+  void Cleanup(Cache* cache, const Status& overall_status);
 
   void AggregateCompactionOutputStats(
       InternalStats::CompactionStatsFull& internal_stats) const;

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

@@ -1717,8 +1717,8 @@ TEST_P(PrecludeLastLevelTest, MigrationFromPreserveTimePartial) {
   ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel());
 
   std::vector<KeyVersion> key_versions;
-  ASSERT_OK(GetAllKeyVersions(db_, {}, {}, std::numeric_limits<size_t>::max(),
-                              &key_versions));
+  ASSERT_OK(GetAllKeyVersions(
+      db_.get(), {}, {}, std::numeric_limits<size_t>::max(), &key_versions));
 
   // make sure there're more than 300 keys and first 100 keys are having seqno
   // zeroed out, the last 100 key seqno not zeroed out
@@ -2319,8 +2319,8 @@ TEST_P(PrecludeLastLevelTest, LastLevelOnlyCompactionPartial) {
   ASSERT_GT(GetSstSizeHelper(Temperature::kUnknown), 0);
 
   std::vector<KeyVersion> key_versions;
-  ASSERT_OK(GetAllKeyVersions(db_, {}, {}, std::numeric_limits<size_t>::max(),
-                              &key_versions));
+  ASSERT_OK(GetAllKeyVersions(
+      db_.get(), {}, {}, std::numeric_limits<size_t>::max(), &key_versions));
 
   // make sure there're more than 300 keys and first 100 keys are having seqno
   // zeroed out, the last 100 key seqno not zeroed out

package/deps/rocksdb/rocksdb/db/comparator_db_test.cc

@@ -258,12 +258,12 @@ class ComparatorDBTest
  private:
   std::string dbname_;
   Env* env_;
-  DB* db_;
+  std::unique_ptr<DB> db_;
   Options last_options_;
   std::unique_ptr<const Comparator> comparator_guard;
 
  public:
-  ComparatorDBTest() : env_(Env::Default()), db_(nullptr) {
+  ComparatorDBTest() : env_(Env::Default()) {
     kTestComparator = BytewiseComparator();
     dbname_ = test::PerThreadDBPath("comparator_db_test");
     BlockBasedTableOptions toptions;
@@ -274,12 +274,12 @@ class ComparatorDBTest
   }
 
   ~ComparatorDBTest() override {
-    delete db_;
+    db_.reset();
     EXPECT_OK(DestroyDB(dbname_, last_options_));
     kTestComparator = BytewiseComparator();
   }
 
-  DB* GetDB() { return db_; }
+  DB* GetDB() { return db_.get(); }
 
   void SetOwnedComparator(const Comparator* cmp, bool owner = true) {
     if (owner) {
@@ -301,14 +301,12 @@ class ComparatorDBTest
   }
 
   void Destroy() {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     ASSERT_OK(DestroyDB(dbname_, last_options_));
   }
 
   Status TryReopen() {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     last_options_.create_if_missing = true;
 
     return DB::Open(last_options_, dbname_, &db_);
@@ -318,7 +316,7 @@ class ComparatorDBTest
 INSTANTIATE_TEST_CASE_P(FormatDef, ComparatorDBTest,
                         testing::Values(test::kDefaultFormatVersion));
 INSTANTIATE_TEST_CASE_P(FormatLatest, ComparatorDBTest,
-                        testing::Values(kLatestFormatVersion));
+                        testing::Values(kLatestBbtFormatVersion));
 
 TEST_P(ComparatorDBTest, Bytewise) {
   for (int rand_seed = 301; rand_seed < 306; rand_seed++) {

package/deps/rocksdb/rocksdb/db/convenience.cc

@@ -65,7 +65,7 @@ Status VerifySstFileChecksum(const Options& options,
 }
 
 Status VerifySstFileChecksumInternal(const Options& options,
-                                     const EnvOptions& env_options,
+                                     const FileOptions& file_options,
                                      const ReadOptions& read_options,
                                      const std::string& file_path,
                                      const SequenceNumber& largest_seqno) {
@@ -74,8 +74,8 @@ Status VerifySstFileChecksumInternal(const Options& options,
   InternalKeyComparator internal_comparator(options.comparator);
   ImmutableOptions ioptions(options);
 
-  Status s = ioptions.fs->NewRandomAccessFile(
-      file_path, FileOptions(env_options), &file, nullptr);
+  Status s =
+      ioptions.fs->NewRandomAccessFile(file_path, file_options, &file, nullptr);
   if (s.ok()) {
     s = ioptions.fs->GetFileSize(file_path, IOOptions(), &file_size, nullptr);
   } else {
@@ -94,7 +94,7 @@ Status VerifySstFileChecksumInternal(const Options& options,
   const bool kImmortal = true;
   auto reader_options = TableReaderOptions(
       ioptions, options.prefix_extractor, options.compression_manager.get(),
-      env_options, internal_comparator, options.block_protection_bytes_per_key,
+      file_options, internal_comparator, options.block_protection_bytes_per_key,
       false /* skip_filters */, !kImmortal, false /* force_direct_prefetch */,
       -1 /* level */);
   reader_options.largest_seqno = largest_seqno;

package/deps/rocksdb/rocksdb/db/convenience_impl.h

@@ -5,10 +5,11 @@
 
 #pragma once
 #include "rocksdb/db.h"
+#include "rocksdb/file_system.h"
 
 namespace ROCKSDB_NAMESPACE {
 Status VerifySstFileChecksumInternal(const Options& options,
-                                     const EnvOptions& env_options,
+                                     const FileOptions& file_options,
                                      const ReadOptions& read_options,
                                      const std::string& file_path,
                                      const SequenceNumber& largest_seqno = 0);

package/deps/rocksdb/rocksdb/db/corruption_test.cc

@@ -73,7 +73,7 @@ class CorruptionTest : public testing::Test {
   std::string dbname_;
   std::shared_ptr<Cache> tiny_cache_;
   Options options_;
-  DB* db_;
+  std::unique_ptr<DB> db_;
 
   CorruptionTest() {
     // If LRU cache shard bit is smaller than 2 (or -1 which will automatically
@@ -105,8 +105,7 @@ class CorruptionTest : public testing::Test {
     SyncPoint::GetInstance()->DisableProcessing();
     SyncPoint::GetInstance()->LoadDependency({});
     SyncPoint::GetInstance()->ClearAllCallBacks();
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     if (getenv("KEEP_DB")) {
       fprintf(stdout, "db is still at %s\n", dbname_.c_str());
     } else {
@@ -116,14 +115,12 @@ class CorruptionTest : public testing::Test {
     }
   }
 
-  void CloseDb() {
-    delete db_;
-    db_ = nullptr;
-  }
+  void CloseDb() { db_.reset(); }
+
+  DBImpl* dbfull() { return static_cast_with_check<DBImpl>(db_.get()); }
 
   Status TryReopen(Options* options = nullptr) {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     Options opt = (options ? *options : options_);
     if (opt.env == Options().env) {
       // If env is not overridden, replace it with ErrorEnv.
@@ -141,8 +138,7 @@ class CorruptionTest : public testing::Test {
   void Reopen(Options* options = nullptr) { ASSERT_OK(TryReopen(options)); }
 
   void RepairDB() {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     ASSERT_OK(::ROCKSDB_NAMESPACE::RepairDB(dbname_, options_));
   }
 
@@ -151,8 +147,7 @@ class CorruptionTest : public testing::Test {
     WriteBatch batch;
     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_);
-        ASSERT_OK(dbi->TEST_FlushMemTable());
+        ASSERT_OK(dbfull()->TEST_FlushMemTable());
       }
       // if ((i % 100) == 0) fprintf(stderr, "@ %d of %d\n", i, n);
       Slice key = Key(i + start, &key_space);
@@ -436,14 +431,14 @@ TEST_F(CorruptionTest, NewFileErrorDuringWrite) {
 
 TEST_F(CorruptionTest, TableFile) {
   Build(100);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
+  DBImpl* dbi = dbfull();
   ASSERT_OK(dbi->TEST_FlushMemTable());
   ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
   ASSERT_OK(dbi->TEST_CompactRange(1, nullptr, nullptr));
 
   Corrupt(kTableFile, 100, 1);
   Check(99, 99);
-  ASSERT_NOK(dbi->VerifyChecksum());
+  ASSERT_NOK(db_->VerifyChecksum());
 }
 
 TEST_F(CorruptionTest, VerifyChecksumReadahead) {
@@ -460,14 +455,14 @@ TEST_F(CorruptionTest, VerifyChecksumReadahead) {
   Reopen(&options);
 
   Build(10000);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
+  DBImpl* dbi = dbfull();
   ASSERT_OK(dbi->TEST_FlushMemTable());
   ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
   ASSERT_OK(dbi->TEST_CompactRange(1, nullptr, nullptr));
 
   senv.count_random_reads_ = true;
   senv.random_read_counter_.Reset();
-  ASSERT_OK(dbi->VerifyChecksum());
+  ASSERT_OK(db_->VerifyChecksum());
 
   // Make sure the counter is enabled.
   ASSERT_GT(senv.random_read_counter_.Read(), 0);
@@ -480,7 +475,7 @@ TEST_F(CorruptionTest, VerifyChecksumReadahead) {
   senv.random_read_bytes_counter_ = 0;
   ReadOptions ro;
   ro.readahead_size = size_t{32 * 1024};
-  ASSERT_OK(dbi->VerifyChecksum(ro));
+  ASSERT_OK(db_->VerifyChecksum(ro));
   // The SST file is about 10MB. We set readahead size to 32KB.
   // Give 0 to 20 reads for metadata blocks, and allow real read
   // to range from 24KB to 48KB. The lower bound would be:
@@ -494,8 +489,7 @@ TEST_F(CorruptionTest, VerifyChecksumReadahead) {
   // disabled).
   options.allow_mmap_reads = true;
   Reopen(&options);
-  dbi = static_cast<DBImpl*>(db_);
-  ASSERT_OK(dbi->VerifyChecksum(ro));
+  ASSERT_OK(db_->VerifyChecksum(ro));
 
   CloseDb();
 }
@@ -508,18 +502,16 @@ TEST_F(CorruptionTest, TableFileIndexData) {
   Reopen(&options);
   // build 2 tables, flush at 5000
   Build(10000, 5000);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
 
   // corrupt an index block of an entire file
   Corrupt(kTableFile, -2000, 500);
   options.paranoid_checks = false;
   Reopen(&options);
-  dbi = static_cast_with_check<DBImpl>(db_);
   // one full file may be readable, since only one was corrupted
   // the other file should be fully non-readable, since index was corrupted
   Check(0, 5000, ReadOptions(true, true));
-  ASSERT_NOK(dbi->VerifyChecksum());
+  ASSERT_NOK(db_->VerifyChecksum());
 
   // In paranoid mode, the db cannot be opened due to the corrupted file.
   ASSERT_TRUE(TryReopen().IsCorruption());
@@ -527,8 +519,7 @@ TEST_F(CorruptionTest, TableFileIndexData) {
 
 TEST_F(CorruptionTest, TableFileFooterMagic) {
   Build(100);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
   Check(100, 100);
   // Corrupt the whole footer
   Corrupt(kTableFile, -100, 100);
@@ -543,8 +534,7 @@ TEST_F(CorruptionTest, TableFileFooterMagic) {
 
 TEST_F(CorruptionTest, TableFileFooterNotMagic) {
   Build(100);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
   Check(100, 100);
   // Corrupt footer except magic number
   Corrupt(kTableFile, -100, 92);
@@ -579,8 +569,7 @@ TEST_F(CorruptionTest, DBOpenWithWrongFileSize) {
     for (auto* cfh : cfhs) {
       delete cfh;
     }
-    DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-    ASSERT_OK(dbi->TEST_FlushMemTable());
+    ASSERT_OK(dbfull()->TEST_FlushMemTable());
 
     // ********************************************
     // Corrupt the file by making the file bigger
@@ -601,7 +590,8 @@ TEST_F(CorruptionTest, DBOpenWithWrongFileSize) {
   // true
   options_.paranoid_checks = true;
   std::vector<ColumnFamilyHandle*> cfhs;
-  auto s = DB::Open(options_, dbname_, cf_descs, &cfhs, &db_);
+  Status s;
+  s = DB::Open(options_, dbname_, cf_descs, &cfhs, &db_);
   ASSERT_TRUE(s.IsCorruption());
   ASSERT_TRUE(s.ToString().find("file size mismatch") != std::string::npos);
 
@@ -626,8 +616,7 @@ TEST_F(CorruptionTest, DBOpenWithWrongFileSize) {
 
 TEST_F(CorruptionTest, TableFileWrongSize) {
   Build(100);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
   Check(100, 100);
 
   // ********************************************
@@ -710,12 +699,11 @@ TEST_F(CorruptionTest, SequenceNumberRecovery) {
 
 TEST_F(CorruptionTest, CorruptedDescriptor) {
   ASSERT_OK(db_->Put(WriteOptions(), "foo", "hello"));
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
   CompactRangeOptions cro;
   cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
   ASSERT_OK(
-      dbi->CompactRange(cro, dbi->DefaultColumnFamily(), nullptr, nullptr));
+      db_->CompactRange(cro, db_->DefaultColumnFamily(), nullptr, nullptr));
 
   Corrupt(kDescriptorFile, 0, 1000);
   Status s = TryReopen();
@@ -734,7 +722,7 @@ TEST_F(CorruptionTest, CompactionInputError) {
   options.env = env_.get();
   Reopen(&options);
   Build(10);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
+  DBImpl* dbi = dbfull();
   ASSERT_OK(dbi->TEST_FlushMemTable());
   ASSERT_OK(dbi->TEST_CompactRange(0, nullptr, nullptr));
   ASSERT_OK(dbi->TEST_CompactRange(1, nullptr, nullptr));
@@ -742,12 +730,12 @@ TEST_F(CorruptionTest, CompactionInputError) {
 
   Corrupt(kTableFile, 100, 1);
   Check(9, 9);
-  ASSERT_NOK(dbi->VerifyChecksum());
+  ASSERT_NOK(db_->VerifyChecksum());
 
   // Force compactions by writing lots of values
   Build(10000);
   Check(10000, 10000);
-  ASSERT_NOK(dbi->VerifyChecksum());
+  ASSERT_NOK(db_->VerifyChecksum());
 }
 
 TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
@@ -758,14 +746,14 @@ TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
   options.write_buffer_size = 131072;
   options.max_write_buffer_number = 2;
   Reopen(&options);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
+  DBImpl* dbi = dbfull();
 
   // Fill levels >= 1
-  for (int level = 1; level < dbi->NumberLevels(); level++) {
-    ASSERT_OK(dbi->Put(WriteOptions(), "", "begin"));
-    ASSERT_OK(dbi->Put(WriteOptions(), "~", "end"));
+  for (int level = 1; level < db_->NumberLevels(); level++) {
+    ASSERT_OK(db_->Put(WriteOptions(), "", "begin"));
+    ASSERT_OK(db_->Put(WriteOptions(), "~", "end"));
     ASSERT_OK(dbi->TEST_FlushMemTable());
-    for (int comp_level = 0; comp_level < dbi->NumberLevels() - level;
+    for (int comp_level = 0; comp_level < db_->NumberLevels() - level;
          ++comp_level) {
       ASSERT_OK(dbi->TEST_CompactRange(comp_level, nullptr, nullptr));
     }
@@ -773,7 +761,7 @@ TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
 
   Reopen(&options);
 
-  dbi = static_cast_with_check<DBImpl>(db_);
+  dbi = dbfull();
   Build(10);
   ASSERT_OK(dbi->TEST_FlushMemTable());
   ASSERT_OK(dbi->TEST_WaitForCompact());
@@ -781,7 +769,7 @@ TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
 
   CorruptTableFileAtLevel(0, 100, 1);
   Check(9, 9);
-  ASSERT_NOK(dbi->VerifyChecksum());
+  ASSERT_NOK(db_->VerifyChecksum());
 
   // Write must eventually fail because of corrupted table
   Status s;
@@ -800,17 +788,16 @@ TEST_F(CorruptionTest, CompactionInputErrorParanoid) {
 
 TEST_F(CorruptionTest, UnrelatedKeys) {
   Build(10);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
   Corrupt(kTableFile, 100, 1);
-  ASSERT_NOK(dbi->VerifyChecksum());
+  ASSERT_NOK(db_->VerifyChecksum());
 
   std::string tmp1, tmp2;
   ASSERT_OK(db_->Put(WriteOptions(), Key(1000, &tmp1), Value(1000, &tmp2)));
   std::string v;
   ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
   ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
   ASSERT_OK(db_->Get(ReadOptions(), Key(1000, &tmp1), &v));
   ASSERT_EQ(Value(1000, &tmp2).ToString(), v);
 }
@@ -857,14 +844,12 @@ TEST_F(CorruptionTest, FileSystemStateCorrupted) {
     Reopen(&options);
     Build(10);
     ASSERT_OK(db_->Flush(FlushOptions()));
-    DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
     std::vector<LiveFileMetaData> metadata;
-    dbi->GetLiveFilesMetaData(&metadata);
+    db_->GetLiveFilesMetaData(&metadata);
     ASSERT_GT(metadata.size(), 0);
     std::string filename = dbname_ + metadata[0].name;
 
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
 
     if (iter == 0) {  // corrupt file size
       std::unique_ptr<WritableFile> file;
@@ -896,8 +881,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnFlush) {
   options.create_if_missing = true;
   Status s;
   for (const auto& mode : corruption_modes) {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     s = DestroyDB(dbname_, options);
     ASSERT_OK(s);
     std::shared_ptr<mock::MockTableFactory> mock =
@@ -924,8 +908,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {
   options.create_if_missing = true;
   Status s;
   for (const auto& mode : corruption_modes) {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     s = DestroyDB(dbname_, options);
     ASSERT_OK(s);
     std::shared_ptr<mock::MockTableFactory> mock =
@@ -934,12 +917,11 @@ TEST_F(CorruptionTest, ParanoidFileChecksOnCompact) {
     ASSERT_OK(DB::Open(options, dbname_, &db_));
     assert(db_ != nullptr);  // suppress false clang-analyze report
     Build(100, 2);
-    DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-    ASSERT_OK(dbi->TEST_FlushMemTable());
+    ASSERT_OK(dbfull()->TEST_FlushMemTable());
     mock->SetCorruptionMode(mode);
     CompactRangeOptions cro;
     cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
-    s = dbi->CompactRange(cro, dbi->DefaultColumnFamily(), nullptr, nullptr);
+    s = db_->CompactRange(cro, db_->DefaultColumnFamily(), nullptr, nullptr);
     if (mode == mock::MockTableFactory::kCorruptNone) {
       ASSERT_OK(s);
     } else {
@@ -955,8 +937,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeFirst) {
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
   for (bool do_flush : {true, false}) {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     ASSERT_OK(DestroyDB(dbname_, options));
     ASSERT_OK(DB::Open(options, dbname_, &db_));
     std::string start, end;
@@ -973,12 +954,11 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeFirst) {
     if (do_flush) {
       ASSERT_OK(db_->Flush(FlushOptions()));
     } else {
-      DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-      ASSERT_OK(dbi->TEST_FlushMemTable());
+      ASSERT_OK(dbfull()->TEST_FlushMemTable());
       CompactRangeOptions cro;
       cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
       ASSERT_OK(
-          dbi->CompactRange(cro, dbi->DefaultColumnFamily(), nullptr, nullptr));
+          db_->CompactRange(cro, db_->DefaultColumnFamily(), nullptr, nullptr));
     }
     db_->ReleaseSnapshot(snap);
   }
@@ -991,8 +971,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRange) {
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
   for (bool do_flush : {true, false}) {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     ASSERT_OK(DestroyDB(dbname_, options));
     ASSERT_OK(DB::Open(options, dbname_, &db_));
     assert(db_ != nullptr);  // suppress false clang-analyze report
@@ -1012,12 +991,11 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRange) {
     if (do_flush) {
       ASSERT_OK(db_->Flush(FlushOptions()));
     } else {
-      DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-      ASSERT_OK(dbi->TEST_FlushMemTable());
+      ASSERT_OK(dbfull()->TEST_FlushMemTable());
       CompactRangeOptions cro;
       cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
       ASSERT_OK(
-          dbi->CompactRange(cro, dbi->DefaultColumnFamily(), nullptr, nullptr));
+          db_->CompactRange(cro, db_->DefaultColumnFamily(), nullptr, nullptr));
     }
     db_->ReleaseSnapshot(snap);
   }
@@ -1030,8 +1008,7 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeLast) {
   options.paranoid_file_checks = true;
   options.create_if_missing = true;
   for (bool do_flush : {true, false}) {
-    delete db_;
-    db_ = nullptr;
+    db_.reset();
     ASSERT_OK(DestroyDB(dbname_, options));
     ASSERT_OK(DB::Open(options, dbname_, &db_));
     assert(db_ != nullptr);  // suppress false clang-analyze report
@@ -1048,12 +1025,11 @@ TEST_F(CorruptionTest, ParanoidFileChecksWithDeleteRangeLast) {
     if (do_flush) {
       ASSERT_OK(db_->Flush(FlushOptions()));
     } else {
-      DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-      ASSERT_OK(dbi->TEST_FlushMemTable());
+      ASSERT_OK(dbfull()->TEST_FlushMemTable());
       CompactRangeOptions cro;
       cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
       ASSERT_OK(
-          dbi->CompactRange(cro, dbi->DefaultColumnFamily(), nullptr, nullptr));
+          db_->CompactRange(cro, db_->DefaultColumnFamily(), nullptr, nullptr));
     }
     db_->ReleaseSnapshot(snap);
   }
@@ -1066,8 +1042,7 @@ TEST_F(CorruptionTest, LogCorruptionErrorsInCompactionIterator) {
   options.create_if_missing = true;
   options.allow_data_in_errors = true;
   auto mode = mock::MockTableFactory::kCorruptKey;
-  delete db_;
-  db_ = nullptr;
+  db_.reset();
   ASSERT_OK(DestroyDB(dbname_, options));
 
   std::shared_ptr<mock::MockTableFactory> mock =
@@ -1079,12 +1054,11 @@ TEST_F(CorruptionTest, LogCorruptionErrorsInCompactionIterator) {
   assert(db_ != nullptr);  // suppress false clang-analyze report
   Build(100, 2);
 
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
   CompactRangeOptions cro;
   cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
   Status s =
-      dbi->CompactRange(cro, dbi->DefaultColumnFamily(), nullptr, nullptr);
+      db_->CompactRange(cro, db_->DefaultColumnFamily(), nullptr, nullptr);
   ASSERT_NOK(s);
   ASSERT_TRUE(s.IsCorruption());
 }
@@ -1095,8 +1069,7 @@ TEST_F(CorruptionTest, CompactionKeyOrderCheck) {
   options.env = env_.get();
   options.paranoid_file_checks = false;
   options.create_if_missing = true;
-  delete db_;
-  db_ = nullptr;
+  db_.reset();
   ASSERT_OK(DestroyDB(dbname_, options));
   std::shared_ptr<mock::MockTableFactory> mock =
       std::make_shared<mock::MockTableFactory>();
@@ -1105,14 +1078,13 @@ TEST_F(CorruptionTest, CompactionKeyOrderCheck) {
   assert(db_ != nullptr);  // suppress false clang-analyze report
   mock->SetCorruptionMode(mock::MockTableFactory::kCorruptReorderKey);
   Build(100, 2);
-  DBImpl* dbi = static_cast_with_check<DBImpl>(db_);
-  ASSERT_OK(dbi->TEST_FlushMemTable());
+  ASSERT_OK(dbfull()->TEST_FlushMemTable());
 
   mock->SetCorruptionMode(mock::MockTableFactory::kCorruptNone);
   CompactRangeOptions cro;
   cro.bottommost_level_compaction = BottommostLevelCompaction::kForce;
   ASSERT_NOK(
-      dbi->CompactRange(cro, dbi->DefaultColumnFamily(), nullptr, nullptr));
+      db_->CompactRange(cro, db_->DefaultColumnFamily(), nullptr, nullptr));
 }
 
 TEST_F(CorruptionTest, FlushKeyOrderCheck) {
@@ -1139,7 +1111,7 @@ TEST_F(CorruptionTest, FlushKeyOrderCheck) {
         }
       });
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  Status s = static_cast_with_check<DBImpl>(db_)->TEST_FlushMemTable();
+  Status s = dbfull()->TEST_FlushMemTable();
   ASSERT_NOK(s);
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
@@ -1263,7 +1235,7 @@ TEST_P(CrashDuringRecoveryWithCorruptionTest, CrashDuringRecovery) {
   // while other don't.
   {
     ASSERT_OK(DB::Open(options, dbname_, cf_descs, &handles, &db_));
-    auto* dbimpl = static_cast_with_check<DBImpl>(db_);
+    auto* dbimpl = dbfull();
     assert(dbimpl);
 
     // Write one key to test_cf.