core/analyzer: analyze without writing to the catalog

A cast to a type the catalog did not hold, and an array expression whose
array type it did not hold, registered the type before reporting it. That
made analysis a writer: the catalog a query was analyzed against depended
on which queries had been analyzed before it, and a query could quietly
define a type.

An expression's type now carries the name the query used when the catalog
has no such type, so the same result is reported without inserting
anything. Nothing in the analyzer calls a catalog mutator any more.

Seeding is deterministic to match: the constant types were written in map
order, so building the same catalog twice produced two byte-different
databases and the cache stored one copy per run instead of one per catalog.

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

Author: claude

internal/core/analyzer/analyzer.go

@@ -2,7 +2,6 @@ package analyzer
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
@@ -43,23 +42,6 @@ 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

internal/core/analyzer/expr.go

@@ -9,7 +9,12 @@ import (
 )
 
 type exprType struct {
-	typeOID            int64
+	typeOID int64
+	// typeName names a type the catalog does not hold — a cast to a type no
+	// dialect seeded and no schema declared, or an array of one. Analysis
+	// never adds a type: it reports the name the query used and carries on,
+	// so a query can be analyzed against a catalog it cannot write to.
+	typeName           string
 	nullable           bool
 	sourceClassOID     int64
 	sourceAttributeOID int64
@@ -202,9 +207,9 @@ func (a *analyzer) inferParam(number int, t exprType) {
 	if !ok {
 		cur = core.Parameter{Number: number}
 	}
-	if cur.TypeOID == 0 && t.typeOID != 0 {
+	if cur.TypeOID == 0 && cur.DataType == "" && (t.typeOID != 0 || t.typeName != "") {
 		cur.TypeOID = t.typeOID
-		cur.DataType, cur.IsArray = a.dataType(t.typeOID)
+		cur.DataType, cur.IsArray = a.typeNameOf(t)
 		cur.NotNull = !t.nullable
 	}
 	if cur.Source == nil && t.sourceAttributeOID != 0 {
@@ -413,22 +418,36 @@ func (a *analyzer) typeArrayExpr(e *ast.A_ArrayExpr) (exprType, error) {
 	if err != nil {
 		return exprType{}, err
 	}
-	if elemT.typeOID == 0 {
+	element, _ := a.typeNameOf(elemT)
+	if element == "" {
 		return exprType{}, nil
 	}
-	name, err := a.cat.TypeName(elemT.typeOID)
-	if err != nil {
-		return exprType{}, nil
+	return a.namedType(element + core.ArraySuffix), nil
+}
+
+// namedType is the type a name refers to, or the name itself when the catalog
+// has no such type.
+func (a *analyzer) namedType(name string) exprType {
+	if oid, err := a.cat.TypeOID(name); err == nil {
+		return exprType{typeOID: oid}
 	}
-	arrayName := name + core.ArraySuffix
-	oid, err := a.cat.TypeOID(arrayName)
-	if err != nil {
-		oid, err = a.cat.CreateArrayType(arrayName, elemT.typeOID)
-		if err != nil {
-			return exprType{}, err
+	return exprType{typeName: name}
+}
+
+// typeNameOf reports a type's name and whether it is an array of that name,
+// whether the type is one the catalog holds or one only the query named.
+func (a *analyzer) typeNameOf(t exprType) (string, bool) {
+	name := t.typeName
+	if t.typeOID != 0 {
+		var err error
+		if name, err = a.cat.TypeName(t.typeOID); err != nil {
+			return "", false
 		}
 	}
-	return exprType{typeOID: oid}, nil
+	if element, ok := strings.CutSuffix(name, core.ArraySuffix); ok {
+		return element, true
+	}
+	return name, false
 }
 
 // typeSubLink types a subquery used as an expression: EXISTS and IN yield a
@@ -497,7 +516,7 @@ func (a *analyzer) typeNullIf(e *ast.A_Expr) (exprType, error) {
 // placeholder that type.
 func (a *analyzer) typeOperands(n ast.Node, other exprType) error {
 	if pr, ok := n.(*ast.ParamRef); ok {
-		if other.typeOID != 0 {
+		if other.typeOID != 0 || other.typeName != "" {
 			a.inferParam(pr.Number, other)
 		}
 		return nil
@@ -710,13 +729,14 @@ func (a *analyzer) typeTypeCast(c *ast.TypeCast) (exprType, error) {
 	if c.TypeName == nil {
 		return exprType{}, fmt.Errorf("cast: missing target type")
 	}
-	oid, err := a.cat.ResolveType(c.TypeName)
-	if err != nil {
-		return exprType{}, fmt.Errorf("cast target %q: %w", core.TypeNameString(c.TypeName), err)
+	name := core.TypeNameString(c.TypeName)
+	if name == "" {
+		return exprType{}, fmt.Errorf("cast: missing target type")
 	}
+	t := a.namedType(name)
 	// A cast is how a query says what an otherwise untyped placeholder holds.
-	if err := a.typeOperands(c.Arg, exprType{typeOID: oid}); err != nil {
+	if err := a.typeOperands(c.Arg, t); err != nil {
 		return exprType{}, err
 	}
-	return exprType{typeOID: oid}, nil
+	return t, nil
 }

internal/core/analyzer/projection.go

@@ -30,7 +30,7 @@ func (a *analyzer) projectTarget(rt *ast.ResTarget) error {
 		SourceClassOID:     t.sourceClassOID,
 		SourceAttributeOID: t.sourceAttributeOID,
 	}
-	col.DataType, col.IsArray = a.dataType(t.typeOID)
+	col.DataType, col.IsArray = a.typeNameOf(t)
 	a.decorateSource(&col, t.sourceAttributeOID, t.sourceTableAlias)
 	a.columns = append(a.columns, col)
 	return nil
@@ -97,7 +97,7 @@ func (a *analyzer) emitStar(fields []string) {
 				SourceClassOID:     rel.classOID,
 				SourceAttributeOID: c.AttOID,
 			}
-			col.DataType, col.IsArray = a.dataType(c.TypeOID)
+			col.DataType, col.IsArray = a.typeNameOf(exprType{typeOID: c.TypeOID})
 			a.decorateSource(&col, c.AttOID, rel.alias)
 			a.columns = append(a.columns, col)
 		}

internal/core/seed/seed.go

@@ -414,11 +414,20 @@ func (b *builder) createType(name, category string) (int64, error) {
 var constKinds = []string{core.ConstInteger, core.ConstFloat, core.ConstString, core.ConstBool}
 
 func (b *builder) consts() error {
-	for kind, name := range b.settings.Const {
+	for kind := range b.settings.Const {
 		if !slices.Contains(constKinds, kind) {
 			return fmt.Errorf("seed %s: unknown constant kind %q, want one of %s",
 				b.settings.Dialect, kind, strings.Join(constKinds, ", "))
 		}
+	}
+	// Written in a fixed order rather than the map's: a catalog built from the
+	// same dialect twice has to come out byte for byte the same, so that the
+	// cache stores one copy of it rather than one per run.
+	for _, kind := range constKinds {
+		name, ok := b.settings.Const[kind]
+		if !ok {
+			continue
+		}
 		if _, ok := b.oids[strings.ToLower(name)]; !ok {
 			return fmt.Errorf("seed %s: constant %s names unknown type %q", b.settings.Dialect, kind, name)
 		}