perf: optimize column metadata parsing and readTypeInfo()

[mykaul]

Summary

• Optimize column metadata parsing by reading keyspace/table once per result set (when flagGlobalTableSpec is set) instead of per-column, and use skipString() to skip redundant per-column keyspace/table reads in readColWithSpec()
• Add a fast-path in readTypeInfo() for simple native types (the common case), avoiding the switch statement overhead for types that need no further parsing
• Fix a bug in prepared batch metadata parsing where metadata was only parsed from the last statement instead of all statements

Extracted from PR #699 (rec_perf_improvements branch). Part 3 of 3 — the other two are:

• PR perf: streamline readHeader() function #778 (streamline_readHeader)
• PR perf: eliminate reflection overhead in RowData() and type instantiation #779 (rowdata_reflection_elimination)

Commits

1. frame: optimize column metadata parsing by reading keyspace/table once — When the global table spec flag is set in result metadata, read keyspace and table name once and share them across all columns instead of re-reading per column. Add skipString() helper. Reduces per-column allocations.

2. Optimize readTypeInfo() with fast-path for simple native types — For the most common type info kinds (varchar, int, bigint, blob, etc.), return a NativeType directly without falling through the full switch. This avoids unnecessary branching for the ~15 simple types that need no sub-type parsing.

3. Fix prepared batch metadata parsing — When preparing a batch, parse result metadata from all statements (not just the last one) so that column metadata is correctly captured for multi-table batches. Includes a unit test covering this case.

Benchmark Results

Benchmarks measured with a temporary metadata_bench_test.go exercising parseResultMetadata and parsePreparedMetadata with synthetic CQL frames.

perColSpec (per-column keyspace/table — biggest improvement)

Benchmark	Before (ns/op)	After (ns/op)	Before (B/op)	After (B/op)	Before (allocs)	After (allocs)
10cols perColSpec	~2,600	~1,000	1,424	1,136	41	23
50cols perColSpec	~7,300	~3,500	7,056	5,488	201	103

~44% fewer allocations and ~55-60% faster for per-column spec results.

The reduction in allocations comes from skipString() which avoids allocating strings that are immediately discarded (the per-column keyspace/table names when global spec is not set are still read but now skipped efficiently).

globalSpec (global table spec — modest improvement from readTypeInfo fast-path)

Benchmark	Before (ns/op)	After (ns/op)	Before (B/op)	After (B/op)
10cols globalSpec	~660	~720	1,136	1,136
50cols globalSpec	~3,100	~3,400	5,488	5,488
100cols globalSpec	~9,000	~5,700	10,560	10,560

For globalSpec, allocations are unchanged (already optimal). The 100-column case shows clear improvement from the readTypeInfo fast-path; smaller sizes are within noise.

PreparedMetadata

Benchmark	Before (ns/op)	After (ns/op)
ParsePreparedMetadata	~1,300	~1,270

Within noise — prepared metadata parsing was already efficient; the fix in commit 3 is a correctness change, not a performance one.

Testing

• go test -tags unit -count=1 ./... — all tests pass
• go vet ./... — clean
• New test TestPrepareBatchMetadataMultipleKeyspaceTables covers the batch metadata fix

Notes

• The globalSpec optimization in commit 1 assumes CQL protocol v3+ where the global table spec flag is standard. All supported protocol versions (v3, v4, v5) use this flag.

[Copilot]

Pull request overview

This PR optimizes result/prepare metadata parsing on the receive path in the GoCQL driver by reducing redundant string allocations and adding a fast-path in type parsing, while also adding a unit test for prepared batch metadata involving multiple keyspaces/tables.

Changes:

• Optimize column metadata parsing by reusing keyspace/table where possible and adding skipString() to avoid unnecessary allocations.
• Add a fast-path in readTypeInfo() for common “simple” native CQL types.
• Add a unit test and test-server support for preparing a BEGIN BATCH ... APPLY BATCH statement with variables spanning multiple keyspaces/tables.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 2 comments.

File	Description
frame.go	Adds readTypeInfo() fast-path, introduces skipString(), and refactors column metadata parsing via readColWithSpec() plus metadata struct changes.
conn_test.go	Adds unit test for batch prepare metadata across multiple keyspaces/tables and updates test server PREPARE handling to support batch statements.

[Copilot]

Pull request overview

This PR improves metadata parsing performance and correctness by reducing redundant keyspace/table reads, adding a fast-path for common native types in readTypeInfo(), and fixing prepared batch metadata parsing to read all statements’ metadata.

