tool: add support for loading blob values for find

This patch adds support for loading a blob value for the
`find` tool.

Informs: #4448

Author: annrpom

sstable/values.go

@@ -39,6 +39,20 @@ var DebugHandlesBlobContext = TableBlobContext{
 	},
 }
 
+// LoadValBlobContext returns a TableBlobContext that configures a
+// sstable iterator to fetch the value stored in a blob file. It is the
+// caller's responsibility to close the ValueFetcher returned.
+func LoadValBlobContext(
+	rp blob.ReaderProvider, blobRefs BlobReferences,
+) (*blob.ValueFetcher, TableBlobContext) {
+	vf := &blob.ValueFetcher{}
+	vf.Init(rp, block.ReadEnv{})
+	return vf, TableBlobContext{
+		ValueFetcher: vf,
+		References:   blobRefs,
+	}
+}
+
 // BlobReferences provides a mapping from an index to a file number for a
 // sstable's blob references. In practice, this is implemented by
 // manifest.BlobReferences.

tool/find.go

@@ -22,6 +22,7 @@ import (
 	"github.com/cockroachdb/pebble/internal/sstableinternal"
 	"github.com/cockroachdb/pebble/record"
 	"github.com/cockroachdb/pebble/sstable"
+	"github.com/cockroachdb/pebble/sstable/blob"
 	"github.com/cockroachdb/pebble/wal"
 	"github.com/spf13/cobra"
 )
@@ -71,6 +72,8 @@ type findT struct {
 	tableRefs map[base.FileNum]bool
 	// Map from file num to table metadata.
 	tableMeta map[base.FileNum]*manifest.TableMetadata
+	// Slice of references to a blob value file.
+	blobRefs manifest.BlobReferences
 	// List of error messages for SSTables that could not be decoded.
 	errors []string
 }
