block: add ParseCompressionStats

This will be necessary to read the compression stats from existing
tables (after Open).

Author: RaduBerinde

internal/compression/compression.go

@@ -6,6 +6,8 @@ package compression
 
 import (
 	"fmt"
+	"strconv"
+	"strings"
 
 	"github.com/minio/minlz"
 )
@@ -23,6 +25,8 @@ const (
 	MinLZ
 
 	NumAlgorithms
+
+	Unknown Algorithm = 100
 )
 
 // String implements fmt.Stringer, returning a human-readable name for the
@@ -37,8 +41,10 @@ func (a Algorithm) String() string {
 		return "ZSTD"
 	case MinLZ:
 		return "MinLZ"
+	case Unknown:
+		return "unknown"
 	default:
-		return fmt.Sprintf("unknown(%d)", a)
+		return fmt.Sprintf("invalid(%d)", a)
 	}
 }
 
@@ -58,6 +64,26 @@ func (s Setting) String() string {
 	return fmt.Sprintf("%s%d", s.Algorithm, s.Level)
 }
 
+// ParseSetting parses the result of Setting.String() back into the setting.
+func ParseSetting(s string) (_ Setting, ok bool) {
+	for i := range NumAlgorithms {
+		remainder, ok := strings.CutPrefix(s, i.String())
+		if !ok {
+			continue
+		}
+		var level int
+		if remainder != "" {
+			var err error
+			level, err = strconv.Atoi(remainder)
+			if err != nil {
+				continue
+			}
+		}
+		return Setting{Algorithm: i, Level: uint8(level)}, true
+	}
+	return Setting{}, false
+}
+
 // Setting presets.
 var (
 	None          = makePreset(NoCompression, 0)

internal/compression/compression_test.go

@@ -80,3 +80,12 @@ func decompress(algo Algorithm, b []byte) ([]byte, error) {
 	}
 	return decodedBuf, nil
 }
+
+func TestSettingString(t *testing.T) {
+	for _, s := range presets {
+		str := s.String()
+		s2, ok := ParseSetting(str)
+		require.True(t, ok)
+		require.Equal(t, s, s2)
+	}
+}

sstable/block/compression_stats.go

@@ -11,6 +11,7 @@ import (
 	"slices"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	"github.com/cockroachdb/pebble/internal/compression"
 	"github.com/cockroachdb/pebble/internal/invariants"
 )
@@ -126,3 +127,27 @@ func (c CompressionStats) String() string {
 	}
 	return buf.String()
 }
+
+// ParseCompressionStats parses the output of CompressionStats.String back into CompressionStats.
+//
+// If the string contains statistics for unknown compression settings, these are
+// accumulated under a special "unknown" setting.
+func ParseCompressionStats(s string) (CompressionStats, error) {
+	var stats CompressionStats
+	for _, a := range strings.Split(s, ",") {
+		b := strings.Split(a, ":")
+		if len(b) != 2 {
+			return CompressionStats{}, errors.Errorf("cannot parse compression stats %q", s)
+		}
+		setting, ok := compression.ParseSetting(b[0])
+		if !ok {
+			setting = compression.Setting{Algorithm: compression.Unknown, Level: 0}
+		}
+		var cs CompressionStatsForSetting
+		if _, err := fmt.Sscanf(b[1], "%d/%d", &cs.CompressedBytes, &cs.UncompressedBytes); err != nil {
+			return CompressionStats{}, errors.Errorf("cannot parse compression stats %q", s)
+		}
+		stats.add(setting, cs)
+	}
+	return stats, nil
+}

sstable/block/compression_stats_test.go

@@ -0,0 +1,67 @@
+// 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.
+
+package block
+
+import (
+	"math/rand/v2"
+	"testing"
+
+	"github.com/cockroachdb/pebble/internal/compression"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCompressionStatsString(t *testing.T) {
+	var stats CompressionStats
+
+	stats.add(compression.None, CompressionStatsForSetting{CompressedBytes: 100, UncompressedBytes: 100})
+	require.Equal(t, "NoCompression:100/100", stats.String())
+
+	stats.add(compression.Snappy, CompressionStatsForSetting{CompressedBytes: 100, UncompressedBytes: 200})
+	require.Equal(t, "NoCompression:100/100,Snappy:100/200", stats.String())
+
+	stats.add(compression.Snappy, CompressionStatsForSetting{CompressedBytes: 100, UncompressedBytes: 200})
+	require.Equal(t, "NoCompression:100/100,Snappy:200/400", stats.String())
+
+	stats.add(compression.MinLZFastest, CompressionStatsForSetting{CompressedBytes: 1000, UncompressedBytes: 4000})
+	require.Equal(t, "MinLZ1:1000/4000,NoCompression:100/100,Snappy:200/400", stats.String())
+
+	stats.add(compression.ZstdLevel1, CompressionStatsForSetting{CompressedBytes: 10000, UncompressedBytes: 80000})
+	require.Equal(t, "MinLZ1:1000/4000,NoCompression:100/100,Snappy:200/400,ZSTD1:10000/80000", stats.String())
+
+	stats = CompressionStats{}
+	stats.add(compression.MinLZFastest, CompressionStatsForSetting{CompressedBytes: 1000, UncompressedBytes: 4000})
+	require.Equal(t, "MinLZ1:1000/4000", stats.String())
+
+	stats = CompressionStats{}
+	stats.add(compression.Snappy, CompressionStatsForSetting{CompressedBytes: 1000, UncompressedBytes: 4000})
+	require.Equal(t, "Snappy:1000/4000", stats.String())
+}
+
+func TestCompressionStatsRoundtrip(t *testing.T) {
+	settings := []compression.Setting{compression.None, compression.Snappy, compression.MinLZFastest, compression.ZstdLevel1, compression.ZstdLevel3}
+	for n := 0; n < 1000; n++ {
+		var stats CompressionStats
+		for _, i := range rand.Perm(len(settings))[:rand.IntN(len(settings)+1)] {
+			compressed := rand.Uint64N(1_000_000)
+			uncompressed := compressed
+			if settings[i] != compression.None {
+				uncompressed += compressed * rand.Uint64N(20) / 10
+			}
+			stats.add(settings[i], CompressionStatsForSetting{CompressedBytes: compressed, UncompressedBytes: uncompressed})
+			str := stats.String()
+			stats2, err := ParseCompressionStats(str)
+			require.NoError(t, err)
+			str2 := stats2.String()
+			require.Equal(t, str, str2)
+		}
+	}
+}
+
+func TestParseCompressionStatsUnknown(t *testing.T) {
+	stats, err := ParseCompressionStats("MinLZ1:100/200,ZSTD9:100/500,MiddleOut10:13/150000,Magic:15/10000000")
+	require.NoError(t, err)
+	expected := "MinLZ1:100/200,ZSTD9:100/500,unknown:28/10150000"
+	require.Equal(t, expected, stats.String())
+}