core: analyze every dialect through the new analysis core

`sqlc analyze` ran ClickHouse and GoogleSQL on the core catalog and
analyzer while PostgreSQL, MySQL and SQLite still went through the legacy
compiler. This routes all five dialects through the core.

- compiler: NewCompiler takes options; WithCoreAnalysis, which the analyze
  command passes, builds a core catalog seeded with the engine's dialect
  and skips the legacy catalog and the analyzer connection entirely.
  ClickHouse and GoogleSQL keep doing so unconditionally. `generate`,
  `vet` and `compile` are untouched.
- core/seed: a declarative description of a dialect — its types and their
  aliases, the operators and casts between them, and the functions it
  ships with — that Apply turns into catalog rows. PostgreSQL, MySQL and
  SQLite seeds are built on it, reusing each engine's existing function
  catalog (pg_catalog and the MySQL and SQLite stdlibs).
- core: literals take the type each dialect names rather than PostgreSQL's,
  a type a schema declares gains the dialect's comparison operators, and
  array types are named after their element.
- core/schema: enums, functions, views, CREATE TABLE AS, ALTER TABLE and
  the rename statements now load into the catalog, and a column's array-ness
  is read from either the type name or the column.
- core/analyzer: CTEs, set operations, subqueries in FROM and as
  expressions, correlated references, functions in FROM, IN, BETWEEN, CASE,
  COALESCE, array expressions, casts and output-name references in GROUP BY
  and HAVING. Overloads are chosen by argument type, polymorphic return
  types resolve to the argument's, and an unknown function or operator
  leaves the expression untyped instead of failing the query.

The SQLite golden changes because the core reports the type name the
catalog stores, which is lower case.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011MnoUabwBWW9gaEn2Nj7eG

Author: claude

docs/howto/analyze.md

@@ -7,6 +7,13 @@ Unlike [`generate`](generate.md), this command does not require a configuration
 file and does not connect to a database. It uses sqlc's native static analysis
 to infer types directly from the provided schema.
 
