core: answer the second review: qualified keys, nested lookups, rewrites after aliases

An instance row's key is built from namespace-qualified names, so
array(myschema.mood) and array(mood) are two rows, and a lookup that may
not write still canonicalizes an expression whose nested instance is not
a row, so $1::varchar(10)[] reports array(character varying(10)). The
array family is seeded for every dialect rather than created on a
read-only lookup. A rewrite is tried with the alias resolved, so dec(7,2)
meets a rule on decimal. A bare CREATE TYPE lands in the dialect's
default schema, so SQL Server's Code and dbo.Code are one row.

A family in types.jsonl may name a base, which is how MySQL's unsigned
families stand on their signed ones; the legacy bridge strips " unsigned"
from the data type and sets the flag. Relations() carries one array
dimension for an array column.

Converters: a PostgreSQL cast to interval day to second decodes the field
mask as a column does; a MySQL cast to float or double carries no
modifier and a decimal cast's scale left out is 0; DuckDB's main schema
no longer leaves a leading dot; ClickHouse's LowCardinality(Nullable(T))
is a nullable column, read as a nullable lowcardinality(T) by the
converter and by goldeneye alike.

goldeneye keeps the case of a MySQL enum's members and unescapes them,
and relabels only the _-prefixed PostgreSQL array types, so int2vector
and oidvector stay their own; the relation seeds and the goldens they
feed are regenerated. The analyze_types cases cover each fix.

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

Author: claude

internal/compiler/catalog_core.go

