feat: Add comprehensive performance benchmarks to CI/CD (fixes #52)

Add complete benchmark suite covering all major conversion features:

**Benchmark Coverage:**
- Simple operations: field comparisons, boolean checks
- Operators: logical, arithmetic, string operations
- Comprehensions: all, exists, exists_one, filter, map
- JSON/JSONB: nested field access, has() checks
- Regex: pattern matching with RE2 to POSIX conversion
- Complex expressions: deeply nested, large expressions
- Timestamps: date/time operations and comparisons
- String operations: startsWith, endsWith, contains
- Query analysis: index recommendation performance
- Conversion options: schema, depth, output length limits

**CI/CD Integration:**
- Benchmark job runs automatically on PR and main push
- Stores benchmark results for historical tracking
- Alerts on performance degradation >150%
- GitHub Actions integration with benchmark-action

**Makefile Targets:**
- make bench: Run all benchmarks
- make bench-compare: Save benchmarks for comparison

**Documentation:**
- Comprehensive benchmark guide in CLAUDE.md
- Examples of running and comparing benchmarks
- Benchmark output interpretation guide

All benchmarks passing with zero panics or failures.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: richardwooding

.github/workflows/ci.yml

@@ -46,3 +46,35 @@ jobs:
         file: ./coverage.out
         fail_ci_if_error: false
         token: ${{ secrets.CODECOV_TOKEN }}  # Add token for better reliability
+
+  benchmark:
+    name: Benchmark
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.24.x'
+        cache: true
+        check-latest: true
+
+    - name: Download dependencies
+      run: go mod download
+
+    - name: Run benchmarks
+      run: go test -bench=. -benchmem -benchtime=1s -run=^$$ ./... | tee benchmark-results.txt
+
+    - name: Store benchmark result
+      uses: benchmark-action/github-action-benchmark@v1
+      with:
+        tool: 'go'
+        output-file-path: benchmark-results.txt
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+        auto-push: false
+        comment-on-alert: true
+        alert-threshold: '150%'
+        fail-on-alert: false
+        summary-always: true

CLAUDE.md

@@ -17,6 +17,8 @@ cel2sql converts CEL (Common Expression Language) expressions to PostgreSQL SQL
 make build              # Build the project
 make test               # Run tests with race detection and coverage
 make test-coverage      # Generate HTML coverage report
+make bench              # Run performance benchmarks
+make bench-compare      # Run benchmarks and save for comparison
 ```
 
 ### Code Quality
@@ -167,6 +169,133 @@ These validations prevent PostgreSQL syntax errors and ensure predictable behavi
 - Verify SQL output matches PostgreSQL syntax (single quotes, proper functions)
 - Use testcontainers for integration tests with real PostgreSQL
 
+### Performance Benchmarks
+
+cel2sql includes comprehensive benchmarks to track performance and detect regressions. Benchmarks are automatically run as part of the CI/CD pipeline.
+
+#### Running Benchmarks Locally
+
+```bash
+# Run all benchmarks
+make bench
+
+# Run benchmarks and save output for comparison
+make bench-compare
+
+# Run specific benchmark
+go test -bench=BenchmarkConvertSimple -benchmem ./...
+
+# Run benchmarks with custom duration
+go test -bench=. -benchmem -benchtime=5s ./...
+```
+
+#### Benchmark Categories
+
+The benchmark suite covers all major conversion features:
+
+**Simple Operations** (`BenchmarkConvertSimple`)
+- Field comparisons (equality, greater than, less than)
+- String operations (equality checks)
+- Boolean checks
+
+**Operators** (`BenchmarkConvertOperators`)
+- Logical operators (AND, OR)
+- Arithmetic operators (+, -, *, /, %)
+- String concatenation
+- Complex nested expressions
+
+**Comprehensions** (`BenchmarkConvertComprehensions`)
+- `all()` - Universal quantification
+- `exists()` - Existential quantification
+- `exists_one()` - Unique existence
+- `filter()` - Array filtering
+- `map()` - Array transformation
+
+**JSON/JSONB** (`BenchmarkConvertJSONPath`)
+- Simple and nested JSON field access
+- JSON field existence checks (`has()`)
+- JSON field comparisons
+- Complex JSON expressions
+
+**Regex** (`BenchmarkConvertRegex`)
+- Simple patterns
+- Case-insensitive patterns
+- Character classes (\\d, \\w, \\s)
+- Word boundaries (\\b)
+
+**Complex Expressions** (`BenchmarkConvertDeeplyNested`, `BenchmarkConvertLargeExpression`)
+- Deeply nested AND/OR chains
+- Nested parentheses
+- Ternary operators
+- Large expressions with many conditions
+
+**Timestamps** (`BenchmarkConvertTimestamps`)
+- Timestamp comparisons
+- Date/time function calls
+- DateTime operations
+
+**String Operations** (`BenchmarkConvertStringOperations`)
+- startsWith, endsWith, contains
+- String concatenation
+- Multiple string operations combined
+
+**Query Analysis** (`BenchmarkAnalyzeQuery`)
+- Index recommendation generation
+- Pattern detection for optimization
+
+**Options** (`BenchmarkConvertWithOptions`)
+- Various conversion option combinations
+- Schema usage overhead
+- Max depth and output length limits
+
+#### Benchmark Output
+
+Benchmarks report:
+- **Iterations**: Number of times the operation was executed
+- **ns/op**: Nanoseconds per operation (lower is better)
+- **B/op**: Bytes allocated per operation (lower is better)
+- **allocs/op**: Number of allocations per operation (lower is better)
+
+Example output:
+```
+BenchmarkConvertSimple/equality-12     1412060    848.7 ns/op    1593 B/op    25 allocs/op
+BenchmarkConvertOperators/logical_and-12   943438    1255 ns/op    2154 B/op    36 allocs/op
+```
+
+#### CI/CD Integration
+
+Benchmarks run automatically on every PR and push to main:
+- Runs on Go 1.24.x
+- Stores benchmark results for historical tracking
+- Comments on PRs if performance degrades >150%
+- Provides summary of all benchmark results
+
+#### Comparing Benchmark Results
+
+To compare benchmarks between two runs:
+
+```bash
+# Run benchmarks and save baseline
+make bench-compare  # Saves to bench-new.txt
+
+# Make changes to code
+
+# Run benchmarks again and compare
+mv bench-new.txt bench-old.txt
+make bench-compare
+
+# Install benchstat for detailed comparison (optional)
+go install golang.org/x/perf/cmd/benchstat@latest
+benchstat bench-old.txt bench-new.txt
+```
+
+#### When to Run Benchmarks
+
+- Before and after performance optimizations
+- When modifying core conversion logic
+- When adding new features that may impact performance
+- To validate that changes don't cause regressions
+
 ## Common Patterns
 
 ### Creating Type Providers

Makefile

@@ -1,6 +1,6 @@
 # Makefile for cel2sql project
 
-.PHONY: build test lint fmt clean help install-tools deps vuln-check
+.PHONY: build test bench lint fmt clean help install-tools deps vuln-check
 
 # Build the project
 build:
@@ -10,6 +10,17 @@ build:
 test:
 	go test -v -race -coverprofile=coverage.out -covermode=atomic ./...
 
+# Run benchmarks
+bench:
+	go test -bench=. -benchmem -run=^$$ ./...
+
+# Run benchmarks with comparison output
+bench-compare:
+	@echo "Running benchmarks and saving to bench-new.txt"
+	@go test -bench=. -benchmem -run=^$$ ./... | tee bench-new.txt
+	@echo ""
+	@echo "Compare with previous run using: benchstat bench-old.txt bench-new.txt"
+
 # Run tests with coverage report
 test-coverage: test
 	go tool cover -html=coverage.out -o coverage.html
@@ -65,6 +76,8 @@ help:
 	@echo "Available targets:"
 	@echo "  build         - Build the project"
 	@echo "  test          - Run tests"
+	@echo "  bench         - Run benchmarks"
+	@echo "  bench-compare - Run benchmarks and save for comparison"
 	@echo "  test-coverage - Run tests with coverage report"
 	@echo "  lint          - Run linting"
 	@echo "  fmt           - Format code"