Upgrade versions of vendored libs

vendor/github.com/cockroachdb/pebble/internal/keyspan/fragmenter.go

@@ -108,20 +108,20 @@ func (f *Fragmenter) checkInvariants(buf []Span) {
 // increasing start key order. That is, Add must be called with a series
 // of spans like:
 //
-//   a---e
-//     c---g
-//     c-----i
-//            j---n
-//            j-l
+//	a---e
+//	  c---g
+//	  c-----i
+//	         j---n
+//	         j-l
 //
 // We need to fragment the spans at overlap points. In the above
 // example, we'd create:
 //
-//   a-c-e
-//     c-e-g
-//     c-e-g-i
-//            j-l-n
-//            j-l
+//	a-c-e
+//	  c-e-g
+//	  c-e-g-i
+//	         j-l-n
+//	         j-l
 //
 // The fragments need to be output sorted by start key, and for equal start
 // keys, sorted by descending sequence number. This last part requires a mild
@@ -134,42 +134,42 @@ func (f *Fragmenter) checkInvariants(buf []Span) {
 //
 // Walking through the example above, we start with:
 //
-//   a---e
+//	a---e
 //
 // Next we add [c,g) resulting in:
 //
-//   a-c-e
-//     c---g
+//	a-c-e
+//	  c---g
 //
 // The fragment [a,c) is flushed leaving the pending spans as:
 //
-//   c-e
-//   c---g
+//	c-e
+//	c---g
 //
 // The next span is [c,i):
 //
-//   c-e
-//   c---g
-//   c-----i
+//	c-e
+//	c---g
+//	c-----i
 //
 // No fragments are flushed. The next span is [j,n):
 //
-//   c-e
-//   c---g
-//   c-----i
-//          j---n
+//	c-e
+//	c---g
+//	c-----i
+//	       j---n
 //
 // The fragments [c,e), [c,g) and [c,i) are flushed. We sort these fragments
 // by their end key, then split the fragments on the end keys:
 //
-//   c-e
-//   c-e-g
-//   c-e---i
+//	c-e
+//	c-e-g
+//	c-e---i
 //
 // The [c,e) fragments all get flushed leaving:
 //
-//   e-g
-//   e---i
+//	e-g
+//	e---i
 //
 // This process continues until there are no more fragments to flush.
 //
@@ -229,16 +229,35 @@ func (f *Fragmenter) Add(s Span) {
 	f.pending = append(f.pending, s)
 }
 
-// Covers returns true if the specified key is covered by one of the pending
-// spans. The key must be consistent with the ordering of the
-// spans. That is, it is invalid to specify a key here that is out of
-// order with the span start keys passed to Add.
-func (f *Fragmenter) Covers(key base.InternalKey, snapshot uint64) bool {
+// Cover is returned by Framenter.Covers and describes a span's relationship to
+// a key at a particular snapshot.
+type Cover int8
+
+const (
+	// NoCover indicates the tested key does not fall within the span's bounds,
+	// or the span contains no keys with sequence numbers higher than the key's.
+	NoCover Cover = iota
+	// CoversInvisibly indicates the tested key does fall within the span's
+	// bounds and the span contains at least one key with a higher sequence
+	// number, but none visible at the provided snapshot.
+	CoversInvisibly
+	// CoversVisibly indicates the tested key does fall within the span's
+	// bounds, and the span constains at least one key with a sequence number
+	// higher than the key's sequence number that is visible at the provided
+	// snapshot.
+	CoversVisibly
+)
+
+// Covers returns an enum indicating whether the specified key is covered by one
+// of the pending keys. The provided key must be consistent with the ordering of
+// the spans. That is, it is invalid to specify a key here that is out of order
+// with the span start keys passed to Add.
+func (f *Fragmenter) Covers(key base.InternalKey, snapshot uint64) Cover {
 	if f.finished {
 		panic("pebble: span fragmenter already finished")
 	}
 	if len(f.pending) == 0 {
-		return false
+		return NoCover
 	}
 
 	if f.Cmp(f.pending[0].Start, key.UserKey) > 0 {
@@ -246,18 +265,31 @@ func (f *Fragmenter) Covers(key base.InternalKey, snapshot uint64) bool {
 			f.Format(f.pending[0].Start), key.Pretty(f.Format)))
 	}
 
+	cover := NoCover
 	seqNum := key.SeqNum()
 	for _, s := range f.pending {
 		if f.Cmp(key.UserKey, s.End) < 0 {
 			// NB: A range deletion tombstone does not delete a point operation
 			// at the same sequence number, and broadly a span is not considered
 			// to cover a point operation at the same sequence number.
-			if s.CoversAt(snapshot, seqNum) {
-				return true
+
+			for i := range s.Keys {
+				if kseq := s.Keys[i].SeqNum(); kseq > seqNum {
+					// This key from the span has a higher sequence number than
+					// `key`. It covers `key`, although the span's key might not
+					// be visible if its snapshot is too high.
+					//
+					// Batch keys are always be visible.
+					if kseq < snapshot || kseq&base.InternalKeySeqNumBatch != 0 {
+						return CoversVisibly
+					}
+					// s.Keys[i] is not visible.
+					cover = CoversInvisibly
+				}
 			}
 		}
 	}
-	return false
+	return cover
 }
 
 // Empty returns true if all fragments added so far have finished flushing.
@@ -270,20 +302,20 @@ func (f *Fragmenter) Empty() bool {
 // emitting of spans which straddle an sstable boundary. Consider
 // the scenario:
 //
-//     a---------k#10
-//          f#8
-//          f#7
-///
+//	a---------k#10
+//	     f#8
+//	     f#7
+//
 // Let's say the next user key after f is g. Calling TruncateAndFlushTo(g) will
 // flush this span:
 //
-//    a-------g#10
-//         f#8
-//         f#7
+//	a-------g#10
+//	     f#8
+//	     f#7
 //
 // And leave this one in f.pending:
 //
-//            g----k#10
+//	g----k#10
 //
 // WARNING: The fragmenter could hold on to the specified end key. Ensure it's
 // a safe byte slice that could outlast the current sstable output, and one
@@ -374,8 +406,8 @@ func (f *Fragmenter) truncateAndFlush(key []byte) {
 // we want to flush (but not truncate) all range tombstones that start at or
 // before the first key in the next sstable. Consider:
 //
-//   a---e#10
-//   a------h#9
+//	a---e#10
+//	a------h#9
 //
 // If a compaction splits the sstables at key c we want the first sstable to
 // contain the tombstones [a,e)#10 and [a,e)#9. Fragmentation would naturally