core: carry enum types through the analysis core to codegen

The core catalog created an enum type on CREATE TYPE ... AS ENUM but kept
none of its labels, and the dump that hands the catalog to codegen carried
relations only. Under SQLCEXPERIMENT=coreanalyzer every enum was missing
from models.go, PostgreSQL enum columns were typed any and MySQL ENUM
columns string.

The catalog now stores enum labels (sql_enum_label, modeled on pg_enum)
and the schema package applies the statements that change them: ALTER TYPE
ADD VALUE (with BEFORE/AFTER and IF NOT EXISTS), RENAME VALUE, RENAME TO,
SET SCHEMA, and DROP TYPE. A MySQL ENUM or SET column declares an enum of
its own, named <table>_<column> as the legacy catalog names it; it follows
the column and the table through renames, is replaced on MODIFY, and goes
with a dropped column or table. The dump adds each enum to its schema so
codegen builds the same Go types either way a query set was analyzed.

Type names now keep the schema an engine reports on the TypeName itself
and drop a spelled-out "public.", so foo.mood and public.status resolve
the way their column references do.

In the core replay context 46 more cases pass, with no case regressing.

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

Author: claude

internal/compiler/catalog_core.go

@@ -10,17 +10,19 @@ import (
 
 // 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.
+// set was analyzed. Relations and enums make the trip: codegen reads tables
+// and their columns to build models and enums to build their Go types, and
+// none of the 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
 	}
+	schemas := map[string]*catalog.Schema{}
 	for _, ns := range namespaces {
 		schema := &catalog.Schema{Name: ns.Name}
+		schemas[ns.Name] = schema
 		tables, err := c.TablesInNamespace(ns.OID)
 		if err != nil {
 			return nil, err
@@ -52,5 +54,29 @@ func coreResultCatalog(c *core.Catalog) (*catalog.Catalog, error) {
 		}
 		cat.Schemas = append(cat.Schemas, schema)
 	}
+
+	// The catalog spells an enum's schema in its name, and a schema that
+	// holds only types has no namespace of its own, so one is made here.
+	enums, err := c.Enums()
+	if err != nil {
+		return nil, err
+	}
+	for _, enum := range enums {
+		labels, err := c.EnumLabels(enum.OID)
+		if err != nil {
+			return nil, err
+		}
+		schemaName, name := core.SplitTypeName(enum.Name)
+		if schemaName == "" {
+			schemaName = cat.DefaultSchema
+		}
+		schema, ok := schemas[schemaName]
+		if !ok {
+			schema = &catalog.Schema{Name: schemaName}
+			schemas[schemaName] = schema
+			cat.Schemas = append(cat.Schemas, schema)
+		}
+		schema.Types = append(schema.Types, &catalog.Enum{Name: name, Vals: labels})
+	}
 	return cat, nil
 }

internal/core/catalogdb/models.go

@@ -67,6 +67,26 @@ SELECT oid, name, category, typtype, preferred
 FROM sql_type
 WHERE oid = ?;
 
+-- name: ListEnumTypes :many
+SELECT oid, name FROM sql_type
+WHERE typtype = 'e'
+ORDER BY oid;
+
+-- name: RenameType :exec
+UPDATE sql_type SET name = sqlc.arg(name) WHERE oid = sqlc.arg(oid);
+
+-- name: DeleteType :exec
+DELETE FROM sql_type WHERE oid = ?;
+
+-- name: CreateEnumLabel :exec
+INSERT INTO sql_enum_label (type_oid, ord, label) VALUES (?, ?, ?);
+
+-- name: ListEnumLabels :many
+SELECT label FROM sql_enum_label WHERE type_oid = ? ORDER BY ord;
+
+-- name: DeleteEnumLabels :exec
+DELETE FROM sql_enum_label WHERE type_oid = ?;
+
 -- =============================== sql_class =============================
 
 -- name: CreateClass :execlastid

internal/core/catalogdb/query.sql.go

@@ -41,6 +41,16 @@ CREATE TABLE sql_type (
 );
 CREATE INDEX idx_sql_type_name ON sql_type(name);
 
