Motivation

sqlc already has a working ClickHouse parser (internal/engine/clickhouse, backed by doubleclick), but no analysis for it: the ClickHouse catalog was a stub, the engine was not wired into the compiler, and there was no EngineClickHouse. The missing layer is a typed catalog + a query analyzer.

This PR merges the xqlc analysis core into sqlc as the future analysis engine, and makes ClickHouse the first engine to run on it, end to end. ClickHouse is a natural first target because it has a parser and zero existing analysis — this is net-new, with no regression surface for the other engines.

What's here

sqlc generate now works for ClickHouse, resolving column and parameter types entirely through the xqlc core.

1. core: land xqlc catalog + analyzer on sqlc's AST

• internal/core/ — xqlc's SQLite-backed catalog (sql_* tables modeled on the Postgres system catalogs).
• internal/core/analyzer/ — xqlc's dialect-neutral analyzer, repointed off xqlc's copy of the AST onto sqlc's internal/sql/ast. Single AST — no second copy, no converter.

2. clickhouse: analyze queries through the core catalog + analyzer

• seed.go (ClickHouse dialect + built-in types) and schema.go (DDL → core catalog).
• Fixes the ClickHouse converter to render nested type parameters (Nullable(String), Array(UInt64), Decimal(18,4)) instead of dropping them as TODO.

3. clickhouse: wire end-to-end sqlc generate onto the core

• config: the clickhouse engine constant.
• compiler: NewCompiler builds a core catalog seeded with the ClickHouse dialect; parseCatalog applies schema DDL to it; a dedicated parseQueryCore resolves columns/params via core/analyzer and assembles *compiler.Query, reusing only the shared query-metadata parsing.
• codegen: a core-catalog → plugin.Catalog projection for models/enums, plus a ClickHouse → Go type map (Nullable(T) → *T, the integer ladder, DateTime → time.Time, …).
• clickhouse parser: computes statement byte-spans (doubleclick reports statement starts but not ends), so -- name: annotations fall inside each statement.
• An endtoend case (clickhouse_select) exercises the full pipeline; its generated Go is committed as golden output.

Example generated output for SELECT id, name, tag, amount, created FROM events over id UInt64, name String, tag Nullable(String), amount Float64, created DateTime:

type ListEventsRow struct {
	ID      uint64
	Name    string
	Tag     *string      // Nullable(String)
	Amount  float64
	Created time.Time
}

Design decisions

• One AST — sqlc's internal/sql/ast; the analyzer was repointed, not duplicated.
• One catalog — the core catalog is the single source of truth for analysis and codegen on this path; the in-memory internal/sql/catalog is not used for ClickHouse.
• No analyzer seam, no legacy analyze step — ClickHouse never enters analyzeQuery/inferQuery/outputColumns or the analyzer.Analyzer interface.

Follow-ups

• Query coverage beyond SELECT in core/analyzer (INSERT/UPDATE/DELETE) and bind-parameter detection for ClickHouse ? placeholders.
• Richer Go types (decimal.Decimal, uuid.UUID, netip.Addr, json.RawMessage) — these need import wiring; they currently resolve to string. Array-ness is not yet modeled on catalog attributes.
• A testgen-style conformance suite against a real ClickHouse.

Still a draft: this is the first engine on the new core and the coverage above is intentionally scoped. When other engines migrate, they follow the same path and the legacy analyze machinery can be retired.

go build ./... and go vet pass; new unit tests and the clickhouse_select / parse_basic/clickhouse endtoend cases are green.

🤖 Generated with Claude Code

https://claude.ai/code/session_01XTGxNHW6v1S1YyC9FDSgrK