Check analyze cases against a real ClickHouse in goldeneye, and make sqlc agree with it

[kyleconroy]

Summary

Extends internal/goldeneye with the analysis checks its README reserved a place for, and then fixes everything they found wrong in sqlc's ClickHouse analysis. All six ClickHouse analyze cases now match what ClickHouse itself reports, byte for byte.

goldeneye check verifies, for each engine with a database available, both the committed dialect and every analyze_*/<engine> case under internal/endtoend/testdata: it loads the case's schema.sql and optional fixture.sql into the database, runs query.sql there, prints what the database reports in the JSON shape sqlc analyze prints, and compares it with the case's committed output.json. go test ./... in the module runs the same checks.

cd internal/goldeneye
go run ./cmd/goldeneye install clickhouse
go run ./cmd/goldeneye check clickhouse

• goldeneye/endtoend finds the cases and compares an engine's answer with the committed output, reusing goldeneye's diff.
• goldeneye/clickhouse gains Analyze and Check next to the dialect generator it shares a binary with. Each case runs in an ephemeral clickhouse local process: column types come from the executed query's result header, provenance from EXPLAIN QUERY TREE, and parameters, which ClickHouse never sees, from ordinal-carrying sentinel constants the query tree describes by the operand they are compared with. INSERT ... VALUES parameters map onto DESCRIBE TABLE.
• The other engines have no analysis check yet.

sqlc analyze output

sqlc analyze prints each column's type as a call expression instead of data_type, not_null and is_array: a name applied to args, each carrying an optional label and exactly one of type, int, bool or string, with nullable set at whatever depth it applies. docs/howto/analyze.md is updated.

{"name": "map", "args": [
  {"type": {"name": "string"}},
  {"type": {"name": "uint8", "nullable": true}}]}

Every analyze case's expected output is renamed from stdout.txt to output.json, which the harness now reads first, and regenerated. New ClickHouse cases analyze_types, analyze_expressions, analyze_subqueries and analyze_exec come with a fixture.sql next to the schema, and analyze_basic and analyze_params gain fixtures.

What the check found, and the fixes

• Types lost their arguments and nesting. The ClickHouse converter keeps a column's full spelling in the type name's Spelling, the schema stores it as the attribute's declared type, and the analysis core writes a TypeExpr for every column and parameter from it. Array(Nullable(String)), Array(Array(UInt8)), LowCardinality(Nullable(String)), Map(String, Nullable(UInt8)), Tuple(lat Float64, lon Float64), Enum8('active' = 1, ...), Decimal(10, 2), DateTime64(3, 'UTC') and FixedString(4) all survive.
• Expression columns had no type. A hand-written ClickHouse function seed of 581 signatures replaces the single count() entry, with "$n" naming the type of the nth argument and never_null for results that stay non-null. dialect.json declares that functions propagate nullability, that comparisons yield UInt8 while true is Bool, that LIMIT counts are UInt64, that an unconstrained placeholder is Nothing, and that the second id of a join is named e.id. The analyzer scores overloads instead of taking the first of the right arity, and COALESCE is now null only when every argument is.
• Parameters went missing. ClickHouse joins the preprocessed engines, so sqlc.arg() and sqlc.narg() work with ? binding; the analyzer types ORDER BY, LIMIT and OFFSET, follows IN (SELECT ...) into the subquery, and names a placeholder compared with a function call after the function. The converter's positions are now zero-based, which is also what made star expansion work.
• Scalar subqueries were ?column? typed bool. The converter treats a subquery in value position as a value rather than EXISTS, and captures aliases on every expression node kind.

Beyond the four: unaliased expression columns get ClickHouse's own names (sum(amount), plus(id, 1)), WITH elements are converted as the parser produces them so CTEs resolve, and coalesce/ifNull convert to COALESCE.

Tests

go test ./... at the root passes apart from the database-backed schema tests that need MySQL. The ClickHouse parse golden changed by one position and one column name, both correct. In internal/goldeneye, check clickhouse reports the dialect and all six analyze cases matching.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Y6XkyWnx7iJFEb8q3AnYps