@@ -42,7 +42,7 @@ func coreResultCatalog(c *core.Catalog) (*catalog.Catalog, error) {
 				inner := expr.Innermost()
 				column := &catalog.Column{
 					Name:       col.Name,
-					Type:       ast.TypeName{Name: inner.Name},
+					Type:       ast.TypeName{Name: strings.TrimSuffix(inner.Name, " unsigned")},
 					IsNotNull:  col.NotNull,
 					IsArray:    expr.IsArray(),
 					ArrayDims:  expr.ArrayDims(),

internal/core/analyzer/expr.go

@@ -575,7 +575,10 @@ func (a *analyzer) typeNameOf(t exprType) (string, bool) {
 	if e == nil {
 		return "", false
 	}
-	return e.Innermost().Name, e.IsArray()
+	// MySQL's unsigned families are their own types, but codegen reads
+	// the signed family and an unsigned flag, which the bridge derives
+	// from the expression.
+	return strings.TrimSuffix(e.Innermost().Name, " unsigned"), e.IsArray()
 }
 
 // columnExprType is the type a result column of a nested query has, as an

internal/core/rewrite.go

@@ -213,13 +213,33 @@ func (c *Catalog) userTypeBase(name string) (int64, error) {
 
 // canonicalize applies the dialect's identifier settings and rewrites to
 // an expression: the first rewrite whose pattern matches is applied, and
-// its result is not rewritten again.
+// its result is not rewritten again. A rewrite names a family as the
+// dialect spells it, so an expression spelled with an alias — dec(10) for
+// a rule on decimal — is tried again with the alias resolved.
 func (c *Catalog) canonicalize(t *TypeExpr) (*TypeExpr, error) {
 	r, err := c.loadRules()
 	if err != nil {
 		return nil, err
 	}
 	t = r.identify(t)
+	if len(r.rewrites) == 0 {
+		return t, nil
+	}
+	if out, ok := r.rewrite(t); ok {
+		return out, nil
+	}
+	if canonical, ok := c.canonicalFamilyName(t.Name); ok && !strings.EqualFold(canonical, t.Name) {
+		resolved := t.Clone()
+		resolved.Name = canonical
+		if out, ok := r.rewrite(resolved); ok {
+			return out, nil
+		}
+	}
+	return t, nil
+}
+
+// rewrite applies the first rewrite whose pattern matches the expression.
+func (r *rules) rewrite(t *TypeExpr) (*TypeExpr, bool) {
 	name := strings.ToLower(t.Name)
 	for _, rw := range r.rewrites {
 		if strings.ToLower(rw.pattern.Name) != name || len(rw.pattern.Args) != len(t.Args) {
@@ -231,9 +251,26 @@ func (c *Catalog) canonicalize(t *TypeExpr) (*TypeExpr, error) {
 		}
 		out := substitute(rw.template, bindings)
 		out.Nullable = t.Nullable
-		return out, nil
+		return out, true
 	}
-	return t, nil
+	return nil, false
+}
+
+// canonicalFamilyName is the name the catalog spells a family by, with
+// aliases resolved, or false when the name is not a family it holds.
+func (c *Catalog) canonicalFamilyName(name string) (string, bool) {
+	oid, err := c.familyOIDByQualifiedName(strings.ToLower(strings.TrimSpace(name)))
+	if err != nil {
+		return "", false
+	}
+	if oid, err = c.canonicalOID(oid); err != nil {
+		return "", false
+	}
+	info, err := c.LookupType(oid)
+	if err != nil {
+		return "", false
+	}
+	return c.qualifiedName(info), true
 }
 
 // identify turns the bare words the dialect calls identifiers into

internal/core/seed/seed.go

@@ -162,6 +162,10 @@ type Type struct {
 	Name     string   `json:"name"`
 	Category string   `json:"category"`
 	Aliases  []string `json:"aliases,omitempty"`
+	// Base names the family this one stands on, which must be listed
+	// before it: MySQL's bigint unsigned is a type of its own that
+	// resolves as a bigint where nothing takes it as itself.
+	Base string `json:"base,omitempty"`
 }
 
 // Operator is a single operator overload.
@@ -305,6 +309,11 @@ func apply(cat *core.Catalog, fsys fs.FS, settings Settings) error {
 	if err := stream(fsys, TypesFile, b.addType); err != nil {
 		return err
 	}
+	// Every dialect has arrays, whether or not its list names the family,
+	// and a lookup of one against the cached catalog cannot add it then.
+	if _, err := b.createType(core.ArrayTypeName, "A", 0); err != nil {
+		return err
+	}
 	if err := b.consts(); err != nil {
 		return err
 	}
@@ -439,6 +448,9 @@ func Relations(fsys fs.FS, dir, schema string) ([]*catalog.Table, error) {
 				IsNotNull: col.NotNull,
 				IsArray:   col.Array,
 			}
+			if col.Array {
+				column.ArrayDims = 1
+			}
 			if col.Length > 0 {
 				length := col.Length
 				column.Length = &length
@@ -513,7 +525,15 @@ type categorized struct {
 }
 
 func (b *builder) addType(t Type) error {
-	oid, err := b.createType(t.Name, t.Category)
+	var baseOID int64
+	if t.Base != "" {
+		oid, ok := b.oids[strings.ToLower(t.Base)]
+		if !ok {
+			return fmt.Errorf("type %q: base %q is not a type listed before it", t.Name, t.Base)
+		}
+		baseOID = oid
+	}
+	oid, err := b.createType(t.Name, t.Category, baseOID)
 	if err != nil {
 		return fmt.Errorf("type %q: %w", t.Name, err)
 	}
@@ -553,7 +573,7 @@ func (b *builder) addAlias(name string, typeOID int64, category string) error {
 	return nil
 }
 
-func (b *builder) createType(name, category string) (int64, error) {
+func (b *builder) createType(name, category string, baseOID int64) (int64, error) {
 	key := strings.ToLower(name)
 	if oid, ok := b.oids[key]; ok {
 		return oid, nil
@@ -562,6 +582,7 @@ func (b *builder) createType(name, category string) (int64, error) {
 		Name:       key,
 		Typtype:    "b",
 		Category:   category,
+		BaseOID:    baseOID,
 		DialectOID: b.dialectOID,
 	})
 	if err != nil {

internal/core/types.go

@@ -362,11 +362,18 @@ func splitQualifiedName(name string) (ns, bare string) {
 }
 
 // declaredTypeNamespace is the namespace a declared type's row goes in: the
-// one its name qualifies, created if the schema has not, or the default.
+// one its name qualifies, created if the schema has not, or the dialect's
+// default schema — dbo, main — so that a bare CREATE TYPE and a qualified
+// reference to it name one row.
 func (c *Catalog) declaredTypeNamespace(name string) (int64, string, error) {
 	ns, bare := splitQualifiedName(name)
 	if ns == "" {
-		return 0, bare, nil
+		if c.dialectOID != 0 {
+			ns, _ = c.DialectFlag(c.dialectOID, FlagDefaultSchema)
+		}
+		if ns == "" {
+			return 0, bare, nil
+		}
 	}
 	oid, err := c.NamespaceOID(ns)
 	if err != nil {
@@ -551,12 +558,7 @@ func (c *Catalog) TypeExprOf(oid int64) (*TypeExpr, error) {
 	if err != nil {
 		return nil, err
 	}
-	expr := &TypeExpr{Name: info.Name}
-	// A type outside the default namespaces is named with its namespace,
-	// as format_type prints a type off the search path.
-	if ns, err := c.namespaceName(info.NamespaceOID); err == nil && ns != "" && !slices.Contains(c.DefaultNamespaces(), ns) {
-		expr.Name = ns + "." + info.Name
-	}
+	expr := &TypeExpr{Name: c.qualifiedName(info)}
 	if !info.IsFamily() {
 		rows, err := c.q.TypeArgs(context.Background(), oid)
 		if err != nil {
@@ -592,6 +594,18 @@ func (c *Catalog) TypeExprOf(oid int64) (*TypeExpr, error) {
 	return expr.Clone(), nil
 }
 
+// qualifiedName is the name a type row is known by in an expression: its
+// name, qualified with its namespace when that is not one of the dialect's
+// defaults, as format_type prints a type off the search path. An
+// instance's key is built from these, so the array of one schema's mood is
+// a row apart from the array of another's.
+func (c *Catalog) qualifiedName(info TypeInfo) string {
+	if ns, err := c.namespaceName(info.NamespaceOID); err == nil && ns != "" && !slices.Contains(c.DefaultNamespaces(), ns) {
+		return ns + "." + info.Name
+	}
+	return info.Name
+}
+
 // ResolveTypeExpr interns the type an expression names and returns its row:
 // the family for a bare name, the instance for a family applied to
 // arguments, each argument type interned first. Names are canonicalized, so
@@ -680,7 +694,7 @@ func (c *Catalog) internType(t *TypeExpr, newFamily func(name string) (int64, er
 	name := strings.ToLower(strings.TrimSpace(t.Name))
 	familyOID, err := c.familyOIDByQualifiedName(name)
 	if err != nil {
-		if name == ArrayTypeName {
+		if name == ArrayTypeName && write {
 			// Every dialect has arrays, whether or not its seed lists the
 			// family; one that does not gets it as an array type rather
 			// than a user type.
@@ -700,27 +714,36 @@ func (c *Catalog) internType(t *TypeExpr, newFamily func(name string) (int64, er
 		return 0, nil, err
 	}
 	if len(t.Args) == 0 {
-		return familyOID, &TypeExpr{Name: family.Name}, nil
+		return familyOID, &TypeExpr{Name: c.qualifiedName(family)}, nil
 	}
 
 	// The instance's canonical spelling is the family applied to its
 	// arguments as the catalog spells them, so each argument type is
-	// resolved first and read back.
-	canonical := &TypeExpr{Name: family.Name, Args: make([]TypeArg, len(t.Args))}
+	// resolved first and read back. An argument whose own instance is not
+	// a row, in a lookup that may not write, still has a canonical
+	// spelling, which the whole expression's is built from.
+	canonical := &TypeExpr{Name: c.qualifiedName(family), Args: make([]TypeArg, len(t.Args))}
 	argOIDs := make([]int64, len(t.Args))
+	unknown := false
 	for i, a := range t.Args {
 		canonical.Args[i] = a
 		if a.Type == nil {
 			continue
 		}
 		oid, argExpr, err := c.internType(a.Type, newFamily, write)
 		if err != nil {
-			return 0, nil, err
+			if !errors.Is(err, errUnknownType) || argExpr == nil {
+				return 0, nil, err
+			}
+			unknown = true
 		}
 		argOIDs[i] = oid
 		argExpr.Nullable = a.Type.Nullable
 		canonical.Args[i].Type = argExpr
 	}
+	if unknown {
+		return 0, canonical, errUnknownType
+	}
 	key := canonical.Key()
 	ctx := context.Background()
 	if oid, err := c.q.TypeOIDByExprInNamespace(ctx, catalogdb.TypeOIDByExprInNamespaceParams{

internal/core/types.md

@@ -658,7 +658,9 @@ and details settled on the way:
   `float($1)` to `real` where `$1 <= 24`, `decimal` to `decimal(18, 0)`,
   `Decimal32($1)` to `Decimal(9, $1)`, `sysname` to `nvarchar(128)` — which
   the seed loads into `sql_type_rewrite` and the catalog applies before
-  interning, first match winning; `idents` and `ident_args`, the words and
+  interning, first match winning, tried once with the name as spelled and
+  once with its alias resolved so that `dec` meets a rule on `decimal`;
+  `idents` and `ident_args`, the words and
   argument positions that are identifiers rather than types, kept as dialect
   flags; and `affinity`, SQLite's ordered rule for a family the seed does
   not list, loaded into `sql_type_affinity` and asked when a schema
@@ -672,7 +674,22 @@ and details settled on the way:
 - A bare type name resolves in the default namespaces only — the catalog's
   own, `pg_catalog` and the dialect's default schema — and `CREATE TYPE`
   deduplicates within the namespace it names, so `foo.mood` and `mood` are
-  two types and a bare `mood` never binds to `foo.mood`.
+  two types and a bare `mood` never binds to `foo.mood`. A bare `CREATE
+  TYPE` lands in the dialect's default schema when it has one, so SQL
+  Server's `PhoneNumber` and `dbo.PhoneNumber` are one row. A type outside
+  the default namespaces is spelled with its namespace wherever the catalog
+  spells it, including inside an instance's key, so `array(foo.mood)` and
+  `array(mood)` are two rows.
+- A lookup that may not write — the analyzer's, against the cached catalog
+  — still canonicalizes an expression whose instance is not a row, however
+  deep the missing instance sits, so `$1::varchar(10)[]` reports
+  `array(character varying(10))` against the `array` family. The seed
+  gives every dialect the `array` family for that reason, whether or not
+  its `types.jsonl` lists it.
+- A family in `types.jsonl` may name a `base` listed before it, which is
+  how MySQL's unsigned families stand on their signed ones: `bigint
+  unsigned` is a type of its own, and resolves as a `bigint` where nothing
+  takes it as itself.
 - SQLite's `dialect.json` says `"alias": "base"`, which makes each alias in
   its `types.jsonl` a type of its own standing on the type it aliases,
   rather than another spelling of it.
@@ -690,7 +707,13 @@ and details settled on the way:
   placeholder gives itself.
 - A cast is NULL when its operand is, or when its type says so, as
   `Nullable(String)` does; a cast of a placeholder types the placeholder
-  and takes its name and source from what it is compared with.
+  and takes its name and source from what it is compared with. A cast to
+  `interval day to second` decodes the field mask the parser reports the
+  way a column definition does.
+- ClickHouse's `LowCardinality(Nullable(T))`, the only order it accepts,
+  is a nullable column, and the converter and `goldeneye` both read it as
+  `lowcardinality(T)` with the nullability on the outside, where the
+  column's nullability lives.
 - MySQL types `CAST(x AS CHAR(10))` as `varchar(10)` and `CAST(x AS
   BINARY(8))` as `varbinary(8)`, which is what its metadata and a view over
   the cast both report, rather than the `char(10)` the table above
@@ -705,7 +728,10 @@ and details settled on the way:
   not its labels, since the canonicalizer cannot see the catalog. A
   GoogleSQL array or struct constructor in a select list is still untyped.
 - PostgreSQL's `relations.jsonl` spells an array column as its element with
-  the array flag, which `goldeneye` now writes from `typelem`.
+  the array flag, which `goldeneye` now writes from `typelem` for the
+  `_`-prefixed array types alone; `int2vector` and `oidvector` share the
+  array category but stay types of their own. MySQL's keeps the case of an
+  enum's members, which are values.
 
 ## Order of work
 

internal/endtoend/testdata/analyze_system_catalog/mysql/stdout.json

@@ -75,13 +75,13 @@
             "name": "enum",
             "args": [
               {
-                "string": "base table"
+                "string": "BASE TABLE"
               },
               {
-                "string": "view"
+                "string": "VIEW"
               },
               {
-                "string": "system view"
+                "string": "SYSTEM VIEW"
               }
             ]
           },

internal/endtoend/testdata/analyze_types/clickhouse/stdout.json

@@ -86,11 +86,11 @@
         "name": "kind",
         "type": {
           "name": "lowcardinality",
+          "nullable": true,
           "args": [
             {
               "type": {
-                "name": "string",
-                "nullable": true
+                "name": "string"
               }
             }
           ]
@@ -456,11 +456,11 @@
         "name": "kind",
         "type": {
           "name": "lowcardinality",
+          "nullable": true,
           "args": [
             {
               "type": {
-                "name": "string",
-                "nullable": true
+                "name": "string"
               }
             }
           ]

internal/endtoend/testdata/analyze_types/duckdb/query.sql

@@ -9,7 +9,8 @@ SELECT
   $4::mood AS d,
   CAST($5 AS VARCHAR(5)) AS e,
   $6::MAP(VARCHAR, INTEGER) AS f,
-  $7::INTEGER[3] AS g
+  $7::INTEGER[3] AS g,
+  $8::main.mood AS h
 FROM things;
 
 -- name: Params :one

internal/endtoend/testdata/analyze_types/duckdb/schema.sql

@@ -11,6 +11,7 @@ CREATE TABLE things (
   title VARCHAR(10),
   kind ENUM('a','b'),
   m mood,
+  mm main.mood,
   big HUGEINT,
   ubig UHUGEINT,
   data BLOB,