core: answer the review: canonical type field, label parsing, namespaces, lookups

A type's canonical rendering now travels in its own field of ast.TypeName,
so DuckDB, GoogleSQL and ClickHouse hand the core struct(a: integer) and
Enum8('a' = 1) while the formatter keeps printing the author's spelling;
ParseTypeExpr reads a label before a colon, and before a space only when
one word follows, so a field typed timestamp with time zone keeps its
type. A lookup that may not write no longer probes by inserting an
empty-named row. A bare type name resolves in the default namespaces
only, and CREATE TYPE deduplicates within the namespace it names, so
foo.mood and mood are two types. IN with a subquery types its left side
once, and an operator's overloads are read once per resolution.

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

Author: claude

internal/core/analyzer/expr.go

@@ -405,8 +405,8 @@ func (a *analyzer) typeIn(e *ast.In) (exprType, error) {
 		if err != nil {
 			return exprType{}, err
 		}
-		if len(cols) > 0 {
-			if err := a.typeOperands(e.Expr, columnExprType(cols[0])); err != nil {
+		if pr, ok := e.Expr.(*ast.ParamRef); ok && len(cols) > 0 {
+			if err := a.typeOperands(pr, columnExprType(cols[0])); err != nil {
 				return exprType{}, err
 			}
 		}
@@ -705,24 +705,29 @@ func opNameFromList(l *ast.List) string {
 func (a *analyzer) resolveOperator(name string, leftT, rightT exprType) (core.OperatorOverload, error) {
 	leftChain := a.cat.ResolutionChain(leftT.typeOID)
 	rightChain := a.cat.ResolutionChain(rightT.typeOID)
+	all, err := a.cat.FindOperators(name, 0, 0)
+	if err != nil {
+		return core.OperatorOverload{}, err
+	}
+	// The operator's overloads are read once; the pairs along the two
+	// chains are tried against them in order, nearest first.
+	byOperands := make(map[[2]int64]core.OperatorOverload, len(all))
+	for _, ov := range all {
+		key := [2]int64{ov.LeftTypeOID, ov.RightTypeOID}
+		if _, seen := byOperands[key]; !seen {
+			byOperands[key] = ov
+		}
+	}
 	for _, l := range leftChain {
 		for _, r := range rightChain {
-			candidates, err := a.cat.FindOperators(name, l, r)
-			if err != nil {
-				return core.OperatorOverload{}, err
-			}
-			if len(candidates) > 0 {
-				return candidates[0], nil
+			if ov, ok := byOperands[[2]int64{l, r}]; ok && l != 0 && r != 0 {
+				return ov, nil
 			}
 		}
 	}
 	leftOID := leftChain[len(leftChain)-1]
 	rightOID := rightChain[len(rightChain)-1]
 
-	all, err := a.cat.FindOperators(name, 0, 0)
-	if err != nil {
-		return core.OperatorOverload{}, err
-	}
 	for _, ov := range all {
 		if leftOID != 0 && ov.LeftTypeOID != 0 && leftOID != ov.LeftTypeOID {
 			ok, _ := a.cat.CastAllowed(leftOID, ov.LeftTypeOID, "i")

internal/core/catalogdb/query.sql.go

@@ -66,6 +66,11 @@ ORDER BY
     ns.name
 LIMIT 1;
 
+-- name: TypeOIDsByNameInNamespaces :many
+SELECT oid, namespace_oid FROM sql_type
+WHERE name = sqlc.arg(name) AND family_oid IS NULL
+  AND namespace_oid IN (sqlc.slice(namespace_oids));
+
 -- name: TypeOIDByNameInNamespace :one
 SELECT oid FROM sql_type
 WHERE namespace_oid = ? AND name = ? AND family_oid IS NULL;

internal/core/catalogdef/query.sql

@@ -367,7 +367,7 @@ func applyCreateEnum(cat *core.Catalog, stmt *ast.CreateEnumStmt) error {
 	if name == "" {
 		return fmt.Errorf("create type with empty name")
 	}
-	if _, err := cat.TypeOID(name); err == nil {
+	if cat.TypeDeclared(name) {
 		return nil
 	}
 	var labels []core.TypeArg
@@ -386,7 +386,7 @@ func applyCreateDomain(cat *core.Catalog, stmt *ast.CreateDomainStmt) error {
 	if name == "" || stmt.TypeName == nil {
 		return fmt.Errorf("create domain: missing name or type")
 	}
-	if _, err := cat.TypeOID(name); err == nil {
+	if cat.TypeDeclared(name) {
 		return nil
 	}
 	baseOID, err := cat.ResolveType(stmt.TypeName)
@@ -423,7 +423,7 @@ func applyCompositeType(cat *core.Catalog, stmt *ast.CompositeTypeStmt) error {
 	if name == "" {
 		return fmt.Errorf("create type with empty name")
 	}
-	if _, err := cat.TypeOID(name); err == nil {
+	if cat.TypeDeclared(name) {
 		return nil
 	}
 	var fields []core.TypeArg
@@ -449,7 +449,7 @@ func applyCreateRange(cat *core.Catalog, stmt *ast.CreateRangeStmt) error {
 	if name == "" {
 		return fmt.Errorf("create type with empty name")
 	}
-	if _, err := cat.TypeOID(name); err == nil {
+	if cat.TypeDeclared(name) {
 		return nil
 	}
 	spec := core.TypeSpec{Name: name, Typtype: "r", Category: "R"}

internal/core/schema/schema.go

@@ -156,16 +156,19 @@ func parseTypeArg(a string) TypeArg {
 		b := strings.EqualFold(a, "true")
 		return TypeArg{Bool: &b}
 	}
-	// A label is a word before a space that comes before any parenthesis,
-	// as in `lat Float64` or `tags Array(String)`.
+	// A label is a word before a colon, as the canonical form writes it:
+	// `lat: Float64`. A word before a space is a label too, as ClickHouse
+	// writes `lat Float64`, but only when what follows is a single word,
+	// since `timestamp with time zone` is a name and not a label.
 	head := a
 	if p := strings.IndexByte(a, '('); p >= 0 {
 		head = a[:p]
 	}
-	if i := strings.IndexByte(head, ' '); i > 0 {
-		arg := parseTypeArg(a[i+1:])
-		arg.Label = a[:i]
-		return arg
+	if i := strings.IndexByte(head, ':'); i > 0 && !strings.ContainsAny(head[:i], " '\"") {
+		return TypeArg{Label: strings.TrimSpace(a[:i]), Type: ParseTypeExpr(a[i+1:])}
+	}
+	if i := strings.IndexByte(head, ' '); i > 0 && !strings.Contains(strings.TrimSpace(head[i+1:]), " ") {
+		return TypeArg{Label: a[:i], Type: ParseTypeExpr(a[i+1:])}
 	}
 	return TypeArg{Type: ParseTypeExpr(a)}
 }

internal/core/typeexpr.go

@@ -8,16 +8,20 @@ import (
 )
 
 // TypeExprOfTypeName reads the type an AST node names into an expression.
-// An engine that folds the whole type into a spelling — ClickHouse's
-// Array(Nullable(String)), SQLite's VARYING CHARACTER(10) — hands it over
-// in Spelling and the spelling is read as written. Otherwise the name comes
-// from Name or the qualifying parts of Names, the type modifiers become
-// integer or string arguments, and each array bound wraps the result in an
-// array.
+// An engine that renders the whole type as a call expression — DuckDB's
+// struct(a: integer, b: varchar) — hands it over in Canonical; one that
+// folds it into the spelling the formatter prints back — ClickHouse's
+// Array(Nullable(String)), SQLite's VARYING CHARACTER(10) — in Spelling.
+// Otherwise the name comes from Name or the qualifying parts of Names, the
+// type modifiers become integer or string arguments, and each array bound
+// wraps the result in an array.
 func TypeExprOfTypeName(tn *ast.TypeName) *TypeExpr {
 	if tn == nil {
 		return nil
 	}
+	if tn.Canonical != "" {
+		return ParseTypeExpr(tn.Canonical)
+	}
 	if tn.Spelling != "" {
 		return ParseTypeExpr(tn.Spelling)
 	}
@@ -79,7 +83,7 @@ func ColumnTypeExpr(col *ast.ColumnDef) *TypeExpr {
 			}
 		}
 	}
-	if col.TypeName.Spelling != "" || listItems(col.TypeName.ArrayBounds) != nil {
+	if col.TypeName.Canonical != "" || col.TypeName.Spelling != "" || listItems(col.TypeName.ArrayBounds) != nil {
 		return t
 	}
 	dims := col.ArrayDims