From c9e419ccb6f29a21f86354afda0256a78579f201 Mon Sep 17 00:00:00 2001
From: Lei Jin <lei@fb.com>
Date: Fri, 5 Sep 2014 11:48:17 -0700
Subject: [PATCH] rename options_ to db_options_ in DBImpl to avoid confusion

Summary: as title

Test Plan: make release

Reviewers: sdong, igor

Reviewed By: igor

Subscribers: leveldb

Differential Revision: https://reviews.facebook.net/D22935
---
 db/db_filesnapshot.cc  |  20 +--
 db/db_impl.cc          | 341 +++++++++++++++++++++--------------------
 db/db_impl.h           |   4 +-
 db/db_impl_readonly.cc |   2 +-
 4 files changed, 188 insertions(+), 179 deletions(-)

diff --git a/db/db_filesnapshot.cc b/db/db_filesnapshot.cc
index aa1408f38b3..9f05b8d3079 100644
--- a/db/db_filesnapshot.cc
+++ b/db/db_filesnapshot.cc
@@ -32,9 +32,9 @@ Status DBImpl::DisableFileDeletions() {
   MutexLock l(&mutex_);
   ++disable_delete_obsolete_files_;
   if (disable_delete_obsolete_files_ == 1) {
-    Log(options_.info_log, "File Deletions Disabled");
+    Log(db_options_.info_log, "File Deletions Disabled");
   } else {
-    Log(options_.info_log,
+    Log(db_options_.info_log,
         "File Deletions Disabled, but already disabled. Counter: %d",
         disable_delete_obsolete_files_);
   }
@@ -53,11 +53,11 @@ Status DBImpl::EnableFileDeletions(bool force) {
       --disable_delete_obsolete_files_;
     }
     if (disable_delete_obsolete_files_ == 0)  {
-      Log(options_.info_log, "File Deletions Enabled");
+      Log(db_options_.info_log, "File Deletions Enabled");
       should_purge_files = true;
       FindObsoleteFiles(deletion_state, true);
     } else {
-      Log(options_.info_log,
+      Log(db_options_.info_log,
           "File Deletions Enable, but not really enabled. Counter: %d",
           disable_delete_obsolete_files_);
     }
@@ -65,7 +65,7 @@ Status DBImpl::EnableFileDeletions(bool force) {
   if (should_purge_files)  {
     PurgeObsoleteFiles(deletion_state);
   }
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
   return Status::OK();
 }
 
@@ -98,7 +98,7 @@ Status DBImpl::GetLiveFiles(std::vector<std::string>& ret,
 
     if (!status.ok()) {
       mutex_.Unlock();
-      Log(options_.info_log, "Cannot Flush data %s\n",
+      Log(db_options_.info_log, "Cannot Flush data %s\n",
           status.ToString().c_str());
       return status;
     }
@@ -136,7 +136,7 @@ Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
   Status s;
   // list wal files in main db dir.
   VectorLogPtr logs;
-  s = GetSortedWalsOfType(options_.wal_dir, logs, kAliveLogFile);
+  s = GetSortedWalsOfType(db_options_.wal_dir, logs, kAliveLogFile);
   if (!s.ok()) {
     return s;
   }
@@ -149,7 +149,7 @@ Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
 
   files.clear();
   // list wal files in archive dir.
-  std::string archivedir = ArchivalDirectory(options_.wal_dir);
+  std::string archivedir = ArchivalDirectory(db_options_.wal_dir);
   if (env_->FileExists(archivedir)) {
     s = GetSortedWalsOfType(archivedir, files, kArchivedLogFile);
     if (!s.ok()) {
@@ -160,7 +160,7 @@ Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
   uint64_t latest_archived_log_number = 0;
   if (!files.empty()) {
     latest_archived_log_number = files.back()->LogNumber();
-    Log(options_.info_log, "Latest Archived log: %" PRIu64,
+    Log(db_options_.info_log, "Latest Archived log: %" PRIu64,
         latest_archived_log_number);
   }
 
@@ -173,7 +173,7 @@ Status DBImpl::GetSortedWalFiles(VectorLogPtr& files) {
       // same log in both db dir and archived dir. Simply
       // ignore the one in db dir. Note that, if we read
       // archived dir first, we would have missed the log file.
-      Log(options_.info_log, "%s already moved to archive",
+      Log(db_options_.info_log, "%s already moved to archive",
           log->PathName().c_str());
     }
   }
diff --git a/db/db_impl.cc b/db/db_impl.cc
index f183044075d..1769471cfbd 100644
--- a/db/db_impl.cc
+++ b/db/db_impl.cc
@@ -335,8 +335,8 @@ CompressionType GetCompressionFlush(const Options& options) {
 DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
     : env_(options.env),
       dbname_(dbname),
-      options_(SanitizeOptions(dbname, options)),
-      stats_(options_.statistics.get()),
+      db_options_(SanitizeOptions(dbname, options)),
+      stats_(db_options_.statistics.get()),
       db_lock_(nullptr),
       mutex_(options.use_adaptive_mutex),
       shutting_down_(nullptr),
@@ -367,23 +367,23 @@ DBImpl::DBImpl(const DBOptions& options, const std::string& dbname)
 
   // Reserve ten files or so for other uses and give the rest to TableCache.
   // Give a large number for setting of "infinite" open files.
-  const int table_cache_size =
-      (options_.max_open_files == -1) ? 4194304 : options_.max_open_files - 10;
+  const int table_cache_size = (db_options_.max_open_files == -1) ?
+        4194304 : db_options_.max_open_files - 10;
   // Reserve ten files or so for other uses and give the rest to TableCache.
   table_cache_ =
-      NewLRUCache(table_cache_size, options_.table_cache_numshardbits,
-                  options_.table_cache_remove_scan_count_limit);
+      NewLRUCache(table_cache_size, db_options_.table_cache_numshardbits,
+                  db_options_.table_cache_remove_scan_count_limit);
 
   versions_.reset(
-      new VersionSet(dbname_, &options_, env_options_, table_cache_.get()));
+      new VersionSet(dbname_, &db_options_, env_options_, table_cache_.get()));
   column_family_memtables_.reset(
       new ColumnFamilyMemTablesImpl(versions_->GetColumnFamilySet()));
 
-  DumpLeveldbBuildVersion(options_.info_log.get());
-  DumpDBFileSummary(options_, dbname_);
-  options_.Dump(options_.info_log.get());
+  DumpLeveldbBuildVersion(db_options_.info_log.get());
+  DumpDBFileSummary(db_options_, dbname_);
+  db_options_.Dump(db_options_.info_log.get());
 
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
 }
 
 DBImpl::~DBImpl() {
@@ -414,7 +414,7 @@ DBImpl::~DBImpl() {
     mutex_.Lock();
   }
 
-  if (options_.allow_thread_local) {
+  if (db_options_.allow_thread_local) {
     // Clean up obsolete files due to SuperVersion release.
     // (1) Need to delete to obsolete files before closing because RepairDB()
     // scans all existing files in the file system and builds manifest file.
@@ -443,7 +443,7 @@ DBImpl::~DBImpl() {
     env_->UnlockFile(db_lock_);
   }
 
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
 }
 
 Status DBImpl::NewDB() {
@@ -452,7 +452,7 @@ Status DBImpl::NewDB() {
   new_db.SetNextFile(2);
   new_db.SetLastSequence(0);
 
-  Log(options_.info_log, "Creating manifest 1 \n");
+  Log(db_options_.info_log, "Creating manifest 1 \n");
   const std::string manifest = DescriptorFileName(dbname_, 1);
   unique_ptr<WritableFile> file;
   Status s = env_->NewWritableFile(
@@ -460,7 +460,7 @@ Status DBImpl::NewDB() {
   if (!s.ok()) {
     return s;
   }
-  file->SetPreallocationBlockSize(options_.manifest_preallocation_size);
+  file->SetPreallocationBlockSize(db_options_.manifest_preallocation_size);
   {
     log::Writer log(std::move(file));
     std::string record;
@@ -477,38 +477,38 @@ Status DBImpl::NewDB() {
 }
 
 void DBImpl::MaybeIgnoreError(Status* s) const {
-  if (s->ok() || options_.paranoid_checks) {
+  if (s->ok() || db_options_.paranoid_checks) {
     // No change needed
   } else {
-    Log(options_.info_log, "Ignoring error %s", s->ToString().c_str());
+    Log(db_options_.info_log, "Ignoring error %s", s->ToString().c_str());
     *s = Status::OK();
   }
 }
 
 const Status DBImpl::CreateArchivalDirectory() {
-  if (options_.WAL_ttl_seconds > 0 || options_.WAL_size_limit_MB > 0) {
-    std::string archivalPath = ArchivalDirectory(options_.wal_dir);
+  if (db_options_.WAL_ttl_seconds > 0 || db_options_.WAL_size_limit_MB > 0) {
+    std::string archivalPath = ArchivalDirectory(db_options_.wal_dir);
     return env_->CreateDirIfMissing(archivalPath);
   }
   return Status::OK();
 }
 
 void DBImpl::PrintStatistics() {
-  auto dbstats = options_.statistics.get();
+  auto dbstats = db_options_.statistics.get();
   if (dbstats) {
-    Log(options_.info_log,
+    Log(db_options_.info_log,
         "STATISTCS:\n %s",
         dbstats->ToString().c_str());
   }
 }
 
 void DBImpl::MaybeDumpStats() {
-  if (options_.stats_dump_period_sec == 0) return;
+  if (db_options_.stats_dump_period_sec == 0) return;
 
   const uint64_t now_micros = env_->NowMicros();
 
   if (last_stats_dump_time_microsec_ +
-      options_.stats_dump_period_sec * 1000000
+      db_options_.stats_dump_period_sec * 1000000
       <= now_micros) {
     // Multiple threads could race in here simultaneously.
     // However, the last one will update last_stats_dump_time_microsec_
@@ -532,8 +532,8 @@ void DBImpl::MaybeDumpStats() {
       default_cf_internal_stats_->GetStringProperty(db_property_type,
                                                     "rocksdb.dbstats", &stats);
     }
-    Log(options_.info_log, "------- DUMPING STATS -------");
-    Log(options_.info_log, "%s", stats.c_str());
+    Log(db_options_.info_log, "------- DUMPING STATS -------");
+    Log(db_options_.info_log, "%s", stats.c_str());
 
     PrintStatistics();
   }
@@ -543,7 +543,7 @@ void DBImpl::MaybeDumpStats() {
 // of all files in the filesystem in 'candidate_files'.
 // no_full_scan = true -- never do the full scan using GetChildren()
 // force = false -- don't force the full scan, except every
-//  options_.delete_obsolete_files_period_micros
+//  db_options_.delete_obsolete_files_period_micros
 // force = true -- force the full scan
 void DBImpl::FindObsoleteFiles(DeletionState& deletion_state,
                                bool force,
@@ -560,12 +560,12 @@ void DBImpl::FindObsoleteFiles(DeletionState& deletion_state,
   // logic for figurint out if we're doing the full scan
   if (no_full_scan) {
     doing_the_full_scan = false;
-  } else if (force || options_.delete_obsolete_files_period_micros == 0) {
+  } else if (force || db_options_.delete_obsolete_files_period_micros == 0) {
     doing_the_full_scan = true;
   } else {
     const uint64_t now_micros = env_->NowMicros();
     if (delete_obsolete_files_last_run_ +
-        options_.delete_obsolete_files_period_micros < now_micros) {
+        db_options_.delete_obsolete_files_period_micros < now_micros) {
       doing_the_full_scan = true;
       delete_obsolete_files_last_run_ = now_micros;
     }
@@ -597,11 +597,12 @@ void DBImpl::FindObsoleteFiles(DeletionState& deletion_state,
   versions_->AddLiveFiles(&deletion_state.sst_live);
 
   if (doing_the_full_scan) {
-    for (uint32_t path_id = 0; path_id < options_.db_paths.size(); path_id++) {
+    for (uint32_t path_id = 0;
+         path_id < db_options_.db_paths.size(); path_id++) {
       // set of all files in the directory. We'll exclude files that are still
       // alive in the subsequent processings.
       std::vector<std::string> files;
-      env_->GetChildren(options_.db_paths[path_id].path,
+      env_->GetChildren(db_options_.db_paths[path_id].path,
                         &files);  // Ignore errors
       for (std::string file : files) {
         deletion_state.candidate_files.emplace_back(file, path_id);
@@ -609,17 +610,18 @@ void DBImpl::FindObsoleteFiles(DeletionState& deletion_state,
     }
 
     //Add log files in wal_dir
-    if (options_.wal_dir != dbname_) {
+    if (db_options_.wal_dir != dbname_) {
       std::vector<std::string> log_files;
-      env_->GetChildren(options_.wal_dir, &log_files); // Ignore errors
+      env_->GetChildren(db_options_.wal_dir, &log_files);  // Ignore errors
       for (std::string log_file : log_files) {
         deletion_state.candidate_files.emplace_back(log_file, 0);
       }
     }
     // Add info log files in db_log_dir
-    if (!options_.db_log_dir.empty() && options_.db_log_dir != dbname_) {
+    if (!db_options_.db_log_dir.empty() && db_options_.db_log_dir != dbname_) {
       std::vector<std::string> info_log_files;
-      env_->GetChildren(options_.db_log_dir, &info_log_files);  // Ignore errors
+      // Ignore errors
+      env_->GetChildren(db_options_.db_log_dir, &info_log_files);
       for (std::string log_file : info_log_files) {
         deletion_state.candidate_files.emplace_back(log_file, 0);
       }
@@ -690,7 +692,7 @@ void DBImpl::PurgeObsoleteFiles(DeletionState& state) {
                         candidate_files.end());
 
   std::vector<std::string> old_info_log_files;
-  InfoLogPrefix info_log_prefix(!options_.db_log_dir.empty(), dbname_);
+  InfoLogPrefix info_log_prefix(!db_options_.db_log_dir.empty(), dbname_);
   for (const auto& candidate_file : candidate_files) {
     std::string to_delete = candidate_file.file_name;
     uint32_t path_id = candidate_file.path_id;
@@ -746,51 +748,51 @@ void DBImpl::PurgeObsoleteFiles(DeletionState& state) {
     if (type == kTableFile) {
       // evict from cache
       TableCache::Evict(table_cache_.get(), number);
-      fname = TableFileName(options_.db_paths, number, path_id);
+      fname = TableFileName(db_options_.db_paths, number, path_id);
     } else {
-      fname =
-          ((type == kLogFile) ? options_.wal_dir : dbname_) + "/" + to_delete;
+      fname = ((type == kLogFile) ?
+          db_options_.wal_dir : dbname_) + "/" + to_delete;
     }
 
     if (type == kLogFile &&
-        (options_.WAL_ttl_seconds > 0 || options_.WAL_size_limit_MB > 0)) {
-      auto archived_log_name = ArchivedLogFileName(options_.wal_dir, number);
+        (db_options_.WAL_ttl_seconds > 0 ||
+         db_options_.WAL_size_limit_MB > 0)) {
+      auto archived_log_name = ArchivedLogFileName(db_options_.wal_dir, number);
       // The sync point below is used in (DBTest,TransactionLogIteratorRace)
       TEST_SYNC_POINT("DBImpl::PurgeObsoleteFiles:1");
       Status s = env_->RenameFile(fname, archived_log_name);
       // The sync point below is used in (DBTest,TransactionLogIteratorRace)
       TEST_SYNC_POINT("DBImpl::PurgeObsoleteFiles:2");
-      Log(options_.info_log,
+      Log(db_options_.info_log,
           "Move log file %s to %s -- %s\n",
           fname.c_str(), archived_log_name.c_str(), s.ToString().c_str());
     } else {
       Status s = env_->DeleteFile(fname);
-      Log(options_.info_log, "Delete %s type=%d #%" PRIu64 " -- %s\n",
+      Log(db_options_.info_log, "Delete %s type=%d #%" PRIu64 " -- %s\n",
           fname.c_str(), type, number, s.ToString().c_str());
     }
   }
 
   // Delete old info log files.
   size_t old_info_log_file_count = old_info_log_files.size();
-  if (old_info_log_file_count >= options_.keep_log_file_num) {
+  if (old_info_log_file_count >= db_options_.keep_log_file_num) {
     std::sort(old_info_log_files.begin(), old_info_log_files.end());
-    size_t end = old_info_log_file_count - options_.keep_log_file_num;
+    size_t end = old_info_log_file_count - db_options_.keep_log_file_num;
     for (unsigned int i = 0; i <= end; i++) {
       std::string& to_delete = old_info_log_files.at(i);
-      std::string full_path_to_delete =
-          (options_.db_log_dir.empty() ? dbname_ : options_.db_log_dir) + "/" +
-          to_delete;
-      Log(options_.info_log, "Delete info log file %s\n",
+      std::string full_path_to_delete = (db_options_.db_log_dir.empty() ?
+           dbname_ : db_options_.db_log_dir) + "/" + to_delete;
+      Log(db_options_.info_log, "Delete info log file %s\n",
           full_path_to_delete.c_str());
       Status s = env_->DeleteFile(full_path_to_delete);
       if (!s.ok()) {
-        Log(options_.info_log, "Delete info log file %s FAILED -- %s\n",
+        Log(db_options_.info_log, "Delete info log file %s FAILED -- %s\n",
             to_delete.c_str(), s.ToString().c_str());
       }
     }
   }
   PurgeObsoleteWALFiles();
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
 }
 
 void DBImpl::DeleteObsoleteFiles() {
@@ -812,8 +814,8 @@ void DBImpl::DeleteObsoleteFiles() {
 //    b. get sorted non-empty archived logs
 //    c. delete what should be deleted
 void DBImpl::PurgeObsoleteWALFiles() {
-  bool const ttl_enabled = options_.WAL_ttl_seconds > 0;
-  bool const size_limit_enabled =  options_.WAL_size_limit_MB > 0;
+  bool const ttl_enabled = db_options_.WAL_ttl_seconds > 0;
+  bool const size_limit_enabled =  db_options_.WAL_size_limit_MB > 0;
   if (!ttl_enabled && !size_limit_enabled) {
     return;
   }
@@ -821,13 +823,14 @@ void DBImpl::PurgeObsoleteWALFiles() {
   int64_t current_time;
   Status s = env_->GetCurrentTime(&current_time);
   if (!s.ok()) {
-    Log(options_.info_log, "Can't get current time: %s", s.ToString().c_str());
+    Log(db_options_.info_log, "Can't get current time: %s",
+        s.ToString().c_str());
     assert(false);
     return;
   }
   uint64_t const now_seconds = static_cast<uint64_t>(current_time);
   uint64_t const time_to_check = (ttl_enabled && !size_limit_enabled) ?
-    options_.WAL_ttl_seconds / 2 : default_interval_to_delete_obsolete_WAL_;
+    db_options_.WAL_ttl_seconds / 2 : default_interval_to_delete_obsolete_WAL_;
 
   if (purge_wal_files_last_run_ + time_to_check > now_seconds) {
     return;
@@ -835,11 +838,12 @@ void DBImpl::PurgeObsoleteWALFiles() {
 
   purge_wal_files_last_run_ = now_seconds;
 
-  std::string archival_dir = ArchivalDirectory(options_.wal_dir);
+  std::string archival_dir = ArchivalDirectory(db_options_.wal_dir);
   std::vector<std::string> files;
   s = env_->GetChildren(archival_dir, &files);
   if (!s.ok()) {
-    Log(options_.info_log, "Can't get archive files: %s", s.ToString().c_str());
+    Log(db_options_.info_log, "Can't get archive files: %s",
+        s.ToString().c_str());
     assert(false);
     return;
   }
@@ -857,14 +861,14 @@ void DBImpl::PurgeObsoleteWALFiles() {
         Status const s = env_->GetFileModificationTime(file_path,
           &file_m_time);
         if (!s.ok()) {
-          Log(options_.info_log, "Can't get file mod time: %s: %s",
+          Log(db_options_.info_log, "Can't get file mod time: %s: %s",
               file_path.c_str(), s.ToString().c_str());
           continue;
         }
-        if (now_seconds - file_m_time > options_.WAL_ttl_seconds) {
+        if (now_seconds - file_m_time > db_options_.WAL_ttl_seconds) {
           Status const s = env_->DeleteFile(file_path);
           if (!s.ok()) {
-            Log(options_.info_log, "Can't delete file: %s: %s",
+            Log(db_options_.info_log, "Can't delete file: %s: %s",
                 file_path.c_str(), s.ToString().c_str());
             continue;
           } else {
@@ -879,7 +883,7 @@ void DBImpl::PurgeObsoleteWALFiles() {
         uint64_t file_size;
         Status const s = env_->GetFileSize(file_path, &file_size);
         if (!s.ok()) {
-          Log(options_.info_log, "Can't get file size: %s: %s",
+          Log(db_options_.info_log, "Can't get file size: %s: %s",
               file_path.c_str(), s.ToString().c_str());
           return;
         } else {
@@ -889,7 +893,7 @@ void DBImpl::PurgeObsoleteWALFiles() {
           } else {
             Status s = env_->DeleteFile(file_path);
             if (!s.ok()) {
-              Log(options_.info_log, "Can't delete file: %s: %s",
+              Log(db_options_.info_log, "Can't delete file: %s: %s",
                   file_path.c_str(), s.ToString().c_str());
               continue;
             } else {
@@ -906,7 +910,7 @@ void DBImpl::PurgeObsoleteWALFiles() {
     return;
   }
 
-  size_t const files_keep_num = options_.WAL_size_limit_MB *
+  size_t const files_keep_num = db_options_.WAL_size_limit_MB *
     1024 * 1024 / log_file_size;
   if (log_files_num <= files_keep_num) {
     return;
@@ -917,7 +921,7 @@ void DBImpl::PurgeObsoleteWALFiles() {
   GetSortedWalsOfType(archival_dir, archived_logs, kArchivedLogFile);
 
   if (files_del_num > archived_logs.size()) {
-    Log(options_.info_log, "Trying to delete more archived log files than "
+    Log(db_options_.info_log, "Trying to delete more archived log files than "
         "exist. Deleting all");
     files_del_num = archived_logs.size();
   }
@@ -926,7 +930,7 @@ void DBImpl::PurgeObsoleteWALFiles() {
     std::string const file_path = archived_logs[i]->PathName();
     Status const s = DeleteFile(file_path);
     if (!s.ok()) {
-      Log(options_.info_log, "Can't delete file: %s: %s",
+      Log(db_options_.info_log, "Can't delete file: %s: %s",
           file_path.c_str(), s.ToString().c_str());
       continue;
     } else {
@@ -1034,7 +1038,7 @@ Status DBImpl::ReadFirstRecord(const WalFileType type, const uint64_t number,
   }
   Status s;
   if (type == kAliveLogFile) {
-    std::string fname = LogFileName(options_.wal_dir, number);
+    std::string fname = LogFileName(db_options_.wal_dir, number);
     s = ReadFirstLine(fname, sequence);
     if (env_->FileExists(fname) && !s.ok()) {
       // return any error that is not caused by non-existing file
@@ -1044,7 +1048,8 @@ Status DBImpl::ReadFirstRecord(const WalFileType type, const uint64_t number,
 
   if (type == kArchivedLogFile || !s.ok()) {
     //  check if the file got moved to archive.
-    std::string archived_file = ArchivedLogFileName(options_.wal_dir, number);
+    std::string archived_file =
+        ArchivedLogFileName(db_options_.wal_dir, number);
     s = ReadFirstLine(archived_file, sequence);
   }
 
@@ -1065,7 +1070,7 @@ Status DBImpl::ReadFirstLine(const std::string& fname,
     const char* fname;
 
     Status* status;
-    bool ignore_error;  // true if options_.paranoid_checks==false
+    bool ignore_error;  // true if db_options_.paranoid_checks==false
     virtual void Corruption(size_t bytes, const Status& s) {
       Log(info_log, "%s%s: dropping %d bytes; %s",
           (this->ignore_error ? "(ignoring error) " : ""), fname,
@@ -1086,17 +1091,17 @@ Status DBImpl::ReadFirstLine(const std::string& fname,
 
   LogReporter reporter;
   reporter.env = env_;
-  reporter.info_log = options_.info_log.get();
+  reporter.info_log = db_options_.info_log.get();
   reporter.fname = fname.c_str();
   reporter.status = &status;
-  reporter.ignore_error = !options_.paranoid_checks;
+  reporter.ignore_error = !db_options_.paranoid_checks;
   log::Reader reader(std::move(file), &reporter, true /*checksum*/,
                      0 /*initial_offset*/);
   std::string scratch;
   Slice record;
 
   if (reader.ReadRecord(&record, &scratch) &&
-      (status.ok() || !options_.paranoid_checks)) {
+      (status.ok() || !db_options_.paranoid_checks)) {
     if (record.size() < 12) {
       reporter.Corruption(record.size(),
                           Status::Corruption("log record too small"));
@@ -1137,7 +1142,7 @@ Status DBImpl::Recover(
       return s;
     }
 
-    for (auto& db_path : options_.db_paths) {
+    for (auto& db_path : db_options_.db_paths) {
       s = env_->CreateDirIfMissing(db_path.path);
       if (!s.ok()) {
         return s;
@@ -1155,7 +1160,7 @@ Status DBImpl::Recover(
     }
 
     if (!env_->FileExists(CurrentFileName(dbname_))) {
-      if (options_.create_if_missing) {
+      if (db_options_.create_if_missing) {
         s = NewDB();
         is_new_db = true;
         if (!s.ok()) {
@@ -1166,7 +1171,7 @@ Status DBImpl::Recover(
             dbname_, "does not exist (create_if_missing is false)");
       }
     } else {
-      if (options_.error_if_exists) {
+      if (db_options_.error_if_exists) {
         return Status::InvalidArgument(
             dbname_, "exists (error_if_exists is true)");
       }
@@ -1181,7 +1186,7 @@ Status DBImpl::Recover(
   }
 
   Status s = versions_->Recover(column_families, read_only);
-  if (options_.paranoid_checks && s.ok()) {
+  if (db_options_.paranoid_checks && s.ok()) {
     s = CheckConsistency();
   }
   if (s.ok()) {
@@ -1202,7 +1207,7 @@ Status DBImpl::Recover(
     const uint64_t min_log = versions_->MinLogNumber();
     const uint64_t prev_log = versions_->PrevLogNumber();
     std::vector<std::string> filenames;
-    s = env_->GetChildren(options_.wal_dir, &filenames);
+    s = env_->GetChildren(db_options_.wal_dir, &filenames);
     if (!s.ok()) {
       return s;
     }
@@ -1255,8 +1260,8 @@ Status DBImpl::RecoverLogFile(uint64_t log_number, SequenceNumber* max_sequence,
     Env* env;
     Logger* info_log;
     const char* fname;
-    Status* status;  // nullptr if options_.paranoid_checks==false or
-                     //            options_.skip_log_error_on_recovery==true
+    Status* status;  // nullptr if db_options_.paranoid_checks==false or
+                     //            db_options_.skip_log_error_on_recovery==true
     virtual void Corruption(size_t bytes, const Status& s) {
       Log(info_log, "%s%s: dropping %d bytes; %s",
           (this->status == nullptr ? "(ignoring error) " : ""),
@@ -1276,7 +1281,7 @@ Status DBImpl::RecoverLogFile(uint64_t log_number, SequenceNumber* max_sequence,
   }
 
   // Open the log file
-  std::string fname = LogFileName(options_.wal_dir, log_number);
+  std::string fname = LogFileName(db_options_.wal_dir, log_number);
   unique_ptr<SequentialFile> file;
   Status status = env_->NewSequentialFile(fname, &file, env_options_);
   if (!status.ok()) {
@@ -1287,17 +1292,18 @@ Status DBImpl::RecoverLogFile(uint64_t log_number, SequenceNumber* max_sequence,
   // Create the log reader.
   LogReporter reporter;
   reporter.env = env_;
-  reporter.info_log = options_.info_log.get();
+  reporter.info_log = db_options_.info_log.get();
   reporter.fname = fname.c_str();
-  reporter.status = (options_.paranoid_checks &&
-                     !options_.skip_log_error_on_recovery ? &status : nullptr);
+  reporter.status = (db_options_.paranoid_checks &&
+                     !db_options_.skip_log_error_on_recovery ? &status
+                                                             : nullptr);
   // We intentially make log::Reader do checksumming even if
   // paranoid_checks==false so that corruptions cause entire commits
   // to be skipped instead of propagating bad information (like overly
   // large sequence numbers).
   log::Reader reader(std::move(file), &reporter, true/*checksum*/,
                      0/*initial_offset*/);
-  Log(options_.info_log, "Recovering log #%" PRIu64 "", log_number);
+  Log(db_options_.info_log, "Recovering log #%" PRIu64 "", log_number);
 
   // Read all the records and add to a memtable
   std::string scratch;
@@ -1425,7 +1431,7 @@ Status DBImpl::WriteLevel0TableForRecovery(ColumnFamilyData* cfd, MemTable* mem,
     const SequenceNumber newest_snapshot = snapshots_.GetNewest();
     const SequenceNumber earliest_seqno_in_memtable =
         mem->GetFirstSequenceNumber();
-    Log(options_.info_log, "[%s] Level-0 table #%" PRIu64 ": started",
+    Log(db_options_.info_log, "[%s] Level-0 table #%" PRIu64 ": started",
         cfd->GetName().c_str(), meta.fd.GetNumber());
 
     {
@@ -1435,11 +1441,11 @@ Status DBImpl::WriteLevel0TableForRecovery(ColumnFamilyData* cfd, MemTable* mem,
           iter.get(), &meta, cfd->internal_comparator(), newest_snapshot,
           earliest_seqno_in_memtable, GetCompressionFlush(*cfd->options()),
           cfd->options()->compression_opts, Env::IO_HIGH);
-      LogFlush(options_.info_log);
+      LogFlush(db_options_.info_log);
       mutex_.Lock();
     }
 
-    Log(options_.info_log,
+    Log(db_options_.info_log,
         "[%s] Level-0 table #%" PRIu64 ": %" PRIu64 " bytes %s",
         cfd->GetName().c_str(), meta.fd.GetNumber(), meta.fd.GetFileSize(),
         s.ToString().c_str());
@@ -1491,7 +1497,7 @@ Status DBImpl::WriteLevel0Table(ColumnFamilyData* cfd,
     ro.total_order_seek = true;
     Arena arena;
     for (MemTable* m : mems) {
-      Log(options_.info_log,
+      Log(db_options_.info_log,
           "[%s] Flushing memtable with next log file: %" PRIu64 "\n",
           cfd->GetName().c_str(), m->GetNextLogNumber());
       memtables.push_back(m->NewIterator(ro, &arena));
@@ -1500,7 +1506,8 @@ Status DBImpl::WriteLevel0Table(ColumnFamilyData* cfd,
       ScopedArenaIterator iter(NewMergingIterator(&cfd->internal_comparator(),
                                                   &memtables[0],
                                                   memtables.size(), &arena));
-      Log(options_.info_log, "[%s] Level-0 flush table #%" PRIu64 ": started",
+      Log(db_options_.info_log,
+           "[%s] Level-0 flush table #%" PRIu64 ": started",
           cfd->GetName().c_str(), meta.fd.GetNumber());
 
       s = BuildTable(
@@ -1508,14 +1515,14 @@ Status DBImpl::WriteLevel0Table(ColumnFamilyData* cfd,
           iter.get(), &meta, cfd->internal_comparator(), newest_snapshot,
           earliest_seqno_in_memtable, GetCompressionFlush(*cfd->options()),
           cfd->options()->compression_opts, Env::IO_HIGH);
-      LogFlush(options_.info_log);
+      LogFlush(db_options_.info_log);
     }
-    Log(options_.info_log,
+    Log(db_options_.info_log,
         "[%s] Level-0 flush table #%" PRIu64 ": %" PRIu64 " bytes %s",
         cfd->GetName().c_str(), meta.fd.GetNumber(), meta.fd.GetFileSize(),
         s.ToString().c_str());
 
-    if (!options_.disableDataSync) {
+    if (!db_options_.disableDataSync) {
       db_directory_->Fsync();
     }
     mutex_.Lock();
@@ -1544,7 +1551,7 @@ Status DBImpl::WriteLevel0Table(ColumnFamilyData* cfd,
     // insert files directly into higher levels because some other
     // threads could be concurrently producing compacted files for
     // that key range.
-    if (base != nullptr && options_.max_background_compactions <= 1 &&
+    if (base != nullptr && db_options_.max_background_compactions <= 1 &&
         cfd->options()->compaction_style == kCompactionStyleLevel) {
       level = base->PickLevelForMemTableOutput(min_user_key, max_user_key);
     }
@@ -1606,7 +1613,7 @@ Status DBImpl::FlushMemTableToOutputFile(ColumnFamilyData* cfd,
   } else {
     // Replace immutable memtable with the generated Table
     s = cfd->imm()->InstallMemtableFlushResults(
-        cfd, mems, versions_.get(), &mutex_, options_.info_log.get(),
+        cfd, mems, versions_.get(), &mutex_, db_options_.info_log.get(),
         file_number, &pending_outputs_, &deletion_state.memtables_to_free,
         db_directory_.get(), log_buffer);
   }
@@ -1632,7 +1639,7 @@ Status DBImpl::FlushMemTableToOutputFile(ColumnFamilyData* cfd,
     }
   }
 
-  if (!s.ok() && !s.IsShutdownInProgress() && options_.paranoid_checks &&
+  if (!s.ok() && !s.IsShutdownInProgress() && db_options_.paranoid_checks &&
       bg_error_.ok()) {
     // if a bad error happened (not ShutdownInProgress) and paranoid_checks is
     // true, mark DB read-only
@@ -1646,7 +1653,7 @@ Status DBImpl::CompactRange(ColumnFamilyHandle* column_family,
                             const Slice* begin, const Slice* end,
                             bool reduce_level, int target_level,
                             uint32_t target_path_id) {
-  if (target_path_id >= options_.db_paths.size()) {
+  if (target_path_id >= db_options_.db_paths.size()) {
     return Status::InvalidArgument("Invalid target path ID");
   }
 
@@ -1655,7 +1662,7 @@ Status DBImpl::CompactRange(ColumnFamilyHandle* column_family,
 
   Status s = FlushMemTable(cfd, FlushOptions());
   if (!s.ok()) {
-    LogFlush(options_.info_log);
+    LogFlush(db_options_.info_log);
     return s;
   }
 
@@ -1683,7 +1690,7 @@ Status DBImpl::CompactRange(ColumnFamilyHandle* column_family,
                               end);
     }
     if (!s.ok()) {
-      LogFlush(options_.info_log);
+      LogFlush(db_options_.info_log);
       return s;
     }
   }
@@ -1691,7 +1698,7 @@ Status DBImpl::CompactRange(ColumnFamilyHandle* column_family,
   if (reduce_level) {
     s = ReFitLevel(cfd, max_level_with_files, target_level);
   }
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
 
   {
     MutexLock l(&mutex_);
@@ -1733,7 +1740,7 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
   // only allow one thread refitting
   if (refitting_level_) {
     mutex_.Unlock();
-    Log(options_.info_log, "ReFitLevel: another thread is refitting");
+    Log(db_options_.info_log, "ReFitLevel: another thread is refitting");
     delete new_superversion;
     return Status::NotSupported("another thread is refitting");
   }
@@ -1742,7 +1749,7 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
   // wait for all background threads to stop
   bg_work_gate_closed_ = true;
   while (bg_compaction_scheduled_ > 0 || bg_flush_scheduled_) {
-    Log(options_.info_log,
+    Log(db_options_.info_log,
         "RefitLevel: waiting for background threads to stop: %d %d",
         bg_compaction_scheduled_, bg_flush_scheduled_);
     bg_cv_.Wait();
@@ -1758,8 +1765,8 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
 
   Status status;
   if (to_level < level) {
-    Log(options_.info_log, "[%s] Before refitting:\n%s", cfd->GetName().c_str(),
-        cfd->current()->DebugString().data());
+    Log(db_options_.info_log, "[%s] Before refitting:\n%s",
+        cfd->GetName().c_str(), cfd->current()->DebugString().data());
 
     VersionEdit edit;
     edit.SetColumnFamily(cfd->GetID());
@@ -1769,18 +1776,18 @@ Status DBImpl::ReFitLevel(ColumnFamilyData* cfd, int level, int target_level) {
                    f->fd.GetFileSize(), f->smallest, f->largest,
                    f->smallest_seqno, f->largest_seqno);
     }
-    Log(options_.info_log, "[%s] Apply version edit:\n%s",
+    Log(db_options_.info_log, "[%s] Apply version edit:\n%s",
         cfd->GetName().c_str(), edit.DebugString().data());
 
     status = versions_->LogAndApply(cfd, &edit, &mutex_, db_directory_.get());
     superversion_to_free = cfd->InstallSuperVersion(new_superversion, &mutex_);
     new_superversion = nullptr;
 
-    Log(options_.info_log, "[%s] LogAndApply: %s\n", cfd->GetName().c_str(),
+    Log(db_options_.info_log, "[%s] LogAndApply: %s\n", cfd->GetName().c_str(),
         status.ToString().data());
 
     if (status.ok()) {
-      Log(options_.info_log, "[%s] After refitting:\n%s",
+      Log(db_options_.info_log, "[%s] After refitting:\n%s",
           cfd->GetName().c_str(), cfd->current()->DebugString().data());
     }
   }
@@ -1870,14 +1877,14 @@ Status DBImpl::RunManualCompaction(ColumnFamilyData* cfd, int input_level,
 
   ++bg_manual_only_;
   while (bg_compaction_scheduled_ > 0) {
-    Log(options_.info_log,
+    Log(db_options_.info_log,
         "[%s] Manual compaction waiting for all other scheduled background "
         "compactions to finish",
         cfd->GetName().c_str());
     bg_cv_.Wait();
   }
 
-  Log(options_.info_log, "[%s] Manual compaction starting",
+  Log(db_options_.info_log, "[%s] Manual compaction starting",
       cfd->GetName().c_str());
 
   while (!manual.done && !shutting_down_.Acquire_Load() && bg_error_.ok()) {
@@ -1965,10 +1972,10 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
     }
     if (is_flush_pending) {
       // memtable flush needed
-      if (bg_flush_scheduled_ < options_.max_background_flushes) {
+      if (bg_flush_scheduled_ < db_options_.max_background_flushes) {
         bg_flush_scheduled_++;
         env_->Schedule(&DBImpl::BGWorkFlush, this, Env::Priority::HIGH);
-      } else if (options_.max_background_flushes > 0) {
+      } else if (db_options_.max_background_flushes > 0) {
         bg_schedule_needed_ = true;
       }
     }
@@ -1987,8 +1994,8 @@ void DBImpl::MaybeScheduleFlushOrCompaction() {
     // bg_manual_only_ == 0
     if (!bg_manual_only_ &&
         (is_compaction_needed ||
-         (is_flush_pending && options_.max_background_flushes == 0))) {
-      if (bg_compaction_scheduled_ < options_.max_background_compactions) {
+         (is_flush_pending && db_options_.max_background_flushes == 0))) {
+      if (bg_compaction_scheduled_ < db_options_.max_background_compactions) {
         bg_compaction_scheduled_++;
         env_->Schedule(&DBImpl::BGWorkCompaction, this, Env::Priority::LOW);
       } else {
@@ -2038,7 +2045,7 @@ Status DBImpl::BackgroundFlush(bool* madeProgress,
           "BackgroundCallFlush doing FlushMemTableToOutputFile with column "
           "family [%s], flush slots available %d",
           cfd->GetName().c_str(),
-          options_.max_background_flushes - bg_flush_scheduled_);
+          db_options_.max_background_flushes - bg_flush_scheduled_);
       flush_status = FlushMemTableToOutputFile(cfd, madeProgress,
                                                deletion_state, log_buffer);
     }
@@ -2056,7 +2063,7 @@ void DBImpl::BackgroundCallFlush() {
   DeletionState deletion_state(true);
   assert(bg_flush_scheduled_);
 
-  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, options_.info_log.get());
+  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, db_options_.info_log.get());
   {
     MutexLock l(&mutex_);
 
@@ -2072,12 +2079,12 @@ void DBImpl::BackgroundCallFlush() {
           default_cf_internal_stats_->BumpAndGetBackgroundErrorCount();
         bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
         mutex_.Unlock();
-        Log(options_.info_log,
+        Log(db_options_.info_log,
             "Waiting after background flush error: %s"
             "Accumulated background error counts: %" PRIu64,
             s.ToString().c_str(), error_cnt);
         log_buffer.FlushBufferToLog();
-        LogFlush(options_.info_log);
+        LogFlush(db_options_.info_log);
         env_->SleepForMicroseconds(1000000);
         mutex_.Lock();
       }
@@ -2123,7 +2130,7 @@ void DBImpl::BackgroundCallCompaction() {
   DeletionState deletion_state(true);
 
   MaybeDumpStats();
-  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, options_.info_log.get());
+  LogBuffer log_buffer(InfoLogLevel::INFO_LEVEL, db_options_.info_log.get());
   {
     MutexLock l(&mutex_);
     assert(bg_compaction_scheduled_);
@@ -2140,11 +2147,11 @@ void DBImpl::BackgroundCallCompaction() {
         bg_cv_.SignalAll();  // In case a waiter can proceed despite the error
         mutex_.Unlock();
         log_buffer.FlushBufferToLog();
-        Log(options_.info_log,
+        Log(db_options_.info_log,
             "Waiting after background compaction error: %s, "
             "Accumulated background error counts: %" PRIu64,
             s.ToString().c_str(), error_cnt);
-        LogFlush(options_.info_log);
+        LogFlush(db_options_.info_log);
         env_->SleepForMicroseconds(1000000);
         mutex_.Lock();
       }
@@ -2228,7 +2235,7 @@ Status DBImpl::BackgroundCompaction(bool* madeProgress,
           log_buffer,
           "BackgroundCompaction doing FlushMemTableToOutputFile, "
           "compaction slots available %d",
-          options_.max_background_compactions - bg_compaction_scheduled_);
+          db_options_.max_background_compactions - bg_compaction_scheduled_);
       cfd->Ref();
       flush_stat = FlushMemTableToOutputFile(cfd, madeProgress, deletion_state,
                                              log_buffer);
@@ -2340,9 +2347,9 @@ Status DBImpl::BackgroundCompaction(bool* madeProgress,
   } else if (status.IsShutdownInProgress()) {
     // Ignore compaction errors found during shutting down
   } else {
-    Log(InfoLogLevel::WARN_LEVEL, options_.info_log, "Compaction error: %s",
+    Log(InfoLogLevel::WARN_LEVEL, db_options_.info_log, "Compaction error: %s",
         status.ToString().c_str());
-    if (options_.paranoid_checks && bg_error_.ok()) {
+    if (db_options_.paranoid_checks && bg_error_.ok()) {
       bg_error_ = status;
     }
   }
@@ -2454,7 +2461,7 @@ Status DBImpl::OpenCompactionOutputFile(CompactionState* compact) {
   compact->outputs.push_back(out);
 
   // Make the output file
-  std::string fname = TableFileName(options_.db_paths, file_number,
+  std::string fname = TableFileName(db_options_.db_paths, file_number,
                                     compact->compaction->GetOutputPathId());
   Status s = env_->NewWritableFile(fname, &compact->outfile, env_options_);
 
@@ -2469,7 +2476,7 @@ Status DBImpl::OpenCompactionOutputFile(CompactionState* compact) {
         compact->compaction->OutputCompressionType(),
         cfd->options()->compression_opts));
   }
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
   return s;
 }
 
@@ -2497,8 +2504,8 @@ Status DBImpl::FinishCompactionOutputFile(CompactionState* compact,
   compact->builder.reset();
 
   // Finish and check for file errors
-  if (s.ok() && !options_.disableDataSync) {
-    if (options_.use_fsync) {
+  if (s.ok() && !db_options_.disableDataSync) {
+    if (db_options_.use_fsync) {
       StopWatch sw(env_, stats_, COMPACTION_OUTFILE_SYNC_MICROS);
       s = compact->outfile->Fsync();
     } else {
@@ -2520,7 +2527,7 @@ Status DBImpl::FinishCompactionOutputFile(CompactionState* compact,
     s = iter->status();
     delete iter;
     if (s.ok()) {
-      Log(options_.info_log, "[%s] Generated table #%" PRIu64 ": %" PRIu64
+      Log(db_options_.info_log, "[%s] Generated table #%" PRIu64 ": %" PRIu64
                              " keys, %" PRIu64 " bytes",
           cfd->GetName().c_str(), output_number, current_entries,
           current_bytes);
@@ -2539,7 +2546,7 @@ Status DBImpl::InstallCompactionResults(CompactionState* compact,
   // This ensures that a concurrent compaction did not erroneously
   // pick the same files to compact.
   if (!versions_->VerifyCompactionFileConsistency(compact->compaction)) {
-    Log(options_.info_log, "[%s] Compaction %d@%d + %d@%d files aborted",
+    Log(db_options_.info_log, "[%s] Compaction %d@%d + %d@%d files aborted",
         compact->compaction->column_family_data()->GetName().c_str(),
         compact->compaction->num_input_files(0), compact->compaction->level(),
         compact->compaction->num_input_files(1),
@@ -2588,7 +2595,7 @@ inline SequenceNumber DBImpl::findEarliestVisibleSnapshot(
     prev = cur; // assignment
     assert(prev);
   }
-  Log(options_.info_log,
+  Log(db_options_.info_log,
       "Looking for seqid %" PRIu64 " but maxseqid is %" PRIu64 "", in,
       snapshots[snapshots.size() - 1]);
   assert(0);
@@ -2598,7 +2605,7 @@ inline SequenceNumber DBImpl::findEarliestVisibleSnapshot(
 uint64_t DBImpl::CallFlushDuringCompaction(ColumnFamilyData* cfd,
                                            DeletionState& deletion_state,
                                            LogBuffer* log_buffer) {
-  if (options_.max_background_flushes > 0) {
+  if (db_options_.max_background_flushes > 0) {
     // flush thread will take care of this
     return 0;
   }
@@ -2643,7 +2650,7 @@ Status DBImpl::ProcessKeyValueCompaction(
   ColumnFamilyData* cfd = compact->compaction->column_family_data();
   MergeHelper merge(
       cfd->user_comparator(), cfd->options()->merge_operator.get(),
-      options_.info_log.get(), cfd->options()->min_partial_merge_operands,
+      db_options_.info_log.get(), cfd->options()->min_partial_merge_operands,
       false /* internal key corruption is expected */);
   auto compaction_filter = cfd->options()->compaction_filter;
   std::unique_ptr<CompactionFilter> compaction_filter_from_factory = nullptr;
@@ -2810,7 +2817,7 @@ Status DBImpl::ProcessKeyValueCompaction(
         // optimization in BuildTable.
         int steps = 0;
         merge.MergeUntil(input, prev_snapshot, bottommost_level,
-            options_.statistics.get(), &steps);
+            db_options_.statistics.get(), &steps);
         // Skip the Merge ops
         combined_idx = combined_idx - 1 + steps;
 
@@ -3037,7 +3044,7 @@ Status DBImpl::DoCompactionWork(CompactionState* compact,
       cfd->GetName().c_str(), compact->compaction->num_input_files(0),
       compact->compaction->level(), compact->compaction->num_input_files(1),
       compact->compaction->output_level(), compact->compaction->score(),
-      options_.max_background_compactions - bg_compaction_scheduled_);
+      db_options_.max_background_compactions - bg_compaction_scheduled_);
   char scratch[2345];
   compact->compaction->Summary(scratch, sizeof(scratch));
   LogToBuffer(log_buffer, "[%s] Compaction start summary: %s\n",
@@ -3113,7 +3120,7 @@ Status DBImpl::DoCompactionWork(CompactionState* compact,
 
       if (!ParseInternalKey(key, &ikey)) {
         // log error
-        Log(options_.info_log, "[%s] Failed to parse key: %s",
+        Log(db_options_.info_log, "[%s] Failed to parse key: %s",
             cfd->GetName().c_str(), key.ToString().c_str());
         continue;
       } else {
@@ -3254,7 +3261,7 @@ Status DBImpl::DoCompactionWork(CompactionState* compact,
   }
   input.reset();
 
-  if (!options_.disableDataSync) {
+  if (!db_options_.disableDataSync) {
     db_directory_->Fsync();
   }
 
@@ -3286,7 +3293,7 @@ Status DBImpl::DoCompactionWork(CompactionState* compact,
 
   RecordCompactionIOStats();
 
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
   mutex_.Lock();
   cfd->internal_stats()->AddCompactionStats(
       compact->compaction->output_level(), stats);
@@ -3598,12 +3605,12 @@ Status DBImpl::CreateColumnFamily(const ColumnFamilyOptions& options,
     assert(cfd != nullptr);
     delete cfd->InstallSuperVersion(new SuperVersion(), &mutex_);
     *handle = new ColumnFamilyHandleImpl(cfd, this, &mutex_);
-    Log(options_.info_log, "Created column family [%s] (ID %u)",
+    Log(db_options_.info_log, "Created column family [%s] (ID %u)",
         column_family_name.c_str(), (unsigned)cfd->GetID());
     max_total_in_memory_state_ += cfd->options()->write_buffer_size *
                                   cfd->options()->max_write_buffer_number;
   } else {
-    Log(options_.info_log, "Creating column family [%s] FAILED -- %s",
+    Log(db_options_.info_log, "Creating column family [%s] FAILED -- %s",
         column_family_name.c_str(), s.ToString().c_str());
   }
   return s;
@@ -3635,9 +3642,11 @@ Status DBImpl::DropColumnFamily(ColumnFamilyHandle* column_family) {
     assert(cfd->IsDropped());
     max_total_in_memory_state_ -= cfd->options()->write_buffer_size *
                                   cfd->options()->max_write_buffer_number;
-    Log(options_.info_log, "Dropped column family with id %u\n", cfd->GetID());
+    Log(db_options_.info_log, "Dropped column family with id %u\n",
+        cfd->GetID());
   } else {
-    Log(options_.info_log, "Dropping column family with id %u FAILED -- %s\n",
+    Log(db_options_.info_log,
+        "Dropping column family with id %u FAILED -- %s\n",
         cfd->GetID(), s.ToString().c_str());
   }
 
@@ -3967,15 +3976,15 @@ Status DBImpl::Write(const WriteOptions& options, WriteBatch* my_batch) {
          versions_->GetColumnFamilySet()->NumberOfColumnFamilies() == 1);
 
   uint64_t flush_column_family_if_log_file = 0;
-  uint64_t max_total_wal_size = (options_.max_total_wal_size == 0)
+  uint64_t max_total_wal_size = (db_options_.max_total_wal_size == 0)
                                     ? 4 * max_total_in_memory_state_
-                                    : options_.max_total_wal_size;
+                                    : db_options_.max_total_wal_size;
   if (UNLIKELY(!single_column_family_mode_) &&
       alive_log_files_.begin()->getting_flushed == false &&
       total_log_size_ > max_total_wal_size) {
     flush_column_family_if_log_file = alive_log_files_.begin()->number;
     alive_log_files_.begin()->getting_flushed = true;
-    Log(options_.info_log,
+    Log(db_options_.info_log,
         "Flushing all column families with data in WAL number %" PRIu64
         ". Total log size is %" PRIu64 " while max_total_wal_size is %" PRIu64,
         flush_column_family_if_log_file, total_log_size_, max_total_wal_size);
@@ -4061,7 +4070,7 @@ Status DBImpl::Write(const WriteOptions& options, WriteBatch* my_batch) {
         RecordTick(stats_, WAL_FILE_SYNCED);
         RecordTick(stats_, WAL_FILE_BYTES, log_size);
         if (status.ok() && options.sync) {
-          if (options_.use_fsync) {
+          if (db_options_.use_fsync) {
             StopWatch(env_, stats_, WAL_FILE_SYNC_MICROS);
             status = log_->file()->Fsync();
           } else {
@@ -4105,7 +4114,7 @@ Status DBImpl::Write(const WriteOptions& options, WriteBatch* my_batch) {
       }
     }
   }
-  if (options_.paranoid_checks && !status.ok() &&
+  if (db_options_.paranoid_checks && !status.ok() &&
       !status.IsTimedOut() && bg_error_.ok()) {
     bg_error_ = status; // stop compaction & fail any further writes
   }
@@ -4270,7 +4279,7 @@ Status DBImpl::MakeRoomForWrite(ColumnFamilyData* cfd,
       // We have filled up the current memtable, but the previous
       // ones are still being flushed, so we wait.
       DelayLoggingAndReset();
-      Log(options_.info_log, "[%s] wait for memtable flush...\n",
+      Log(db_options_.info_log, "[%s] wait for memtable flush...\n",
           cfd->GetName().c_str());
       if (schedule_background_work) {
         MaybeScheduleFlushOrCompaction();
@@ -4290,7 +4299,7 @@ Status DBImpl::MakeRoomForWrite(ColumnFamilyData* cfd,
           InternalStats::MEMTABLE_COMPACTION, stall);
     } else if (cfd->NeedWaitForNumLevel0Files()) {
       DelayLoggingAndReset();
-      Log(options_.info_log, "[%s] wait for fewer level0 files...\n",
+      Log(db_options_.info_log, "[%s] wait for fewer level0 files...\n",
           cfd->GetName().c_str());
       uint64_t stall;
       {
@@ -4374,9 +4383,9 @@ Status DBImpl::SetNewMemtableAndNewLogFile(ColumnFamilyData* cfd,
   {
     DelayLoggingAndReset();
     if (creating_new_log) {
-      s = env_->NewWritableFile(LogFileName(options_.wal_dir, new_log_number),
-                                &lfile,
-                                env_->OptimizeForLogWrite(env_options_));
+      s = env_->NewWritableFile(
+          LogFileName(db_options_.wal_dir, new_log_number),
+          &lfile, env_->OptimizeForLogWrite(env_options_));
       if (s.ok()) {
         // Our final size should be less than write_buffer_size
         // (compression, etc) but err on the side of caution.
@@ -4423,7 +4432,7 @@ Status DBImpl::SetNewMemtableAndNewLogFile(ColumnFamilyData* cfd,
   cfd->imm()->Add(cfd->mem());
   new_mem->Ref();
   cfd->SetMemtable(new_mem);
-  Log(options_.info_log,
+  Log(db_options_.info_log,
       "[%s] New memtable created with log file: #%" PRIu64 "\n",
       cfd->GetName().c_str(), logfile_number_);
   context->superversions_to_free_.push_back(
@@ -4528,7 +4537,7 @@ bool DBImpl::GetIntPropertyInternal(ColumnFamilyHandle* column_family,
 
 SuperVersion* DBImpl::GetAndRefSuperVersion(ColumnFamilyData* cfd) {
   // TODO(ljin): consider using GetReferencedSuperVersion() directly
-  if (LIKELY(options_.allow_thread_local)) {
+  if (LIKELY(db_options_.allow_thread_local)) {
     return cfd->GetThreadLocalSuperVersion(&mutex_);
   } else {
     MutexLock l(&mutex_);
@@ -4539,7 +4548,7 @@ SuperVersion* DBImpl::GetAndRefSuperVersion(ColumnFamilyData* cfd) {
 void DBImpl::ReturnAndCleanupSuperVersion(ColumnFamilyData* cfd,
                                           SuperVersion* sv) {
   bool unref_sv = true;
-  if (LIKELY(options_.allow_thread_local)) {
+  if (LIKELY(db_options_.allow_thread_local)) {
     unref_sv = !cfd->ReturnThreadLocalSuperVersion(sv);
   }
 
@@ -4586,7 +4595,7 @@ void DBImpl::GetApproximateSizes(ColumnFamilyHandle* column_family,
 
 inline void DBImpl::DelayLoggingAndReset() {
   if (delayed_writes_ > 0) {
-    Log(options_.info_log, "delayed %d write...\n", delayed_writes_ );
+    Log(db_options_.info_log, "delayed %d write...\n", delayed_writes_);
     delayed_writes_ = 0;
   }
 }
@@ -4613,7 +4622,7 @@ Status DBImpl::GetUpdatesSince(
   if (!s.ok()) {
     return s;
   }
-  iter->reset(new TransactionLogIteratorImpl(options_.wal_dir, &options_,
+  iter->reset(new TransactionLogIteratorImpl(db_options_.wal_dir, &db_options_,
                                              read_options, env_options_,
                                              seq, std::move(wal_files), this));
   return (*iter)->status();
@@ -4625,7 +4634,7 @@ Status DBImpl::DeleteFile(std::string name) {
   WalFileType log_type;
   if (!ParseFileName(name, &number, &type, &log_type) ||
       (type != kTableFile && type != kLogFile)) {
-    Log(options_.info_log, "DeleteFile %s failed.\n", name.c_str());
+    Log(db_options_.info_log, "DeleteFile %s failed.\n", name.c_str());
     return Status::InvalidArgument("Invalid file name");
   }
 
@@ -4633,13 +4642,13 @@ Status DBImpl::DeleteFile(std::string name) {
   if (type == kLogFile) {
     // Only allow deleting archived log files
     if (log_type != kArchivedLogFile) {
-      Log(options_.info_log, "DeleteFile %s failed - not archived log.\n",
+      Log(db_options_.info_log, "DeleteFile %s failed - not archived log.\n",
           name.c_str());
       return Status::NotSupported("Delete only supported for archived logs");
     }
-    status = env_->DeleteFile(options_.wal_dir + "/" + name.c_str());
+    status = env_->DeleteFile(db_options_.wal_dir + "/" + name.c_str());
     if (!status.ok()) {
-      Log(options_.info_log, "DeleteFile %s failed -- %s.\n",
+      Log(db_options_.info_log, "DeleteFile %s failed -- %s.\n",
           name.c_str(), status.ToString().c_str());
     }
     return status;
@@ -4654,7 +4663,7 @@ Status DBImpl::DeleteFile(std::string name) {
     MutexLock l(&mutex_);
     status = versions_->GetMetadataForFile(number, &level, &metadata, &cfd);
     if (!status.ok()) {
-      Log(options_.info_log, "DeleteFile %s failed. File not found\n",
+      Log(db_options_.info_log, "DeleteFile %s failed. File not found\n",
                              name.c_str());
       return Status::InvalidArgument("File not found");
     }
@@ -4662,7 +4671,7 @@ Status DBImpl::DeleteFile(std::string name) {
 
     // If the file is being compacted no need to delete.
     if (metadata->being_compacted) {
-      Log(options_.info_log,
+      Log(db_options_.info_log,
           "DeleteFile %s Skipped. File about to be compacted\n", name.c_str());
       return Status::OK();
     }
@@ -4672,7 +4681,7 @@ Status DBImpl::DeleteFile(std::string name) {
     // lost. Check that the level passed is the last level.
     for (int i = level + 1; i < cfd->NumberLevels(); i++) {
       if (cfd->current()->NumLevelFiles(i) != 0) {
-        Log(options_.info_log,
+        Log(db_options_.info_log,
             "DeleteFile %s FAILED. File not in last level\n", name.c_str());
         return Status::InvalidArgument("File not in last level");
       }
@@ -4684,7 +4693,7 @@ Status DBImpl::DeleteFile(std::string name) {
     }
     FindObsoleteFiles(deletion_state, false);
   } // lock released here
-  LogFlush(options_.info_log);
+  LogFlush(db_options_.info_log);
   // remove files outside the db-lock
   if (deletion_state.HaveSomethingToDelete()) {
     PurgeObsoleteFiles(deletion_state);
@@ -4846,9 +4855,9 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
   }
 
   DBImpl* impl = new DBImpl(db_options, dbname);
-  s = impl->env_->CreateDirIfMissing(impl->options_.wal_dir);
+  s = impl->env_->CreateDirIfMissing(impl->db_options_.wal_dir);
   if (s.ok()) {
-    for (auto db_path : impl->options_.db_paths) {
+    for (auto db_path : impl->db_options_.db_paths) {
       s = impl->env_->CreateDirIfMissing(db_path.path);
       if (!s.ok()) {
         break;
@@ -4873,9 +4882,9 @@ Status DB::Open(const DBOptions& db_options, const std::string& dbname,
     uint64_t new_log_number = impl->versions_->NewFileNumber();
     unique_ptr<WritableFile> lfile;
     EnvOptions soptions(db_options);
-    s = impl->options_.env->NewWritableFile(
-        LogFileName(impl->options_.wal_dir, new_log_number), &lfile,
-        impl->options_.env->OptimizeForLogWrite(soptions));
+    s = impl->db_options_.env->NewWritableFile(
+        LogFileName(impl->db_options_.wal_dir, new_log_number), &lfile,
+        impl->db_options_.env->OptimizeForLogWrite(soptions));
     if (s.ok()) {
       lfile->SetPreallocationBlockSize(1.1 * max_write_buffer_size);
       impl->logfile_number_ = new_log_number;
diff --git a/db/db_impl.h b/db/db_impl.h
index 1ccaabb6ce0..e49b954cc5d 100644
--- a/db/db_impl.h
+++ b/db/db_impl.h
@@ -276,7 +276,7 @@ class DBImpl : public DB {
   // Returns the list of live files in 'live' and the list
   // of all files in the filesystem in 'candidate_files'.
   // If force == false and the last call was less than
-  // options_.delete_obsolete_files_period_micros microseconds ago,
+  // db_options_.delete_obsolete_files_period_micros microseconds ago,
   // it will not fill up the deletion_state
   void FindObsoleteFiles(DeletionState& deletion_state,
                          bool force,
@@ -294,7 +294,7 @@ class DBImpl : public DB {
   Env* const env_;
   const std::string dbname_;
   unique_ptr<VersionSet> versions_;
-  const DBOptions options_;
+  const DBOptions db_options_;
   Statistics* stats_;
 
   Iterator* NewInternalIterator(const ReadOptions&, ColumnFamilyData* cfd,
diff --git a/db/db_impl_readonly.cc b/db/db_impl_readonly.cc
index 6c864aefd80..db0718bd1f8 100644
--- a/db/db_impl_readonly.cc
+++ b/db/db_impl_readonly.cc
@@ -44,7 +44,7 @@ namespace rocksdb {
 DBImplReadOnly::DBImplReadOnly(const DBOptions& options,
                                const std::string& dbname)
     : DBImpl(options, dbname) {
-  Log(options_.info_log, "Opening the db in read only mode");
+  Log(db_options_.info_log, "Opening the db in read only mode");
 }
 
 DBImplReadOnly::~DBImplReadOnly() {