Add coreanalyzer experiment routing generate through the analysis core

SQLCEXPERIMENT=coreanalyzer builds each query set's compiler with
WithCoreAnalysis, the same path sqlc analyze and the ClickHouse and
GoogleSQL engines already use. The experiment now actually reaches the
compiler: processQuerySets threads it into the parser options, which
were previously always empty.

Generating through the core also needs a catalog for codegen to build
models from, which the core path never carried: its Result held a nil
catalog that pluginCatalog would dereference. The core catalog is now
dumped into the legacy catalog shape after the schema is applied. Array
columns additionally set ArrayDims, which codegen renders a [] per, so
they come out as slices rather than silently losing their array-ness.

An end-to-end case pins the generated output for postgresql, sqlite and
mysql.

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

Author: claude

docs/reference/environment-variables.md

@@ -14,8 +14,26 @@ SQLCEXPERIMENT=nofoo        # explicitly disable foo experiment
 SQLCEXPERIMENT=foo,nobar    # enable foo, disable bar
 ```
 
-Currently, no experiments are defined. Experiments will be documented here as
-they are introduced.
+The following experiments are defined:
+
+### analyzerv2
+
+Enables the database-only analyzer mode (`analyzer.database: only`), which uses
+the database for all type resolution instead of parsing schema files.
+
+```
+SQLCEXPERIMENT=analyzerv2
+```
+
+### coreanalyzer
+
+Routes `sqlc generate` through the core catalog and analyzer instead of each
+engine's own analysis path. This is the same analysis used by `sqlc analyze`,
+and the only analysis path for the ClickHouse and GoogleSQL engines.
+
+```
+SQLCEXPERIMENT=coreanalyzer
+```
 
 ## SQLCCACHE
 

internal/cmd/generate.go

@@ -254,7 +254,11 @@ func (g *generator) ProcessResult(ctx context.Context, combo config.CombinedSett
 
 func parse(ctx context.Context, name, dir string, sql config.SQL, combo config.CombinedSettings, parserOpts opts.Parser, stderr io.Writer) (*compiler.Result, bool) {
 	defer trace.StartRegion(ctx, "parse").End()
-	c, err := compiler.NewCompiler(sql, combo, parserOpts)
+	var copts []compiler.Option
+	if parserOpts.Experiment.CoreAnalyzer {
+		copts = append(copts, compiler.WithCoreAnalysis())
+	}
+	c, err := compiler.NewCompiler(sql, combo, parserOpts, copts...)
 	defer func() {
 		if c != nil {
 			c.Close(ctx)

internal/cmd/process.go

@@ -86,7 +86,15 @@ func processQuerySets(ctx context.Context, rp ResultProcessor, conf *config.Conf
 			sql.Queries = joined
 
 			var name, lang string
-			parseOpts := opts.Parser{}
+			parseOpts := opts.Parser{
+				// Only the coreanalyzer experiment reaches the compiler.
+				// analyzerv2 is intentionally left behind: the goldens of the
+				// tests that name it predate this wiring and pin the ordinary
+				// analyzer path.
+				Experiment: opts.Experiment{
+					CoreAnalyzer: o.Env.Experiment.CoreAnalyzer,
+				},
+			}
 
 			switch {
 			case sql.Gen.Go != nil:

internal/compiler/catalog_core.go

@@ -0,0 +1,56 @@
+package compiler
+
+import (
+	"strings"
+
+	"github.com/sqlc-dev/sqlc/internal/core"
+	"github.com/sqlc-dev/sqlc/internal/sql/ast"
+	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
+)
+
+// coreResultCatalog dumps the core catalog into the legacy catalog shape a
+// Result carries, so codegen sees the same table models either way a query
+// set was analyzed. Only relations make the trip: codegen reads tables and
+// their columns to build models, and none of the types, functions or
+// operators the core catalog also holds.
+func coreResultCatalog(c *core.Catalog) (*catalog.Catalog, error) {
+	cat := catalog.New("public")
+	namespaces, err := c.Namespaces()
+	if err != nil {
+		return nil, err
+	}
+	for _, ns := range namespaces {
+		schema := &catalog.Schema{Name: ns.Name}
+		tables, err := c.TablesInNamespace(ns.OID)
+		if err != nil {
+			return nil, err
+		}
+		for _, table := range tables {
+			cols, err := c.ClassCodegenColumns(table.OID)
+			if err != nil {
+				return nil, err
+			}
+			t := &catalog.Table{Rel: &ast.TableName{Schema: ns.Name, Name: table.Name}}
+			for _, col := range cols {
+				// The catalog names an array type after its element with the
+				// suffix appended, which is codegen's data type and array
+				// flag in one string. The core catalog holds one dimension,
+				// and codegen renders a "[]" per dimension.
+				dataType, isArray := strings.CutSuffix(col.TypeName, core.ArraySuffix)
+				column := &catalog.Column{
+					Name:      col.Name,
+					Type:      ast.TypeName{Name: dataType},
+					IsNotNull: col.NotNull,
+					IsArray:   isArray,
+				}
+				if isArray {
+					column.ArrayDims = 1
+				}
+				t.Columns = append(t.Columns, column)
+			}
+			schema.Tables = append(schema.Tables, t)
+		}
+		cat.Schemas = append(cat.Schemas, schema)
+	}
+	return cat, nil
+}

internal/compiler/compile.go

@@ -150,6 +150,13 @@ func (c *Compiler) parseCatalogCore(files []schemaFile, merr *multierr.Error) er
 	}
 	// Whatever apply reported is already in merr, which the caller returns.
 	c.coreCatalog = cat
+
+	// Codegen consumes the catalog through the Result, in the legacy shape.
+	legacy, err := coreResultCatalog(cat)
+	if err != nil {
+		return fmt.Errorf("%s: dump catalog: %w", c.conf.Engine, err)
+	}
+	c.catalog = legacy
 	return nil
 }
 

internal/compiler/parse_core.go

@@ -94,6 +94,11 @@ func coreColumn(c core.Column) *Column {
 		NotNull:  c.NotNull,
 		IsArray:  c.IsArray,
 	}
+	// The core reports arrays without dimensions, and codegen renders one
+	// "[]" per dimension.
+	if c.IsArray {
+		col.ArrayDims = 1
+	}
 	if c.Source != nil && c.Source.Table != "" {
 		col.Table = &ast.TableName{Schema: c.Source.Schema, Name: c.Source.Table}
 		col.TableAlias = c.Source.TableAlias
@@ -113,6 +118,9 @@ func coreParamColumn(p core.Parameter, params *named.ParamSet) *Column {
 		NotNull:  p.NotNull,
 		IsArray:  p.IsArray,
 	}
+	if p.IsArray {
+		col.ArrayDims = 1
+	}
 	if p.Source != nil && p.Source.Table != "" {
 		col.Table = &ast.TableName{Schema: p.Source.Schema, Name: p.Source.Table}
 		col.OriginalName = p.Source.Column

internal/endtoend/testdata/experiment_coreanalyzer/mysql/exec.json

@@ -0,0 +1,6 @@
+{
+  "command": "generate",
+  "env": {
+    "SQLCEXPERIMENT": "coreanalyzer"
+  }
+}