internal: clean up tests to use the new key format

Also improve some of the update code to use existing routines.

Author: RaduBerinde

internal/base/internal_test.go

@@ -133,21 +133,21 @@ func TestInternalKeySeparator(t *testing.T) {
 		b        string
 		expected string
 	}{
-		{"foo.SET.100", "foo.SET.99", "foo.SET.100"},
-		{"foo.SET.100", "foo.SET.100", "foo.SET.100"},
-		{"foo.SET.100", "foo.DEL.100", "foo.SET.100"},
-		{"foo.SET.100", "foo.SET.101", "foo.SET.100"},
-		{"foo.SET.100", "bar.SET.99", "foo.SET.100"},
-		{"foo.SET.100", "hello.SET.200", "g.SEPARATOR.72057594037927935"},
-		{"ABC1AAAAA.SET.100", "ABC2ABB.SET.200", "ABC2.SEPARATOR.72057594037927935"},
-		{"AAA1AAA.SET.100", "AAA2AA.SET.200", "AAA2.SEPARATOR.72057594037927935"},
-		{"AAA1AAA.SET.100", "AAA4.SET.200", "AAA2.SEPARATOR.72057594037927935"},
-		{"AAA1AAA.SET.100", "AAA2.SET.200", "AAA1B.SEPARATOR.72057594037927935"},
-		{"AAA1AAA.SET.100", "AAA2A.SET.200", "AAA2.SEPARATOR.72057594037927935"},
-		{"AAA1.SET.100", "AAA2.SET.200", "AAA1.SET.100"},
-		{"foo.SET.100", "foobar.SET.200", "foo.SET.100"},
-		{"foobar.SET.100", "foo.SET.200", "foobar.SET.100"},
-		{"foo.INGESTSST.100", "foo.INGESTSST.99", "foo.INGESTSST.100"},
+		{"foo#100,SET", "foo#99,SET", "foo#100,SET"},
+		{"foo#100,SET", "foo#100,SET", "foo#100,SET"},
+		{"foo#100,SET", "foo#100,DEL", "foo#100,SET"},
+		{"foo#100,SET", "foo#101,SET", "foo#100,SET"},
+		{"foo#100,SET", "bar#99,SET", "foo#100,SET"},
+		{"foo#100,SET", "hello#200,SET", "g#72057594037927935,SEPARATOR"},
+		{"ABC1AAAAA#100,SET", "ABC2ABB#200,SET", "ABC2#72057594037927935,SEPARATOR"},
+		{"AAA1AAA#100,SET", "AAA2AA#200,SET", "AAA2#72057594037927935,SEPARATOR"},
+		{"AAA1AAA#100,SET", "AAA4#200,SET", "AAA2#72057594037927935,SEPARATOR"},
+		{"AAA1AAA#100,SET", "AAA2#200,SET", "AAA1B#72057594037927935,SEPARATOR"},
+		{"AAA1AAA#100,SET", "AAA2A#200,SET", "AAA2#72057594037927935,SEPARATOR"},
+		{"AAA1#100,SET", "AAA2#200,SET", "AAA1#100,SET"},
+		{"foo#100,SET", "foobar#200,SET", "foo#100,SET"},
+		{"foobar#100,SET", "foo#200,SET", "foobar#100,SET"},
+		{"foo#100,INGESTSST", "foo#99,INGESTSST", "foo#100,INGESTSST"},
 	}
 	d := DefaultComparer
 	for _, c := range testCases {

internal/compact/iterator_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/cockroachdb/pebble/internal/base"
 	"github.com/cockroachdb/pebble/internal/keyspan"
 	"github.com/cockroachdb/pebble/internal/rangekey"
+	"github.com/cockroachdb/pebble/sstable"
 	"github.com/cockroachdb/pebble/sstable/valblk"
 	"github.com/stretchr/testify/require"
 )
@@ -112,47 +113,57 @@ func TestCompactionIter(t *testing.T) {
 				kvs = kvs[:0]
 				rangeKeys = rangeKeys[:0]
 				rangeDels = rangeDels[:0]
+
+				parsed, err := sstable.ParseTestKVsAndSpans(d.Input, nil /* bv */)
+				require.NoError(t, err)
+
 				rangeDelFragmenter := keyspan.Fragmenter{
 					Cmp:    base.DefaultComparer.Compare,
 					Format: base.DefaultComparer.FormatKey,
 					Emit: func(s keyspan.Span) {
 						rangeDels = append(rangeDels, s)
 					},
 				}
-				for _, key := range strings.Split(d.Input, "\n") {
-					// If the line ends in a '}' assume it's a span.
-					if strings.HasSuffix(key, "}") {
-						s := keyspan.ParseSpan(strings.TrimSpace(key))
-						rangeKeys = append(rangeKeys, s)
+
+				for _, kv := range parsed {
+					if kv.IsKeySpan() {
+						// Pre-fragmented range key span
+						if rangekey.IsRangeKey(kv.Span.Keys[0].Kind()) {
+							rangeKeys = append(rangeKeys, *kv.Span)
+						} else {
+							// Range delete - add to fragmenter.
+							rangeDelFragmenter.Add(*kv.Span)
+						}
 						continue
 					}
 
-					j := strings.Index(key, ":")
-					ik := base.ParseInternalKey(key[:j])
-					if rangekey.IsRangeKey(ik.Kind()) {
+					// Point key - check for range keys and range deletes
+					if rangekey.IsRangeKey(kv.Key.Kind()) {
 						panic("range keys must be pre-fragmented and formatted as spans")
 					}
-					if ik.Kind() == base.InternalKeyKindRangeDelete {
+
+					if kv.Key.Kind() == base.InternalKeyKindRangeDelete {
+						// Range delete in old format: key#seq,RANGEDEL = endKey
 						rangeDelFragmenter.Add(keyspan.Span{
-							Start: ik.UserKey,
-							End:   []byte(key[j+1:]),
-							Keys:  []keyspan.Key{{Trailer: ik.Trailer}},
+							Start: kv.Key.UserKey,
+							End:   kv.Value,
+							Keys:  []keyspan.Key{{Trailer: kv.Key.Trailer}},
 						})
 						continue
 					}
 
 					var iv base.InternalValue
-					if strings.HasPrefix(key[j+1:], "varint(") {
-						valueStr := strings.TrimSuffix(strings.TrimPrefix(key[j+1:], "varint("), ")")
-						v, err := strconv.ParseUint(valueStr, 10, 64)
+					valueStr := string(kv.Value)
+					if strings.HasPrefix(valueStr, "varint(") {
+						v, err := strconv.ParseUint(strings.TrimSuffix(strings.TrimPrefix(valueStr, "varint("), ")"), 10, 64)
 						require.NoError(t, err)
 						iv = base.MakeInPlaceValue(binary.AppendUvarint([]byte(nil), v))
-					} else if strings.HasPrefix(key[j+1:], "blobref(") {
-						iv = decodeBlobReference(t, key[j+1:])
+					} else if strings.HasPrefix(valueStr, "blobref(") {
+						iv = decodeBlobReference(t, valueStr)
 					} else {
-						iv = base.MakeInPlaceValue([]byte(key[j+1:]))
+						iv = base.MakeInPlaceValue(kv.Value)
 					}
-					kvs = append(kvs, base.InternalKV{K: ik, V: iv})
+					kvs = append(kvs, base.InternalKV{K: kv.Key, V: iv})
 				}
 				rangeDelFragmenter.Finish()
 				return ""