@nxtedition/rocksdb 8.2.0-alpha.1 → 8.2.0

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

@@ -226,6 +226,15 @@ uint64_t CompactionOutputs::GetCurrentKeyGrandparentOverlappedBytes(
 bool CompactionOutputs::ShouldStopBefore(const CompactionIterator& c_iter) {
   assert(c_iter.Valid());
   const Slice& internal_key = c_iter.key();
+#ifndef NDEBUG
+  bool should_stop = false;
+  std::pair<bool*, const Slice> p{&should_stop, internal_key};
+  TEST_SYNC_POINT_CALLBACK(
+      "CompactionOutputs::ShouldStopBefore::manual_decision", (void*)&p);
+  if (should_stop) {
+    return true;
+  }
+#endif  // NDEBUG
   const uint64_t previous_overlapped_bytes = grandparent_overlapped_bytes_;
   const InternalKeyComparator* icmp =
       &compaction_->column_family_data()->internal_comparator();
@@ -347,8 +356,14 @@ Status CompactionOutputs::AddToOutput(
     const CompactionFileOpenFunc& open_file_func,
     const CompactionFileCloseFunc& close_file_func) {
   Status s;
+  bool is_range_del = c_iter.IsDeleteRangeSentinelKey();
+  if (is_range_del && compaction_->bottommost_level()) {
+    // We don't consider range tombstone for bottommost level since:
+    // 1. there is no grandparent and hence no overlap to consider
+    // 2. range tombstone may be dropped at bottommost level.
+    return s;
+  }
   const Slice& key = c_iter.key();
-
   if (ShouldStopBefore(c_iter) && HasBuilder()) {
     s = close_file_func(*this, c_iter.InputStatus(), key);
     if (!s.ok()) {
@@ -358,6 +373,13 @@ Status CompactionOutputs::AddToOutput(
     grandparent_boundary_switched_num_ = 0;
     grandparent_overlapped_bytes_ =
         GetCurrentKeyGrandparentOverlappedBytes(key);
+    if (UNLIKELY(is_range_del)) {
+      // lower bound for this new output file, this is needed as the lower bound
+      // does not come from the smallest point key in this case.
+      range_tombstone_lower_bound_.DecodeFrom(key);
+    } else {
+      range_tombstone_lower_bound_.Clear();
+    }
   }
 
   // Open output file if necessary
@@ -368,6 +390,17 @@ Status CompactionOutputs::AddToOutput(
     }
   }
 
+  // c_iter may emit range deletion keys, so update `last_key_for_partitioner_`
+  // here before returning below when `is_range_del` is true
+  if (partitioner_) {
+    last_key_for_partitioner_.assign(c_iter.user_key().data_,
+                                     c_iter.user_key().size_);
+  }
+
+  if (UNLIKELY(is_range_del)) {
+    return s;
+  }
+
   assert(builder_ != nullptr);
   const Slice& value = c_iter.value();
   s = current_output().validator.Add(key, value);
@@ -391,28 +424,33 @@ Status CompactionOutputs::AddToOutput(
   s = current_output().meta.UpdateBoundaries(key, value, ikey.sequence,
                                              ikey.type);
 
-  if (partitioner_) {
-    last_key_for_partitioner_.assign(c_iter.user_key().data_,
-                                     c_iter.user_key().size_);
-  }
-
   return s;
 }
 
+namespace {
+void SetMaxSeqAndTs(InternalKey& internal_key, const Slice& user_key,
+                    const size_t ts_sz) {
+  if (ts_sz) {
+    static constexpr char kTsMax[] = "\xff\xff\xff\xff\xff\xff\xff\xff\xff";
+    if (ts_sz <= strlen(kTsMax)) {
+      internal_key = InternalKey(user_key, kMaxSequenceNumber,
+                                 kTypeRangeDeletion, Slice(kTsMax, ts_sz));
+    } else {
+      internal_key =
+          InternalKey(user_key, kMaxSequenceNumber, kTypeRangeDeletion,
+                      std::string(ts_sz, '\xff'));
+    }
+  } else {
+    internal_key.Set(user_key, kMaxSequenceNumber, kTypeRangeDeletion);
+  }
+}
+}  // namespace
+
 Status CompactionOutputs::AddRangeDels(
     const Slice* comp_start_user_key, const Slice* comp_end_user_key,
     CompactionIterationStats& range_del_out_stats, bool bottommost_level,
     const InternalKeyComparator& icmp, SequenceNumber earliest_snapshot,
     const Slice& next_table_min_key, const std::string& full_history_ts_low) {
-  assert(HasRangeDel());
-  FileMetaData& meta = current_output().meta;
-  const Comparator* ucmp = icmp.user_comparator();
-
-  Slice lower_bound_guard, upper_bound_guard;
-  std::string smallest_user_key;
-  const Slice *lower_bound, *upper_bound;
-  bool lower_bound_from_sub_compact = false;
-
   // The following example does not happen since
   // CompactionOutput::ShouldStopBefore() always return false for the first
   // point key. But we should consider removing this dependency. Suppose for the
@@ -424,98 +462,134 @@ Status CompactionOutputs::AddRangeDels(
   // Then meta.smallest will be set to comp_start_user_key@seqno
   // and meta.largest will be set to comp_start_user_key@kMaxSequenceNumber
   // which violates the assumption that meta.smallest should be <= meta.largest.
+  assert(HasRangeDel());
+  FileMetaData& meta = current_output().meta;
+  const Comparator* ucmp = icmp.user_comparator();
+  InternalKey lower_bound_buf, upper_bound_buf;
+  Slice lower_bound_guard, upper_bound_guard;
+  std::string smallest_user_key;
+  const Slice *lower_bound, *upper_bound;
+
+  // We first determine the internal key lower_bound and upper_bound for
+  // this output file. All and only range tombstones that overlap with
+  // [lower_bound, upper_bound] should be added to this file. File
+  // boundaries (meta.smallest/largest) should be updated accordingly when
+  // extended by range tombstones.
   size_t output_size = outputs_.size();
   if (output_size == 1) {
-    // For the first output table, include range tombstones before the min
-    // key but after the subcompaction boundary.
-    lower_bound = comp_start_user_key;
-    lower_bound_from_sub_compact = true;
-  } else if (meta.smallest.size() > 0) {
+    // This is the first file in the subcompaction.
+    //
+    // When outputting a range tombstone that spans a subcompaction boundary,
+    // the files on either side of that boundary need to include that
+    // boundary's user key. Otherwise, the spanning range tombstone would lose
+    // coverage.
+    //
+    // To achieve this while preventing files from overlapping in internal key
+    // (an LSM invariant violation), we allow the earlier file to include the
+    // boundary user key up to `kMaxSequenceNumber,kTypeRangeDeletion`. The
+    // later file can begin at the boundary user key at the newest key version
+    // it contains. At this point that version number is unknown since we have
+    // not processed the range tombstones yet, so permit any version. Same story
+    // applies to timestamp, and a non-nullptr `comp_start_user_key` should have
+    // `kMaxTs` here, which similarly permits any timestamp.
+    if (comp_start_user_key) {
+      lower_bound_buf.Set(*comp_start_user_key, kMaxSequenceNumber,
+                          kTypeRangeDeletion);
+      lower_bound_guard = lower_bound_buf.Encode();
+      lower_bound = &lower_bound_guard;
+    } else {
+      lower_bound = nullptr;
+    }
+  } else {
     // For subsequent output tables, only include range tombstones from min
     // key onwards since the previous file was extended to contain range
     // tombstones falling before min key.
-    smallest_user_key = meta.smallest.user_key().ToString(false /*hex*/);
-    lower_bound_guard = Slice(smallest_user_key);
-    lower_bound = &lower_bound_guard;
-  } else {
-    lower_bound = nullptr;
-  }
-  if (!next_table_min_key.empty()) {
-    // This may be the last file in the subcompaction in some cases, so we
-    // need to compare the end key of subcompaction with the next file start
-    // key. When the end key is chosen by the subcompaction, we know that
-    // it must be the biggest key in output file. Therefore, it is safe to
-    // use the smaller key as the upper bound of the output file, to ensure
-    // that there is no overlapping between different output files.
-    upper_bound_guard = ExtractUserKey(next_table_min_key);
-    if (comp_end_user_key != nullptr &&
-        ucmp->CompareWithoutTimestamp(upper_bound_guard, *comp_end_user_key) >=
-            0) {
-      upper_bound = comp_end_user_key;
+    if (range_tombstone_lower_bound_.size() > 0) {
+      assert(meta.smallest.size() == 0 ||
+             icmp.Compare(range_tombstone_lower_bound_, meta.smallest) < 0);
+      lower_bound_guard = range_tombstone_lower_bound_.Encode();
     } else {
+      assert(meta.smallest.size() > 0);
+      lower_bound_guard = meta.smallest.Encode();
+    }
+    lower_bound = &lower_bound_guard;
+  }
+
+  const size_t ts_sz = ucmp->timestamp_size();
+  if (next_table_min_key.empty()) {
+    // Last file of the subcompaction.
+    if (comp_end_user_key) {
+      upper_bound_buf.Set(*comp_end_user_key, kMaxSequenceNumber,
+                          kTypeRangeDeletion);
+      upper_bound_guard = upper_bound_buf.Encode();
       upper_bound = &upper_bound_guard;
+    } else {
+      upper_bound = nullptr;
     }
   } else {
-    // This is the last file in the subcompaction, so extend until the
-    // subcompaction ends.
-    upper_bound = comp_end_user_key;
-  }
-  bool has_overlapping_endpoints;
-  if (upper_bound != nullptr && meta.largest.size() > 0) {
-    has_overlapping_endpoints = ucmp->CompareWithoutTimestamp(
-                                    meta.largest.user_key(), *upper_bound) == 0;
-  } else {
-    has_overlapping_endpoints = false;
+    // There is another file coming whose coverage will begin at
+    // `next_table_min_key`. The current file needs to extend range tombstone
+    // coverage through its own keys (through `meta.largest`) and through user
+    // keys preceding `next_table_min_key`'s user key.
+    ParsedInternalKey next_table_min_key_parsed;
+    ParseInternalKey(next_table_min_key, &next_table_min_key_parsed,
+                     false /* log_err_key */)
+        .PermitUncheckedError();
+    assert(next_table_min_key_parsed.sequence < kMaxSequenceNumber);
+    assert(meta.largest.size() == 0 ||
+           icmp.Compare(meta.largest.Encode(), next_table_min_key) < 0);
+    assert(!lower_bound || icmp.Compare(*lower_bound, next_table_min_key) <= 0);
+    if (meta.largest.size() > 0 &&
+        ucmp->EqualWithoutTimestamp(meta.largest.user_key(),
+                                    next_table_min_key_parsed.user_key)) {
+      // Caution: this assumes meta.largest.Encode() lives longer than
+      // upper_bound, which is only true if meta.largest is never updated.
+      // This just happens to be the case here since meta.largest serves
+      // as the upper_bound.
+      upper_bound_guard = meta.largest.Encode();
+    } else {
+      SetMaxSeqAndTs(upper_bound_buf, next_table_min_key_parsed.user_key,
+                     ts_sz);
+      upper_bound_guard = upper_bound_buf.Encode();
+    }
+    upper_bound = &upper_bound_guard;
+  }
+  if (lower_bound && upper_bound &&
+      icmp.Compare(*lower_bound, *upper_bound) > 0) {
+    assert(meta.smallest.size() == 0 &&
+           ucmp->EqualWithoutTimestamp(ExtractUserKey(*lower_bound),
+                                       ExtractUserKey(*upper_bound)));
+    // This can only happen when lower_bound have the same user key as
+    // next_table_min_key and that there is no point key in the current
+    // compaction output file.
+    return Status::OK();
   }
-
   // The end key of the subcompaction must be bigger or equal to the upper
   // bound. If the end of subcompaction is null or the upper bound is null,
   // it means that this file is the last file in the compaction. So there
   // will be no overlapping between this file and others.
   assert(comp_end_user_key == nullptr || upper_bound == nullptr ||
-         ucmp->CompareWithoutTimestamp(*upper_bound, *comp_end_user_key) <= 0);
-  auto it = range_del_agg_->NewIterator(lower_bound, upper_bound,
-                                        has_overlapping_endpoints);
-  // Position the range tombstone output iterator. There may be tombstone
-  // fragments that are entirely out of range, so make sure that we do not
-  // include those.
-  if (lower_bound != nullptr) {
-    it->Seek(*lower_bound);
-  } else {
-    it->SeekToFirst();
-  }
+         ucmp->CompareWithoutTimestamp(ExtractUserKey(*upper_bound),
+                                       *comp_end_user_key) <= 0);
+  auto it = range_del_agg_->NewIterator(lower_bound, upper_bound);
   Slice last_tombstone_start_user_key{};
-  for (; it->Valid(); it->Next()) {
+  bool reached_lower_bound = false;
+  for (it->SeekToFirst(); it->Valid(); it->Next()) {
     auto tombstone = it->Tombstone();
-    if (upper_bound != nullptr) {
-      int cmp =
-          ucmp->CompareWithoutTimestamp(*upper_bound, tombstone.start_key_);
-      // Tombstones starting after upper_bound only need to be included in
-      // the next table.
-      // If the current SST ends before upper_bound, i.e.,
-      // `has_overlapping_endpoints == false`, we can also skip over range
-      // tombstones that start exactly at upper_bound. Such range
-      // tombstones will be included in the next file and are not relevant
-      // to the point keys or endpoints of the current file.
-      // If the current SST ends at the same user key at upper_bound,
-      // i.e., `has_overlapping_endpoints == true`, AND the tombstone has
-      // the same start key as upper_bound, i.e., cmp == 0, then
-      // the tombstone is relevant only if the tombstone's sequence number
-      // is no larger than this file's largest key's sequence number. This
-      // is because the upper bound to truncate this file's range tombstone
-      // will be meta.largest in this case, and any tombstone that starts after
-      // it will not be relevant.
-      if (cmp < 0) {
-        break;
-      } else if (cmp == 0) {
-        if (!has_overlapping_endpoints ||
-            tombstone.seq_ < GetInternalKeySeqno(meta.largest.Encode())) {
-          break;
-        }
-      }
+    auto kv = tombstone.Serialize();
+    InternalKey tombstone_end = tombstone.SerializeEndKey();
+    // TODO: the underlying iterator should support clamping the bounds.
+    // tombstone_end.Encode is of form user_key@kMaxSeqno
+    // if it is equal to lower_bound, there is no need to include
+    // such range tombstone.
+    if (!reached_lower_bound && lower_bound &&
+        icmp.Compare(tombstone_end.Encode(), *lower_bound) <= 0) {
+      continue;
     }
+    assert(!lower_bound ||
+           icmp.Compare(*lower_bound, tombstone_end.Encode()) <= 0);
+    reached_lower_bound = true;
 
-    const size_t ts_sz = ucmp->timestamp_size();
     // Garbage collection for range tombstones.
     // If user-defined timestamp is enabled, range tombstones are dropped if
     // they are at bottommost_level, below full_history_ts_low and not visible
@@ -534,83 +608,93 @@ Status CompactionOutputs::AddRangeDels(
       continue;
     }
 
-    auto kv = tombstone.Serialize();
     assert(lower_bound == nullptr ||
-           ucmp->CompareWithoutTimestamp(*lower_bound, kv.second) < 0);
+           ucmp->CompareWithoutTimestamp(ExtractUserKey(*lower_bound),
+                                         kv.second) < 0);
+    InternalKey tombstone_start = kv.first;
+    if (lower_bound &&
+        ucmp->CompareWithoutTimestamp(tombstone_start.user_key(),
+                                      ExtractUserKey(*lower_bound)) < 0) {
+      // This just updates the non-timestamp portion of `tombstone_start`'s user
+      // key. Ideally there would be a simpler API usage
+      ParsedInternalKey tombstone_start_parsed;
+      ParseInternalKey(tombstone_start.Encode(), &tombstone_start_parsed,
+                       false /* log_err_key */)
+          .PermitUncheckedError();
+      // timestamp should be from where sequence number is from, which is from
+      // tombstone in this case
+      std::string ts =
+          tombstone_start_parsed.GetTimestamp(ucmp->timestamp_size())
+              .ToString();
+      tombstone_start_parsed.user_key = ExtractUserKey(*lower_bound);
+      tombstone_start.SetFrom(tombstone_start_parsed, ts);
+    }
+    if (upper_bound != nullptr &&
+        icmp.Compare(*upper_bound, tombstone_start.Encode()) < 0) {
+      break;
+    }
+    // Here we show that *only* range tombstones that overlap with
+    // [lower_bound, upper_bound] are added to the current file, and
+    // sanity checking invariants that should hold:
+    // - [tombstone_start, tombstone_end] overlaps with [lower_bound,
+    // upper_bound]
+    // - meta.smallest <= meta.largest
+    // Corresponding assertions are made, the proof is broken is any of them
+    // fails.
+    // TODO: show that *all* range tombstones that overlap with
+    //  [lower_bound, upper_bound] are added.
+    // TODO: some invariant about boundaries are correctly updated.
+    //
+    // Note that `tombstone_start` is updated in the if condition above, we use
+    // tombstone_start to refer to its initial value, i.e.,
+    // it->Tombstone().first, and use tombstone_start* to refer to its value
+    // after the update.
+    //
+    // To show [lower_bound, upper_bound] overlaps with [tombstone_start,
+    // tombstone_end]:
+    // lower_bound <= upper_bound from the if condition right after all
+    // bounds are initialized. We assume each tombstone fragment has
+    // start_key.user_key < end_key.user_key, so
+    // tombstone_start < tombstone_end by
+    // FragmentedTombstoneIterator::Tombstone(). So these two ranges are both
+    // non-emtpy. The flag `reached_lower_bound` and the if logic before it
+    // ensures lower_bound <= tombstone_end. tombstone_start is only updated
+    // if it has a smaller user_key than lower_bound user_key, so
+    // tombstone_start <= tombstone_start*. The above if condition implies
+    // tombstone_start* <= upper_bound. So we have
+    // tombstone_start <= upper_bound and lower_bound <= tombstone_end
+    // and the two ranges overlap.
+    //
+    // To show meta.smallest <= meta.largest:
+    // From the implementation of UpdateBoundariesForRange(), it suffices to
+    // prove that when it is first called in this function, its parameters
+    // satisfy `start <= end`, where start = max(tombstone_start*, lower_bound)
+    // and end = min(tombstone_end, upper_bound). From the above proof we have
+    // lower_bound <= tombstone_end and lower_bound <= upper_bound. We only need
+    // to show that tombstone_start* <= min(tombstone_end, upper_bound).
+    // Note that tombstone_start*.user_key = max(tombstone_start.user_key,
+    // lower_bound.user_key). Assuming tombstone_end always has
+    // kMaxSequenceNumber and lower_bound.seqno < kMaxSequenceNumber.
+    // Since lower_bound <= tombstone_end and lower_bound.seqno <
+    // tombstone_end.seqno (in absolute number order, not internal key order),
+    // lower_bound.user_key < tombstone_end.user_key.
+    // Since lower_bound.user_key < tombstone_end.user_key and
+    // tombstone_start.user_key < tombstone_end.user_key, tombstone_start* <
+    // tombstone_end. Since tombstone_start* <= upper_bound from the above proof
+    // and tombstone_start* < tombstone_end, tombstone_start* <=
+    // min(tombstone_end, upper_bound), so the two ranges overlap.
+
     // Range tombstone is not supported by output validator yet.
     builder_->Add(kv.first.Encode(), kv.second);
-    InternalKey tombstone_start = std::move(kv.first);
-    InternalKey smallest_candidate{tombstone_start};
-    if (lower_bound != nullptr &&
-        ucmp->CompareWithoutTimestamp(smallest_candidate.user_key(),
-                                      *lower_bound) <= 0) {
-      // Pretend the smallest key has the same user key as lower_bound
-      // (the max key in the previous table or subcompaction) in order for
-      // files to appear key-space partitioned.
-      if (lower_bound_from_sub_compact) {
-        // When lower_bound is chosen by a subcompaction
-        // (lower_bound_from_sub_compact), we know that subcompactions over
-        // smaller keys cannot contain any keys at lower_bound. We also know
-        // that smaller subcompactions exist, because otherwise the
-        // subcompaction woud be unbounded on the left. As a result, we know
-        // that no other files on the output level will contain actual keys at
-        // lower_bound (an output file may have a largest key of
-        // lower_bound@kMaxSequenceNumber, but this only indicates a large range
-        // tombstone was truncated). Therefore, it is safe to use the
-        // tombstone's sequence number, to ensure that keys at lower_bound at
-        // lower levels are covered by truncated tombstones.
-        if (ts_sz) {
-          assert(tombstone.ts_.size() == ts_sz);
-          smallest_candidate = InternalKey(*lower_bound, tombstone.seq_,
-                                           kTypeRangeDeletion, tombstone.ts_);
-        } else {
-          smallest_candidate =
-              InternalKey(*lower_bound, tombstone.seq_, kTypeRangeDeletion);
-        }
-      } else {
-        // If lower_bound was chosen by the smallest data key in the file,
-        // choose lowest seqnum so this file's smallest internal key comes
-        // after the previous file's largest. The fake seqnum is OK because
-        // the read path's file-picking code only considers user key.
-        smallest_candidate = InternalKey(*lower_bound, 0, kTypeRangeDeletion);
-      }
+    if (lower_bound &&
+        icmp.Compare(tombstone_start.Encode(), *lower_bound) < 0) {
+      tombstone_start.DecodeFrom(*lower_bound);
     }
-    InternalKey tombstone_end = tombstone.SerializeEndKey();
-    InternalKey largest_candidate{tombstone_end};
-    if (upper_bound != nullptr &&
-        ucmp->CompareWithoutTimestamp(*upper_bound,
-                                      largest_candidate.user_key()) <= 0) {
-      // Pretend the largest key has the same user key as upper_bound (the
-      // min key in the following table or subcompaction) in order for files
-      // to appear key-space partitioned.
-      //
-      // Choose highest seqnum so this file's largest internal key comes
-      // before the next file's/subcompaction's smallest. The fake seqnum is
-      // OK because the read path's file-picking code only considers the
-      // user key portion.
-      //
-      // Note Seek() also creates InternalKey with (user_key,
-      // kMaxSequenceNumber), but with kTypeDeletion (0x7) instead of
-      // kTypeRangeDeletion (0xF), so the range tombstone comes before the
-      // Seek() key in InternalKey's ordering. So Seek() will look in the
-      // next file for the user key
-      if (ts_sz) {
-        static constexpr char kTsMax[] = "\xff\xff\xff\xff\xff\xff\xff\xff\xff";
-        if (ts_sz <= strlen(kTsMax)) {
-          largest_candidate =
-              InternalKey(*upper_bound, kMaxSequenceNumber, kTypeRangeDeletion,
-                          Slice(kTsMax, ts_sz));
-        } else {
-          largest_candidate =
-              InternalKey(*upper_bound, kMaxSequenceNumber, kTypeRangeDeletion,
-                          std::string(ts_sz, '\xff'));
-        }
-      } else {
-        largest_candidate =
-            InternalKey(*upper_bound, kMaxSequenceNumber, kTypeRangeDeletion);
-      }
+    if (upper_bound && icmp.Compare(*upper_bound, tombstone_end.Encode()) < 0) {
+      tombstone_end.DecodeFrom(*upper_bound);
     }
-    meta.UpdateBoundariesForRange(smallest_candidate, largest_candidate,
+    assert(icmp.Compare(tombstone_start, tombstone_end) <= 0);
+    meta.UpdateBoundariesForRange(tombstone_start, tombstone_end,
                                   tombstone.seq_, icmp);
     if (!bottommost_level) {
       bool start_user_key_changed =
@@ -618,17 +702,8 @@ Status CompactionOutputs::AddRangeDels(
           ucmp->CompareWithoutTimestamp(last_tombstone_start_user_key,
                                         it->start_key()) < 0;
       last_tombstone_start_user_key = it->start_key();
-      // Range tombstones are truncated at file boundaries
-      if (icmp.Compare(tombstone_start, meta.smallest) < 0) {
-        tombstone_start = meta.smallest;
-      }
-      if (icmp.Compare(tombstone_end, meta.largest) > 0) {
-        tombstone_end = meta.largest;
-      }
-      // this assertion validates invariant (2) in the comment below.
-      assert(icmp.Compare(tombstone_start, tombstone_end) <= 0);
       if (start_user_key_changed) {
-        // if tombstone_start >= tombstone_end, then either no key range is
+        // If tombstone_start >= tombstone_end, then either no key range is
         // covered, or that they have the same user key. If they have the same
         // user key, then the internal key range should only be within this
         // level, and no keys from older levels is covered.
@@ -646,138 +721,6 @@ Status CompactionOutputs::AddRangeDels(
         }
       }
     }
-    // TODO: show invariants that ensure all necessary range tombstones are
-    // added
-    //  and that file boundaries ensure no coverage is lost.
-    // Each range tombstone with internal key range [tombstone_start,
-    // tombstone_end] is being added to the current compaction output file here.
-    // The range tombstone is going to be truncated at range [meta.smallest,
-    // meta.largest] during reading/scanning. We should maintain invariants
-    // (1) meta.smallest <= meta.largest and,
-    // (2) [tombstone_start, tombstone_end] and [meta.smallest, meta.largest]
-    // overlaps, as there is no point adding range tombstone with a range
-    // outside the file's range.
-    // Since `tombstone_end` is always some user_key@kMaxSeqno, it is okay to
-    // use either open or closed range. Using closed range here to make
-    // reasoning easier, and it is more consistent with an ongoing work that
-    // tries to simplify this method.
-    //
-    // There are two cases:
-    // Case 1. Output file has no point key:
-    //   First we show this case only happens when the entire compaction output
-    //   is range tombstone only. This is true if CompactionIterator does not
-    //   emit any point key. Suppose CompactionIterator emits some point key.
-    //   Based on the assumption that CompactionOutputs::ShouldStopBefore()
-    //   always return false for the first point key, the first compaction
-    //   output file always contains a point key. Each new compaction output
-    //   file is created if there is a point key for which ShouldStopBefore()
-    //   returns true, and the point key would be added to the new compaction
-    //   output file. So each new compaction file always contains a point key.
-    //   So Case 1 only happens when CompactionIterator does not emit any
-    //   point key.
-    //
-    //   To show (1) meta.smallest <= meta.largest:
-    //   Since the compaction output is range tombstone only, `lower_bound` and
-    //   `upper_bound` are either null or comp_start/end_user_key respectively.
-    //   According to how UpdateBoundariesForRange() is implemented, it blindly
-    //   updates meta.smallest and meta.largest to smallest_candidate and
-    //   largest_candidate the first time it is called. Subsequently, it
-    //   compares input parameter with meta.smallest and meta.largest and only
-    //   updates them when input is smaller/larger. So we only need to show
-    //   smallest_candidate <= largest_candidate the first time
-    //   UpdateBoundariesForRange() is called. Here we show something stronger
-    //   that smallest_candidate.user_key < largest_candidate.user_key always
-    //   hold for Case 1.
-    //   We assume comp_start_user_key < comp_end_user_key, if provided. We
-    //   assume that tombstone_start < tombstone_end. This assumption is based
-    //   on that each fragment in FragmentedTombstoneList has
-    //   start_key < end_key (user_key) and that
-    //   FragmentedTombstoneIterator::Tombstone() returns the pair
-    //   (start_key@tombstone_seqno with op_type kTypeRangeDeletion, end_key).
-    //   The logic in this loop sets smallest_candidate to
-    //   max(tombstone_start.user_key, comp_start_user_key)@tombstone.seq_ with
-    //   op_type kTypeRangeDeletion, largest_candidate to
-    //   min(tombstone_end.user_key, comp_end_user_key)@kMaxSequenceNumber with
-    //   op_type kTypeRangeDeletion. When a bound is null, there is no
-    //   truncation on that end. To show that smallest_candidate.user_key <
-    //   largest_candidate.user_key, it suffices to show
-    //   tombstone_start.user_key < comp_end_user_key (if not null) AND
-    //   comp_start_user_key (if not null) < tombstone_end.user_key.
-    //   Since the file has no point key, `has_overlapping_endpoints` is false.
-    //   In the first sanity check of this for-loop, we compare
-    //   tombstone_start.user_key against upper_bound = comp_end_user_key,
-    //   and only proceed if tombstone_start.user_key < comp_end_user_key.
-    //   We assume FragmentedTombstoneIterator::Seek(k) lands
-    //   on a tombstone with end_key > k. So the call it->Seek(*lower_bound)
-    //   above implies compact_start_user_key < tombstone_end.user_key.
-    //
-    //   To show (2) [tombstone_start, tombstone_end] and [meta.smallest,
-    //   meta.largest] overlaps (after the call to UpdateBoundariesForRange()):
-    //   In the proof for (1) we have shown that
-    //   smallest_candidate <= largest_candidate. Since tombstone_start <=
-    //   smallest_candidate <= largest_candidate <= tombstone_end, for (2) to
-    //   hold, it suffices to show that [smallest_candidate, largest_candidate]
-    //   overlaps with [meta.smallest, meta.largest]. too.
-    //   Given meta.smallest <= meta.largest shown above, we need to show
-    //   that it is impossible to have largest_candidate < meta.smallest or
-    //   meta.largest < smallest_candidate. If the above
-    //   meta.UpdateBoundariesForRange(smallest_candidate, largest_candidate)
-    //   updates meta.largest or meta.smallest, then the two ranges overlap.
-    //   So we assume meta.UpdateBoundariesForRange(smallest_candidate,
-    //   largest_candidate) did not update meta.smallest nor meta.largest, which
-    //   means meta.smallest < smallest_candidate and largest_candidate <
-    //   meta.largest.
-    //
-    // Case 2. Output file has >= 1 point key. This means meta.smallest and
-    // meta.largest are not empty when AddRangeDels() is called.
-    //   To show (1) meta.smallest <= meta.largest:
-    //   Assume meta.smallest <= meta.largest when AddRangeDels() is called,
-    //   this follow from how UpdateBoundariesForRange() is implemented where it
-    //   takes min or max to update meta.smallest or meta.largest.
-    //
-    //   To show (2) [tombstone_start, tombstone_end] and [meta.smallest,
-    //   meta.largest] overlaps (after the call to UpdateBoundariesForRange()):
-    //   When smallest_candidate <= largest_candidate, the proof in Case 1
-    //   applies, so we only need to show (2) holds when smallest_candidate >
-    //   largest_candidate. When both bounds are either null or from
-    //   subcompaction boundary, the proof in Case 1 applies, so we only need to
-    //   show (2) holds when at least one bound is from a point key (either
-    //   meta.smallest for lower bound or next_table_min_key for upper bound).
-    //
-    //   Suppose lower bound is meta.smallest.user_key. The call
-    //   it->Seek(*lower_bound) implies tombstone_end.user_key >
-    //   meta.smallest.user_key. We have smallest_candidate.user_key =
-    //   max(tombstone_start.user_key, meta.smallest.user_key). For
-    //   smallest_candidate to be > largest_candidate, we need
-    //   largest_candidate.user_key = upper_bound = smallest_candidate.user_key,
-    //   where tombstone_end is truncated to largest_candidate.
-    //   Subcase 1:
-    //   Suppose largest_candidate.user_key = comp_end_user_key (there is no
-    //   next point key). Subcompaction ensures any point key from this
-    //   subcompaction has a user_key < comp_end_user_key, so 1)
-    //   meta.smallest.user_key < comp_end_user_key, 2)
-    //   `has_overlapping_endpoints` is false, and the first if condition in
-    //   this for-loop ensures tombstone_start.user_key < comp_end_user_key. So
-    //   smallest_candidate.user_key < largest_candidate.user_key. This case
-    //   cannot happen when smallest > largest_candidate.
-    //   Subcase 2:
-    //   Suppose largest_candidate.user_key = next_table_min_key.user_key.
-    //   The first if condition in this for-loop together with
-    //   smallest_candidate.user_key = next_table_min_key.user_key =
-    //   upper_bound implies `has_overlapping_endpoints` is true (so meta
-    //   largest.user_key = upper_bound) and
-    //   tombstone.seq_ < meta.largest.seqno. So
-    //   tombstone_start < meta.largest < tombstone_end.
-    //
-    //   Suppose lower bound is comp_start_user_key and upper_bound is
-    //   next_table_min_key. The call it->Seek(*lower_bound) implies we have
-    //   tombstone_end_key.user_key > comp_start_user_key. So
-    //   tombstone_end_key.user_key > smallest_candidate.user_key. For
-    //   smallest_candidate to be > largest_candidate, we need
-    //   tombstone_start.user_key = largest_candidate.user_key = upper_bound =
-    //   next_table_min_key.user_key. This means `has_overlapping_endpoints` is
-    //   true (so meta.largest.user_key = upper_bound) and tombstone.seq_ <
-    //   meta.largest.seqno. So tombstone_start < meta.largest < tombstone_end.
   }
   return Status::OK();
 }