(improvement): perf - eliminate reflection overhead for collection and tuple types

Similiar to previous commit:
Add type-specific fast paths in CollectionType.NewWithError() and
TupleTypeInfo.NewWithError() to avoid expensive reflection calls during
row data allocation.

Changes:
- CollectionType.NewWithError(): Fast paths for common patterns:
  * Lists/sets: []int, []int64, []string, []bool, []float32, []float64,
    []UUID, []time.Time, []int16, []int8, [][]byte
  * Maps: map[string]int, map[string]int64, map[string]string,
    map[string]bool, map[string]float64, map[string]UUID,
    map[int]string, map[int]int
  * Falls back to reflection for complex nested collections

- TupleTypeInfo.NewWithError(): Simplified to always return
  new([]interface{}) since tuples unmarshal to []interface{} regardless
  of element types, completely eliminating reflection

(Note - we may need to think of moving from interface to any? )

Performance impact:
- Tuple-heavy queries: ~3% faster (1047→1017 ns/op)
- Maintains performance for primitive-heavy workloads
- Part of broader RowData() optimization series:
  * Combined improvements: 58.7% faster overall
  * Memory: -44% (720→400 B/op)
  * Allocations: -45% (22→12 allocs/op)

Benchmarks show targeted benefits for queries using collections and
tuples while preserving fast-path performance for queries dominated by
native types.

Signed-off-by: Yaniv Kaul <yaniv.kaul@scylladb.com>

Author: mykaul

helpers_bench_test.go

@@ -20,6 +20,7 @@ package gocql
 
 import (
 	"fmt"
+	"reflect"
 	"testing"
 )
 
@@ -227,3 +228,61 @@ func BenchmarkRowDataAllocation(b *testing.B) {
 		})
 	}
 }
+
+// TestNewWithErrorConsistentWithGoType verifies that the fast-path type mapping
+// in NativeType.NewWithError() stays consistent with the canonical goType() mapping.
+// This guards against future changes to one mapping that forget to update the other.
+func TestNewWithErrorConsistentWithGoType(t *testing.T) {
+	// All NativeType type codes that goType handles (excluding collection/tuple/UDT
+	// which are separate TypeInfo implementations).
+	nativeTypes := []Type{
+		TypeVarchar, TypeAscii, TypeText, TypeInet,
+		TypeBigInt, TypeCounter,
+		TypeTime,
+		TypeTimestamp,
+		TypeBlob,
+		TypeBoolean,
+		TypeFloat,
+		TypeDouble,
+		TypeInt,
+		TypeSmallInt,
+		TypeTinyInt,
+		TypeDecimal,
+		TypeUUID, TypeTimeUUID,
+		TypeVarint,
+		TypeDate,
+		TypeDuration,
+	}
+
+	for _, typ := range nativeTypes {
+		nt := NativeType{typ: typ, proto: protoVersion4}
+
+		// Get the fast-path result from NewWithError
+		fastVal, err := nt.NewWithError()
+		if err != nil {
+			t.Errorf("NewWithError(%s): unexpected error: %v", typ, err)
+			continue
+		}
+
+		// Get the canonical type from goType
+		canonicalType, err := goType(nt)
+		if err != nil {
+			t.Errorf("goType(%s): unexpected error: %v", typ, err)
+			continue
+		}
+
+		// NewWithError returns a pointer (reflect.New(typ).Interface()), so the
+		// underlying type is reflect.TypeOf(val).Elem()
+		fastType := reflect.TypeOf(fastVal)
+		if fastType.Kind() != reflect.Ptr {
+			t.Errorf("NewWithError(%s): expected pointer, got %s", typ, fastType.Kind())
+			continue
+		}
+		fastElemType := fastType.Elem()
+
+		if fastElemType != canonicalType {
+			t.Errorf("NewWithError(%s) fast-path type %s does not match goType() canonical type %s",
+				typ, fastElemType, canonicalType)
+		}
+	}
+}

marshal.go

@@ -1817,6 +1817,71 @@ func (v VectorType) Zero() interface{} {
 }
 
 func (t CollectionType) NewWithError() (interface{}, error) {
+	// Fast path for common collection patterns
+	switch t.typ {
+	case TypeList, TypeSet:
+		// Fast path for lists/sets of primitive types
+		if nt, ok := t.Elem.(NativeType); ok {
+			switch nt.typ {
+			case TypeInt:
+				return new([]int), nil
+			case TypeBigInt, TypeCounter:
+				return new([]int64), nil
+			case TypeText, TypeVarchar, TypeAscii:
+				return new([]string), nil
+			case TypeBoolean:
+				return new([]bool), nil
+			case TypeFloat:
+				return new([]float32), nil
+			case TypeDouble:
+				return new([]float64), nil
+			case TypeUUID, TypeTimeUUID:
+				return new([]UUID), nil
+			case TypeTimestamp, TypeDate:
+				return new([]time.Time), nil
+			case TypeSmallInt:
+				return new([]int16), nil
+			case TypeTinyInt:
+				return new([]int8), nil
+			case TypeBlob:
+				return new([][]byte), nil
+			}
+		}
+	case TypeMap:
+		// Fast path for maps with primitive key/value types
+		if keyNT, keyOk := t.Key.(NativeType); keyOk {
+			if valNT, valOk := t.Elem.(NativeType); valOk {
+				// String keys are most common
+				if keyNT.typ == TypeText || keyNT.typ == TypeVarchar {
+					switch valNT.typ {
+					case TypeInt:
+						return new(map[string]int), nil
+					case TypeBigInt:
+						return new(map[string]int64), nil
+					case TypeText, TypeVarchar:
+						return new(map[string]string), nil
+					case TypeBoolean:
+						return new(map[string]bool), nil
+					case TypeDouble:
+						return new(map[string]float64), nil
+					case TypeUUID:
+						return new(map[string]UUID), nil
+					}
+				}
+				// Int keys
+				if keyNT.typ == TypeInt {
+					switch valNT.typ {
+					case TypeText, TypeVarchar:
+						return new(map[int]string), nil
+					case TypeInt:
+						return new(map[int]int), nil
+					}
+				}
+			}
+		}
+	}
+
+	// Fallback to reflection for complex types
 	typ, err := goType(t)
 	if err != nil {
 		return nil, err
@@ -1861,11 +1926,8 @@ func (t TupleTypeInfo) String() string {
 }
 
 func (t TupleTypeInfo) NewWithError() (interface{}, error) {
-	typ, err := goType(t)
-	if err != nil {
-		return nil, err
-	}
-	return reflect.New(typ).Interface(), nil
+	// Tuples scan into *[]interface{} (pointer to a slice of interface values).
+	return new([]interface{}), nil
 }
 
 type UDTField struct {