core: one type row per expression, canonicalized per dialect, across every engine

[kyleconroy]

Summary

The analysis core's catalog held one sql_type row per flat name, so a type argument, a struct field, an enum label, a domain's base, a MySQL UNSIGNED or a second array dimension had nowhere to go, and sqlc analyze reported numeric(10,2) as numeric, int[][] as one dimension, and a ClickHouse CAST(x AS Nullable(String)) as nullable. Three of those were regressions against the legacy compiler on the core path: codegen lost unsigned, length and array_dims.

This branch starts with a design note (internal/core/types.md) that evaluates the current representation, reviews how each engine's own catalog represents a type (PostgreSQL, MySQL, SQLite, ClickHouse and DuckDB queried live; SQL Server and GoogleSQL from their catalogs and parsers), and then implements the design engine by engine.

The catalog

• sql_type holds one row per type expression: a family row for a name the dialect or the schema declares (numeric, array, mood) and an instance row for a family applied to arguments (numeric(10, 2), array(array(integer))), with expr as the canonical spelling and identity, and family_oid, element_oid, base_oid and canonical_oid pointing at what resolution falls back to. Arguments, fields and labels live in a new sql_type_arg table.
• An alias spelling is a row pointing at its canonical type instead of a mesh of implicit casts. SQLite's aliases are types of their own standing on a base, so a column reports the spelling it was declared with while comparing by affinity.
• Interning canonicalizes, and every engine reports the form its own catalog stores: PostgreSQL uses format_type names (integer, character varying(255), timestamp with time zone), MySQL spells BOOLEAN as tinyint(1), ClickHouse stores Decimal32(4) as Decimal(9, 4), DuckDB drops varchar(10)'s length, SQL Server keeps float(24) as real.
• Nullability is never part of a row: it stays on the attribute, the analysis and the reported column, with inner nullability a flag on the argument position (Array(Nullable(String))).
• A bare type name resolves in the default namespaces only, and a type elsewhere is reported qualified (myschema.mood), the way format_type prints a type off the search path; an instance's key is built from qualified names, so array(myschema.mood) and array(mood) are two rows.

What a dialect says, as data

Nothing about a dialect is Go code, so a new engine adds one by writing files. dialect.json carries rewrites (pattern, template, optional bound: float($1) → real where $1 <= 24), the words and positions that are identifiers rather than types (max, the function of SimpleAggregateFunction), SQLite's affinity rule, and a default schema. types.jsonl may give a family a base, which is how MySQL's unsigned families stand on their signed ones. functions.jsonl may spell a value-dependent result as a template ("returns": "Decimal(18, $2)"). The seed loads these into sql_type_rewrite, sql_type_affinity, dialect flags and sql_proc.return_template.

The analyzer

exprType carries the expression beside the row, so casts, typed placeholders, constructors and function results report whole types; resolution walks the pointer chain, so numeric(10, 2) + numeric(5, 1) resolves on numeric. A cast is NULL when its operand is or its type says so. The legacy bridge derives ArrayDims, Length and Unsigned from the expression.

Engines

Each engine's converter hands the core a canonical rendering (TypeName.Canonical, with fields labelled a: integer), the author's spelling, or a name with modifiers. PostgreSQL carries typmods, interval fields, dimensions, domains, composites, ranges, enum labels and namespaces. MySQL carries unsigned families, typmods, enum and set members, and names a cast as MySQL types it. ClickHouse handles casts, {name:Type} placeholders, Nested columns and canonical enum and variant spellings. DuckDB, GoogleSQL and SQL Server carry nested types, parameters, MAX, defaults and alias types.

Tests

• An analyze_types/<engine> case for every engine, checked by goldeneye against live MySQL, SQLite and ClickHouse (goldeneye now reads MySQL's COLUMN_TYPE, binds ClickHouse placeholders, and writes PostgreSQL array columns as element plus flag, which also fixes the legacy path's _text columns in codegen_json).
• The full suite with --tags=examples passes against live PostgreSQL and MySQL. The opt-in core context (SQLC_TEST_CORE=1) goes from 347 failing cases to 292; the one case that newly differs from its legacy golden, func_call_cast/mysql, now generates uint64 for CAST(... AS UNSIGNED), which is the correct answer.
• A first adversarial review of the branch found and this branch fixes: a label heuristic that mis-read a struct field typed timestamp with time zone, a write probe that inserted an empty-named type row, CREATE TYPE deduplication that ignored the schema so foo.mood and mood collapsed, bare names binding to types in unrelated schemas, IN (SELECT ...) typing its left side twice, and operator resolution issuing one query per chain pair.
• A second review, fanned out over the analyzer, the seed and converters, goldeneye, and the core's type and rewrite code, found and the last commit fixes: an instance key that dropped an argument's namespace; a read-only lookup that failed outright when a nested instance was not a row ($1::varchar(10)[]) or tried to create the array family; rewrites applied before alias resolution, so dec(7,2) missed MySQL's rule on decimal; a bare SQL Server CREATE TYPE landing in public while dbo.Code resolved elsewhere; the legacy bridge reporting bigint unsigned as the data type instead of bigint plus the flag; a PostgreSQL cast to interval day to second carrying the raw field mask; MySQL CAST(x AS DOUBLE) carrying the parser's display width; DuckDB's main. schema leaving a leading dot; ClickHouse LowCardinality(Nullable(T)) columns reported NOT NULL; goldeneye lowercasing MySQL enum members and relabelling int2vector and oidvector columns as arrays. The analyze_types cases cover each.

Output changes

sqlc analyze output changes for every dialect: canonical names, arguments, nested arrays, a fifth argument kind ident, and qualified names for types outside the default namespaces. The how-to is updated. The new analyzer has not shipped, so nothing released changes.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Qryf7a1doPFuCz2eGT3bCr