manifest: use new InternalKeyBounds struct in TableMetadata's range keys

This patch introduces (and uses) a new `InternalKeyBounds` struct to represent
both the smallest, largest range keys (if they exist) in our
`TableMetadata` struct. These keys are now stored as a single string --
spliced by a separator index for individual access.

This allows us to save 24 bytes for our `TableMetadata` struct.

Informs: #2047

Author: annrpom

compaction.go

@@ -2612,7 +2612,7 @@ func (d *DB) runCopyCompaction(
 		newMeta.ExtendPointKeyBounds(c.cmp, inputMeta.SmallestPointKey, inputMeta.LargestPointKey)
 	}
 	if inputMeta.HasRangeKeys {
-		newMeta.ExtendRangeKeyBounds(c.cmp, inputMeta.SmallestRangeKey, inputMeta.LargestRangeKey)
+		newMeta.ExtendRangeKeyBounds(c.cmp, inputMeta.RangeKeyBounds.Smallest(), inputMeta.RangeKeyBounds.Largest())
 	}
 	newMeta.FileNum = d.mu.versions.getNextFileNum()
 	if objMeta.IsExternal() {

db.go

@@ -3043,23 +3043,23 @@ func (d *DB) checkVirtualBounds(m *tableMetadata) {
 	// Check that the lower bound is tight.
 	if s, err := rangeKeyIter.First(); err != nil {
 		panic(err)
-	} else if d.cmp(s.SmallestKey().UserKey, m.SmallestRangeKey.UserKey) != 0 {
+	} else if d.cmp(s.SmallestKey().UserKey, m.RangeKeyBounds.SmallestUserKey()) != 0 {
 		panic(errors.Newf("pebble: virtual sstable %s lower range key bound is not tight", m.FileNum))
 	}
 
 	// Check that upper bound is tight.
 	if s, err := rangeKeyIter.Last(); err != nil {
 		panic(err)
-	} else if d.cmp(s.LargestKey().UserKey, m.LargestRangeKey.UserKey) != 0 {
+	} else if d.cmp(s.LargestKey().UserKey, m.RangeKeyBounds.LargestUserKey()) != 0 {
 		panic(errors.Newf("pebble: virtual sstable %s upper range key bound is not tight", m.FileNum))
 	}
 
 	s, err := rangeKeyIter.First()
 	for ; s != nil; s, err = rangeKeyIter.Next() {
-		if d.cmp(s.SmallestKey().UserKey, m.SmallestRangeKey.UserKey) < 0 {
+		if d.cmp(s.SmallestKey().UserKey, m.RangeKeyBounds.SmallestUserKey()) < 0 {
 			panic(errors.Newf("pebble: virtual sstable %s point key %s is not within bounds", m.FileNum, s.SmallestKey().UserKey))
 		}
-		if d.cmp(s.LargestKey().UserKey, m.LargestRangeKey.UserKey) > 0 {
+		if d.cmp(s.LargestKey().UserKey, m.RangeKeyBounds.LargestUserKey()) > 0 {
 			panic(errors.Newf("pebble: virtual sstable %s point key %s is not within bounds", m.FileNum, s.LargestKey().UserKey))
 		}
 	}

excise.go

@@ -266,11 +266,11 @@ func looseLeftTableBounds(
 		leftTable.ExtendPointKeyBounds(cmp, originalTable.SmallestPointKey, largestPointKey)
 	}
 	if originalTable.HasRangeKeys {
-		largestRangeKey := originalTable.LargestRangeKey
+		largestRangeKey := originalTable.RangeKeyBounds.Largest()
 		if largestRangeKey.IsUpperBoundFor(cmp, exciseSpanStart) {
 			largestRangeKey = base.MakeExclusiveSentinelKey(InternalKeyKindRangeKeyMin, exciseSpanStart)
 		}
-		leftTable.ExtendRangeKeyBounds(cmp, originalTable.SmallestRangeKey, largestRangeKey)
+		leftTable.ExtendRangeKeyBounds(cmp, originalTable.RangeKeyBounds.Smallest(), largestRangeKey)
 	}
 }
 
@@ -294,11 +294,11 @@ func looseRightTableBounds(
 		rightTable.ExtendPointKeyBounds(cmp, smallestPointKey, originalTable.LargestPointKey)
 	}
 	if originalTable.HasRangeKeys {
-		smallestRangeKey := originalTable.SmallestRangeKey
+		smallestRangeKey := originalTable.RangeKeyBounds.Smallest()
 		if !smallestRangeKey.IsUpperBoundFor(cmp, exciseSpanEnd) {
 			smallestRangeKey = base.MakeInternalKey(exciseSpanEnd, 0, base.InternalKeyKindRangeKeyMax)
 		}
-		rightTable.ExtendRangeKeyBounds(cmp, smallestRangeKey, originalTable.LargestRangeKey)
+		rightTable.ExtendRangeKeyBounds(cmp, smallestRangeKey, originalTable.RangeKeyBounds.Largest())
 	}
 }
 
@@ -332,7 +332,7 @@ func determineLeftTableBounds(
 		}
 	}
 
-	if originalTable.HasRangeKeys && cmp(originalTable.SmallestRangeKey.UserKey, exciseSpanStart) < 0 {
+	if originalTable.HasRangeKeys && cmp(originalTable.RangeKeyBounds.SmallestUserKey(), exciseSpanStart) < 0 {
 		rkey, err := iters.RangeKey().SeekLT(exciseSpanStart)
 		if err != nil {
 			return err
@@ -344,7 +344,7 @@ func determineLeftTableBounds(
 				// The key is owned by the range key iter, so we need to copy it.
 				lastRangeKey = slices.Clone(rkey.End)
 			}
-			leftTable.ExtendRangeKeyBounds(cmp, originalTable.SmallestRangeKey,
+			leftTable.ExtendRangeKeyBounds(cmp, originalTable.RangeKeyBounds.Smallest(),
 				base.MakeExclusiveSentinelKey(rkey.LargestKey().Kind(), lastRangeKey))
 		}
 	}
@@ -393,7 +393,7 @@ func determineRightTableBounds(
 			}, originalTable.LargestPointKey)
 		}
 	}
