perf: pool []queryValues slices to reduce per-request allocations

Use bucketed sync.Pool (caps 8/16/32/64/128) to reuse []queryValues
slices in executeQuery() and executeBatch(). Slices are returned to the
pool immediately after c.exec() serializes the frame, with clear() to
release string/[]byte references.

Benchmark (8 values, sequential): ~3.9x faster than make().
Benchmark (8 values, parallel):   ~7.7x faster than make().

Author: mykaul

conn.go

@@ -1537,12 +1537,13 @@ func (c *Conn) executeQuery(ctx context.Context, qry *Query) (iter *Iter) {
 			return &Iter{err: fmt.Errorf("gocql: expected %d values send got %d", info.request.actualColCount, len(values))}
 		}
 
-		params.values = make([]queryValues, len(values))
+		params.values = getQueryValues(len(values))
 		for i := 0; i < len(values); i++ {
 			v := &params.values[i]
 			value := values[i]
 			typ := info.request.columns[i].TypeInfo
 			if err := marshalQueryValue(typ, value, v); err != nil {
+				putQueryValues(params.values)
 				return &Iter{err: err}
 			}
 		}
@@ -1571,6 +1572,8 @@ func (c *Conn) executeQuery(ctx context.Context, qry *Query) (iter *Iter) {
 	}
 
 	framer, err := c.exec(ctx, frame, qry.trace, qry.GetRequestTimeout())
+	// Return pooled queryValues now that the frame has been serialized.
+	putQueryValues(params.values)
 	if err != nil {
 		return &Iter{err: err}
 	}
@@ -1737,6 +1740,7 @@ func (c *Conn) executeBatch(ctx context.Context, batch *Batch) (iter *Iter) {
 		if len(entry.Args) > 0 || entry.binding != nil {
 			info, err := c.prepareStatement(batch.Context(), entry.Stmt, batch.trace, batch.GetRequestTimeout())
 			if err != nil {
+				putBatchQueryValues(req.statements)
 				return &Iter{err: err}
 			}
 
@@ -1751,24 +1755,27 @@ func (c *Conn) executeBatch(ctx context.Context, batch *Batch) (iter *Iter) {
 					PKeyColumns: info.request.pkeyColumns,
 				})
 				if err != nil {
+					putBatchQueryValues(req.statements)
 					return &Iter{err: err}
 				}
 			}
 
 			if len(values) != info.request.actualColCount {
+				putBatchQueryValues(req.statements)
 				return &Iter{err: fmt.Errorf("gocql: batch statement %d expected %d values send got %d", i, info.request.actualColCount, len(values))}
 			}
 
 			b.preparedID = info.id
 			stmts[string(info.id)] = entry.Stmt
 
-			b.values = make([]queryValues, info.request.actualColCount)
+			b.values = getQueryValues(info.request.actualColCount)
 
 			for j := 0; j < info.request.actualColCount; j++ {
 				v := &b.values[j]
 				value := values[j]
 				typ := info.request.columns[j].TypeInfo
 				if err := marshalQueryValue(typ, value, v); err != nil {
+					putBatchQueryValues(req.statements)
 					return &Iter{err: err}
 				}
 			}
