base: add ParseInternalKV

Author: RaduBerinde

internal/base/internal.go

@@ -585,19 +585,35 @@ func ParseInternalKey(s string) InternalKey {
 		seqNum := ParseSeqNum(x[2])
 		return MakeInternalKey([]byte(ukey), seqNum, kind)
 	}
-	x := strings.FieldsFunc(s, func(c rune) bool { return c == '#' || c == ',' })
-	if len(x) != 3 {
-		panic(fmt.Sprintf("invalid key internal %q", s))
+	sep1 := strings.Index(s, "#")
+	sep2 := strings.Index(s, ",")
+	if sep1 == -1 || sep2 == -1 || sep2 < sep1 {
+		panic(fmt.Sprintf("invalid internal key %q", s))
 	}
-	userKey := []byte(x[0])
-	seqNum := ParseSeqNum(x[1])
-	kind, ok := kindsMap[x[2]]
+
+	userKey := []byte(s[:sep1])
+	seqNum := ParseSeqNum(s[sep1+1 : sep2])
+	kind, ok := kindsMap[s[sep2+1:]]
 	if !ok {
-		panic(fmt.Sprintf("unknown kind: %q", x[2]))
+		panic(fmt.Sprintf("unknown kind: %q", s[sep2+1:]))
 	}
 	return MakeInternalKey(userKey, seqNum, kind)
 }
 
+// ParseInternalKV parses the string representation of an internal KV. The
+// format is "<user-key>#<seq-num>,<kind>:value". The value is encoded in-place.
+func ParseInternalKV(s string) InternalKV {
+	// Cut the key at the first ":".
+	sepIdx := strings.Index(s, ":")
+	if sepIdx == -1 {
+		panic(fmt.Sprintf("invalid KV %q", s))
+	}
+	keyStr := strings.TrimSpace(s[:sepIdx])
+	valStr := strings.TrimSpace(s[sepIdx+1:])
+	key := ParseInternalKey(keyStr)
+	return MakeInternalKV(key, []byte(valStr))
+}
+
 // ParseInternalKeyRange parses a string of the form:
 //
 //	[<user-key>#<seq-num>,<kind>-<user-key>#<seq-num>,<kind>]

sstable/test_utils.go

@@ -165,27 +165,23 @@ func ParseTestKVsAndSpans(input string, bv *blobtest.Values) (_ []ParsedKVOrSpan
 
 		var kv ParsedKVOrSpan
 		line, kv.ForceObsolete = strings.CutPrefix(line, "force-obsolete:")
-		// Cut the key at the first ":".
-		sepIdx := strings.Index(line, ":")
-		if sepIdx == -1 {
-			return nil, errors.Newf("KV format is \"[force-obsolete:] <key>:<value>\": %q", line)
-		}
-		keyStr := strings.TrimSpace(line[:sepIdx])
-		valStr := strings.TrimSpace(line[sepIdx+1:])
-		kv.Key = base.ParseInternalKey(keyStr)
+		internalKV := base.ParseInternalKV(line)
+		kv.Key = internalKV.K
+		kv.Value = internalKV.InPlaceValue()
 
 		if kv.ForceObsolete && kv.Key.Kind() == InternalKeyKindRangeDelete {
 			return nil, errors.Errorf("force-obsolete is not allowed for RANGEDEL")
 		}
 
-		if blobtest.IsBlobHandle(valStr) {
+		if blobtest.IsBlobHandle(string(kv.Value)) {
 			if bv == nil {
 				return nil, errors.Errorf("test not set up to support blob handles")
 			}
-			handle, remaining, err := bv.ParseInlineHandle(valStr)
+			handle, remaining, err := bv.ParseInlineHandle(string(kv.Value))
 			if err != nil {
 				return nil, errors.Wrapf(err, "parsing blob handle")
 			}
+			kv.Value = nil
 			kv.BlobHandle = handle
 			if remaining != "" {
 				p := strparse.MakeParser("=", remaining)
@@ -196,8 +192,6 @@ func ParseTestKVsAndSpans(input string, bv *blobtest.Values) (_ []ParsedKVOrSpan
 					return nil, errors.Newf("unexpected trailing input %q", p.Remaining())
 				}
 			}
-		} else {
-			kv.Value = []byte(valStr)
 		}
 		result = append(result, kv)
 	}