@@ -179,6 +182,7 @@ func (f *findT) findFiles(stdout, stderr io.Writer, dir string) error {
 	f.manifests = nil
 	f.tables = nil
 	f.tableMeta = make(map[base.FileNum]*manifest.TableMetadata)
+	f.blobRefs = nil
 
 	if _, err := f.opts.FS.Stat(dir); err != nil {
 		return err
@@ -227,6 +231,7 @@ func (f *findT) findFiles(stdout, stderr io.Writer, dir string) error {
 // Read the manifests and populate the editRefs map which is used to determine
 // the provenance and metadata of tables.
 func (f *findT) readManifests(stdout io.Writer) {
+	blobMetas := make(map[base.DiskFileNum]struct{})
 	for _, fl := range f.manifests {
 		func() {
 			mf, err := f.opts.FS.Open(fl.path)
@@ -281,9 +286,22 @@ func (f *findT) readManifests(stdout io.Writer) {
 						f.tableMeta[nf.Meta.FileNum] = nf.Meta
 					}
 				}
+				for _, bf := range ve.NewBlobFiles {
+					if _, ok := blobMetas[bf.FileNum]; !ok {
+						blobMetas[bf.FileNum] = struct{}{}
+					}
+				}
 			}
 		}()
 	}
+	f.blobRefs = make(manifest.BlobReferences, len(blobMetas))
+	i := 0
+	for fn := range blobMetas {
+		f.blobRefs[i] = manifest.BlobReference{
+			FileNum: fn,
+		}
+		i++
+	}
 
 	if f.verbose {
 		fmt.Fprintf(stdout, "%5d %s\n", len(f.edits), makePlural("edit", int64(len(f.edits))))
@@ -476,12 +494,18 @@ func (f *findT) searchTables(stdout io.Writer, searchKey []byte, refs []findRef)
 			switch ConvertToBlobRefMode(f.blobMode) {
 			case BlobRefModePrint:
 				blobContext = sstable.DebugHandlesBlobContext
+			case BlobRefModeLoad:
+				provider := debugReaderProvider{
+					fs:  f.opts.FS,
+					dir: f.Root.Flags().Arg(0),
+				}
+				f.fmtValue.mustSet("[%s]")
+				var vf *blob.ValueFetcher
+				vf, blobContext = sstable.LoadValBlobContext(&provider, f.blobRefs)
+				defer func() { _ = vf.Close() }()
 			default:
 				blobContext = sstable.AssertNoBlobHandles
 			}
-			// TODO(annie): Adjust to support two modes: one that surfaces the
-			// raw blob value handles, and one that fetches the blob values from
-			// blob files uncovered by scanning the directory entries. See #4448.
 			iter, err := r.NewIter(transforms, nil, nil, blobContext)
 			if err != nil {
 				return err

tool/make_test_find_db_val_sep.go

@@ -0,0 +1,82 @@
+// Copyright 2025 The LevelDB-Go and Pebble Authors. All rights reserved. Use
+// of this source code is governed by a BSD-style license that can be found in
+// the LICENSE file.
+
+//go:build make_test_find_db
+
+// Run using: go run -tags make_test_find_db_val_sep ./tool/make_test_find_db_val_sep.go
+package main
+
+import (
+	"log"
+
+	"github.com/cockroachdb/pebble"
+	"github.com/cockroachdb/pebble/cockroachkvs"
+	"github.com/cockroachdb/pebble/internal/blobtest"
+	"github.com/cockroachdb/pebble/sstable"
+	"github.com/cockroachdb/pebble/vfs"
+)
+
+const minSizeForValSep = 3
+
+type db struct {
+	db *pebble.DB
+	bv blobtest.Values
+}
+
+func (d *db) set(key, value string) {
+	encodedKey := cockroachkvs.ParseFormattedKey(key)
+	if err := d.db.Set(encodedKey, []byte(value), nil); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func (d *db) flush() {
+	if err := d.db.Flush(); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func (d *db) close() {
+	if err := d.db.Close(); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func main() {
+	const dir = "tool/testdata/find-db-val-sep"
+
+	fs := vfs.Default
+	if err := fs.RemoveAll(dir); err != nil {
+		log.Fatal(err)
+	}
+	opts := pebble.Options{
+		FS:        fs,
+		KeySchema: cockroachkvs.KeySchema.Name,
+		KeySchemas: sstable.KeySchemas{
+			cockroachkvs.KeySchema.Name: &cockroachkvs.KeySchema,
+		},
+		FormatMajorVersion: pebble.FormatExperimentalValueSeparation,
+	}
+	opts.Experimental.ValueSeparationPolicy = func() pebble.ValueSeparationPolicy {
+		return pebble.ValueSeparationPolicy{
+			Enabled:               true,
+			MinimumSize:           minSizeForValSep,
+			MaxBlobReferenceDepth: 10,
+		}
+	}
+	d, err := pebble.Open(dir, &opts)
+	if err != nil {
+		return
+	}
+	tdb := &db{
+		db: d,
+	}
+	defer tdb.close()
+
+	tdb.set("aaa", "yuumi")
+	tdb.set("bbb", "mai")
+	tdb.set("ccc", "poiandyaya")
+	tdb.set("ddd", "6")
+	tdb.flush()
+}

tool/sstable.go

@@ -122,8 +122,6 @@ inclusive-inclusive range specified by --start and --end.
 
 	s.Check.Flags().Var(
 		&s.fmtKey, "key", "key formatter")
-	s.Check.Flags().StringVar(
-		&s.blobMode, "blob-mode", "none", "blob value formatter")
 	s.Layout.Flags().Var(
 		&s.fmtKey, "key", "key formatter")
 	s.Layout.Flags().Var(
@@ -168,17 +166,7 @@ func (s *sstableT) runCheck(cmd *cobra.Command, args []string) {
 		s.fmtKey.setForComparer(r.Properties.ComparerName, s.comparers)
 		s.fmtValue.setForComparer(r.Properties.ComparerName, s.comparers)
 
-		var blobContext sstable.TableBlobContext
-		switch ConvertToBlobRefMode(s.blobMode) {
-		case BlobRefModePrint:
-			blobContext = sstable.DebugHandlesBlobContext
-		default:
-			blobContext = sstable.AssertNoBlobHandles
-		}
-		// TODO(annie): Adjust to support two modes: one that surfaces the raw
-		// blob value handles, and one that fetches the blob values from blob
-		// files uncovered by scanning the directory entries. See #4448.
-		iter, err := r.NewIter(sstable.NoTransforms, nil, nil, blobContext)
+		iter, err := r.NewIter(sstable.NoTransforms, nil, nil, sstable.AssertNoBlobHandles)
 		if err != nil {
 			fmt.Fprintf(stderr, "%s\n", err)
 			return

tool/testdata/find

@@ -138,3 +138,55 @@ hex:636363
 000002.sst
     test formatter: ccc#14,MERGE
 Unable to decode sstable find-mixed/000001.sst, pebble/table: invalid table 000001 (file size is too small)
+
+find
+testdata/find-db
+eee
+--blob-mode=print
+----
+000004.log
+    bbb-eee#19,RANGEDEL
+
+find
+testdata/find-db-val-sep
+crdb:aaa
+--blob-mode=print
+----
+000002.log
+    aaa\x00#10,SET [7975756d69]
+000005.sst [aaa\x00#10,SET-ddd\x00#13,SET]
+    (flushed to L0)
+    aaa\x00#10,SET [2866302c626c6b305b303a355d29]
+
+find
+testdata/find-db-val-sep
+crdb:ddd
+--blob-mode=print
+----
+000002.log
+    ddd\x00#13,SET [36]
+000005.sst [aaa\x00#10,SET-ddd\x00#13,SET]
+    (flushed to L0)
+    ddd\x00#13,SET [36]
+
+find
+testdata/find-db-val-sep
+crdb:aaa
+--blob-mode=load
+----
+000002.log
+    aaa\x00#10,SET [yuumi]
+000005.sst [aaa\x00#10,SET-ddd\x00#13,SET]
+    (flushed to L0)
+    aaa\x00#10,SET [yuumi]
+
+find
+testdata/find-db-val-sep
+crdb:ddd
+--blob-mode=load
+----
+000002.log
+    ddd\x00#13,SET [6]
+000005.sst [aaa\x00#10,SET-ddd\x00#13,SET]
+    (flushed to L0)
+    ddd\x00#13,SET [6]