-	if originalTable.HasRangeKeys && !exciseSpanEnd.IsUpperBoundForInternalKey(cmp, originalTable.LargestRangeKey) {
+	if originalTable.HasRangeKeys && !exciseSpanEnd.IsUpperBoundForInternalKey(cmp, originalTable.RangeKeyBounds.Largest()) {
 		rkey, err := iters.RangeKey().SeekGE(exciseSpanEnd.Key)
 		if err != nil {
 			return err
@@ -410,7 +410,7 @@ func determineRightTableBounds(
 			rightTable.ExtendRangeKeyBounds(cmp, base.InternalKey{
 				UserKey: firstRangeKey,
 				Trailer: rkey.SmallestKey().Trailer,
-			}, originalTable.LargestRangeKey)
+			}, originalTable.RangeKeyBounds.Largest())
 		}
 	}
 	return nil

excise_test.go

@@ -804,7 +804,7 @@ func TestExciseBounds(t *testing.T) {
 				fmt.Fprintf(&buf, "  point:   %v - %v\n", m.SmallestPointKey, m.LargestPointKey)
 			}
 			if m.HasRangeKeys {
-				fmt.Fprintf(&buf, "  range:   %v - %v\n", m.SmallestRangeKey, m.LargestRangeKey)
+				fmt.Fprintf(&buf, "  range:   %v - %v\n", m.RangeKeyBounds.Smallest(), m.RangeKeyBounds.Largest())
 			}
 		}
 		switch td.Cmd {

file_cache_test.go

@@ -369,11 +369,12 @@ func TestVirtualReadsWiring(t *testing.T) {
 		LargestSeqNumAbsolute: parentFile.LargestSeqNumAbsolute,
 		SmallestPointKey:      base.MakeInternalKey([]byte{'d'}, seqNumCEDel, InternalKeyKindRangeDelete),
 		LargestPointKey:       base.MakeInternalKey([]byte{'z'}, seqNumZ, InternalKeyKindSet),
-		SmallestRangeKey:      base.MakeInternalKey([]byte{'f'}, seqNumRangeSet, InternalKeyKindRangeKeySet),
-		LargestRangeKey:       base.MakeInternalKey([]byte{'k'}, seqNumRangeUnset, InternalKeyKindRangeKeyUnset),
 		HasPointKeys:          true,
 		Virtual:               true,
 	}
+	v2.RangeKeyBounds.SetInternalKeyBounds(
+		base.MakeInternalKey([]byte{'f'}, seqNumRangeSet, InternalKeyKindRangeKeySet),
+		base.MakeInternalKey([]byte{'k'}, seqNumRangeUnset, InternalKeyKindRangeKeyUnset))
 	v2.ExtendPointKeyBounds(DefaultComparer.Compare, v2.SmallestPointKey, v2.LargestPointKey)
 	v2.AttachVirtualBacking(parentFile.FileBacking)
 	v2.Stats.NumEntries = 6

ingest.go

@@ -881,7 +881,7 @@ func setSeqNumInMetadata(
 		m.SmallestPointKey = setSeqFn(m.SmallestPointKey)
 	}
 	if m.HasRangeKeys {
-		m.SmallestRangeKey = setSeqFn(m.SmallestRangeKey)
+		m.RangeKeyBounds.SetSmallest(setSeqFn(m.RangeKeyBounds.Smallest()))
 	}
 	// Only update the seqnum for the largest key if that key is not an
 	// "exclusive sentinel" (i.e. a range deletion sentinel or a range key

ingest_test.go

@@ -155,7 +155,7 @@ func TestIngestLoad(t *testing.T) {
 			for _, m := range lr.local {
 				fmt.Fprintf(&buf, "%d: %s-%s\n", m.FileNum, m.Smallest(), m.Largest())
 				fmt.Fprintf(&buf, "  points: %s-%s\n", m.SmallestPointKey, m.LargestPointKey)
-				fmt.Fprintf(&buf, "  ranges: %s-%s\n", m.SmallestRangeKey, m.LargestRangeKey)
+				fmt.Fprintf(&buf, "  ranges: %s-%s\n", m.RangeKeyBounds.Smallest(), m.RangeKeyBounds.Largest())
 			}
 			return buf.String()
 
@@ -2660,7 +2660,7 @@ func TestIngest_UpdateSequenceNumber(t *testing.T) {
 				fmt.Fprintf(&buf, "file %d:\n", i)
 				fmt.Fprintf(&buf, "  combined: %s-%s\n", m.Smallest(), m.Largest())
 				fmt.Fprintf(&buf, "    points: %s-%s\n", m.SmallestPointKey, m.LargestPointKey)
-				fmt.Fprintf(&buf, "    ranges: %s-%s\n", m.SmallestRangeKey, m.LargestRangeKey)
+				fmt.Fprintf(&buf, "    ranges: %s-%s\n", m.RangeKeyBounds.Smallest(), m.RangeKeyBounds.Largest())
 			}
 
 			return buf.String()

internal/keyspan/keyspanimpl/level_iter.go

@@ -182,13 +182,14 @@ func (l *LevelIter) SeekGE(key []byte) (*keyspan.Span, error) {
 		l.setPosBeforeFile(nil)
 		return nil, nil
 	}
-	if l.straddleSpansEnabled() && l.cmp(key, file.SmallestRangeKey.UserKey) < 0 {
+	if l.straddleSpansEnabled() && l.cmp(key, file.RangeKeyBounds.SmallestUserKey()) < 0 {
 		// Peek at the previous file.
 		if prevFile := l.files.Prev(); prevFile != nil {
-			// We could unconditionally return an empty span between the seek key and
-			// f.SmallestRangeKey, however if this span is to the left of all range
-			// keys on this level, it could lead to inconsistent behaviour in relative
-			// positioning operations. Consider this example, with a b-c range key:
+			// We could unconditionally return an empty span between the seek
+			// key and f.RangeKeyBounds.Smallest(), however if this span is to
+			// the left of all range keys on this level, it could lead to
+			// inconsistent behaviour in relative positioning operations.
+			// Consider this example, with a b-c range key:
 			//   SeekGE(a) -> a-b:{}
 			//   Next() -> b-c{(#5,RANGEKEYSET,@4,foo)}
 			//   Prev() -> nil
@@ -221,7 +222,7 @@ func (l *LevelIter) SeekLT(key []byte) (*keyspan.Span, error) {
 		l.setPosAfterFile(nil)
 		return nil, nil
 	}
-	if l.straddleSpansEnabled() && l.cmp(file.LargestRangeKey.UserKey, key) < 0 {
+	if l.straddleSpansEnabled() && l.cmp(file.RangeKeyBounds.LargestUserKey(), key) < 0 {
 		// Peek at the next file.
 		if nextFile := l.files.Next(); nextFile != nil {
 			// We could unconditionally return an empty span between f.LargestRangeKey
@@ -488,15 +489,15 @@ func (l *LevelIter) straddleSpansEnabled() bool {
 func (l *LevelIter) needStraddleSpan(file, nextFile *manifest.TableMetadata) bool {
 	// We directly use range key bounds because that is the current condition for
 	// straddleSpansEnabled.
-	return l.straddleSpansEnabled() && l.cmp(file.LargestRangeKey.UserKey, nextFile.SmallestRangeKey.UserKey) < 0
+	return l.straddleSpansEnabled() && l.cmp(file.RangeKeyBounds.LargestUserKey(), nextFile.RangeKeyBounds.SmallestUserKey()) < 0
 }
 
 // makeStraddleSpan returns a straddle span that covers the gap between file and
 // nextFile.
 func (l *LevelIter) makeStraddleSpan(file, nextFile *manifest.TableMetadata) *keyspan.Span {
 	l.straddleSpan = keyspan.Span{
-		Start: file.LargestRangeKey.UserKey,
-		End:   nextFile.SmallestRangeKey.UserKey,
+		Start: file.RangeKeyBounds.LargestUserKey(),
+		End:   nextFile.RangeKeyBounds.SmallestUserKey(),
 		Keys:  nil,
 	}
 	return &l.straddleSpan

internal/keyspan/keyspanimpl/level_iter_test.go

@@ -292,13 +292,14 @@ func TestLevelIterEquivalence(t *testing.T) {
 					SmallestSeqNum:        2,
 					LargestSeqNum:         2,
 					LargestSeqNumAbsolute: 2,
-					SmallestRangeKey:      base.MakeInternalKey(file[0].Start, file[0].SmallestKey().SeqNum(), file[0].SmallestKey().Kind()),
-					LargestRangeKey:       base.MakeExclusiveSentinelKey(file[len(file)-1].LargestKey().Kind(), file[len(file)-1].End),
 					HasPointKeys:          false,
 					HasRangeKeys:          true,
 				}
 				meta.InitPhysicalBacking()
-				meta.ExtendRangeKeyBounds(base.DefaultComparer.Compare, meta.SmallestRangeKey, meta.LargestRangeKey)
+				meta.RangeKeyBounds.SetInternalKeyBounds(
+					base.MakeInternalKey(file[0].Start, file[0].SmallestKey().SeqNum(), file[0].SmallestKey().Kind()),
+					base.MakeExclusiveSentinelKey(file[len(file)-1].LargestKey().Kind(), file[len(file)-1].End))
+				meta.ExtendRangeKeyBounds(base.DefaultComparer.Compare, meta.RangeKeyBounds.Smallest(), meta.RangeKeyBounds.Largest())
 				metas = append(metas, meta)
 			}