+Every dialect is analyzed by the same engine-neutral analysis core: the schema
+is loaded into a catalog seeded with the dialect's types, operators and
+functions, and each query is resolved against it. `generate` still uses each
+engine's own analysis path, so the two can report a type differently — most
+visibly, `analyze` reports type names as the catalog stores them, in lower
+case.
+
 ## Usage
 
 ```sh

internal/cmd/analyze.go

@@ -130,7 +130,7 @@ Examples:
 			parserOpts := opts.Parser{}
 
 			ctx := cmd.Context()
-			c, err := compiler.NewCompiler(sql, combo, parserOpts)
+			c, err := compiler.NewCompiler(sql, combo, parserOpts, compiler.WithCoreAnalysis())
 			if err != nil {
 				return fmt.Errorf("error creating compiler: %w", err)
 			}

internal/compiler/engine.go

@@ -32,6 +32,9 @@ type Compiler struct {
 
 	coreCatalog *core.Catalog
 
+	// coreAnalysis routes every engine through the core catalog and analyzer.
+	coreAnalysis bool
+
 	schema []string
 
 	// databaseOnlyMode indicates that the compiler should use database-only analysis
@@ -41,8 +44,33 @@ type Compiler struct {
 	expander *expander.Expander
 }
 
-func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts.Parser) (*Compiler, error) {
+// Option configures a Compiler.
+type Option func(*Compiler)
+
+// WithCoreAnalysis analyzes queries with the core catalog and analyzer rather
+// than each engine's own analysis path. ClickHouse and GoogleSQL always do;
+// this opts the remaining engines in.
+func WithCoreAnalysis() Option {
+	return func(c *Compiler) { c.coreAnalysis = true }
+}
+
+func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts.Parser, options ...Option) (*Compiler, error) {
 	c := &Compiler{conf: conf, combo: combo}
+	for _, o := range options {
+		o(c)
+	}
+
+	// ClickHouse and GoogleSQL have no legacy analysis path to fall back to.
+	switch conf.Engine {
+	case config.EngineClickHouse, config.EngineGoogleSQL:
+		c.coreAnalysis = true
+	}
+	if c.coreAnalysis {
+		if err := c.initCore(); err != nil {
+			return nil, err
+		}
+		return c, nil
+	}
 
 	if conf.Database != nil && conf.Database.Managed {
 		client := dbmanager.NewClient(combo.Global.Servers)
@@ -116,26 +144,46 @@ func NewCompiler(conf config.SQL, combo config.CombinedSettings, parserOpts opts
 				)
 			}
 		}
+	default:
+		return nil, fmt.Errorf("unknown engine: %s", conf.Engine)
+	}
+	return c, nil
+}
+
+// initCore wires up the engine's parser and a core catalog seeded with its
+// dialect. No legacy catalog and no analyzer connection are involved.
+func (c *Compiler) initCore() error {
+	var dialect core.Option
+	switch c.conf.Engine {
+	case config.EngineSQLite:
+		c.parser = sqlite.NewParser()
+		c.selector = newSQLiteSelector()
+		dialect = sqlite.Dialect()
+	case config.EngineMySQL:
+		c.parser = dolphin.NewParser()
+		c.selector = newDefaultSelector()
+		dialect = dolphin.Dialect()
+	case config.EnginePostgreSQL:
+		c.parser = postgresql.NewParser()
+		c.selector = newDefaultSelector()
+		dialect = postgresql.Dialect()
 	case config.EngineClickHouse:
 		c.parser = clickhouse.NewParser()
 		c.selector = newDefaultSelector()
-		cat, err := core.New(clickhouse.Dialect())
-		if err != nil {
-			return nil, fmt.Errorf("clickhouse: init catalog: %w", err)
-		}
-		c.coreCatalog = cat
+		dialect = clickhouse.Dialect()
 	case config.EngineGoogleSQL:
 		c.parser = googlesql.NewParser()
 		c.selector = newDefaultSelector()
-		cat, err := core.New(googlesql.Dialect())
-		if err != nil {
-			return nil, fmt.Errorf("googlesql: init catalog: %w", err)
-		}
-		c.coreCatalog = cat
+		dialect = googlesql.Dialect()
 	default:
-		return nil, fmt.Errorf("unknown engine: %s", conf.Engine)
+		return fmt.Errorf("unknown engine: %s", c.conf.Engine)
 	}
-	return c, nil
+	cat, err := core.New(dialect)
+	if err != nil {
+		return fmt.Errorf("%s: init catalog: %w", c.conf.Engine, err)
+	}
+	c.coreCatalog = cat
+	return nil
 }
 
 func (c *Compiler) Catalog() *catalog.Catalog {

internal/compiler/parse_core.go

@@ -92,6 +92,7 @@ func coreColumn(c core.Column) *Column {
 		Name:     c.Name,
 		DataType: c.DataType,
 		NotNull:  c.NotNull,
+		IsArray:  c.IsArray,
 	}
 	if c.Source != nil && c.Source.Table != "" {
 		col.Table = &ast.TableName{Schema: c.Source.Schema, Name: c.Source.Table}
@@ -110,6 +111,7 @@ func coreParamColumn(p core.Parameter, params *named.ParamSet) *Column {
 		Name:     p.Name,
 		DataType: p.DataType,
 		NotNull:  p.NotNull,
+		IsArray:  p.IsArray,
 	}
 	if p.Source != nil && p.Source.Table != "" {
 		col.Table = &ast.TableName{Schema: p.Source.Schema, Name: p.Source.Table}

internal/core/analysis.go

@@ -27,6 +27,7 @@ type Column struct {
 	DataType           string        `json:"data_type"`
 	TypeOID            int64         `json:"type_oid,omitempty"`
 	NotNull            bool          `json:"not_null"`
+	IsArray            bool          `json:"is_array,omitempty"`
 	SourceClassOID     int64         `json:"source_class_oid,omitempty"`
 	SourceAttributeOID int64         `json:"source_attribute_oid,omitempty"`
 	Source             *ColumnSource `json:"source,omitempty"`
@@ -44,5 +45,6 @@ type Parameter struct {
 	DataType string        `json:"data_type,omitempty"`
 	TypeOID  int64         `json:"type_oid,omitempty"`
 	NotNull  bool          `json:"not_null"`
+	IsArray  bool          `json:"is_array,omitempty"`
 	Source   *ColumnSource `json:"source,omitempty"`
 }

internal/core/analyzer/analyzer.go

@@ -2,6 +2,7 @@ package analyzer
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
@@ -42,12 +43,83 @@ func Prepare(cat *core.Catalog, stmt ast.Node) (core.PrepareResult, error) {
 	return a.result(), nil
 }
 
+// dataType reports the type's name and whether it is an array of that type.
+// The catalog names an array after its element, so a caller that reports the
+// two separately gets them apart here.
+func (a *analyzer) dataType(oid int64) (string, bool) {
+	if oid == 0 {
+		return "", false
+	}
+	name, err := a.cat.TypeName(oid)
+	if err != nil {
+		return "", false
+	}
+	if element, ok := strings.CutSuffix(name, core.ArraySuffix); ok {
+		return element, true
+	}
+	return name, false
+}
+
 type analyzer struct {
 	cat     *core.Catalog
 	scope   *scope
 	columns []core.Column
 	params  map[int]core.Parameter
 	command core.Command
+
+	// outer is the scope of the query this one is nested in, which a
+	// correlated subquery refers to.
+	outer *scope
+
+	// ctes are the relations a WITH clause defined, visible to this query and
+	// to the ones nested in it.
+	ctes map[string]scopeRel
+
+	// aliases are the names the target list gives its expressions. GROUP BY,
+	// HAVING and ORDER BY may refer to a result column by its output name.
+	aliases map[string]ast.Node
+
+	// resolving guards against an alias that refers to itself.
+	resolving map[string]bool
+}
+
+// subquery analyzes a nested SELECT. It shares the parameter set, so a
+// placeholder inside the subquery is reported with the rest, and it sees this
+// query's scope, so a correlated reference resolves.
+func (a *analyzer) subquery(s *ast.SelectStmt) (*analyzer, error) {
+	sub := &analyzer{
+		cat:    a.cat,
+		params: a.params,
+		outer:  a.scope,
+		ctes:   a.ctes,
+	}
+	if err := sub.analyzeSelect(s); err != nil {
+		return nil, err
+	}
+	return sub, nil
+}
+
+func (a *analyzer) subqueryColumns(s *ast.SelectStmt) ([]core.Column, error) {
+	sub, err := a.subquery(s)
+	if err != nil {
+		return nil, err
+	}
+	return sub.columns, nil
+}
+
+// derivedRel turns a subquery's result columns into a relation, so that the
+// query selecting from it resolves columns the same way as from a table.
+func derivedRel(alias string, cols []core.Column) scopeRel {
+	rel := scopeRel{alias: alias, cols: make([]core.ClassColumn, 0, len(cols))}
+	for _, col := range cols {
+		rel.cols = append(rel.cols, core.ClassColumn{
+			AttOID:  col.SourceAttributeOID,
+			Name:    col.Name,
+			TypeOID: col.TypeOID,
+			NotNull: col.NotNull,
+		})
+	}
+	return rel
 }
 
 func (a *analyzer) result() core.PrepareResult {
@@ -78,12 +150,27 @@ func orderedParams(m map[int]core.Parameter) []core.Parameter {
 }
 
 func (a *analyzer) analyzeSelect(s *ast.SelectStmt) error {
+	if err := a.bindCTEs(s.WithClause); err != nil {
+		return err
+	}
+
+	// A set operation reports the columns of its first branch. The other
+	// branches still get analyzed, for the placeholders they hold.
+	if s.Larg != nil && s.Rarg != nil {
+		if err := a.analyzeSetOperation(s); err != nil {
+			return err
+		}
+		return nil
+	}
+
 	sc, err := a.buildScope(s.FromClause)
 	if err != nil {
 		return err
 	}
 	a.scope = sc
 
+	a.bindAliases(s.TargetList)
+
 	for _, item := range listItems(s.FromClause) {
 		if err := a.typeJoinConditions(item); err != nil {
 			return fmt.Errorf("join: %w", err)
@@ -110,6 +197,10 @@ func (a *analyzer) analyzeSelect(s *ast.SelectStmt) error {
 
 	targets := listItems(s.TargetList)
 	if targets == nil {
+		// A VALUES list produces rows without naming columns.
+		if s.ValuesLists != nil {
+			return a.typeValuesLists(s.ValuesLists)
+		}
 		return fmt.Errorf("select: empty target list")
 	}
 	a.columns = make([]core.Column, 0, len(targets))
@@ -125,6 +216,107 @@ func (a *analyzer) analyzeSelect(s *ast.SelectStmt) error {
 	return nil
 }
 
+func (a *analyzer) typeValuesLists(l *ast.List) error {
+	for _, row := range listItems(l) {
+		if _, err := a.typeExpr(row); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// analyzeSetOperation types both sides of UNION, INTERSECT or EXCEPT and
+// reports the first branch's columns, the way the databases name the result.
+func (a *analyzer) analyzeSetOperation(s *ast.SelectStmt) error {
+	left, err := a.subquery(s.Larg)
+	if err != nil {
+		return err
+	}
+	if _, err := a.subquery(s.Rarg); err != nil {
+		return err
+	}
+	a.columns = left.columns
+	a.scope = left.scope
+	return nil
+}
+
+// bindCTEs analyzes a WITH clause, making each common table expression
+// available to the query as a relation.
+func (a *analyzer) bindCTEs(with *ast.WithClause) error {
+	if with == nil {
+		return nil
+	}
+	for _, item := range listItems(with.Ctes) {
+		cte, ok := item.(*ast.CommonTableExpr)
+		if !ok || cte.Ctename == nil {
+			continue
+		}
+		sel, ok := cte.Ctequery.(*ast.SelectStmt)
+		if !ok {
+			continue
+		}
+		cols, err := a.subqueryColumns(sel)
+		if err != nil {
+			return fmt.Errorf("with %s: %w", *cte.Ctename, err)
+		}
+		rel := derivedRel(*cte.Ctename, cols)
+		renameColumns(&rel, cte.Aliascolnames)
+		if a.ctes == nil {
+			a.ctes = map[string]scopeRel{}
+		}
+		a.ctes[*cte.Ctename] = rel
+	}
+	return nil
+}
+
+// bindAliases records the output names the target list assigns, so a later
+// clause can refer to a result column by name.
+func (a *analyzer) bindAliases(targets *ast.List) {
+	for _, item := range listItems(targets) {
+		rt, ok := item.(*ast.ResTarget)
+		if !ok || rt.Name == nil || *rt.Name == "" {
+			continue
+		}
+		if a.aliases == nil {
+			a.aliases = map[string]ast.Node{}
+		}
+		a.aliases[*rt.Name] = rt.Val
+	}
+}
+
+// typeAlias types the expression an output name stands for, which is how a
+// GROUP BY or HAVING clause refers to a result column.
+func (a *analyzer) typeAlias(name string) (exprType, bool, error) {
+	val, ok := a.aliases[name]
+	if !ok || a.resolving[name] {
+		return exprType{}, false, nil
+	}
+	if a.resolving == nil {
+		a.resolving = map[string]bool{}
+	}
+	a.resolving[name] = true
+	defer delete(a.resolving, name)
+
+	t, err := a.typeExpr(val)
+	if err != nil {
+		return exprType{}, false, err
+	}
+	return t, true, nil
+}
+
+// renameColumns applies the column aliases a derived relation was declared
+// with, as in "WITH t(a, b) AS (...)".
+func renameColumns(rel *scopeRel, names *ast.List) {
+	for i, item := range listItems(names) {
+		if i >= len(rel.cols) {
+			break
+		}
+		if s, ok := item.(*ast.String); ok && s.Str != "" {
+			rel.cols[i].Name = s.Str
+		}
+	}
+}
+
 func listItems(l *ast.List) []ast.Node {
 	if l == nil {
 		return nil