refactor(format): add TypeName method to Formatter interface

- Add TypeName(ns, name string) string method to Formatter interface
- Implement TypeName on postgresql.Parser with pg_catalog type mappings
- Add TypeName method to TrackedBuffer that delegates to Formatter
- Update ast.TypeName.Format to use buf.TypeName()
- Remove mapTypeName from ast package (moved to postgresql package)

This allows each SQL dialect to provide its own type name mappings
(e.g., pg_catalog.int4 -> integer for PostgreSQL).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: kyleconroy

internal/engine/postgresql/reserved.go

@@ -22,6 +22,39 @@ func (p *Parser) QuoteIdent(s string) string {
 	return s
 }
 
+// TypeName returns the SQL type name for the given namespace and name.
+// This implements the format.Formatter interface.
+func (p *Parser) TypeName(ns, name string) string {
+	if ns == "pg_catalog" {
+		switch name {
+		case "int4":
+			return "integer"
+		case "int8":
+			return "bigint"
+		case "int2":
+			return "smallint"
+		case "float4":
+			return "real"
+		case "float8":
+			return "double precision"
+		case "bool":
+			return "boolean"
+		case "bpchar":
+			return "character"
+		case "timestamptz":
+			return "timestamp with time zone"
+		case "timetz":
+			return "time with time zone"
+		default:
+			return name
+		}
+	}
+	if ns != "" {
+		return ns + "." + name
+	}
+	return name
+}
+
 // https://www.postgresql.org/docs/current/sql-keywords-appendix.html
 func (p *Parser) IsReservedKeyword(s string) bool {
 	switch strings.ToLower(s) {

internal/sql/ast/print.go

@@ -34,6 +34,18 @@ func (t *TrackedBuffer) QuoteIdent(s string) string {
 	return s
 }
 
+// TypeName returns the SQL type name for the given namespace and name.
+// If no formatter is set, it returns "ns.name" or just "name".
+func (t *TrackedBuffer) TypeName(ns, name string) string {
+	if t.formatter != nil {
+		return t.formatter.TypeName(ns, name)
+	}
+	if ns != "" {
+		return ns + "." + name
+	}
+	return name
+}
+
 func (t *TrackedBuffer) astFormat(n Node) {
 	if ft, ok := n.(nodeFormatter); ok {
 		ft.Format(t)

internal/sql/ast/type_name.go

@@ -20,68 +20,30 @@ func (n *TypeName) Pos() int {
 	return n.Location
 }
 
-// mapTypeName converts internal PostgreSQL type names to their SQL equivalents
-func mapTypeName(name string) string {
-	switch name {
-	case "int4":
-		return "integer"
-	case "int8":
-		return "bigint"
-	case "int2":
-		return "smallint"
-	case "float4":
-		return "real"
-	case "float8":
-		return "double precision"
-	case "bool":
-		return "boolean"
-	case "bpchar":
-		return "character"
-	case "timestamptz":
-		return "timestamp with time zone"
-	case "timetz":
-		return "time with time zone"
-	default:
-		return name
-	}
-}
-
 func (n *TypeName) Format(buf *TrackedBuffer) {
 	if n == nil {
 		return
 	}
 	if items(n.Names) {
-		// Check if this is a pg_catalog type that should be expanded
+		// Check if this is a qualified type (e.g., pg_catalog.int4)
 		if len(n.Names.Items) == 2 {
 			first, _ := n.Names.Items[0].(*String)
 			second, _ := n.Names.Items[1].(*String)
-			if first != nil && second != nil && first.Str == "pg_catalog" {
-				// pg_catalog.timestamptz -> timestamp with time zone
-				// pg_catalog.timetz -> time with time zone
-				// etc.
-				buf.WriteString(mapTypeName(second.Str))
+			if first != nil && second != nil {
+				buf.WriteString(buf.TypeName(first.Str, second.Str))
 				goto addMods
 			}
 		}
-		// For single name types, just output as-is (don't expand)
+		// For single name types, just output as-is
 		if len(n.Names.Items) == 1 {
 			if s, ok := n.Names.Items[0].(*String); ok {
-				buf.WriteString(s.Str)
+				buf.WriteString(buf.TypeName("", s.Str))
 				goto addMods
 			}
 		}
 		buf.join(n.Names, ".")
-	} else if n.Schema == "pg_catalog" {
-		// pg_catalog.typename -> expanded form (via Schema/Name fields)
-		buf.WriteString(mapTypeName(n.Name))
-	} else if n.Schema != "" {
-		// schema.typename
-		buf.WriteString(n.Schema)
-		buf.WriteString(".")
-		buf.WriteString(n.Name)
 	} else {
-		// Simple type name - don't expand aliases
-		buf.WriteString(n.Name)
+		buf.WriteString(buf.TypeName(n.Schema, n.Name))
 	}
 addMods:
 	// Add type modifiers (e.g., varchar(255))

internal/sql/format/format.go

@@ -5,4 +5,8 @@ type Formatter interface {
 	// QuoteIdent returns a quoted identifier if it needs quoting
 	// (e.g., reserved words, mixed case identifiers)
 	QuoteIdent(s string) string
+
+	// TypeName returns the SQL type name for the given namespace and name.
+	// This handles dialect-specific type name mappings (e.g., pg_catalog.int4 -> integer)
+	TypeName(ns, name string) string
 }