+-- sql_enum_label: the labels of an enum type, in declaration order.
+--   Modeled on pg_enum. A MySQL ENUM or SET column declares one of these
+--   for the column alone, under the name the legacy catalog gives it.
+CREATE TABLE sql_enum_label (
+    type_oid INTEGER NOT NULL REFERENCES sql_type(oid),
+    ord      INTEGER NOT NULL,
+    label    TEXT NOT NULL,
+    PRIMARY KEY (type_oid, ord)
+);
+
 -- sql_class: relations (tables, views, indexes).
 --   kind: 'r' = table, 'v' = view, 'i' = index, 'c' = composite type, 'f' = foreign
 CREATE TABLE sql_class (

internal/core/catalogdef/query.sql

@@ -0,0 +1,105 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/sqlc-dev/sqlc/internal/core/catalogdb"
+)
+
+// EnumInfo describes an enum type the schema declared.
+type EnumInfo struct {
+	OID int64
+	// Name is the name the catalog stores, which carries the schema when the
+	// type was declared with one ("foo.mood").
+	Name string
+}
+
+// CreateEnumType registers an enum type with its labels in declaration order.
+func (c *Catalog) CreateEnumType(name string, labels []string) (int64, error) {
+	oid, err := c.CreateUserType(name, "E")
+	if err != nil {
+		return 0, err
+	}
+	if err := c.SetEnumLabels(oid, labels); err != nil {
+		return 0, err
+	}
+	return oid, nil
+}
+
+// EnumLabels returns an enum type's labels in declaration order.
+func (c *Catalog) EnumLabels(oid int64) ([]string, error) {
+	labels, err := c.q.ListEnumLabels(context.Background(), oid)
+	if err != nil {
+		return nil, fmt.Errorf("enum labels of type oid %d: %w", oid, err)
+	}
+	return labels, nil
+}
+
+// SetEnumLabels replaces an enum type's labels.
+func (c *Catalog) SetEnumLabels(oid int64, labels []string) error {
+	ctx := context.Background()
+	if err := c.q.DeleteEnumLabels(ctx, oid); err != nil {
+		return fmt.Errorf("enum labels of type oid %d: %w", oid, err)
+	}
+	for i, label := range labels {
+		if err := c.q.CreateEnumLabel(ctx, catalogdb.CreateEnumLabelParams{TypeOid: oid, Ord: int64(i + 1), Label: label}); err != nil {
+			return fmt.Errorf("enum label %q of type oid %d: %w", label, oid, err)
+		}
+	}
+	return nil
+}
+
+// Enums lists the enum types the schema declared, in declaration order.
+func (c *Catalog) Enums() ([]EnumInfo, error) {
+	rows, err := c.q.ListEnumTypes(context.Background())
+	if err != nil {
+		return nil, fmt.Errorf("list enum types: %w", err)
+	}
+	out := make([]EnumInfo, 0, len(rows))
+	for _, r := range rows {
+		out = append(out, EnumInfo{OID: r.Oid, Name: r.Name})
+	}
+	return out, nil
+}
+
+// RenameType gives a type a new name. Columns refer to the type by OID, so
+// they follow the rename.
+func (c *Catalog) RenameType(oid int64, name string) error {
+	if err := c.q.RenameType(context.Background(), catalogdb.RenameTypeParams{Oid: oid, Name: strings.ToLower(name)}); err != nil {
+		return fmt.Errorf("rename type oid %d to %q: %w", oid, name, err)
+	}
+	return nil
+}
+
+// DropType removes a type and, when it is an enum, its labels.
+func (c *Catalog) DropType(oid int64) error {
+	ctx := context.Background()
+	if err := c.q.DeleteEnumLabels(ctx, oid); err != nil {
+		return fmt.Errorf("drop type oid %d: %w", oid, err)
+	}
+	if err := c.q.DeleteType(ctx, oid); err != nil {
+		return fmt.Errorf("drop type oid %d: %w", oid, err)
+	}
+	return nil
+}
+
+// SplitTypeName separates the schema a type name carries from the name
+// itself: "foo.mood" is the type mood in schema foo, and a bare name is in
+// the default schema.
+func SplitTypeName(name string) (schema, typ string) {
+	if i := strings.LastIndex(name, "."); i >= 0 {
+		return name[:i], name[i+1:]
+	}
+	return "", name
+}
+
+// JoinTypeName is the inverse of SplitTypeName: the name the catalog stores
+// for a type in a schema. The default schema is not spelled.
+func JoinTypeName(schema, typ string) string {
+	if schema == "" || schema == "public" {
+		return typ
+	}
+	return schema + "." + typ
+}