feat(ast): complete SQL AST formatting implementation

Fixes all ast.Format test failures by implementing comprehensive
Format methods for SQL AST nodes. Key improvements include:

- Named parameters (@param) formatting without space after @
- NULLIF expression support in A_Expr
- NULLS FIRST/LAST in ORDER BY clauses
- Type name mapping (int4→integer, timestamptz→timestamp with time zone)
- Array type support (text[]) and type modifiers (varchar(32))
- CREATE FUNCTION with parameters, options (AS, LANGUAGE), and modes
- CREATE EXTENSION statement formatting
- DO $$ ... $$ anonymous code blocks
- WITHIN GROUP clause for ordered-set aggregates
- Automatic quoting for SQL reserved words and mixed-case identifiers
- CROSS JOIN detection (JOIN without ON/USING clause)
- LATERAL keyword in subselects and function calls
- Array subscript access in UPDATE statements (names[$1])
- Proper AS keyword before aliases

Also removes unused deparse files and cleans up fmt_test.go to use
ast.Format directly.

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

Co-Authored-By: Claude <[email protected]>

Author: kyleconroy

internal/endtoend/fmt_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/debug"
 	"github.com/sqlc-dev/sqlc/internal/engine/postgresql"
+	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 )
 
 func TestFormat(t *testing.T) {
@@ -103,27 +104,18 @@ func TestFormat(t *testing.T) {
 							t.Fatal(err)
 						}
 
-						// Parse the query to get a ParseResult for Deparse
-						parseResult, err := postgresql.Parse(query)
-						if err != nil {
-							t.Fatal(err)
-						}
-
 						if false {
-							debug.Dump(parseResult)
-						}
-
-						out, err := postgresql.Deparse(parseResult)
-						if err != nil {
-							t.Fatal(err)
+							r, err := postgresql.Parse(query)
+							debug.Dump(r, err)
 						}
 
+						out := ast.Format(stmt.Raw)
 						actual, err := postgresql.Fingerprint(out)
 						if err != nil {
 							t.Error(err)
 						}
 						if expected != actual {
-							debug.Dump(parseResult)
+							debug.Dump(stmt.Raw)
 							t.Errorf("- %s", expected)
 							t.Errorf("- %s", query)
 							t.Errorf("+ %s", actual)

internal/engine/postgresql/convert.go

@@ -1965,6 +1965,22 @@ func convertNullTest(n *pg.NullTest) *ast.NullTest {
 	}
 }
 
+func convertNullIfExpr(n *pg.NullIfExpr) *ast.NullIfExpr {
+	if n == nil {
+		return nil
+	}
+	return &ast.NullIfExpr{
+		Xpr:          convertNode(n.Xpr),
+		Opno:         ast.Oid(n.Opno),
+		Opresulttype: ast.Oid(n.Opresulttype),
+		Opretset:     n.Opretset,
+		Opcollid:     ast.Oid(n.Opcollid),
+		Inputcollid:  ast.Oid(n.Inputcollid),
+		Args:         convertSlice(n.Args),
+		Location:     int(n.Location),
+	}
+}
+
 func convertObjectWithArgs(n *pg.ObjectWithArgs) *ast.ObjectWithArgs {
 	if n == nil {
 		return nil
@@ -3420,6 +3436,9 @@ func convertNode(node *pg.Node) ast.Node {
 	case *pg.Node_NullTest:
 		return convertNullTest(n.NullTest)
 
+	case *pg.Node_NullIfExpr:
+		return convertNullIfExpr(n.NullIfExpr)
+
 	case *pg.Node_ObjectWithArgs:
 		return convertObjectWithArgs(n.ObjectWithArgs)
 

internal/engine/postgresql/deparse.go

@@ -34,6 +34,94 @@ func stringSliceFromNodes(s []*nodes.Node) []string {
 	return items
 }
 
+func translateNode(node *nodes.Node) ast.Node {
+	if node == nil {
+		return nil
+	}
+	switch n := node.Node.(type) {
+	case *nodes.Node_String_:
+		return &ast.String{Str: n.String_.Sval}
+	case *nodes.Node_Integer:
+		return &ast.Integer{Ival: int64(n.Integer.Ival)}
+	case *nodes.Node_Boolean:
+		return &ast.Boolean{Boolval: n.Boolean.Boolval}
+	case *nodes.Node_AConst:
+		// A_Const contains a constant value (used in type modifiers like varchar(32))
+		if n.AConst.GetIval() != nil {
+			return &ast.Integer{Ival: int64(n.AConst.GetIval().Ival)}
+		}
+		if n.AConst.GetSval() != nil {
+			return &ast.String{Str: n.AConst.GetSval().Sval}
+		}
+		if n.AConst.GetFval() != nil {
+			return &ast.Float{Str: n.AConst.GetFval().Fval}
+		}
+		if n.AConst.GetBoolval() != nil {
+			return &ast.Boolean{Boolval: n.AConst.GetBoolval().Boolval}
+		}
+		return &ast.TODO{}
+	case *nodes.Node_List:
+		list := &ast.List{}
+		for _, item := range n.List.Items {
+			list.Items = append(list.Items, translateNode(item))
+		}
+		return list
+	default:
+		return &ast.TODO{}
+	}
+}
+
+func translateDefElem(n *nodes.DefElem) *ast.DefElem {
+	if n == nil {
+		return nil
+	}
+	defname := n.Defname
+	return &ast.DefElem{
+		Defname:  &defname,
+		Arg:      translateNode(n.Arg),
+		Location: int(n.Location),
+	}
+}
+
+func translateOptions(opts []*nodes.Node) *ast.List {
+	if opts == nil {
+		return nil
+	}
+	list := &ast.List{}
+	for _, opt := range opts {
+		if de, ok := opt.Node.(*nodes.Node_DefElem); ok {
+			list.Items = append(list.Items, translateDefElem(de.DefElem))
+		}
+	}
+	return list
+}
+
+func translateTypeNameFromPG(tn *nodes.TypeName) *ast.TypeName {
+	if tn == nil {
+		return nil
+	}
+	rel, err := parseRelationFromNodes(tn.Names)
+	if err != nil {
+		return nil
+	}
+	result := rel.TypeName()
+	// Preserve array bounds
+	if len(tn.ArrayBounds) > 0 {
+		result.ArrayBounds = &ast.List{}
+		for _, ab := range tn.ArrayBounds {
+			result.ArrayBounds.Items = append(result.ArrayBounds.Items, translateNode(ab))
+		}
+	}
+	// Preserve type modifiers
+	if len(tn.Typmods) > 0 {
+		result.Typmods = &ast.List{}
+		for _, tm := range tn.Typmods {
+			result.Typmods.Items = append(result.Typmods.Items, translateNode(tm))
+		}
+	}
+	return result
+}
+
 type relation struct {
 	Catalog string
 	Schema  string
@@ -431,11 +519,6 @@ func translate(node *nodes.Node) (ast.Node, error) {
 		for _, elt := range n.TableElts {
 			switch item := elt.Node.(type) {
 			case *nodes.Node_ColumnDef:
-				rel, err := parseRelationFromNodes(item.ColumnDef.TypeName.Names)
-				if err != nil {
-					return nil, err
-				}
-
 				primary := false
 				for _, con := range item.ColumnDef.Constraints {
 					if constraint, ok := con.Node.(*nodes.Node_Constraint); ok {
@@ -445,7 +528,7 @@ func translate(node *nodes.Node) (ast.Node, error) {
 
 				create.Cols = append(create.Cols, &ast.ColumnDef{
 					Colname:    item.ColumnDef.Colname,
-					TypeName:   rel.TypeName(),
+					TypeName:   translateTypeNameFromPG(item.ColumnDef.TypeName),
 					IsNotNull:  isNotNull(item.ColumnDef) || primaryKey[item.ColumnDef.Colname],
 					IsArray:    isArray(item.ColumnDef.TypeName),
 					ArrayDims:  len(item.ColumnDef.TypeName.ArrayBounds),
@@ -494,6 +577,7 @@ func translate(node *nodes.Node) (ast.Node, error) {
 			ReturnType: rt,
 			Replace:    n.Replace,
 			Params:     &ast.List{},
+			Options:    translateOptions(n.Options),
 		}
 		for _, item := range n.Parameters {
 			arg := item.Node.(*nodes.Node_FunctionParameter).FunctionParameter

internal/engine/postgresql/deparse_wasi.go

@@ -8,5 +8,3 @@ import (
 
 var Parse = nodes.Parse
 var Fingerprint = nodes.Fingerprint
-
-var nodeDeparse = nodes.Deparse

internal/engine/postgresql/parse.go

@@ -8,5 +8,3 @@ import (
 
 var Parse = nodes.Parse
 var Fingerprint = nodes.Fingerprint
-
-var nodeDeparse = nodes.Deparse

internal/engine/postgresql/parse_default.go

@@ -58,16 +58,35 @@ func (n *A_Expr) Format(buf *TrackedBuffer) {
 		buf.astFormat(n.Lexpr)
 		buf.WriteString(" IS NOT DISTINCT FROM ")
 		buf.astFormat(n.Rexpr)
+	case A_Expr_Kind_NULLIF:
+		buf.WriteString("NULLIF(")
+		buf.astFormat(n.Lexpr)
+		buf.WriteString(", ")
+		buf.astFormat(n.Rexpr)
+		buf.WriteString(")")
 	case A_Expr_Kind_OP:
-		// Standard binary operator
-		if set(n.Lexpr) {
-			buf.astFormat(n.Lexpr)
-			buf.WriteString(" ")
+		// Check if this is a named parameter (@name)
+		opName := ""
+		if n.Name != nil && len(n.Name.Items) == 1 {
+			if s, ok := n.Name.Items[0].(*String); ok {
+				opName = s.Str
+			}
 		}
-		buf.astFormat(n.Name)
-		if set(n.Rexpr) {
-			buf.WriteString(" ")
+		if opName == "@" && !set(n.Lexpr) && set(n.Rexpr) {
+			// Named parameter: @name (no space after @)
+			buf.WriteString("@")
 			buf.astFormat(n.Rexpr)
+		} else {
+			// Standard binary operator
+			if set(n.Lexpr) {
+				buf.astFormat(n.Lexpr)
+				buf.WriteString(" ")
+			}
+			buf.astFormat(n.Name)
+			if set(n.Rexpr) {
+				buf.WriteString(" ")
+				buf.astFormat(n.Rexpr)
+			}
 		}
 	default:
 		// Fallback for other cases

internal/engine/postgresql/parse_wasi.go

@@ -9,3 +9,22 @@ type A_Indices struct {
 func (n *A_Indices) Pos() int {
 	return 0
 }
+
+func (n *A_Indices) Format(buf *TrackedBuffer) {
+	if n == nil {
+		return
+	}
+	buf.WriteString("[")
+	if n.IsSlice {
+		if set(n.Lidx) {
+			buf.astFormat(n.Lidx)
+		}
+		buf.WriteString(":")
+		if set(n.Uidx) {
+			buf.astFormat(n.Uidx)
+		}
+	} else {
+		buf.astFormat(n.Uidx)
+	}
+	buf.WriteString("]")
+}

internal/sql/ast/a_expr.go

@@ -2,6 +2,57 @@ package ast
 
 import "strings"
 
+// sqlReservedWords is a set of SQL keywords that must be quoted when used as identifiers
+var sqlReservedWords = map[string]bool{
+	"all": true, "analyse": true, "analyze": true, "and": true, "any": true,
+	"array": true, "as": true, "asc": true, "asymmetric": true, "authorization": true,
+	"between": true, "binary": true, "both": true, "case": true, "cast": true,
+	"check": true, "collate": true, "collation": true, "column": true, "concurrently": true,
+	"constraint": true, "create": true, "cross": true, "current_catalog": true,
+	"current_date": true, "current_role": true, "current_schema": true,
+	"current_time": true, "current_timestamp": true, "current_user": true,
+	"default": true, "deferrable": true, "desc": true, "distinct": true, "do": true,
+	"else": true, "end": true, "except": true, "false": true, "fetch": true,
+	"for": true, "foreign": true, "freeze": true, "from": true, "full": true,
+	"grant": true, "group": true, "having": true, "ilike": true, "in": true,
+	"initially": true, "inner": true, "intersect": true, "into": true, "is": true,
+	"isnull": true, "join": true, "lateral": true, "leading": true, "left": true,
+	"like": true, "limit": true, "localtime": true, "localtimestamp": true,
+	"natural": true, "not": true, "notnull": true, "null": true, "offset": true,
+	"on": true, "only": true, "or": true, "order": true, "outer": true,
+	"overlaps": true, "placing": true, "primary": true, "references": true,
+	"returning": true, "right": true, "select": true, "session_user": true,
+	"similar": true, "some": true, "symmetric": true, "table": true, "tablesample": true,
+	"then": true, "to": true, "trailing": true, "true": true, "union": true,
+	"unique": true, "user": true, "using": true, "variadic": true, "verbose": true,
+	"when": true, "where": true, "window": true, "with": true,
+}
+
+// needsQuoting returns true if the identifier is a SQL reserved word
+// that needs to be quoted when used as an identifier
+func needsQuoting(s string) bool {
+	return sqlReservedWords[strings.ToLower(s)]
+}
+
+// hasMixedCase returns true if the string has any uppercase letters
+// (identifiers with mixed case need quoting in PostgreSQL)
+func hasMixedCase(s string) bool {
+	for _, r := range s {
+		if r >= 'A' && r <= 'Z' {
+			return true
+		}
+	}
+	return false
+}
+
+// quoteIdent returns a quoted identifier if it needs quoting
+func quoteIdent(s string) string {
+	if needsQuoting(s) || hasMixedCase(s) {
+		return `"` + s + `"`
+	}
+	return s
+}
+
 type ColumnRef struct {
 	Name string
 
@@ -24,11 +75,7 @@ func (n *ColumnRef) Format(buf *TrackedBuffer) {
 		for _, item := range n.Fields.Items {
 			switch nn := item.(type) {
 			case *String:
-				if nn.Str == "user" {
-					items = append(items, `"user"`)
-				} else {
-					items = append(items, nn.Str)
-				}
+				items = append(items, quoteIdent(nn.Str))
 			case *A_Star:
 				items = append(items, "*")
 			}