db: add excise_bound tests

Add tests for `determineLeft/RightTableBounds` during excise.

Author: RaduBerinde

data_test.go

@@ -608,13 +608,18 @@ func runBuildRemoteCmd(td *datadriven.TestData, d *DB, storage remote.Storage) e
 }
 
 type dataDrivenCmdOptions struct {
-	blobValues *blobtest.Values
+	blobValues        *blobtest.Values
+	defaultWriterOpts sstable.WriterOptions
 }
 
 func withBlobValues(bv *blobtest.Values) func(*dataDrivenCmdOptions) {
 	return func(o *dataDrivenCmdOptions) { o.blobValues = bv }
 }
 
+func withDefaultWriterOpts(defaultWriterOpts sstable.WriterOptions) func(*dataDrivenCmdOptions) {
+	return func(o *dataDrivenCmdOptions) { o.defaultWriterOpts = defaultWriterOpts }
+}
+
 func combineDataDrivenOpts(opts ...func(*dataDrivenCmdOptions)) dataDrivenCmdOptions {
 	combined := dataDrivenCmdOptions{}
 	for _, opt := range opts {
@@ -623,6 +628,7 @@ func combineDataDrivenOpts(opts ...func(*dataDrivenCmdOptions)) dataDrivenCmdOpt
 	return combined
 }
 
+// TODO(radu): remove this in favor of runBuildSSTCmd.
 func runBuildCmd(
 	td *datadriven.TestData, d *DB, fs vfs.FS, opts ...func(*dataDrivenCmdOptions),
 ) error {
@@ -718,6 +724,38 @@ func runBuildCmd(
 	return w.Close()
 }
 
+func runBuildSSTCmd(
+	input string,
+	writerArgs []datadriven.CmdArg,
+	path string,
+	fs vfs.FS,
+	opts ...func(*dataDrivenCmdOptions),
+) (sstable.WriterMetadata, error) {
+	ddOpts := combineDataDrivenOpts(opts...)
+
+	writerOpts := ddOpts.defaultWriterOpts
+	if err := sstable.ParseWriterOptions(&writerOpts, writerArgs...); err != nil {
+		return sstable.WriterMetadata{}, err
+	}
+
+	f, err := fs.Create(path, vfs.WriteCategoryUnspecified)
+	if err != nil {
+		return sstable.WriterMetadata{}, err
+	}
+	w := sstable.NewWriter(objstorageprovider.NewFileWritable(f), writerOpts)
+	if err := sstable.ParseTestSST(w.Raw(), input, nil /* bv */); err != nil {
+		return sstable.WriterMetadata{}, err
+	}
+	if err := w.Close(); err != nil {
+		return sstable.WriterMetadata{}, err
+	}
+	metadata, err := w.Metadata()
+	if err != nil {
+		return sstable.WriterMetadata{}, err
+	}
+	return *metadata, nil
+}
+
 func runCompactCmd(td *datadriven.TestData, d *DB) error {
 	if len(td.CmdArgs) > 4 {
 		return errors.Errorf("%s expects at most four arguments", td.Cmd)

excise_test.go

@@ -7,6 +7,7 @@ package pebble
 import (
 	"context"
 	"fmt"
+	"math/rand/v2"
 	"strconv"
 	"strings"
 	"sync"
@@ -306,6 +307,7 @@ func TestExcise(t *testing.T) {
 				fileNums[base.FileNum(fNum)] = struct{}{}
 			}
 			d.mu.Lock()
+			defer d.mu.Unlock()
 			currVersion := d.mu.versions.currentVersion()
 			var ptr *manifest.FileBacking
 			for _, level := range currVersion.Levels {
@@ -322,7 +324,6 @@ func TestExcise(t *testing.T) {
 					}
 				}
 			}
-			d.mu.Unlock()
 			return "file backings are the same"
 		case "compact":
 			if len(td.CmdArgs) != 2 {
@@ -431,7 +432,6 @@ func TestConcurrentExcise(t *testing.T) {
 			FormatMajorVersion:    FormatVirtualSSTables,
 			Logger:                testLogger{t},
 		}
-		// lel.
 		lel := MakeLoggingEventListener(testLogger{t})
 		tel := TeeEventListener(lel, el)
 		opts1.EventListener = &tel
@@ -763,3 +763,108 @@ func TestConcurrentExcise(t *testing.T) {
 		}
 	})
 }
+
+func TestExciseBounds(t *testing.T) {
+	const sstPath = "foo.sst"
+	var fs vfs.FS
+	var m *manifest.TableMetadata
+	cmp := base.DefaultComparer.Compare
+
+	datadriven.RunTest(t, "testdata/excise_bounds", func(t *testing.T, td *datadriven.TestData) string {
+		checkErr := func(err error) {
+			if err != nil {
+				t.Helper()
+				td.Fatalf(t, "%v", err)
+			}
+		}
+		var buf strings.Builder
+		printBounds := func(title string, m *tableMetadata) {
+			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)
+			}
+			if m.HasRangeKeys {
+				fmt.Fprintf(&buf, "  range:   %v - %v\n", m.SmallestRangeKey, m.LargestRangeKey)
+			}
+		}
+		switch td.Cmd {
+		case "build-sst":
+			fs = vfs.NewMem()
+			var writerOpts sstable.WriterOptions
+			writerOpts.TableFormat = sstable.TableFormat(rand.IntN(int(sstable.TableFormatMax)) + 1)
+			// We need at least v2 for tests with range keys.
+			writerOpts.TableFormat = max(writerOpts.TableFormat, sstable.TableFormatPebblev2)
+			sstMeta, err := runBuildSSTCmd(td.Input, td.CmdArgs, sstPath, fs, withDefaultWriterOpts(writerOpts))
+			checkErr(err)
+
+			m = &manifest.TableMetadata{}
+			if sstMeta.HasPointKeys {
+				m.ExtendPointKeyBounds(cmp, sstMeta.SmallestPoint, sstMeta.LargestPoint)
+			}
+			if sstMeta.HasRangeDelKeys {
+				m.ExtendPointKeyBounds(cmp, sstMeta.SmallestRangeDel, sstMeta.LargestRangeDel)
+			}
+			if sstMeta.HasRangeKeys {
+				m.ExtendRangeKeyBounds(cmp, sstMeta.SmallestRangeKey, sstMeta.LargestRangeKey)
+			}
+			printBounds("Bounds", m)
+
+		case "excise":
+			f, err := fs.Open(sstPath)
+			checkErr(err)
+			readable, err := sstable.NewSimpleReadable(f)
+			checkErr(err)
+			ctx := context.Background()
+			r, err := sstable.NewReader(ctx, readable, sstable.ReaderOptions{})
+			checkErr(err)
+			pointIter, err := r.NewPointIter(ctx, sstable.IterOptions{})
+			checkErr(err)
+			rangeDelIter, err := r.NewRawRangeDelIter(ctx, sstable.NoFragmentTransforms, block.ReadEnv{})
+			checkErr(err)
+			rangeKeyIter, err := r.NewRawRangeKeyIter(ctx, sstable.NoFragmentTransforms, block.ReadEnv{})
+			checkErr(err)
+			iters := iterSet{
+				point:         pointIter,
+				rangeDeletion: rangeDelIter,
+				rangeKey:      rangeKeyIter,
+			}
+
+			exciseSpan := base.ParseUserKeyBounds(td.Input)
+			if cmp(m.Smallest.UserKey, exciseSpan.Start) < 0 {
+				var t manifest.TableMetadata
+				checkErr(determineLeftTableBounds(cmp, m, &t, exciseSpan.Start, iters))
+				printBounds("Left table bounds", &t)
+			}
+
+			if !exciseSpan.End.IsUpperBoundForInternalKey(cmp, m.Largest) {
+				var t manifest.TableMetadata
+				err := func() (err error) {
+					// determineRightTableBounds can return assertion errors which we want
+					// to see in the tests but which panic in invariant builds.
+					defer func() {
+						if p := recover(); p != nil {
+							if e, ok := p.(error); ok {
+								err = e
+							} else {
+								panic(p)
+							}
+						}
+					}()
+					return determineRightTableBounds(cmp, m, &t, exciseSpan.End, iters)
+				}()
+				if err != nil {
+					fmt.Fprintf(&buf, "determineRightTableBounds error: %v", err)
+				} else {
+					printBounds("Right table bounds", &t)
+				}
+			}
+			checkErr(iters.CloseAll())
+
+		default:
+			td.Fatalf(t, "unknown command %q", td.Cmd)
+		}
+
+		return buf.String()
+	})
+}

ingest_test.go

@@ -684,7 +684,6 @@ func testIngestSharedImpl(
 			FormatMajorVersion:    FormatVirtualSSTables,
 			Logger:                testLogger{t},
 		}
-		// lel.
 		lel := MakeLoggingEventListener(testLogger{t})
 		opts1.EventListener = &lel
 		opts1.Experimental.RemoteStorage = remote.MakeSimpleFactory(map[remote.Locator]remote.Storage{