sstable: export parsing of WriterOptions from testdata args

Author: RaduBerinde

sstable/blob/handle.go

@@ -89,7 +89,7 @@ func (h InlineHandle) String() string {
 
 // SafeFormat implements redact.SafeFormatter.
 func (h InlineHandle) SafeFormat(w redact.SafePrinter, _ rune) {
-	w.Printf("(%d, blk%d[%d:%d])",
+	w.Printf("(f%d,blk%d[%d:%d])",
 		h.ReferenceID, h.BlockNum, h.OffsetInBlock, h.OffsetInBlock+h.ValueLen)
 }
 

sstable/data_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/cockroachdb/crlib/crstrings"
 	"github.com/cockroachdb/datadriven"
 	"github.com/cockroachdb/errors"
-	"github.com/cockroachdb/pebble/bloom"
 	"github.com/cockroachdb/pebble/internal/base"
 	"github.com/cockroachdb/pebble/internal/cache"
 	"github.com/cockroachdb/pebble/internal/keyspan"
@@ -28,43 +27,8 @@ import (
 )
 
 func optsFromArgs(td *datadriven.TestData, writerOpts *WriterOptions) error {
-	for _, arg := range td.CmdArgs {
-		switch arg.Key {
-		case "leveldb":
-			if len(arg.Vals) != 0 {
-				return errors.Errorf("%s: arg %s expects 0 values", td.Cmd, arg.Key)
-			}
-			writerOpts.TableFormat = TableFormatLevelDB
-		case "block-size":
-			if len(arg.Vals) != 1 {
-				return errors.Errorf("%s: arg %s expects 1 value", td.Cmd, arg.Key)
-			}
-			var err error
-			writerOpts.BlockSize, err = strconv.Atoi(arg.Vals[0])
-			if err != nil {
-				return err
-			}
-		case "index-block-size":
-			if len(arg.Vals) != 1 {
-				return errors.Errorf("%s: arg %s expects 1 value", td.Cmd, arg.Key)
-			}
-			var err error
-			writerOpts.IndexBlockSize, err = strconv.Atoi(arg.Vals[0])
-			if err != nil {
-				return err
-			}
-		case "filter":
-			writerOpts.FilterPolicy = bloom.FilterPolicy(10)
-		case "comparer":
-			var err error
-			if writerOpts.Comparer, err = comparerFromCmdArg(arg); err != nil {
-				return err
-			}
-		case "writing-to-lowest-level":
-			writerOpts.WritingToLowestLevel = true
-		case "is-strict-obsolete":
-			writerOpts.IsStrictObsolete = true
-		}
+	if err := ParseWriterOptions(writerOpts, td.CmdArgs...); err != nil {
+		return err
 	}
 	if writerOpts.Comparer == nil {
 		writerOpts.Comparer = testkeys.Comparer
@@ -76,19 +40,6 @@ func optsFromArgs(td *datadriven.TestData, writerOpts *WriterOptions) error {
 	return nil
 }
 
-func comparerFromCmdArg(arg datadriven.CmdArg) (*Comparer, error) {
-	switch arg.Vals[0] {
-	case "split-4b-suffix":
-		return test4bSuffixComparer, nil
-	case "testkeys":
-		return testkeys.Comparer, nil
-	case "default":
-		return base.DefaultComparer, nil
-	default:
-		return nil, errors.Errorf("unknown comparer: %s", arg.Vals[0])
-	}
-}
-
 func runBuildMemObjCmd(
 	td *datadriven.TestData, writerOpts *WriterOptions,
 ) (*WriterMetadata, *objstorage.MemObj, error) {

sstable/suffix_rewriter_test.go

@@ -278,16 +278,3 @@ func BenchmarkRewriteSST(b *testing.B) {
 		})
 	}
 }
-
-var test4bSuffixComparer = func() *base.Comparer {
-	c := new(base.Comparer)
-	*c = *base.DefaultComparer
-	c.Split = func(key []byte) int {
-		if len(key) > 4 {
-			return len(key) - 4
-		}
-		return len(key)
-	}
-	c.Name = "comparer-split-4b-suffix"
-	return c
-}()

sstable/test_utils.go

@@ -15,8 +15,10 @@ import (
 
 	"github.com/cockroachdb/crlib/crstrings"
 	"github.com/cockroachdb/errors"
+	"github.com/cockroachdb/pebble/bloom"
 	"github.com/cockroachdb/pebble/internal/base"
 	"github.com/cockroachdb/pebble/internal/keyspan"
+	"github.com/cockroachdb/pebble/internal/testkeys"
 	"github.com/cockroachdb/pebble/objstorage"
 	"github.com/cockroachdb/pebble/sstable/blob"
 	"github.com/cockroachdb/pebble/sstable/block"
@@ -258,3 +260,91 @@ func decodeBlobInlineHandleAndAttribute(
 		},
 	}, base.ShortAttribute(attr[0]), nil
 }
+
+// ParseWriterOptions modifies WriterOptions based on the given arguments. Each
+// argument is a string or a fmt.Stringer (like datadriven.TestData.CmdArg) with
+// format either "<key>" or "<key>=<value>".
+func ParseWriterOptions[StringOrStringer any](o *WriterOptions, args ...StringOrStringer) error {
+	for _, arg := range args {
+		str, ok := any(arg).(string)
+		if !ok {
+			str = any(arg).(fmt.Stringer).String()
+		}
+		key, value, _ := strings.Cut(str, "=")
+		var err error
+		switch key {
+		case "leveldb":
+			o.TableFormat = TableFormatLevelDB
+		case "format":
+			switch value {
+			case "leveldb":
+				o.TableFormat = TableFormatLevelDB
+			case "pebblev1":
+				o.TableFormat = TableFormatPebblev1
+			case "pebblev2":
+				o.TableFormat = TableFormatPebblev2
+			case "pebblev3":
+				o.TableFormat = TableFormatPebblev3
+			case "pebblev4":
+				o.TableFormat = TableFormatPebblev4
+			case "pebblev5":
+				o.TableFormat = TableFormatPebblev5
+			case "pebblev6":
+				o.TableFormat = TableFormatPebblev6
+			default:
+				return errors.Errorf("unknown format string %s", value)
+			}
+		case "block-size":
+			o.BlockSize, err = strconv.Atoi(value)
+
+		case "index-block-size":
+			o.IndexBlockSize, err = strconv.Atoi(value)
+
+		case "filter":
+			o.FilterPolicy = bloom.FilterPolicy(10)
+
+		case "comparer":
+			o.Comparer, err = comparerFromCmdArg(value)
+
+		case "writing-to-lowest-level":
+			o.WritingToLowestLevel = true
+
+		case "is-strict-obsolete":
+			o.IsStrictObsolete = true
+
+		default:
+			// TODO(radu): ignoring unknown keys is error-prone; we need to find an
+			// easy way for the upper layer to extract its own arguments.
+		}
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func comparerFromCmdArg(value string) (*Comparer, error) {
+	switch value {
+	case "split-4b-suffix":
+		return test4bSuffixComparer, nil
+	case "testkeys":
+		return testkeys.Comparer, nil
+	case "default":
+		return base.DefaultComparer, nil
+	default:
+		return nil, errors.Errorf("unknown comparer: %s", value)
+	}
+}
+
+var test4bSuffixComparer = func() *base.Comparer {
+	c := new(base.Comparer)
+	*c = *base.DefaultComparer
+	c.Split = func(key []byte) int {
+		if len(key) > 4 {
+			return len(key) - 4
+		}
+		return len(key)
+	}
+	c.Name = "comparer-split-4b-suffix"
+	return c
+}()