query: Optimize away allocations in string matching

Improves performance by ~4x or more.

```
$ benchstat old.txt new.txt
goos: darwin
goarch: arm64
pkg: github.com/parca-dev/parca/pkg/query
cpu: Apple M1 Max
                                               │   old.txt    │               new.txt                │
                                               │    sec/op    │    sec/op     vs base                │
StringMatching/equalFoldBytes-10                 58.745n ± 1%   2.923n ±  7%  -95.02% (p=0.000 n=10)
StringMatching/containsFoldBytes-10               69.07n ± 7%   18.68n ±  3%  -72.95% (p=0.000 n=10)
StringMatching/hasPrefixFoldBytes-10              62.72n ± 2%   10.06n ± 13%  -83.96% (p=0.000 n=10)
StringMatchingLongStrings/containsFoldBytes-10   203.30n ± 2%   55.16n ±  2%  -72.87% (p=0.000 n=10)
geomean                                           84.81n        13.19n        -84.44%
```

Author: brancz

pkg/query/columnquery.go

@@ -982,33 +982,92 @@ func matchesFrameFilter(r *profile.RecordReader, locationIndex, lineIndex int, f
 	return true
 }
 
+// toLower converts ASCII byte to lowercase without allocation.
+// Non-ASCII bytes are left unchanged.
+func toLower(b byte) byte {
+	if b >= 'A' && b <= 'Z' {
+		return b + ('a' - 'A')
+	}
+	return b
+}
+
+// equalFoldBytes performs case-insensitive comparison without allocation.
+func equalFoldBytes(s, t []byte) bool {
+	if len(s) != len(t) {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		if toLower(s[i]) != toLower(t[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// containsFoldBytes performs case-insensitive contains check without allocation.
+func containsFoldBytes(s, substr []byte) bool {
+	if len(substr) == 0 {
+		return true
+	}
+	if len(substr) > len(s) {
+		return false
+	}
+
+	// Search for substring
+	for i := 0; i <= len(s)-len(substr); i++ {
+		// Check if substring matches at position i
+		match := true
+		for j := 0; j < len(substr); j++ {
+			if toLower(s[i+j]) != toLower(substr[j]) {
+				match = false
+				break
+			}
+		}
+		if match {
+			return true
+		}
+	}
+	return false
+}
+
+// hasPrefixFoldBytes performs case-insensitive prefix check without allocation.
+func hasPrefixFoldBytes(s, prefix []byte) bool {
+	if len(prefix) > len(s) {
+		return false
+	}
+	for i := 0; i < len(prefix); i++ {
+		if toLower(s[i]) != toLower(prefix[i]) {
+			return false
+		}
+	}
+	return true
+}
+
 // matchesStringCondition checks if a value matches a string condition.
 func matchesStringCondition(value []byte, condition *pb.StringCondition) bool {
 	if condition == nil {
 		return true
 	}
 
-	valueLower := bytes.ToLower(value)
-
 	switch condition.GetCondition().(type) {
 	case *pb.StringCondition_Equal:
-		target := bytes.ToLower([]byte(condition.GetEqual()))
-		return bytes.Equal(valueLower, target)
+		target := []byte(condition.GetEqual())
+		return equalFoldBytes(value, target)
 	case *pb.StringCondition_NotEqual:
-		target := bytes.ToLower([]byte(condition.GetNotEqual()))
-		return !bytes.Equal(valueLower, target)
+		target := []byte(condition.GetNotEqual())
+		return !equalFoldBytes(value, target)
 	case *pb.StringCondition_Contains:
-		target := bytes.ToLower([]byte(condition.GetContains()))
-		return bytes.Contains(valueLower, target)
+		target := []byte(condition.GetContains())
+		return containsFoldBytes(value, target)
 	case *pb.StringCondition_NotContains:
-		target := bytes.ToLower([]byte(condition.GetNotContains()))
-		return !bytes.Contains(valueLower, target)
+		target := []byte(condition.GetNotContains())
+		return !containsFoldBytes(value, target)
 	case *pb.StringCondition_StartsWith:
-		target := bytes.ToLower([]byte(condition.GetStartsWith()))
-		return bytes.HasPrefix(valueLower, target)
+		target := []byte(condition.GetStartsWith())
+		return hasPrefixFoldBytes(value, target)
 	case *pb.StringCondition_NotStartsWith:
-		target := bytes.ToLower([]byte(condition.GetNotStartsWith()))
-		return !bytes.HasPrefix(valueLower, target)
+		target := []byte(condition.GetNotStartsWith())
+		return !hasPrefixFoldBytes(value, target)
 	default:
 		return true
 	}

pkg/query/string_match_bench_test.go

@@ -19,7 +19,6 @@ import (
 	pb "github.com/parca-dev/parca/gen/proto/go/parca/query/v1alpha1"
 )
 
-// Benchmark comparing old bytes.ToLower approach vs new zero-allocation approach
 func BenchmarkStringMatching(b *testing.B) {
 	testValue := []byte("runtime.goexit")
 	testTarget := []byte("goexit")