manifest: use InternalKeyBounds struct in TableMetadata's point keys

This patch uses our `InternalKeyBounds` struct to represent
both the smallest, largest point keys 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

@@ -2609,7 +2609,7 @@ func (d *DB) runCopyCompaction(
 		SyntheticPrefixAndSuffix: inputMeta.SyntheticPrefixAndSuffix,
 	}
 	if inputMeta.HasPointKeys {
-		newMeta.ExtendPointKeyBounds(c.cmp, inputMeta.SmallestPointKey, inputMeta.LargestPointKey)
+		newMeta.ExtendPointKeyBounds(c.cmp, inputMeta.PointKeyBounds.Smallest(), inputMeta.PointKeyBounds.Largest())
 	}
 	if inputMeta.HasRangeKeys {
 		newMeta.ExtendRangeKeyBounds(c.cmp, inputMeta.RangeKeyBounds.Smallest(), inputMeta.RangeKeyBounds.Largest())

compaction_picker_test.go

@@ -1716,6 +1716,6 @@ func checkClone(t *testing.T, pc *pickedCompaction) {
 }
 
 func checkTableBoundary(a, b *tableMetadata, cmp base.Compare) (ok bool) {
-	c := cmp(a.LargestPointKey.UserKey, b.SmallestPointKey.UserKey)
-	return c < 0 || (c == 0 && a.LargestPointKey.IsExclusiveSentinel())
+	c := cmp(a.PointKeyBounds.LargestUserKey(), b.PointKeyBounds.SmallestUserKey())
+	return c < 0 || (c == 0 && a.PointKeyBounds.Largest().IsExclusiveSentinel())
 }

data_test.go

@@ -942,12 +942,14 @@ func runDBDefineCmdReuseFS(td *datadriven.TestData, opts *Options) (*DB, error)
 		largestSeqNum := d.mu.versions.logSeqNum.Load()
 		ve.NewBlobFiles = append(ve.NewBlobFiles, newVE.NewBlobFiles...)
 		for _, f := range newVE.NewTables {
-			if start != nil {
-				f.Meta.SmallestPointKey = *start
+			if start != nil && end != nil {
+				f.Meta.PointKeyBounds.SetInternalKeyBounds(*start, *end)
+				f.Meta.ExtendPointKeyBounds(DefaultComparer.Compare, *start, *end)
+			} else if start != nil {
+				f.Meta.PointKeyBounds.SetSmallest(*start)
 				f.Meta.ExtendPointKeyBounds(DefaultComparer.Compare, *start, *start)
-			}
-			if end != nil {
-				f.Meta.LargestPointKey = *end
+			} else if end != nil {
+				f.Meta.PointKeyBounds.SetLargest(*end)
 				f.Meta.ExtendPointKeyBounds(DefaultComparer.Compare, *end, *end)
 			}
 			if blobDepth > 0 {

db.go

@@ -2999,8 +2999,8 @@ func (d *DB) checkVirtualBounds(m *tableMetadata) {
 		if err != nil {
 			panic(err)
 		}
-		if (rangeDel == nil || d.cmp(rangeDel.SmallestKey().UserKey, m.SmallestPointKey.UserKey) != 0) &&
-			(pointKV == nil || d.cmp(pointKV.K.UserKey, m.SmallestPointKey.UserKey) != 0) {
+		if (rangeDel == nil || d.cmp(rangeDel.SmallestKey().UserKey, m.PointKeyBounds.Smallest().UserKey) != 0) &&
+			(pointKV == nil || d.cmp(pointKV.K.UserKey, m.PointKeyBounds.Smallest().UserKey) != 0) {
 			panic(errors.Newf("pebble: virtual sstable %s lower point key bound is not tight", m.FileNum))
 		}
 
@@ -3010,23 +3010,23 @@ func (d *DB) checkVirtualBounds(m *tableMetadata) {
 		if err != nil {
 			panic(err)
 		}
-		if (rangeDel == nil || d.cmp(rangeDel.LargestKey().UserKey, m.LargestPointKey.UserKey) != 0) &&
-			(pointKV == nil || d.cmp(pointKV.K.UserKey, m.LargestPointKey.UserKey) != 0) {
+		if (rangeDel == nil || d.cmp(rangeDel.LargestKey().UserKey, m.PointKeyBounds.LargestUserKey()) != 0) &&
+			(pointKV == nil || d.cmp(pointKV.K.UserKey, m.PointKeyBounds.Largest().UserKey) != 0) {
 			panic(errors.Newf("pebble: virtual sstable %s upper point key bound is not tight", m.FileNum))
 		}
 
 		// Check that iterator keys are within bounds.
 		for kv := pointIter.First(); kv != nil; kv = pointIter.Next() {
-			if d.cmp(kv.K.UserKey, m.SmallestPointKey.UserKey) < 0 || d.cmp(kv.K.UserKey, m.LargestPointKey.UserKey) > 0 {
+			if d.cmp(kv.K.UserKey, m.PointKeyBounds.Smallest().UserKey) < 0 || d.cmp(kv.K.UserKey, m.PointKeyBounds.LargestUserKey()) > 0 {
 				panic(errors.Newf("pebble: virtual sstable %s point key %s is not within bounds", m.FileNum, kv.K.UserKey))
 			}
 		}
 		s, err := rangeDelIter.First()
 		for ; s != nil; s, err = rangeDelIter.Next() {
-			if d.cmp(s.SmallestKey().UserKey, m.SmallestPointKey.UserKey) < 0 {
+			if d.cmp(s.SmallestKey().UserKey, m.PointKeyBounds.Smallest().UserKey) < 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.LargestPointKey.UserKey) > 0 {
+			if d.cmp(s.LargestKey().UserKey, m.PointKeyBounds.Largest().UserKey) > 0 {
 				panic(errors.Newf("pebble: virtual sstable %s point key %s is not within bounds", m.FileNum, s.LargestKey().UserKey))
 			}
 		}

excise.go

@@ -259,11 +259,11 @@ func looseLeftTableBounds(
 	cmp Compare, originalTable, leftTable *tableMetadata, exciseSpanStart []byte,
 ) {
 	if originalTable.HasPointKeys {
-		largestPointKey := originalTable.LargestPointKey
+		largestPointKey := originalTable.PointKeyBounds.Largest()
 		if largestPointKey.IsUpperBoundFor(cmp, exciseSpanStart) {
 			largestPointKey = base.MakeRangeDeleteSentinelKey(exciseSpanStart)
 		}
-		leftTable.ExtendPointKeyBounds(cmp, originalTable.SmallestPointKey, largestPointKey)
+		leftTable.ExtendPointKeyBounds(cmp, originalTable.PointKeyBounds.Smallest(), largestPointKey)
 	}
 	if originalTable.HasRangeKeys {
 		largestRangeKey := originalTable.RangeKeyBounds.Largest()
@@ -287,11 +287,11 @@ func looseRightTableBounds(
 	cmp Compare, originalTable, rightTable *tableMetadata, exciseSpanEnd []byte,
 ) {
 	if originalTable.HasPointKeys {
-		smallestPointKey := originalTable.SmallestPointKey
+		smallestPointKey := originalTable.PointKeyBounds.Smallest()
 		if !smallestPointKey.IsUpperBoundFor(cmp, exciseSpanEnd) {
 			smallestPointKey = base.MakeInternalKey(exciseSpanEnd, 0, base.InternalKeyKindMaxForSSTable)
 		}
-		rightTable.ExtendPointKeyBounds(cmp, smallestPointKey, originalTable.LargestPointKey)
+		rightTable.ExtendPointKeyBounds(cmp, smallestPointKey, originalTable.PointKeyBounds.Largest())
 	}
 	if originalTable.HasRangeKeys {
 		smallestRangeKey := originalTable.RangeKeyBounds.Smallest()
@@ -311,10 +311,10 @@ func looseRightTableBounds(
 func determineLeftTableBounds(
 	cmp Compare, originalTable, leftTable *tableMetadata, exciseSpanStart []byte, iters iterSet,
 ) error {
-	if originalTable.HasPointKeys && cmp(originalTable.SmallestPointKey.UserKey, exciseSpanStart) < 0 {
+	if originalTable.HasPointKeys && cmp(originalTable.PointKeyBounds.Smallest().UserKey, exciseSpanStart) < 0 {
 		// This file will probably contain point keys.
 		if kv := iters.Point().SeekLT(exciseSpanStart, base.SeekLTFlagsNone); kv != nil {
-			leftTable.ExtendPointKeyBounds(cmp, originalTable.SmallestPointKey, kv.K.Clone())
+			leftTable.ExtendPointKeyBounds(cmp, originalTable.PointKeyBounds.Smallest(), kv.K.Clone())
 		}
 		rdel, err := iters.RangeDeletion().SeekLT(exciseSpanStart)
 		if err != nil {
@@ -327,7 +327,7 @@ func determineLeftTableBounds(
 				// The key is owned by the range del iter, so we need to copy it.
 				lastRangeDel = slices.Clone(rdel.End)
 			}
-			leftTable.ExtendPointKeyBounds(cmp, originalTable.SmallestPointKey,
+			leftTable.ExtendPointKeyBounds(cmp, originalTable.PointKeyBounds.Smallest(),
 				base.MakeExclusiveSentinelKey(InternalKeyKindRangeDelete, lastRangeDel))
 		}
 	}
@@ -367,12 +367,12 @@ func determineRightTableBounds(
 	exciseSpanEnd base.UserKeyBoundary,
 	iters iterSet,
 ) error {
-	if originalTable.HasPointKeys && !exciseSpanEnd.IsUpperBoundForInternalKey(cmp, originalTable.LargestPointKey) {
+	if originalTable.HasPointKeys && !exciseSpanEnd.IsUpperBoundForInternalKey(cmp, originalTable.PointKeyBounds.Largest()) {
 		if kv := iters.Point().SeekGE(exciseSpanEnd.Key, base.SeekGEFlagsNone); kv != nil {
 			if exciseSpanEnd.Kind == base.Inclusive && cmp(exciseSpanEnd.Key, kv.K.UserKey) == 0 {
 				return base.AssertionFailedf("cannot excise with an inclusive end key and data overlap at end key")
 			}
-			rightTable.ExtendPointKeyBounds(cmp, kv.K.Clone(), originalTable.LargestPointKey)
+			rightTable.ExtendPointKeyBounds(cmp, kv.K.Clone(), originalTable.PointKeyBounds.Largest())
 		}
 		rdel, err := iters.RangeDeletion().SeekGE(exciseSpanEnd.Key)
 		if err != nil {
@@ -390,7 +390,7 @@ func determineRightTableBounds(
 			rightTable.ExtendPointKeyBounds(cmp, base.InternalKey{
 				UserKey: firstRangeDel,
 				Trailer: rdel.SmallestKey().Trailer,
-			}, originalTable.LargestPointKey)
+			}, originalTable.PointKeyBounds.Largest())
 		}
 	}
 	if originalTable.HasRangeKeys && !exciseSpanEnd.IsUpperBoundForInternalKey(cmp, originalTable.RangeKeyBounds.Largest()) {

excise_test.go

@@ -801,7 +801,7 @@ func TestExciseBounds(t *testing.T) {
 			fmt.Fprintf(&buf, "%s:\n", title)
 			fmt.Fprintf(&buf, "  overall: %v - %v\n", m.Smallest(), m.Largest())
 			if m.HasPointKeys {
-				fmt.Fprintf(&buf, "  point:   %v - %v\n", m.SmallestPointKey, m.LargestPointKey)
+				fmt.Fprintf(&buf, "  point:   %v - %v\n", m.PointKeyBounds.Smallest(), m.PointKeyBounds.Largest())
 			}
 			if m.HasRangeKeys {
 				fmt.Fprintf(&buf, "  range:   %v - %v\n", m.RangeKeyBounds.Smallest(), m.RangeKeyBounds.Largest())

file_cache.go

@@ -737,7 +737,7 @@ func newRangeDelIter(
 			cmp = handle.readerOpts.Comparer.Compare
 		}
 		rangeDelIter = keyspan.AssertBounds(
-			rangeDelIter, file.SmallestPointKey, file.LargestPointKey.UserKey, cmp,
+			rangeDelIter, file.PointKeyBounds.Smallest(), file.PointKeyBounds.LargestUserKey(), cmp,
 		)
 	}
 	return rangeDelIter, nil

file_cache_test.go

@@ -351,12 +351,12 @@ func TestVirtualReadsWiring(t *testing.T) {
 		SmallestSeqNum:        parentFile.SmallestSeqNum,
 		LargestSeqNum:         parentFile.LargestSeqNum,
 		LargestSeqNumAbsolute: parentFile.LargestSeqNumAbsolute,
-		SmallestPointKey:      base.MakeInternalKey([]byte{'a'}, seqNumA, InternalKeyKindSet),
-		LargestPointKey:       base.MakeInternalKey([]byte{'a'}, seqNumA, InternalKeyKindSet),
 		HasPointKeys:          true,
 		Virtual:               true,
 	}
-	v1.ExtendPointKeyBounds(DefaultComparer.Compare, v1.SmallestPointKey, v1.LargestPointKey)
+	v1.PointKeyBounds.SetInternalKeyBounds(base.MakeInternalKey([]byte{'a'}, seqNumA, InternalKeyKindSet),
+		base.MakeInternalKey([]byte{'a'}, seqNumA, InternalKeyKindSet))
+	v1.ExtendPointKeyBounds(DefaultComparer.Compare, v1.PointKeyBounds.Smallest(), v1.PointKeyBounds.Largest())
 	v1.AttachVirtualBacking(parentFile.FileBacking)
 	v1.Stats.NumEntries = 1
 
@@ -367,23 +367,21 @@ func TestVirtualReadsWiring(t *testing.T) {
 		SmallestSeqNum:        parentFile.SmallestSeqNum,
 		LargestSeqNum:         parentFile.LargestSeqNum,
 		LargestSeqNumAbsolute: parentFile.LargestSeqNumAbsolute,
-		SmallestPointKey:      base.MakeInternalKey([]byte{'d'}, seqNumCEDel, InternalKeyKindRangeDelete),
-		LargestPointKey:       base.MakeInternalKey([]byte{'z'}, seqNumZ, InternalKeyKindSet),
 		HasPointKeys:          true,
 		Virtual:               true,
 	}
+	v2.PointKeyBounds.SetInternalKeyBounds(base.MakeInternalKey([]byte{'d'}, seqNumCEDel, InternalKeyKindRangeDelete),
+		base.MakeInternalKey([]byte{'z'}, seqNumZ, InternalKeyKindSet))
 	v2.RangeKeyBounds.SetInternalKeyBounds(
 		base.MakeInternalKey([]byte{'f'}, seqNumRangeSet, InternalKeyKindRangeKeySet),
 		base.MakeInternalKey([]byte{'k'}, seqNumRangeUnset, InternalKeyKindRangeKeyUnset))
-	v2.ExtendPointKeyBounds(DefaultComparer.Compare, v2.SmallestPointKey, v2.LargestPointKey)
+	v2.ExtendPointKeyBounds(DefaultComparer.Compare, v2.PointKeyBounds.Smallest(), v2.PointKeyBounds.Largest())
 	v2.AttachVirtualBacking(parentFile.FileBacking)
 	v2.Stats.NumEntries = 6
 
-	v1.LargestPointKey = v1.Largest()
-	v1.SmallestPointKey = v1.Smallest()
+	v1.PointKeyBounds.SetInternalKeyBounds(v1.Smallest(), v1.Largest())
 
-	v2.LargestPointKey = v2.Largest()
-	v2.SmallestPointKey = v2.Smallest()
+	v2.PointKeyBounds.SetInternalKeyBounds(v2.Smallest(), v2.Largest())
 
 	v1.ValidateVirtual(parentFile)
 	d.checkVirtualBounds(v1)

get_iter.go

@@ -267,7 +267,7 @@ func (g *getIter) getSSTableIterators(
 	}
 	// m is now positioned at the file containing the first point key ≥ `g.key`.
 	// Does it exist and possibly contain point keys with the user key 'g.key'?
-	if m == nil || !m.HasPointKeys || g.comparer.Compare(m.SmallestPointKey.UserKey, g.key) > 0 {
+	if m == nil || !m.HasPointKeys || g.comparer.Compare(m.PointKeyBounds.SmallestUserKey(), g.key) > 0 {
 		return emptyIter, nil, nil
 	}
 	// m may possibly contain point (or range deletion) keys relevant to g.key.

ingest.go

@@ -878,7 +878,7 @@ func setSeqNumInMetadata(
 	// NB: we set the fields directly here, rather than via their Extend*
 	// methods, as we are updating sequence numbers.
 	if m.HasPointKeys {
-		m.SmallestPointKey = setSeqFn(m.SmallestPointKey)
+		m.PointKeyBounds.SetSmallest(setSeqFn(m.PointKeyBounds.Smallest()))
 	}
 	if m.HasRangeKeys {
 		m.RangeKeyBounds.SetSmallest(setSeqFn(m.RangeKeyBounds.Smallest()))
@@ -890,8 +890,8 @@ func setSeqNumInMetadata(
 	// table.
 	// NB: as the largest range key is always an exclusive sentinel, it is never
 	// updated.
-	if m.HasPointKeys && !m.LargestPointKey.IsExclusiveSentinel() {
-		m.LargestPointKey = setSeqFn(m.LargestPointKey)
+	if m.HasPointKeys && !m.PointKeyBounds.Largest().IsExclusiveSentinel() {
+		m.PointKeyBounds.SetLargest(setSeqFn(m.PointKeyBounds.Largest()))
 	}
 	// Setting smallestSeqNum == largestSeqNum triggers the setting of
 	// Properties.GlobalSeqNum when an sstable is loaded.