rename Minlz to MinLZ

Author: RaduBerinde

db.go

@@ -2100,7 +2100,7 @@ func (d *DB) Metrics() *Metrics {
 		metrics.Table.CompressedCountUnknown += int64(compressionTypes.unknown)
 		metrics.Table.CompressedCountSnappy += int64(compressionTypes.snappy)
 		metrics.Table.CompressedCountZstd += int64(compressionTypes.zstd)
-		metrics.Table.CompressedCountMinlz += int64(compressionTypes.minlz)
+		metrics.Table.CompressedCountMinLZ += int64(compressionTypes.minlz)
 		metrics.Table.CompressedCountNone += int64(compressionTypes.none)
 	}
 

metrics.go

@@ -304,7 +304,7 @@ type Metrics struct {
 		// The number of sstables that are compressed with zstd.
 		CompressedCountZstd int64
 		// The number of sstables that are compressed with minlz.
-		CompressedCountMinlz int64
+		CompressedCountMinLZ int64
 		// The number of sstables that are uncompressed.
 		CompressedCountNone int64
 
@@ -740,7 +740,7 @@ func (m *Metrics) SafeFormat(w redact.SafePrinter, _ rune) {
 	if count := m.Table.CompressedCountZstd; count > 0 {
 		w.Printf(" zstd: %d", redact.Safe(count))
 	}
-	if count := m.Table.CompressedCountMinlz; count > 0 {
+	if count := m.Table.CompressedCountMinLZ; count > 0 {
 		w.Printf(" minlz: %d", redact.Safe(count))
 	}
 	if count := m.Table.CompressedCountNone; count > 0 {

options.go

@@ -49,7 +49,7 @@ const (
 	NoCompression      = block.NoCompression
 	SnappyCompression  = block.SnappyCompression
 	ZstdCompression    = block.ZstdCompression
-	MinlzCompression   = block.MinlzCompression
+	MinLZCompression   = block.MinLZCompression
 )
 
 // FilterType exports the base.FilterType type.
@@ -2038,8 +2038,8 @@ func (o *Options) Parse(s string, hooks *ParseHooks) error {
 					l.Compression = func() Compression { return SnappyCompression }
 				case "ZSTD":
 					l.Compression = func() Compression { return ZstdCompression }
-				case "Minlz":
-					l.Compression = func() Compression { return MinlzCompression }
+				case "MinLZ":
+					l.Compression = func() Compression { return MinLZCompression }
 				default:
 					return errors.Errorf("pebble: unknown compression: %q", errors.Safe(value))
 				}

sstable/block/compression.go

@@ -25,7 +25,7 @@ const (
 	NoCompression
 	SnappyCompression
 	ZstdCompression
-	MinlzCompression
+	MinLZCompression
 	NCompression
 )
 
@@ -41,8 +41,8 @@ func (c Compression) String() string {
 		return "Snappy"
 	case ZstdCompression:
 		return "ZSTD"
-	case MinlzCompression:
-		return "Minlz"
+	case MinLZCompression:
+		return "MinLZ"
 	default:
 		return "Unknown"
 	}
@@ -60,8 +60,8 @@ func CompressionFromString(s string) Compression {
 		return SnappyCompression
 	case "ZSTD":
 		return ZstdCompression
-	case "Minlz":
-		return MinlzCompression
+	case "MinLZ":
+		return MinLZCompression
 	default:
 		return DefaultCompression
 	}
@@ -89,7 +89,7 @@ const (
 	Lz4hcCompressionIndicator  CompressionIndicator = 5
 	XpressCompressionIndicator CompressionIndicator = 6
 	ZstdCompressionIndicator   CompressionIndicator = 7
-	MinlzCompressionIndicator  CompressionIndicator = 8
+	MinLZCompressionIndicator  CompressionIndicator = 8
 )
 
 // String implements fmt.Stringer.

sstable/block/compression_test.go

@@ -140,8 +140,8 @@ func TestBufferRandomized(t *testing.T) {
 	}
 }
 
-func TestMinlzEncodingLimit(t *testing.T) {
-	// Tests that Minlz compression has a strict limit of minlz.MaxBlockSize: 8<<20 (8MiB)
+func TestMinLZEncodingLimit(t *testing.T) {
+	// Tests that MinLZ compression has a strict limit of minlz.MaxBlockSize: 8<<20 (8MiB)
 	_, err := minlz.Encode([]byte{}, bytes.Repeat([]byte{0}, minlz.MaxBlockSize-1), minlz.LevelFastest)
 	require.NoError(t, err)
 	_, err = minlz.Encode([]byte{}, bytes.Repeat([]byte{0}, minlz.MaxBlockSize), minlz.LevelFastest)
@@ -151,12 +151,12 @@ func TestMinlzEncodingLimit(t *testing.T) {
 		require.Fail(t, "Expected minlz.ErrTooLarge Error")
 	}
 
-	c := GetCompressor(MinlzCompression)
+	c := GetCompressor(MinLZCompression)
 	defer c.Close()
 	algo, _ := c.Compress([]byte{}, bytes.Repeat([]byte{0}, minlz.MaxBlockSize-1))
-	require.Equal(t, algo, MinlzCompressionIndicator)
+	require.Equal(t, algo, MinLZCompressionIndicator)
 	algo, _ = c.Compress([]byte{}, bytes.Repeat([]byte{0}, minlz.MaxBlockSize))
-	require.Equal(t, algo, MinlzCompressionIndicator)
+	require.Equal(t, algo, MinLZCompressionIndicator)
 	algo, _ = c.Compress([]byte{}, bytes.Repeat([]byte{0}, minlz.MaxBlockSize+1))
 	require.Equal(t, algo, SnappyCompressionIndicator)
 }

sstable/block/compressor.go

@@ -39,7 +39,7 @@ func (snappyCompressor) Compress(dst, src []byte) (CompressionIndicator, []byte)
 func (snappyCompressor) Close() {}
 
 func (minlzCompressor) Compress(dst, src []byte) (CompressionIndicator, []byte) {
-	// Minlz cannot encode blocks greater than 8MB. Fall back to Snappy in those cases.
+	// MinLZ cannot encode blocks greater than 8MB. Fall back to Snappy in those cases.
 	if len(src) > minlz.MaxBlockSize {
 		return (snappyCompressor{}).Compress(dst, src)
 	}
@@ -48,7 +48,7 @@ func (minlzCompressor) Compress(dst, src []byte) (CompressionIndicator, []byte)
 	if err != nil {
 		panic(errors.Wrap(err, "minlz compression"))
 	}
-	return MinlzCompressionIndicator, compressed
+	return MinLZCompressionIndicator, compressed
 }
 
 func (minlzCompressor) Close() {}
@@ -61,7 +61,7 @@ func GetCompressor(c Compression) Compressor {
 		return snappyCompressor{}
 	case ZstdCompression:
 		return getZstdCompressor()
-	case MinlzCompression:
+	case MinLZCompression:
 		return minlzCompressor{}
 	default:
 		panic("Invalid compression type.")
@@ -156,7 +156,7 @@ func GetDecompressor(c CompressionIndicator) Decompressor {
 		return snappyDecompressor{}
 	case ZstdCompressionIndicator:
 		return getZstdDecompressor()
-	case MinlzCompressionIndicator:
+	case MinLZCompressionIndicator:
 		return minlzDecompressor{}
 	default:
 		panic("Invalid compression type.")

sstable/writer_test.go

@@ -1242,7 +1242,7 @@ func runWriterBench(b *testing.B, keys [][]byte, comparer *base.Comparer, format
 		b.Run(fmt.Sprintf("block=%s", humanize.Bytes.Int64(int64(bs))), func(b *testing.B) {
 			for _, filter := range []bool{true, false} {
 				b.Run(fmt.Sprintf("filter=%t", filter), func(b *testing.B) {
-					for _, comp := range []block.Compression{block.NoCompression, block.SnappyCompression, block.ZstdCompression, block.MinlzCompression} {
+					for _, comp := range []block.Compression{block.NoCompression, block.SnappyCompression, block.ZstdCompression, block.MinLZCompression} {
 						b.Run(fmt.Sprintf("compression=%s", comp), func(b *testing.B) {
 							opts := WriterOptions{
 								BlockRestartInterval: 16,

table_stats.go

@@ -1127,7 +1127,7 @@ func (a compressionTypeAggregator) Accumulate(
 		dst.snappy++
 	case ZstdCompression:
 		dst.zstd++
-	case MinlzCompression:
+	case MinLZCompression:
 		dst.minlz++
 	case NoCompression:
 		dst.none++