@nxtedition/rocksdb 10.0.13 → 10.0.15

package/deps/rocksdb/rocksdb/db/version_edit_handler.cc

@@ -34,37 +34,36 @@ void VersionEditHandlerBase::Iterate(log::Reader& reader,
          reader.ReadRecord(&record, &scratch) && log_read_status->ok()) {
     VersionEdit edit;
     s = edit.DecodeFrom(record);
-    if (!s.ok()) {
-      break;
-    }
-
-    s = read_buffer_.AddEdit(&edit);
-    if (!s.ok()) {
-      break;
+    if (s.ok()) {
+      s = read_buffer_.AddEdit(&edit);
     }
-    ColumnFamilyData* cfd = nullptr;
-    if (edit.is_in_atomic_group_) {
-      if (read_buffer_.IsFull()) {
-        for (auto& e : read_buffer_.replay_buffer()) {
-          s = ApplyVersionEdit(e, &cfd);
-          if (!s.ok()) {
-            break;
+    if (s.ok()) {
+      ColumnFamilyData* cfd = nullptr;
+      if (edit.IsInAtomicGroup()) {
+        if (read_buffer_.IsFull()) {
+          s = OnAtomicGroupReplayBegin();
+          for (size_t i = 0; s.ok() && i < read_buffer_.replay_buffer().size();
+               i++) {
+            auto& e = read_buffer_.replay_buffer()[i];
+            s = ApplyVersionEdit(e, &cfd);
+            if (s.ok()) {
+              recovered_edits++;
+            }
+          }
+          if (s.ok()) {
+            read_buffer_.Clear();
+            s = OnAtomicGroupReplayEnd();
           }
-          ++recovered_edits;
         }
-        if (!s.ok()) {
-          break;
+      } else {
+        s = ApplyVersionEdit(edit, &cfd);
+        if (s.ok()) {
+          recovered_edits++;
         }
-        read_buffer_.Clear();
-      }
-    } else {
-      s = ApplyVersionEdit(edit, &cfd);
-      if (s.ok()) {
-        ++recovered_edits;
       }
     }
   }
-  if (!log_read_status->ok()) {
+  if (s.ok() && !log_read_status->ok()) {
     s = *log_read_status;
   }
 
@@ -101,20 +100,18 @@ void VersionEditHandlerBase::Iterate(log::Reader& reader,
 Status ListColumnFamiliesHandler::ApplyVersionEdit(
     VersionEdit& edit, ColumnFamilyData** /*unused*/) {
   Status s;
-  if (edit.is_column_family_add_) {
-    if (column_family_names_.find(edit.column_family_) !=
-        column_family_names_.end()) {
+  uint32_t cf_id = edit.GetColumnFamily();
+  if (edit.IsColumnFamilyAdd()) {
+    if (column_family_names_.find(cf_id) != column_family_names_.end()) {
       s = Status::Corruption("Manifest adding the same column family twice");
     } else {
-      column_family_names_.insert(
-          {edit.column_family_, edit.column_family_name_});
+      column_family_names_.insert({cf_id, edit.GetColumnFamilyName()});
     }
-  } else if (edit.is_column_family_drop_) {
-    if (column_family_names_.find(edit.column_family_) ==
-        column_family_names_.end()) {
+  } else if (edit.IsColumnFamilyDrop()) {
+    if (column_family_names_.find(cf_id) == column_family_names_.end()) {
       s = Status::Corruption("Manifest - dropping non-existing column family");
     } else {
-      column_family_names_.erase(edit.column_family_);
+      column_family_names_.erase(cf_id);
     }
   }
   return s;
@@ -155,7 +152,7 @@ Status FileChecksumRetriever::ApplyVersionEdit(VersionEdit& edit,
 
 VersionEditHandler::VersionEditHandler(
     bool read_only, std::vector<ColumnFamilyDescriptor> column_families,
-    VersionSet* version_set, bool track_missing_files,
+    VersionSet* version_set, bool track_found_and_missing_files,
     bool no_error_if_files_missing, const std::shared_ptr<IOTracer>& io_tracer,
     const ReadOptions& read_options, bool skip_load_table_files,
     EpochNumberRequirement epoch_number_requirement)
@@ -163,7 +160,7 @@ VersionEditHandler::VersionEditHandler(
       read_only_(read_only),
       column_families_(std::move(column_families)),
       version_set_(version_set),
-      track_missing_files_(track_missing_files),
+      track_found_and_missing_files_(track_found_and_missing_files),
       no_error_if_files_missing_(no_error_if_files_missing),
       io_tracer_(io_tracer),
       skip_load_table_files_(skip_load_table_files),
@@ -201,9 +198,9 @@ Status VersionEditHandler::Initialize() {
 Status VersionEditHandler::ApplyVersionEdit(VersionEdit& edit,
                                             ColumnFamilyData** cfd) {
   Status s;
-  if (edit.is_column_family_add_) {
+  if (edit.IsColumnFamilyAdd()) {
     s = OnColumnFamilyAdd(edit, cfd);
-  } else if (edit.is_column_family_drop_) {
+  } else if (edit.IsColumnFamilyDrop()) {
     s = OnColumnFamilyDrop(edit, cfd);
   } else if (edit.IsWalAddition()) {
     s = OnWalAddition(edit);
@@ -227,22 +224,22 @@ Status VersionEditHandler::OnColumnFamilyAdd(VersionEdit& edit,
 
   assert(cfd != nullptr);
   *cfd = nullptr;
+  const std::string& cf_name = edit.GetColumnFamilyName();
   Status s;
   if (cf_in_builders || cf_in_not_found) {
     s = Status::Corruption("MANIFEST adding the same column family twice: " +
-                           edit.column_family_name_);
+                           cf_name);
   }
   if (s.ok()) {
-    auto cf_options = name_to_options_.find(edit.column_family_name_);
+    auto cf_options = name_to_options_.find(cf_name);
     // implicitly add persistent_stats column family without requiring user
     // to specify
     ColumnFamilyData* tmp_cfd = nullptr;
     bool is_persistent_stats_column_family =
-        edit.column_family_name_.compare(kPersistentStatsColumnFamilyName) == 0;
+        cf_name.compare(kPersistentStatsColumnFamilyName) == 0;
     if (cf_options == name_to_options_.end() &&
         !is_persistent_stats_column_family) {
-      column_families_not_found_.emplace(edit.column_family_,
-                                         edit.column_family_name_);
+      column_families_not_found_.emplace(edit.GetColumnFamily(), cf_name);
     } else {
       if (is_persistent_stats_column_family) {
         ColumnFamilyOptions cfo;
@@ -270,7 +267,7 @@ Status VersionEditHandler::OnColumnFamilyDrop(VersionEdit& edit,
   if (cf_in_builders) {
     tmp_cfd = DestroyCfAndCleanup(edit);
   } else if (cf_in_not_found) {
-    column_families_not_found_.erase(edit.column_family_);
+    column_families_not_found_.erase(edit.GetColumnFamily());
   } else {
     s = Status::Corruption("MANIFEST - dropping non-existing column family");
   }
@@ -305,10 +302,10 @@ Status VersionEditHandler::OnNonCfOperation(VersionEdit& edit,
     }
     ColumnFamilyData* tmp_cfd = nullptr;
     if (s.ok()) {
-      auto builder_iter = builders_.find(edit.column_family_);
+      auto builder_iter = builders_.find(edit.GetColumnFamily());
       assert(builder_iter != builders_.end());
       tmp_cfd = version_set_->GetColumnFamilySet()->GetColumnFamily(
-          edit.column_family_);
+          edit.GetColumnFamily());
       assert(tmp_cfd != nullptr);
       // It's important to handle file boundaries before `MaybeCreateVersion`
       // because `VersionEditHandlerPointInTime::MaybeCreateVersion` does
@@ -362,11 +359,12 @@ void VersionEditHandler::CheckColumnFamilyId(const VersionEdit& edit,
   // record. Once we encounter column family drop record,
   // we will delete the column family from
   // column_families_not_found.
-  bool in_not_found = column_families_not_found_.find(edit.column_family_) !=
+  uint32_t cf_id = edit.GetColumnFamily();
+  bool in_not_found = column_families_not_found_.find(cf_id) !=
                       column_families_not_found_.end();
   // in builders means that user supplied that column family
   // option AND that we encountered column family add record
-  bool in_builders = builders_.find(edit.column_family_) != builders_.end();
+  bool in_builders = builders_.find(cf_id) != builders_.end();
   // They cannot both be true
   assert(!(in_not_found && in_builders));
   *cf_in_not_found = in_not_found;
@@ -378,17 +376,17 @@ void VersionEditHandler::CheckIterationResult(const log::Reader& reader,
   assert(s != nullptr);
   if (!s->ok()) {
     // Do nothing here.
-  } else if (!version_edit_params_.has_log_number_ ||
-             !version_edit_params_.has_next_file_number_ ||
-             !version_edit_params_.has_last_sequence_) {
+  } else if (!version_edit_params_.HasLogNumber() ||
+             !version_edit_params_.HasNextFile() ||
+             !version_edit_params_.HasLastSequence()) {
     std::string msg("no ");
-    if (!version_edit_params_.has_log_number_) {
+    if (!version_edit_params_.HasLogNumber()) {
       msg.append("log_file_number, ");
     }
-    if (!version_edit_params_.has_next_file_number_) {
+    if (!version_edit_params_.HasNextFile()) {
       msg.append("next_file_number, ");
     }
-    if (!version_edit_params_.has_last_sequence_) {
+    if (!version_edit_params_.HasLastSequence()) {
       msg.append("last_sequence, ");
     }
     msg = msg.substr(0, msg.size() - 2);
@@ -409,11 +407,11 @@ void VersionEditHandler::CheckIterationResult(const log::Reader& reader,
   }
   if (s->ok()) {
     version_set_->GetColumnFamilySet()->UpdateMaxColumnFamily(
-        version_edit_params_.max_column_family_);
+        version_edit_params_.GetMaxColumnFamily());
     version_set_->MarkMinLogNumberToKeep(
-        version_edit_params_.min_log_number_to_keep_);
-    version_set_->MarkFileNumberUsed(version_edit_params_.prev_log_number_);
-    version_set_->MarkFileNumberUsed(version_edit_params_.log_number_);
+        version_edit_params_.GetMinLogNumberToKeep());
+    version_set_->MarkFileNumberUsed(version_edit_params_.GetPrevLogNumber());
+    version_set_->MarkFileNumberUsed(version_edit_params_.GetLogNumber());
     for (auto* cfd : *(version_set_->GetColumnFamilySet())) {
       if (cfd->IsDropped()) {
         continue;
@@ -464,9 +462,9 @@ void VersionEditHandler::CheckIterationResult(const log::Reader& reader,
   if (s->ok()) {
     version_set_->manifest_file_size_ = reader.GetReadOffset();
     assert(version_set_->manifest_file_size_ > 0);
-    version_set_->next_file_number_.store(
-        version_edit_params_.next_file_number_ + 1);
-    SequenceNumber last_seq = version_edit_params_.last_sequence_;
+    version_set_->next_file_number_.store(version_edit_params_.GetNextFile() +
+                                          1);
+    SequenceNumber last_seq = version_edit_params_.GetLastSequence();
     assert(last_seq != kMaxSequenceNumber);
     if (last_seq != kMaxSequenceNumber &&
         last_seq > version_set_->last_allocated_sequence_.load()) {
@@ -488,46 +486,51 @@ void VersionEditHandler::CheckIterationResult(const log::Reader& reader,
       // sequence number zeroed through compaction.
       version_set_->descriptor_last_sequence_ = last_seq;
     }
-    version_set_->prev_log_number_ = version_edit_params_.prev_log_number_;
+    version_set_->prev_log_number_ = version_edit_params_.GetPrevLogNumber();
   }
 }
 
 ColumnFamilyData* VersionEditHandler::CreateCfAndInit(
     const ColumnFamilyOptions& cf_options, const VersionEdit& edit) {
+  uint32_t cf_id = edit.GetColumnFamily();
   ColumnFamilyData* cfd =
       version_set_->CreateColumnFamily(cf_options, read_options_, &edit);
   assert(cfd != nullptr);
   cfd->set_initialized();
-  assert(builders_.find(edit.column_family_) == builders_.end());
-  builders_.emplace(edit.column_family_,
+  assert(builders_.find(cf_id) == builders_.end());
+  builders_.emplace(cf_id,
                     VersionBuilderUPtr(new BaseReferencedVersionBuilder(cfd)));
-  if (track_missing_files_) {
-    cf_to_missing_files_.emplace(edit.column_family_,
-                                 std::unordered_set<uint64_t>());
-    cf_to_missing_blob_files_high_.emplace(edit.column_family_,
-                                           kInvalidBlobFileNumber);
+  if (track_found_and_missing_files_) {
+    cf_to_found_files_.emplace(cf_id, std::unordered_set<uint64_t>());
+    cf_to_missing_files_.emplace(cf_id, std::unordered_set<uint64_t>());
+    cf_to_missing_blob_files_high_.emplace(cf_id, kInvalidBlobFileNumber);
   }
   return cfd;
 }
 
 ColumnFamilyData* VersionEditHandler::DestroyCfAndCleanup(
     const VersionEdit& edit) {
-  auto builder_iter = builders_.find(edit.column_family_);
+  uint32_t cf_id = edit.GetColumnFamily();
+  auto builder_iter = builders_.find(cf_id);
   assert(builder_iter != builders_.end());
   builders_.erase(builder_iter);
-  if (track_missing_files_) {
-    auto missing_files_iter = cf_to_missing_files_.find(edit.column_family_);
+  if (track_found_and_missing_files_) {
+    auto found_files_iter = cf_to_found_files_.find(cf_id);
+    assert(found_files_iter != cf_to_found_files_.end());
+    cf_to_found_files_.erase(found_files_iter);
+
+    auto missing_files_iter = cf_to_missing_files_.find(cf_id);
     assert(missing_files_iter != cf_to_missing_files_.end());
     cf_to_missing_files_.erase(missing_files_iter);
 
     auto missing_blob_files_high_iter =
-        cf_to_missing_blob_files_high_.find(edit.column_family_);
+        cf_to_missing_blob_files_high_.find(cf_id);
     assert(missing_blob_files_high_iter !=
            cf_to_missing_blob_files_high_.end());
     cf_to_missing_blob_files_high_.erase(missing_blob_files_high_iter);
   }
   ColumnFamilyData* ret =
-      version_set_->GetColumnFamilySet()->GetColumnFamily(edit.column_family_);
+      version_set_->GetColumnFamilySet()->GetColumnFamily(cf_id);
   assert(ret != nullptr);
   ret->SetDropped();
   ret->UnrefAndTryDelete();
@@ -598,33 +601,33 @@ Status VersionEditHandler::LoadTables(ColumnFamilyData* cfd,
 Status VersionEditHandler::ExtractInfoFromVersionEdit(ColumnFamilyData* cfd,
                                                       const VersionEdit& edit) {
   Status s;
-  if (edit.has_db_id_) {
+  if (edit.HasDbId()) {
     version_set_->db_id_ = edit.GetDbId();
-    version_edit_params_.SetDBId(edit.db_id_);
+    version_edit_params_.SetDBId(edit.GetDbId());
   }
   if (cfd != nullptr) {
-    if (edit.has_log_number_) {
-      if (cfd->GetLogNumber() > edit.log_number_) {
+    if (edit.HasLogNumber()) {
+      if (cfd->GetLogNumber() > edit.GetLogNumber()) {
         ROCKS_LOG_WARN(
             version_set_->db_options()->info_log,
             "MANIFEST corruption detected, but ignored - Log numbers in "
             "records NOT monotonically increasing");
       } else {
-        cfd->SetLogNumber(edit.log_number_);
-        version_edit_params_.SetLogNumber(edit.log_number_);
+        cfd->SetLogNumber(edit.GetLogNumber());
+        version_edit_params_.SetLogNumber(edit.GetLogNumber());
       }
     }
-    if (edit.has_comparator_) {
+    if (edit.HasComparatorName()) {
       bool mark_sst_files_has_no_udt = false;
       // If `persist_user_defined_timestamps` flag is recorded in manifest, it
       // is guaranteed to be in the same VersionEdit as comparator. Otherwise,
       // it's not recorded and it should have default value true.
       s = ValidateUserDefinedTimestampsOptions(
-          cfd->user_comparator(), edit.comparator_,
+          cfd->user_comparator(), edit.GetComparatorName(),
           cfd->ioptions()->persist_user_defined_timestamps,
-          edit.persist_user_defined_timestamps_, &mark_sst_files_has_no_udt);
+          edit.GetPersistUserDefinedTimestamps(), &mark_sst_files_has_no_udt);
       if (!s.ok() && cf_to_cmp_names_) {
-        cf_to_cmp_names_->emplace(cfd->GetID(), edit.comparator_);
+        cf_to_cmp_names_->emplace(cfd->GetID(), edit.GetComparatorName());
       }
       if (mark_sst_files_has_no_udt) {
         cfds_to_mark_no_udt_.insert(cfd->GetID());
@@ -637,29 +640,29 @@ Status VersionEditHandler::ExtractInfoFromVersionEdit(ColumnFamilyData* cfd,
   }
 
   if (s.ok()) {
-    if (edit.has_prev_log_number_) {
-      version_edit_params_.SetPrevLogNumber(edit.prev_log_number_);
+    if (edit.HasPrevLogNumber()) {
+      version_edit_params_.SetPrevLogNumber(edit.GetPrevLogNumber());
     }
-    if (edit.has_next_file_number_) {
-      version_edit_params_.SetNextFile(edit.next_file_number_);
+    if (edit.HasNextFile()) {
+      version_edit_params_.SetNextFile(edit.GetNextFile());
     }
-    if (edit.has_max_column_family_) {
-      version_edit_params_.SetMaxColumnFamily(edit.max_column_family_);
+    if (edit.HasMaxColumnFamily()) {
+      version_edit_params_.SetMaxColumnFamily(edit.GetMaxColumnFamily());
     }
-    if (edit.has_min_log_number_to_keep_) {
-      version_edit_params_.min_log_number_to_keep_ =
-          std::max(version_edit_params_.min_log_number_to_keep_,
-                   edit.min_log_number_to_keep_);
+    if (edit.HasMinLogNumberToKeep()) {
+      version_edit_params_.SetMinLogNumberToKeep(
+          std::max(version_edit_params_.GetMinLogNumberToKeep(),
+                   edit.GetMinLogNumberToKeep()));
     }
-    if (edit.has_last_sequence_) {
+    if (edit.HasLastSequence()) {
       // `VersionEdit::last_sequence_`s are assumed to be non-decreasing. This
       // is legacy behavior that cannot change without breaking downgrade
       // compatibility.
-      assert(!version_edit_params_.has_last_sequence_ ||
-             version_edit_params_.last_sequence_ <= edit.last_sequence_);
-      version_edit_params_.SetLastSequence(edit.last_sequence_);
+      assert(!version_edit_params_.HasLastSequence() ||
+             version_edit_params_.GetLastSequence() <= edit.GetLastSequence());
+      version_edit_params_.SetLastSequence(edit.GetLastSequence());
     }
-    if (!version_edit_params_.has_prev_log_number_) {
+    if (!version_edit_params_.HasPrevLogNumber()) {
       version_edit_params_.SetPrevLogNumber(0);
     }
   }
@@ -710,9 +713,15 @@ Status VersionEditHandler::MaybeHandleFileBoundariesForNewFiles(
     }
     std::string smallest_buf;
     std::string largest_buf;
+    Slice largest_slice = meta.largest.Encode();
     PadInternalKeyWithMinTimestamp(&smallest_buf, meta.smallest.Encode(),
                                    ts_sz);
-    PadInternalKeyWithMinTimestamp(&largest_buf, meta.largest.Encode(), ts_sz);
+    auto largest_footer = ExtractInternalKeyFooter(largest_slice);
+    if (largest_footer == kRangeTombstoneSentinel) {
+      PadInternalKeyWithMaxTimestamp(&largest_buf, largest_slice, ts_sz);
+    } else {
+      PadInternalKeyWithMinTimestamp(&largest_buf, largest_slice, ts_sz);
+    }
     meta.smallest.DecodeFrom(smallest_buf);
     meta.largest.DecodeFrom(largest_buf);
   }
@@ -725,17 +734,85 @@ VersionEditHandlerPointInTime::VersionEditHandlerPointInTime(
     const ReadOptions& read_options,
     EpochNumberRequirement epoch_number_requirement)
     : VersionEditHandler(read_only, column_families, version_set,
-                         /*track_missing_files=*/true,
+                         /*track_found_and_missing_files=*/true,
                          /*no_error_if_files_missing=*/true, io_tracer,
                          read_options, epoch_number_requirement) {}
 
 VersionEditHandlerPointInTime::~VersionEditHandlerPointInTime() {
+  for (const auto& cfid_and_version : atomic_update_versions_) {
+    delete cfid_and_version.second;
+  }
   for (const auto& elem : versions_) {
     delete elem.second;
   }
   versions_.clear();
 }
 
+Status VersionEditHandlerPointInTime::OnAtomicGroupReplayBegin() {
+  if (in_atomic_group_) {
+    return Status::Corruption("unexpected AtomicGroup start");
+  }
+
+  // The AtomicGroup that is about to begin may block column families in a valid
+  // state from saving any more updates. So we should save any valid states
+  // before proceeding.
+  for (const auto& cfid_and_builder : builders_) {
+    ColumnFamilyData* cfd = version_set_->GetColumnFamilySet()->GetColumnFamily(
+        cfid_and_builder.first);
+    assert(!cfd->IsDropped());
+    assert(cfd->initialized());
+    VersionEdit edit;
+    Status s = MaybeCreateVersion(edit, cfd, true /* force_create_version */);
+    if (!s.ok()) {
+      return s;
+    }
+  }
+
+  // An old AtomicGroup is incomplete. Throw away the versions that failed to
+  // complete it. They must not be used for completing the upcoming
+  // AtomicGroup since they are too old.
+  for (auto& cfid_and_version : atomic_update_versions_) {
+    delete cfid_and_version.second;
+  }
+
+  in_atomic_group_ = true;
+  // We lazily assume the column families that exist at this point are all
+  // involved in the AtomicGroup. Overestimating the scope of the AtomicGroup
+  // will sometimes cause less data to be recovered, which is fine for
+  // best-effort recovery.
+  atomic_update_versions_.clear();
+  for (const auto& cfid_and_builder : builders_) {
+    atomic_update_versions_[cfid_and_builder.first] = nullptr;
+  }
+  atomic_update_versions_missing_ = atomic_update_versions_.size();
+  return Status::OK();
+}
+
+Status VersionEditHandlerPointInTime::OnAtomicGroupReplayEnd() {
+  if (!in_atomic_group_) {
+    return Status::Corruption("unexpected AtomicGroup end");
+  }
+  in_atomic_group_ = false;
+
+  // The AtomicGroup must not have changed the column families. We don't support
+  // CF adds or drops in an AtomicGroup.
+  if (builders_.size() != atomic_update_versions_.size()) {
+    return Status::Corruption("unexpected CF change in AtomicGroup");
+  }
+  for (const auto& cfid_and_builder : builders_) {
+    if (atomic_update_versions_.find(cfid_and_builder.first) ==
+        atomic_update_versions_.end()) {
+      return Status::Corruption("unexpected CF add in AtomicGroup");
+    }
+  }
+  for (const auto& cfid_and_version : atomic_update_versions_) {
+    if (builders_.find(cfid_and_version.first) == builders_.end()) {
+      return Status::Corruption("unexpected CF drop in AtomicGroup");
+    }
+  }
+  return Status::OK();
+}
+
 void VersionEditHandlerPointInTime::CheckIterationResult(
     const log::Reader& reader, Status* s) {
   VersionEditHandler::CheckIterationResult(reader, s);
@@ -752,6 +829,12 @@ void VersionEditHandlerPointInTime::CheckIterationResult(
 
         version_set_->AppendVersion(cfd, v_iter->second);
         versions_.erase(v_iter);
+        // Let's clear found_files, since any files in that are part of the
+        // installed Version. Any files that got obsoleted would have already
+        // been moved to intermediate_files_
+        auto found_files_iter = cf_to_found_files_.find(cfd->GetID());
+        assert(found_files_iter != cf_to_found_files_.end());
+        found_files_iter->second.clear();
       }
     }
   } else {
@@ -765,7 +848,14 @@ void VersionEditHandlerPointInTime::CheckIterationResult(
 ColumnFamilyData* VersionEditHandlerPointInTime::DestroyCfAndCleanup(
     const VersionEdit& edit) {
   ColumnFamilyData* cfd = VersionEditHandler::DestroyCfAndCleanup(edit);
-  auto v_iter = versions_.find(edit.column_family_);
+  uint32_t cfid = edit.GetColumnFamily();
+  if (AtomicUpdateVersionsContains(cfid)) {
+    AtomicUpdateVersionsDropCf(cfid);
+    if (AtomicUpdateVersionsCompleted()) {
+      AtomicUpdateVersionsApply();
+    }
+  }
+  auto v_iter = versions_.find(cfid);
   if (v_iter != versions_.end()) {
     delete v_iter->second;
     versions_.erase(v_iter);
@@ -775,10 +865,16 @@ ColumnFamilyData* VersionEditHandlerPointInTime::DestroyCfAndCleanup(
 
 Status VersionEditHandlerPointInTime::MaybeCreateVersion(
     const VersionEdit& edit, ColumnFamilyData* cfd, bool force_create_version) {
+  TEST_SYNC_POINT("VersionEditHandlerPointInTime::MaybeCreateVersion:Begin1");
+  TEST_SYNC_POINT("VersionEditHandlerPointInTime::MaybeCreateVersion:Begin2");
   assert(cfd != nullptr);
   if (!force_create_version) {
-    assert(edit.column_family_ == cfd->GetID());
+    assert(edit.GetColumnFamily() == cfd->GetID());
   }
+  auto found_files_iter = cf_to_found_files_.find(cfd->GetID());
+  assert(found_files_iter != cf_to_found_files_.end());
+  std::unordered_set<uint64_t>& found_files = found_files_iter->second;
+
   auto missing_files_iter = cf_to_missing_files_.find(cfd->GetID());
   assert(missing_files_iter != cf_to_missing_files_.end());
   std::unordered_set<uint64_t>& missing_files = missing_files_iter->second;
@@ -810,6 +906,18 @@ Status VersionEditHandlerPointInTime::MaybeCreateVersion(
     auto fiter = missing_files.find(file_num);
     if (fiter != missing_files.end()) {
       missing_files.erase(fiter);
+    } else {
+      fiter = found_files.find(file_num);
+      // Only mark new files added during this catchup attempt for deletion.
+      // These files were never installed in VersionStorageInfo.
+      // Already referenced files that are deleted by a VersionEdit will
+      // be added to the VersionStorageInfo's obsolete files when the old
+      // version is dereferenced.
+      if (fiter != found_files.end()) {
+        intermediate_files_.emplace_back(
+            MakeTableFileName(cfd->ioptions()->cf_paths[0].path, file_num));
+        found_files.erase(fiter);
+      }
     }
   }
 
@@ -825,9 +933,14 @@ Status VersionEditHandlerPointInTime::MaybeCreateVersion(
     s = VerifyFile(cfd, fpath, level, meta);
     if (s.IsPathNotFound() || s.IsNotFound() || s.IsCorruption()) {
       missing_files.insert(file_num);
+      if (s.IsCorruption()) {
+        found_files.insert(file_num);
+      }
       s = Status::OK();
     } else if (!s.ok()) {
       break;
+    } else {
+      found_files.insert(file_num);
     }
   }
 
@@ -860,21 +973,22 @@ Status VersionEditHandlerPointInTime::MaybeCreateVersion(
   const bool has_missing_files =
       !missing_files.empty() || has_missing_blob_files;
 
-  bool missing_info = !version_edit_params_.has_log_number_ ||
-                      !version_edit_params_.has_next_file_number_ ||
-                      !version_edit_params_.has_last_sequence_;
+  bool missing_info = !version_edit_params_.HasLogNumber() ||
+                      !version_edit_params_.HasNextFile() ||
+                      !version_edit_params_.HasLastSequence();
 
   // Create version before apply edit. The version will represent the state
   // before applying the version edit.
-  // A new version will created if:
+  // A new version will be created if:
   // 1) no error has occurred so far, and
   // 2) log_number_, next_file_number_ and last_sequence_ are known, and
-  // 3) any of the following:
+  // 3) not in an AtomicGroup
+  // 4) any of the following:
   //   a) no missing file before, but will have missing file(s) after applying
   //      this version edit.
   //   b) no missing file after applying the version edit, and the caller
   //      explicitly request that a new version be created.
-  if (s.ok() && !missing_info &&
+  if (s.ok() && !missing_info && !in_atomic_group_ &&
       ((has_missing_files && !prev_has_missing_files) ||
        (!has_missing_files && force_create_version))) {
     if (!builder) {
@@ -903,15 +1017,22 @@ Status VersionEditHandlerPointInTime::MaybeCreateVersion(
     }
     s = builder->SaveTo(version->storage_info());
     if (s.ok()) {
-      version->PrepareAppend(
-          *cfd->GetLatestMutableCFOptions(), read_options_,
-          !version_set_->db_options_->skip_stats_update_on_db_open);
-      auto v_iter = versions_.find(cfd->GetID());
-      if (v_iter != versions_.end()) {
-        delete v_iter->second;
-        v_iter->second = version;
+      if (AtomicUpdateVersionsContains(cfd->GetID())) {
+        AtomicUpdateVersionsPut(version);
+        if (AtomicUpdateVersionsCompleted()) {
+          AtomicUpdateVersionsApply();
+        }
       } else {
-        versions_.emplace(cfd->GetID(), version);
+        version->PrepareAppend(
+            *cfd->GetLatestMutableCFOptions(), read_options_,
+            !version_set_->db_options_->skip_stats_update_on_db_open);
+        auto v_iter = versions_.find(cfd->GetID());
+        if (v_iter != versions_.end()) {
+          delete v_iter->second;
+          v_iter->second = version;
+        } else {
+          versions_.emplace(cfd->GetID(), version);
+        }
       }
     } else {
       delete version;
@@ -951,6 +1072,60 @@ Status VersionEditHandlerPointInTime::LoadTables(
   return Status::OK();
 }
 
+bool VersionEditHandlerPointInTime::AtomicUpdateVersionsCompleted() {
+  return atomic_update_versions_missing_ == 0;
+}
+
+bool VersionEditHandlerPointInTime::AtomicUpdateVersionsContains(
+    uint32_t cfid) {
+  return atomic_update_versions_.find(cfid) != atomic_update_versions_.end();
+}
+
+void VersionEditHandlerPointInTime::AtomicUpdateVersionsDropCf(uint32_t cfid) {
+  assert(!AtomicUpdateVersionsCompleted());
+  auto atomic_update_versions_iter = atomic_update_versions_.find(cfid);
+  assert(atomic_update_versions_iter != atomic_update_versions_.end());
+  if (atomic_update_versions_iter->second == nullptr) {
+    atomic_update_versions_missing_--;
+  } else {
+    delete atomic_update_versions_iter->second;
+  }
+  atomic_update_versions_.erase(atomic_update_versions_iter);
+}
+
+void VersionEditHandlerPointInTime::AtomicUpdateVersionsPut(Version* version) {
+  assert(!AtomicUpdateVersionsCompleted());
+  auto atomic_update_versions_iter =
+      atomic_update_versions_.find(version->cfd()->GetID());
+  assert(atomic_update_versions_iter != atomic_update_versions_.end());
+  if (atomic_update_versions_iter->second == nullptr) {
+    atomic_update_versions_missing_--;
+  } else {
+    delete atomic_update_versions_iter->second;
+  }
+  atomic_update_versions_iter->second = version;
+}
+
+void VersionEditHandlerPointInTime::AtomicUpdateVersionsApply() {
+  assert(AtomicUpdateVersionsCompleted());
+  for (const auto& cfid_and_version : atomic_update_versions_) {
+    uint32_t cfid = cfid_and_version.first;
+    Version* version = cfid_and_version.second;
+    assert(version != nullptr);
+    version->PrepareAppend(
+        *version->cfd()->GetLatestMutableCFOptions(), read_options_,
+        !version_set_->db_options_->skip_stats_update_on_db_open);
+    auto versions_iter = versions_.find(cfid);
+    if (versions_iter != versions_.end()) {
+      delete versions_iter->second;
+      versions_iter->second = version;
+    } else {
+      versions_.emplace(cfid, version);
+    }
+  }
+  atomic_update_versions_.clear();
+}
+
 Status ManifestTailer::Initialize() {
   if (Mode::kRecovery == mode_) {
     return VersionEditHandler::Initialize();