@nxtedition/rocksdb 10.0.13 → 10.0.15

package/deps/rocksdb/rocksdb/db/obsolete_files_test.cc

@@ -7,10 +7,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
-
-#include <stdlib.h>
-
 #include <algorithm>
+#include <cstdlib>
 #include <map>
 #include <string>
 #include <vector>
@@ -68,7 +66,7 @@ class ObsoleteFilesTest : public DBTestBase {
     int log_cnt = 0;
     int sst_cnt = 0;
     int manifest_cnt = 0;
-    for (auto file : filenames) {
+    for (const auto& file : filenames) {
       uint64_t number;
       FileType type;
       if (ParseFileName(file, &number, &type)) {
@@ -120,7 +118,7 @@ TEST_F(ObsoleteFilesTest, RaceForObsoleteFileDeletion) {
   });
   SyncPoint::GetInstance()->SetCallBack(
       "DBImpl::DeleteObsoleteFileImpl:AfterDeletion", [&](void* arg) {
-        Status* p_status = reinterpret_cast<Status*>(arg);
+        Status* p_status = static_cast<Status*>(arg);
         ASSERT_OK(*p_status);
       });
   SyncPoint::GetInstance()->SetCallBack(
@@ -165,7 +163,7 @@ TEST_F(ObsoleteFilesTest, DeleteObsoleteOptionsFile) {
                                      {{"paranoid_file_checks", "true"}}));
     }
   }
-  ASSERT_OK(dbfull()->EnableFileDeletions(true /* force */));
+  ASSERT_OK(dbfull()->EnableFileDeletions());
 
   Close();
 

package/deps/rocksdb/rocksdb/db/options_file_test.cc

@@ -28,7 +28,7 @@ void UpdateOptionsFiles(DB* db,
   uint64_t number;
   FileType type;
   *options_files_count = 0;
-  for (auto filename : filenames) {
+  for (const auto& filename : filenames) {
     if (ParseFileName(filename, &number, &type) && type == kOptionsFile) {
       filename_history->insert(filename);
       (*options_files_count)++;
@@ -44,16 +44,16 @@ void VerifyOptionsFileName(
   EXPECT_OK(db->GetEnv()->GetChildren(db->GetName(), &filenames));
   uint64_t number;
   FileType type;
-  for (auto filename : filenames) {
+  for (const auto& filename : filenames) {
     if (ParseFileName(filename, &number, &type) && type == kOptionsFile) {
       current_filenames.insert(filename);
     }
   }
-  for (auto past_filename : past_filenames) {
+  for (const auto& past_filename : past_filenames) {
     if (current_filenames.find(past_filename) != current_filenames.end()) {
       continue;
     }
-    for (auto filename : current_filenames) {
+    for (const auto& filename : current_filenames) {
       ASSERT_GT(filename, past_filename);
     }
   }

package/deps/rocksdb/rocksdb/db/output_validator.cc

@@ -15,19 +15,15 @@ Status OutputValidator::Add(const Slice& key, const Slice& value) {
     paranoid_hash_ = NPHash64(key.data(), key.size(), paranoid_hash_);
     paranoid_hash_ = NPHash64(value.data(), value.size(), paranoid_hash_);
   }
-  if (enable_order_check_) {
-    TEST_SYNC_POINT_CALLBACK("OutputValidator::Add:order_check",
-                             /*arg=*/nullptr);
-    if (key.size() < kNumInternalBytes) {
-      return Status::Corruption(
-          "Compaction tries to write a key without internal bytes.");
-    }
-    // prev_key_ starts with empty.
-    if (!prev_key_.empty() && icmp_.Compare(key, prev_key_) < 0) {
-      return Status::Corruption("Compaction sees out-of-order keys.");
-    }
-    prev_key_.assign(key.data(), key.size());
+  if (key.size() < kNumInternalBytes) {
+    return Status::Corruption(
+        "Compaction tries to write a key without internal bytes.");
   }
+  // prev_key_ starts with empty.
+  if (!prev_key_.empty() && icmp_.Compare(key, prev_key_) < 0) {
+    return Status::Corruption("Compaction sees out-of-order keys.");
+  }
+  prev_key_.assign(key.data(), key.size());
   return Status::OK();
 }
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/output_validator.h

@@ -15,12 +15,10 @@ namespace ROCKSDB_NAMESPACE {
 // of all the key and value.
 class OutputValidator {
  public:
-  explicit OutputValidator(const InternalKeyComparator& icmp,
-                           bool enable_order_check, bool enable_hash,
+  explicit OutputValidator(const InternalKeyComparator& icmp, bool enable_hash,
                            uint64_t precalculated_hash = 0)
       : icmp_(icmp),
         paranoid_hash_(precalculated_hash),
-        enable_order_check_(enable_order_check),
         enable_hash_(enable_hash) {}
 
   // Add a key to the KV sequence, and return whether the key follows
@@ -42,7 +40,6 @@ class OutputValidator {
   const InternalKeyComparator& icmp_;
   std::string prev_key_;
   uint64_t paranoid_hash_ = 0;
-  bool enable_order_check_;
   bool enable_hash_;
 };
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/db/perf_context_test.cc

@@ -943,15 +943,17 @@ TEST_F(PerfContextTest, CPUTimer) {
 
     // monotonically increasing
     get_perf_context()->Reset();
-    auto count = get_perf_context()->iter_seek_cpu_nanos;
+    uint64_t count = get_perf_context()->iter_seek_cpu_nanos;
+    uint64_t before_count = count;
     for (int i = 0; i < FLAGS_total_keys; ++i) {
       iter->Seek("k" + std::to_string(i));
       ASSERT_TRUE(iter->Valid());
       ASSERT_EQ("v" + std::to_string(i), iter->value().ToString());
       auto next_count = get_perf_context()->iter_seek_cpu_nanos;
-      ASSERT_GT(next_count, count);
+      ASSERT_GE(next_count, count);
       count = next_count;
     }
+    ASSERT_GT(count, before_count);
 
     // iterator creation/destruction; multiple iterators
     {
@@ -1050,7 +1052,7 @@ TEST_F(PerfContextTest, MergeOperandCount) {
         std::vector<Status> statuses(num_keys);
 
         db->MultiGet(ReadOptions(), db->DefaultColumnFamily(), num_keys,
-                     &key_slices[0], &results[0], &statuses[0]);
+                     key_slices.data(), results.data(), statuses.data());
 
         for (size_t i = 0; i < num_keys; ++i) {
           ASSERT_OK(statuses[i]);
@@ -1068,7 +1070,7 @@ TEST_F(PerfContextTest, MergeOperandCount) {
         std::vector<Status> statuses(num_keys);
 
         db->MultiGetEntity(ReadOptions(), db->DefaultColumnFamily(), num_keys,
-                           &key_slices[0], &results[0], &statuses[0]);
+                           key_slices.data(), results.data(), statuses.data());
 
         for (size_t i = 0; i < num_keys; ++i) {
           ASSERT_OK(statuses[i]);
@@ -1119,6 +1121,23 @@ TEST_F(PerfContextTest, MergeOperandCount) {
   verify();
 }
 
+TEST_F(PerfContextTest, WriteMemtableTimePerfLevel) {
+  // Write and check time
+  ASSERT_OK(DestroyDB(kDbName, Options()));
+  std::shared_ptr<DB> db = OpenDb();
+
+  SetPerfLevel(PerfLevel::kEnableWait);
+  PerfContext* perf_ctx = get_perf_context();
+  perf_ctx->Reset();
+  ASSERT_OK(db->Put(WriteOptions(), "foo1", "bar"));
+  ASSERT_GT(perf_context.write_memtable_time, 0);
+
+  SetPerfLevel(PerfLevel::kEnableCount);
+  perf_ctx->Reset();
+  ASSERT_OK(db->Put(WriteOptions(), "foo0", "bar"));
+  ASSERT_EQ(perf_context.write_memtable_time, 0);
+}
+
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {

package/deps/rocksdb/rocksdb/db/periodic_task_scheduler.cc

@@ -76,7 +76,7 @@ Status PeriodicTaskScheduler::Register(PeriodicTaskType task_type,
       task_type, TaskInfo{unique_id, repeat_period_seconds});
   if (!result.second) {
     return Status::Aborted("Failed to add periodic task");
-  };
+  }
   return Status::OK();
 }
 
@@ -94,7 +94,7 @@ Status PeriodicTaskScheduler::Unregister(PeriodicTaskType task_type) {
 }
 
 Timer* PeriodicTaskScheduler::Default() {
-  static Timer timer(SystemClock::Default().get());
+  STATIC_AVOID_DESTRUCTION(Timer, timer)(SystemClock::Default().get());
   return &timer;
 }
 
@@ -108,4 +108,3 @@ void PeriodicTaskScheduler::TEST_OverrideTimer(SystemClock* clock) {
 #endif  // NDEBUG
 
 }  // namespace ROCKSDB_NAMESPACE
-

package/deps/rocksdb/rocksdb/db/periodic_task_scheduler_test.cc

@@ -29,7 +29,7 @@ class PeriodicTaskSchedulerTest : public DBTestBase {
     SyncPoint::GetInstance()->SetCallBack(
         "DBImpl::StartPeriodicTaskScheduler:Init", [&](void* arg) {
           auto periodic_task_scheduler_ptr =
-              reinterpret_cast<PeriodicTaskScheduler*>(arg);
+              static_cast<PeriodicTaskScheduler*>(arg);
           periodic_task_scheduler_ptr->TEST_OverrideTimer(mock_clock_.get());
         });
   }

package/deps/rocksdb/rocksdb/db/pinned_iterators_manager.h

@@ -78,11 +78,11 @@ class PinnedIteratorsManager : public Cleanable {
 
  private:
   static void ReleaseInternalIterator(void* ptr) {
-    delete reinterpret_cast<InternalIterator*>(ptr);
+    delete static_cast<InternalIterator*>(ptr);
   }
 
   static void ReleaseArenaInternalIterator(void* ptr) {
-    reinterpret_cast<InternalIterator*>(ptr)->~InternalIterator();
+    static_cast<InternalIterator*>(ptr)->~InternalIterator();
   }
 
   bool pinning_enabled;

package/deps/rocksdb/rocksdb/db/plain_table_db_test.cc

@@ -252,8 +252,6 @@ TEST_P(PlainTableDBTest, Empty) {
   ASSERT_EQ("NOT_FOUND", Get("0000000000000foo"));
 }
 
-extern const uint64_t kPlainTableMagicNumber;
-
 class TestPlainTableReader : public PlainTableReader {
  public:
   TestPlainTableReader(
@@ -292,7 +290,7 @@ class TestPlainTableReader : public PlainTableReader {
     table_properties_ = std::move(props);
   }
 
-  ~TestPlainTableReader() override {}
+  ~TestPlainTableReader() override = default;
 
  private:
   bool MatchBloom(uint32_t hash) const override {
@@ -307,7 +305,6 @@ class TestPlainTableReader : public PlainTableReader {
   bool* expect_bloom_not_match_;
 };
 
-extern const uint64_t kPlainTableMagicNumber;
 class TestPlainTableFactory : public PlainTableFactory {
  public:
   explicit TestPlainTableFactory(bool* expect_bloom_not_match,
@@ -499,8 +496,8 @@ TEST_P(PlainTableDBTest, Flush) {
             ASSERT_GT(int_num, 0U);
 
             TablePropertiesCollection ptc;
-            ASSERT_OK(reinterpret_cast<DB*>(dbfull())->GetPropertiesOfAllTables(
-                &ptc));
+            ASSERT_OK(
+                static_cast<DB*>(dbfull())->GetPropertiesOfAllTables(&ptc));
             ASSERT_EQ(1U, ptc.size());
             auto row = ptc.begin();
             auto tp = row->second;

package/deps/rocksdb/rocksdb/db/prefix_test.cc

@@ -89,8 +89,12 @@ class TestKeyComparator : public Comparator {
     const TestKey* key_a = &kkey_a;
     const TestKey* key_b = &kkey_b;
     if (key_a->prefix != key_b->prefix) {
-      if (key_a->prefix < key_b->prefix) return -1;
-      if (key_a->prefix > key_b->prefix) return 1;
+      if (key_a->prefix < key_b->prefix) {
+        return -1;
+      }
+      if (key_a->prefix > key_b->prefix) {
+        return 1;
+      }
     } else {
       EXPECT_TRUE(key_a->prefix == key_b->prefix);
       // note, both a and b could be prefix only
@@ -99,8 +103,12 @@ class TestKeyComparator : public Comparator {
         EXPECT_TRUE(
             (a.size() == sizeof(uint64_t) && b.size() == sizeof(TestKey)) ||
             (b.size() == sizeof(uint64_t) && a.size() == sizeof(TestKey)));
-        if (a.size() < b.size()) return -1;
-        if (a.size() > b.size()) return 1;
+        if (a.size() < b.size()) {
+          return -1;
+        }
+        if (a.size() > b.size()) {
+          return 1;
+        }
       } else {
         // both a and b are prefix
         if (a.size() == sizeof(uint64_t)) {
@@ -109,9 +117,15 @@ class TestKeyComparator : public Comparator {
 
         // both a and b are whole key
         EXPECT_TRUE(a.size() == sizeof(TestKey) && b.size() == sizeof(TestKey));
-        if (key_a->sorted < key_b->sorted) return -1;
-        if (key_a->sorted > key_b->sorted) return 1;
-        if (key_a->sorted == key_b->sorted) return 0;
+        if (key_a->sorted < key_b->sorted) {
+          return -1;
+        }
+        if (key_a->sorted > key_b->sorted) {
+          return 1;
+        }
+        if (key_a->sorted == key_b->sorted) {
+          return 0;
+        }
       }
     }
     return 0;
@@ -892,4 +906,3 @@ int main(int argc, char** argv) {
 }
 
 #endif  // GFLAGS
-

package/deps/rocksdb/rocksdb/db/range_del_aggregator.cc

@@ -8,13 +8,11 @@
 #include "db/compaction/compaction_iteration_stats.h"
 #include "db/dbformat.h"
 #include "db/pinned_iterators_manager.h"
-#include "db/range_del_aggregator.h"
 #include "db/range_tombstone_fragmenter.h"
 #include "db/version_edit.h"
 #include "rocksdb/comparator.h"
 #include "rocksdb/types.h"
 #include "table/internal_iterator.h"
-#include "table/scoped_arena_iterator.h"
 #include "table/table_builder.h"
 #include "util/heap.h"
 #include "util/kv_map.h"

package/deps/rocksdb/rocksdb/db/range_del_aggregator.h

@@ -22,7 +22,6 @@
 #include "rocksdb/comparator.h"
 #include "rocksdb/types.h"
 #include "table/internal_iterator.h"
-#include "table/scoped_arena_iterator.h"
 #include "table/table_builder.h"
 #include "util/heap.h"
 #include "util/kv_map.h"

package/deps/rocksdb/rocksdb/db/range_tombstone_fragmenter.cc

@@ -20,7 +20,8 @@ namespace ROCKSDB_NAMESPACE {
 FragmentedRangeTombstoneList::FragmentedRangeTombstoneList(
     std::unique_ptr<InternalIterator> unfragmented_tombstones,
     const InternalKeyComparator& icmp, bool for_compaction,
-    const std::vector<SequenceNumber>& snapshots) {
+    const std::vector<SequenceNumber>& snapshots,
+    const bool tombstone_end_include_ts) {
   if (unfragmented_tombstones == nullptr) {
     return;
   }
@@ -45,7 +46,12 @@ FragmentedRangeTombstoneList::FragmentedRangeTombstoneList(
       last_start_key = pinned_last_start_key.Encode();
     }
   }
-  if (is_sorted) {
+
+  auto ucmp = icmp.user_comparator();
+  assert(ucmp);
+  const size_t ts_sz = ucmp->timestamp_size();
+  bool pad_min_ts_for_end = ts_sz > 0 && !tombstone_end_include_ts;
+  if (is_sorted && !pad_min_ts_for_end) {
     FragmentTombstones(std::move(unfragmented_tombstones), icmp, for_compaction,
                        snapshots);
     return;
@@ -63,8 +69,15 @@ FragmentedRangeTombstoneList::FragmentedRangeTombstoneList(
                                       unfragmented_tombstones->value().size();
     keys.emplace_back(unfragmented_tombstones->key().data(),
                       unfragmented_tombstones->key().size());
-    values.emplace_back(unfragmented_tombstones->value().data(),
-                        unfragmented_tombstones->value().size());
+    Slice value = unfragmented_tombstones->value();
+    if (pad_min_ts_for_end) {
+      AppendKeyWithMinTimestamp(&values.emplace_back(), value, ts_sz);
+    } else {
+      values.emplace_back(value.data(), value.size());
+    }
+  }
+  if (pad_min_ts_for_end) {
+    total_tombstone_payload_bytes_ += num_unfragmented_tombstones_ * ts_sz;
   }
   // VectorIterator implicitly sorts by key during construction.
   auto iter = std::make_unique<VectorIterator>(std::move(keys),

package/deps/rocksdb/rocksdb/db/range_tombstone_fragmenter.h

@@ -54,7 +54,8 @@ struct FragmentedRangeTombstoneList {
   FragmentedRangeTombstoneList(
       std::unique_ptr<InternalIterator> unfragmented_tombstones,
       const InternalKeyComparator& icmp, bool for_compaction = false,
-      const std::vector<SequenceNumber>& snapshots = {});
+      const std::vector<SequenceNumber>& snapshots = {},
+      const bool tombstone_end_include_ts = true);
 
   std::vector<RangeTombstoneStack>::const_iterator begin() const {
     return tombstones_.begin();
@@ -198,13 +199,15 @@ class FragmentedRangeTombstoneIterator : public InternalIterator {
     pinned_seq_pos_ = tombstones_->seq_end();
   }
 
-  RangeTombstone Tombstone() const {
+  RangeTombstone Tombstone(bool logical_strip_timestamp = false) const {
     assert(Valid());
     if (icmp_->user_comparator()->timestamp_size()) {
-      return RangeTombstone(start_key(), end_key(), seq(), timestamp());
+      return RangeTombstone(start_key(), end_key(), seq(), timestamp(),
+                            logical_strip_timestamp);
     }
     return RangeTombstone(start_key(), end_key(), seq());
   }
+
   // Note that start_key() and end_key() are not guaranteed to have the
   // correct timestamp. User can call timestamp() to get the correct
   // timestamp().

package/deps/rocksdb/rocksdb/db/repair.cc

@@ -81,7 +81,6 @@
 #include "rocksdb/env.h"
 #include "rocksdb/options.h"
 #include "rocksdb/write_buffer_manager.h"
-#include "table/scoped_arena_iterator.h"
 #include "table/unique_id_impl.h"
 #include "util/string_util.h"
 
@@ -122,7 +121,8 @@ class Repairer {
         vset_(dbname_, &immutable_db_options_, file_options_,
               raw_table_cache_.get(), &wb_, &wc_,
               /*block_cache_tracer=*/nullptr, /*io_tracer=*/nullptr,
-              /*db_id=*/"", db_session_id_),
+              /*db_id=*/"", db_session_id_, db_options.daily_offpeak_time_utc,
+              /*error_handler=*/nullptr, /*read_only=*/false),
         next_file_number_(1),
         db_lock_(nullptr),
         closed_(false) {
@@ -145,8 +145,10 @@ class Repairer {
   // Adds a column family to the VersionSet with cf_options_ and updates
   // manifest.
   Status AddColumnFamily(const std::string& cf_name, uint32_t cf_id) {
-    // TODO: plumb Env::IOActivity;
+    // TODO: plumb Env::IOActivity, Env::IOPriority;
     const ReadOptions read_options;
+    const WriteOptions write_options;
+
     const auto* cf_opts = GetColumnFamilyOptions(cf_name);
     if (cf_opts == nullptr) {
       return Status::Corruption("Encountered unknown column family with name=" +
@@ -169,9 +171,9 @@ class Repairer {
     Status status = env_->GetFileSystem()->NewDirectory(dbname_, IOOptions(),
                                                         &db_dir, nullptr);
     if (status.ok()) {
-      status = vset_.LogAndApply(cfd, mut_cf_opts, read_options, &edit, &mutex_,
-                                 db_dir.get(), false /* new_descriptor_log */,
-                                 cf_opts);
+      status = vset_.LogAndApply(cfd, mut_cf_opts, read_options, write_options,
+                                 &edit, &mutex_, db_dir.get(),
+                                 false /* new_descriptor_log */, cf_opts);
     }
     mutex_.Unlock();
     return status;
@@ -361,9 +363,6 @@ class Repairer {
       }
     };
 
-    // TODO: plumb Env::IOActivity
-    const ReadOptions read_options;
-
     // Open the log file
     std::string logname = LogFileName(wal_dir, log);
     const auto& fs = env_->GetFileSystem();
@@ -439,11 +438,12 @@ class Repairer {
 
       FileMetaData meta;
       meta.fd = FileDescriptor(next_file_number_++, 0, 0);
-      // TODO: plumb Env::IOActivity
+      // TODO: plumb Env::IOActivity, Env::IOPriority
       ReadOptions ro;
       ro.total_order_seek = true;
       Arena arena;
-      ScopedArenaIterator iter(mem->NewIterator(ro, &arena));
+      ScopedArenaPtr<InternalIterator> iter(
+          mem->NewIterator(ro, /*seqno_to_time_mapping=*/nullptr, &arena));
       int64_t _current_time = 0;
       immutable_db_options_.clock->GetCurrentTime(&_current_time)
           .PermitUncheckedError();  // ignore error
@@ -462,26 +462,29 @@ class Repairer {
 
       IOStatus io_s;
       CompressionOptions default_compression;
+      // TODO: plumb Env::IOActivity, Env::IOPriority
+      const ReadOptions read_options;
+      const WriteOptions write_option(Env::IO_HIGH);
       TableBuilderOptions tboptions(
-          *cfd->ioptions(), *cfd->GetLatestMutableCFOptions(),
-          cfd->internal_comparator(), cfd->int_tbl_prop_collector_factories(),
-          kNoCompression, default_compression, cfd->GetID(), cfd->GetName(),
-          -1 /* level */, false /* is_bottommost */,
-          TableFileCreationReason::kRecovery, 0 /* oldest_key_time */,
-          0 /* file_creation_time */, "DB Repairer" /* db_id */, db_session_id_,
-          0 /*target_file_size*/, meta.fd.GetNumber());
+          *cfd->ioptions(), *cfd->GetLatestMutableCFOptions(), read_options,
+          write_option, cfd->internal_comparator(),
+          cfd->internal_tbl_prop_coll_factories(), kNoCompression,
+          default_compression, cfd->GetID(), cfd->GetName(), -1 /* level */,
+          false /* is_bottommost */, TableFileCreationReason::kRecovery,
+          0 /* oldest_key_time */, 0 /* file_creation_time */,
+          "DB Repairer" /* db_id */, db_session_id_, 0 /*target_file_size*/,
+          meta.fd.GetNumber());
 
       SeqnoToTimeMapping empty_seqno_to_time_mapping;
       status = BuildTable(
           dbname_, /* versions */ nullptr, immutable_db_options_, tboptions,
-          file_options_, read_options, table_cache_.get(), iter.get(),
+          file_options_, table_cache_.get(), iter.get(),
           std::move(range_del_iters), &meta, nullptr /* blob_file_additions */,
           {}, kMaxSequenceNumber, kMaxSequenceNumber, snapshot_checker,
           false /* paranoid_file_checks*/, nullptr /* internal_stats */, &io_s,
           nullptr /*IOTracer*/, BlobFileCreationReason::kRecovery,
-          empty_seqno_to_time_mapping, nullptr /* event_logger */,
-          0 /* job_id */, Env::IO_HIGH, nullptr /* table_properties */,
-          write_hint);
+          nullptr /* seqno_to_time_mapping */, nullptr /* event_logger */,
+          0 /* job_id */, nullptr /* table_properties */, write_hint);
       ROCKS_LOG_INFO(db_options_.info_log,
                      "Log #%" PRIu64 ": %d ops saved to Table #%" PRIu64 " %s",
                      log, counter, meta.fd.GetNumber(),
@@ -528,7 +531,7 @@ class Repairer {
                                 file_size);
     std::shared_ptr<const TableProperties> props;
     if (status.ok()) {
-      // TODO: plumb Env::IOActivity
+      // TODO: plumb Env::IOActivity, Env::IOPriority
       const ReadOptions read_options;
       status = table_cache_->GetTableProperties(
           file_options_, read_options, icmp_, t->meta, &props,
@@ -591,7 +594,7 @@ class Repairer {
       }
     }
     if (status.ok()) {
-      // TODO: plumb Env::IOActivity
+      // TODO: plumb Env::IOActivity, Env::IOPriority
       ReadOptions ropts;
       ropts.total_order_seek = true;
       InternalIterator* iter = table_cache_->NewIterator(
@@ -640,7 +643,7 @@ class Repairer {
       // an SST file is a full sorted run. This probably needs the extra logic
       // from compaction_job.cc around call to UpdateBoundariesForRange (to
       // handle range tombstones extendingg beyond range of other entries).
-      // TODO: plumb Env::IOActivity
+      // TODO: plumb Env::IOActivity, Env::IOPriority
       ReadOptions ropts;
       std::unique_ptr<FragmentedRangeTombstoneIterator> r_iter;
       status = table_cache_->GetRangeTombstoneIterator(
@@ -665,8 +668,10 @@ class Repairer {
   }
 
   Status AddTables() {
-    // TODO: plumb Env::IOActivity;
+    // TODO: plumb Env::IOActivity, Env::IOPriority;
     const ReadOptions read_options;
+    const WriteOptions write_options;
+
     std::unordered_map<uint32_t, std::vector<const TableInfo*>> cf_id_to_tables;
     SequenceNumber max_sequence = 0;
     for (size_t i = 0; i < tables_.size(); i++) {
@@ -694,7 +699,8 @@ class Repairer {
           cfd->NumberLevels(), cfd->ioptions()->compaction_style,
           nullptr /* src_vstorage */, cfd->ioptions()->force_consistency_checks,
           EpochNumberRequirement::kMightMissing, cfd->ioptions()->clock,
-          /*bottommost_file_compaction_delay=*/0);
+          /*bottommost_file_compaction_delay=*/0,
+          cfd->current()->version_set()->offpeak_time_option());
       Status s;
       VersionEdit dummy_edit;
       for (const auto* table : cf_id_and_tables.second) {
@@ -753,8 +759,8 @@ class Repairer {
                                                 nullptr);
         if (s.ok()) {
           s = vset_.LogAndApply(cfd, *cfd->GetLatestMutableCFOptions(),
-                                read_options, &edit, &mutex_, db_dir.get(),
-                                false /* new_descriptor_log */);
+                                read_options, write_options, &edit, &mutex_,
+                                db_dir.get(), false /* new_descriptor_log */);
         }
         mutex_.Unlock();
       }

package/deps/rocksdb/rocksdb/db/repair_test.cc

@@ -378,8 +378,7 @@ TEST_P(RepairTestWithTimestamp, UnflushedSst) {
 
   ColumnFamilyOptions cf_options(options);
   std::vector<ColumnFamilyDescriptor> column_families;
-  column_families.push_back(
-      ColumnFamilyDescriptor(kDefaultColumnFamilyName, cf_options));
+  column_families.emplace_back(kDefaultColumnFamilyName, cf_options);
 
   ASSERT_OK(DB::Open(options, dbname_, column_families, &handles_, &db_));