Changes:

• Cache keyspace/table at the result-metadata level and skip redundant per-column reads via skipString().
• Add a fast-path in readTypeInfo() for simple scalar native types.
• Fix prepared batch metadata parsing to capture column metadata across all batch statements, with a new unit test.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 4 comments.

File	Description
frame.go	Adds type-info fast-path, optimizes metadata parsing by caching keyspace/table and skipping redundant per-column strings, and introduces skipString() plus prepared-metadata tracking for mixed table specs.
conn_test.go	Adds a unit test for prepared batch metadata across multiple keyspace/tables and extends the test server’s prepare handling to emit batch-metadata responses.

[mykaul]

Addressed review feedback:

Fixed (this push):

• Grammar fix in skipString() panic message: "require" → "requires" (line 1554)
• Strengthened the !globalSpec comment in parseResultMetadata() to explicitly explain why the single-table assumption is safe: CQL SELECT results always come from a single table. Also clarified that parsePreparedMetadata() intentionally does NOT use this optimization (it uses readPerColumnSpec for the result-set part, where prepared batch metadata may reference multiple tables).

Already fixed in prior revision:

• Magic number 0x0015 was already replaced with uint16(TypeDuration) in a previous push.

Not changing (style preference):

• The readColWithSpec high-arity signature suggestion: while a struct could reduce parameters, the current approach is straightforward and all call sites are within the same file. The function is internal and the parameters are well-documented. Refactoring to a struct would add indirection without clear benefit for 2 call sites.

Not a bug (Copilot false positive):

• The repeated concern about !globalSpec mixed-table metadata in ROWS results: CQL protocol ROWS responses always contain columns from a single table (SELECT cannot join tables). The per-column encoding exists in the protocol spec but is never exercised for ROWS in practice. The parsePreparedMetadata() path correctly handles the multi-table case for prepared batches.

[Copilot]

Pull request overview

This PR improves receive-path efficiency and correctness in frame parsing for the GoCQL driver by reducing redundant allocations/reads in result metadata parsing, adding a fast-path for common type info parsing, and fixing prepared batch metadata handling (with a new unit test).

Changes:

• Optimize column metadata parsing by reusing keyspace/table at the result-metadata level and skipping redundant per-column strings via skipString() and readColWithSpec().
• Add a fast-path in readTypeInfo() for simple native scalar types to avoid extra branching/work.
• Fix/cover prepared batch metadata parsing for multi-table batches via a new unit test + test-server behavior.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 2 comments.

File	Description
frame.go	Adds readTypeInfo() fast-path, introduces skipString(), refactors column parsing into readColWithSpec(), and adjusts prepared/result metadata parsing behavior.
conn_test.go	Adds a unit test for multi-keyspace/table prepared batch metadata and updates the test server’s PREPARE handling to return appropriate synthetic metadata.

[Copilot]

Pull request overview

This PR improves receive-path performance in frame metadata parsing and fixes correctness for prepared batch metadata, especially when multiple keyspace/table pairs are involved.

Changes:

• Optimize column metadata parsing by reusing keyspace/table across columns (and skipping redundant per-column strings without allocating) when possible.
• Add a fast-path in readTypeInfo() for native types that require no additional parsing.
• Fix prepared batch metadata handling to correctly retain per-column keyspace/table information across mixed-table batches, with new unit coverage.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 2 comments.

File	Description
frame.go	Adds skipString(), reworks column spec parsing to avoid redundant allocations, adds readTypeInfo() fast-path, and improves prepared metadata handling for mixed batches.
frame_test.go	Adds a unit test validating per-column table spec parsing + skipString() alignment (buffer fully consumed).
conn_test.go	Adds a unit test ensuring prepared batch metadata preserves per-column keyspace/table for mixed-table batches; extends test server PREPARE handling to support it.

[mykaul]

Error:
Failed to truncate test table:
exceptions::invalid_request_exception
(Another global topology request is ongoing, please retry.)
Verdict: Flaky test — unrelated to the PR changes.
Key reasons:

1. The error is a transient Scylla server-side issue (topology contention during parallel test execution), not a driver bug.
2. The PR only modifies frame parsing code (frame.go) and test server logic (conn_test.go/frame_test.go) — it doesn't touch serialization tests or truncation logic.
3. All other integration test jobs (Scylla LATEST, PRIOR, LTS-LATEST, Cassandra 4/5-LATEST) pass.
4. The same job passes on the latest master commit.