@@ -1789,6 +1796,8 @@ func (c *Conn) executeBatch(ctx context.Context, batch *Batch) (iter *Iter) {
 
 	// TODO: should batch support tracing?
 	framer, err := c.exec(batch.Context(), req, batch.trace, batch.GetRequestTimeout())
+	// Return pooled queryValues now that the frame has been serialized.
+	putBatchQueryValues(req.statements)
 	if err != nil {
 		return &Iter{err: err}
 	}

frame.go

@@ -34,6 +34,7 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	frm "github.com/gocql/gocql/internal/frame"
@@ -1163,6 +1164,68 @@ type queryValues struct {
 	isUnset bool
 }
 
+// queryValuesPool is a set of size-bucketed sync.Pools for []queryValues slices.
+// Buckets: 0→cap 8, 1→cap 16, 2→cap 32, 3→cap 64, 4→cap 128.
+// Slices larger than 128 are not pooled.
+var queryValuesPools [5]sync.Pool
+
+// queryValuesBucket returns the pool bucket index for a given count.
+// Returns -1 if the count exceeds the maximum pooled size.
+func queryValuesBucket(n int) int {
+	switch {
+	case n <= 8:
+		return 0
+	case n <= 16:
+		return 1
+	case n <= 32:
+		return 2
+	case n <= 64:
+		return 3
+	case n <= 128:
+		return 4
+	default:
+		return -1
+	}
+}
+
+// getQueryValues returns a []queryValues of length n from the pool.
+// The returned slice elements are zeroed.
+func getQueryValues(n int) []queryValues {
+	bucket := queryValuesBucket(n)
+	if bucket < 0 {
+		return make([]queryValues, n)
+	}
+	if v := queryValuesPools[bucket].Get(); v != nil {
+		s := v.([]queryValues)
+		return s[:n]
+	}
+	// Allocate with the bucket's capacity so future returns fit.
+	return make([]queryValues, n, 8<<bucket)
+}
+
+// putQueryValues returns a []queryValues slice to the pool.
+// It clears all elements to release references to marshaled byte slices.
+func putQueryValues(s []queryValues) {
+	if s == nil {
+		return
+	}
+	bucket := queryValuesBucket(cap(s))
+	if bucket < 0 {
+		return
+	}
+	// Clear to release references (name strings, value []byte).
+	clear(s[:cap(s)])
+	queryValuesPools[bucket].Put(s[:cap(s)])
+}
+
+// putBatchQueryValues returns all pooled []queryValues slices from batch statements.
+func putBatchQueryValues(stmts []batchStatment) {
+	for i := range stmts {
+		putQueryValues(stmts[i].values)
+		stmts[i].values = nil
+	}
+}
+
 type queryParams struct {
 	keyspace              string
 	values                []queryValues

frame_test.go

@@ -30,6 +30,7 @@ package gocql
 import (
 	"bytes"
 	"os"
+	"runtime"
 	"testing"
 
 	frm "github.com/gocql/gocql/internal/frame"
@@ -162,3 +163,172 @@ func TestParseEventFrame_ClientRoutesChanged(t *testing.T) {
 		t.Fatalf("HostIDs = %v, want empty", evt.HostIDs)
 	}
 }
+
+// --- queryValues pool tests ---
+
+func TestQueryValuesBucket(t *testing.T) {
+	tests := []struct {
+		n      int
+		bucket int
+	}{
+		{0, 0}, {1, 0}, {8, 0},
+		{9, 1}, {16, 1},
+		{17, 2}, {32, 2},
+		{33, 3}, {64, 3},
+		{65, 4}, {128, 4},
+		{129, -1}, {1000, -1},
+	}
+	for _, tt := range tests {
+		got := queryValuesBucket(tt.n)
+		if got != tt.bucket {
+			t.Errorf("queryValuesBucket(%d) = %d, want %d", tt.n, got, tt.bucket)
+		}
+	}
+}
+
+func TestGetQueryValuesLength(t *testing.T) {
+	for _, n := range []int{0, 1, 5, 8, 10, 16, 30, 64, 128, 200} {
+		s := getQueryValues(n)
+		if len(s) != n {
+			t.Errorf("getQueryValues(%d): len = %d, want %d", n, len(s), n)
+		}
+		// For pooled sizes, capacity should be the bucket size.
+		bucket := queryValuesBucket(n)
+		if bucket >= 0 {
+			wantCap := 8 << bucket
+			if cap(s) != wantCap {
+				t.Errorf("getQueryValues(%d): cap = %d, want %d", n, cap(s), wantCap)
+			}
+		}
+	}
+}
+
+func TestPutGetQueryValuesClearsReferences(t *testing.T) {
+	s := getQueryValues(4)
+	s[0].name = "col1"
+	s[0].value = []byte("data")
+	s[1].name = "col2"
+	s[1].value = []byte("more")
+	s[2].isUnset = true
+
+	putQueryValues(s)
+
+	// Get a new slice from the same bucket. It should have zeroed elements.
+	s2 := getQueryValues(4)
+	for i := 0; i < 4; i++ {
+		if s2[i].name != "" {
+			t.Errorf("element %d: name = %q, want empty", i, s2[i].name)
+		}
+		if s2[i].value != nil {
+			t.Errorf("element %d: value = %v, want nil", i, s2[i].value)
+		}
+		if s2[i].isUnset {
+			t.Errorf("element %d: isUnset = true, want false", i)
+		}
+	}
+}
+
+func TestPutQueryValuesNilSafe(t *testing.T) {
+	// Must not panic.
+	putQueryValues(nil)
+}
+
+func TestPutBatchQueryValues(t *testing.T) {
+	stmts := make([]batchStatment, 3)
+	stmts[0].values = getQueryValues(5)
+	stmts[0].values[0].name = "a"
+	// stmts[1].values is nil (simulates entry without args)
+	stmts[2].values = getQueryValues(10)
+	stmts[2].values[0].value = []byte("x")
+
+	putBatchQueryValues(stmts)
+
+	for i, s := range stmts {
+		if s.values != nil {
+			t.Errorf("stmts[%d].values should be nil after putBatchQueryValues", i)
+		}
+	}
+}
+
+func TestGetQueryValuesOversize(t *testing.T) {
+	// Slices larger than 128 should not be pooled.
+	s := getQueryValues(200)
+	if len(s) != 200 {
+		t.Errorf("getQueryValues(200): len = %d, want 200", len(s))
+	}
+	// Should not panic when returning oversize.
+	putQueryValues(s)
+}
+
+// --- benchmarks ---
+
+// queryValuesSink forces escape analysis to heap-allocate make() in baseline
+// benchmarks. Assigned once after the loop to avoid per-iteration cache-line
+// effects that would unfairly penalize the baseline.
+var queryValuesSink []queryValues
+
+func BenchmarkGetPutQueryValues_8_Seq(b *testing.B) {
+	for b.Loop() {
+		s := getQueryValues(8)
+		s[0].name = "col"
+		s[0].value = []byte("val")
+		putQueryValues(s)
+	}
+}
+
+func BenchmarkGetPutQueryValues_8_Parallel(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			s := getQueryValues(8)
+			s[0].name = "col"
+			s[0].value = []byte("val")
+			putQueryValues(s)
+		}
+	})
+}
+
+func BenchmarkMakeQueryValues_8_Seq(b *testing.B) {
+	var s []queryValues
+	for b.Loop() {
+		s = make([]queryValues, 8)
+		s[0].name = "col"
+		s[0].value = []byte("val")
+	}
+	queryValuesSink = s
+}
+
+func BenchmarkMakeQueryValues_8_Parallel(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		var s []queryValues
+		for pb.Next() {
+			s = make([]queryValues, 8)
+			s[0].name = "col"
+			s[0].value = []byte("val")
+		}
+		runtime.KeepAlive(s)
+	})
+}
+
+func BenchmarkPutBatchQueryValues_10x8(b *testing.B) {
+	for b.Loop() {
+		stmts := make([]batchStatment, 10)
+		for i := range stmts {
+			stmts[i].values = getQueryValues(8)
+			stmts[i].values[0].name = "col"
+		}
+		putBatchQueryValues(stmts)
+	}
+}
+
+func BenchmarkPutBatchQueryValues_10x8_Parallel(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			stmts := make([]batchStatment, 10)
+			for i := range stmts {
+				stmts[i].values = getQueryValues(8)
+				stmts[i].values[0].name = "col"
+			}
+			putBatchQueryValues(stmts)
+		}
+	})
+}