block: support different setting for value blocks

A possible "balanced" setting could be to use Zstd1 for value blocks
and MinLZ for everything else.

Author: RaduBerinde

sstable/block/compression.go

@@ -25,16 +25,18 @@ import (
 type CompressionProfile struct {
 	Name string
 
-	// DataBlocks applies to sstable data and value blocks, as well as blob file
-	// value blocks. OtherBlocks applies to all other blocks (such as index,
-	// filter, metadata blocks).
+	// DataBlocks applies to sstable data blocks.
+	// ValueBlocks applies to sstable value blocks and blob file value blocks.
+	// OtherBlocks applies to all other blocks (such as index, filter, metadata
+	// blocks).
 	//
 	// Some blocks (like rangedel) never use compression; this is at the
 	// discretion of the sstable or blob file writer.
 	//
 	// Note that MinLZ is only supported with table formats v6+. Older formats
 	// fall back to Snappy.
 	DataBlocks  compression.Setting
+	ValueBlocks compression.Setting
 	OtherBlocks compression.Setting
 
 	// Blocks that are reduced by less than this percentage are stored
@@ -44,6 +46,14 @@ type CompressionProfile struct {
 	// TODO(radu): knobs for adaptive compression go here.
 }
 
+// UsesMinLZ returns true if the profile uses the MinLZ compression algorithm
+// (for any block kind).
+func (p *CompressionProfile) UsesMinLZ() bool {
+	return p.DataBlocks.Algorithm == compression.MinLZ ||
+		p.ValueBlocks.Algorithm == compression.MinLZ ||
+		p.OtherBlocks.Algorithm == compression.MinLZ
+}
+
 var (
 	NoCompression     = simpleCompressionProfile("NoCompression", compression.None)
 	SnappyCompression = simpleCompressionProfile("Snappy", compression.Snappy)
@@ -73,6 +83,7 @@ func simpleCompressionProfile(name string, setting compression.Setting) *Compres
 	p := &CompressionProfile{
 		Name:                name,
 		DataBlocks:          setting,
+		ValueBlocks:         setting,
 		OtherBlocks:         setting,
 		MinReductionPercent: 12,
 	}

sstable/block/compressor.go

@@ -14,6 +14,9 @@ import (
 type Compressor struct {
 	profile              CompressionProfile
 	dataBlocksCompressor compression.Compressor
+	// valueBlocksCompressor is used for value blocks; It can be the same object as
+	// dataBlocksCompressor.
+	valueBlocksCompressor compression.Compressor
 	// otherBlocksCompressor is used for blocks that are not data blocks, such as
 	// index blocks or metadata blocks. It can be the same object as
 	// dataBlocksCompressor.
@@ -27,8 +30,14 @@ func MakeCompressor(profile *CompressionProfile) Compressor {
 		profile: *profile,
 	}
 	c.dataBlocksCompressor = compression.GetCompressor(profile.DataBlocks)
-	c.otherBlocksCompressor = c.dataBlocksCompressor
-	if profile.OtherBlocks != profile.DataBlocks {
+	if profile.ValueBlocks == profile.DataBlocks {
+		c.valueBlocksCompressor = c.dataBlocksCompressor
+	} else {
+		c.valueBlocksCompressor = compression.GetCompressor(profile.ValueBlocks)
+	}
+	if profile.OtherBlocks == profile.DataBlocks {
+		c.otherBlocksCompressor = c.dataBlocksCompressor
+	} else {
 		c.otherBlocksCompressor = compression.GetCompressor(profile.OtherBlocks)
 	}
 	return c
@@ -40,6 +49,9 @@ func (c *Compressor) Close() {
 	if c.otherBlocksCompressor != c.dataBlocksCompressor {
 		c.otherBlocksCompressor.Close()
 	}
+	if c.valueBlocksCompressor != c.dataBlocksCompressor {
+		c.valueBlocksCompressor.Close()
+	}
 	c.dataBlocksCompressor.Close()
 	*c = Compressor{}
 }
@@ -48,10 +60,16 @@ func (c *Compressor) Close() {
 //
 // In addition to the buffer, returns the algorithm that was used.
 func (c *Compressor) Compress(dst, src []byte, kind Kind) (CompressionIndicator, []byte) {
-	compressor := c.dataBlocksCompressor
-	if kind != blockkind.SSTableData && kind != blockkind.SSTableValue && kind != blockkind.BlobValue {
+	var compressor compression.Compressor
+	switch kind {
+	case blockkind.SSTableData:
+		compressor = c.dataBlocksCompressor
+	case blockkind.SSTableValue, blockkind.BlobValue:
+		compressor = c.valueBlocksCompressor
+	default:
 		compressor = c.otherBlocksCompressor
 	}
+
 	out := compressor.Compress(dst, src)
 
 	// Return the original data uncompressed if the reduction is less than the

sstable/block/compressor_test.go

@@ -0,0 +1,52 @@
+// 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/cockroachdb/pebble/sstable/block/blockkind"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCompressor(t *testing.T) {
+	settings := []compression.Setting{
+		compression.None,
+		compression.Snappy,
+		compression.MinLZFastest,
+		compression.ZstdLevel3,
+	}
+
+	src := make([]byte, 1024)
+	dst := make([]byte, 0, 1024)
+	for runs := 0; runs < 100; runs++ {
+		profile := &CompressionProfile{
+			DataBlocks:          settings[rand.IntN(len(settings))],
+			ValueBlocks:         settings[rand.IntN(len(settings))],
+			OtherBlocks:         settings[rand.IntN(len(settings))],
+			MinReductionPercent: 0,
+		}
+
+		compressor := MakeCompressor(profile)
+		ci, _ := compressor.Compress(dst, src, blockkind.SSTableData)
+		require.Equal(t, compressionIndicatorFromAlgorithm(profile.DataBlocks.Algorithm), ci)
+
+		ci, _ = compressor.Compress(dst, src, blockkind.SSTableValue)
+		require.Equal(t, compressionIndicatorFromAlgorithm(profile.ValueBlocks.Algorithm), ci)
+
+		ci, _ = compressor.Compress(dst, src, blockkind.BlobValue)
+		require.Equal(t, compressionIndicatorFromAlgorithm(profile.ValueBlocks.Algorithm), ci)
+
+		ci, _ = compressor.Compress(dst, src, blockkind.Index)
+		require.Equal(t, compressionIndicatorFromAlgorithm(profile.OtherBlocks.Algorithm), ci)
+
+		ci, _ = compressor.Compress(dst, src, blockkind.Metadata)
+		require.Equal(t, compressionIndicatorFromAlgorithm(profile.OtherBlocks.Algorithm), ci)
+
+		compressor.Close()
+	}
+}

sstable/options.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 
 	"github.com/cockroachdb/pebble/internal/base"
-	"github.com/cockroachdb/pebble/internal/compression"
 	"github.com/cockroachdb/pebble/internal/sstableinternal"
 	"github.com/cockroachdb/pebble/sstable/block"
 	"github.com/cockroachdb/pebble/sstable/colblk"
@@ -355,12 +354,9 @@ func (o WriterOptions) ensureDefaults() WriterOptions {
 }
 
 func tableFormatSupportsCompressionProfile(tf TableFormat, profile *block.CompressionProfile) bool {
-	if tf < TableFormatPebblev6 {
-		// MinLZ is only supported in TableFormatPebblev6 and higher.
-		if profile.DataBlocks.Algorithm == compression.MinLZ ||
-			profile.OtherBlocks.Algorithm == compression.MinLZ {
-			return false
-		}
+	// MinLZ is only supported in TableFormatPebblev6 and higher.
+	if tf < TableFormatPebblev6 && profile.UsesMinLZ() {
+		return false
 	}
 	return true
 }