refactor(format): add Formatter interface for SQL dialect-specific quoting

- Create internal/sql/format package with Formatter interface
- Add QuoteIdent method to TrackedBuffer that delegates to Formatter
- Implement QuoteIdent on postgresql.Parser using existing IsReservedKeyword
- Update all Format() methods to use buf.QuoteIdent() instead of local quoteIdent()
- Remove duplicate reserved word logic from ast/column_ref.go
- Update ast.Format() to accept a Formatter parameter

This allows each SQL dialect to provide its own identifier quoting logic
based on its reserved keywords and quoting rules.

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

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

Author: kyleconroy

internal/endtoend/fmt_test.go

@@ -109,7 +109,7 @@ func TestFormat(t *testing.T) {
 							debug.Dump(r, err)
 						}
 
-						out := ast.Format(stmt.Raw)
+						out := ast.Format(stmt.Raw, parse)
 						actual, err := postgresql.Fingerprint(out)
 						if err != nil {
 							t.Error(err)

internal/engine/postgresql/reserved.go

@@ -2,6 +2,26 @@ package postgresql
 
 import "strings"
 
+// 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.
+// This implements the format.Formatter interface.
+func (p *Parser) QuoteIdent(s string) string {
+	if p.IsReservedKeyword(s) || hasMixedCase(s) {
+		return `"` + s + `"`
+	}
+	return s
+}
+
 // https://www.postgresql.org/docs/current/sql-keywords-appendix.html
 func (p *Parser) IsReservedKeyword(s string) bool {
 	switch strings.ToLower(s) {

internal/sql/ast/column_ref.go

@@ -2,57 +2,6 @@ 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
 
@@ -75,7 +24,7 @@ func (n *ColumnRef) Format(buf *TrackedBuffer) {
 		for _, item := range n.Fields.Items {
 			switch nn := item.(type) {
 			case *String:
-				items = append(items, quoteIdent(nn.Str))
+				items = append(items, buf.QuoteIdent(nn.Str))
 			case *A_Star:
 				items = append(items, "*")
 			}

internal/sql/ast/print.go

@@ -4,26 +4,38 @@ import (
 	"strings"
 
 	"github.com/sqlc-dev/sqlc/internal/debug"
+	"github.com/sqlc-dev/sqlc/internal/sql/format"
 )
 
-type formatter interface {
+type nodeFormatter interface {
 	Format(*TrackedBuffer)
 }
 
 type TrackedBuffer struct {
 	*strings.Builder
+	formatter format.Formatter
 }
 
-// NewTrackedBuffer creates a new TrackedBuffer.
-func NewTrackedBuffer() *TrackedBuffer {
+// NewTrackedBuffer creates a new TrackedBuffer with the given formatter.
+func NewTrackedBuffer(f format.Formatter) *TrackedBuffer {
 	buf := &TrackedBuffer{
-		Builder: new(strings.Builder),
+		Builder:   new(strings.Builder),
+		formatter: f,
 	}
 	return buf
 }
 
+// QuoteIdent returns a quoted identifier if it needs quoting.
+// If no formatter is set, it returns the identifier unchanged.
+func (t *TrackedBuffer) QuoteIdent(s string) string {
+	if t.formatter != nil {
+		return t.formatter.QuoteIdent(s)
+	}
+	return s
+}
+
 func (t *TrackedBuffer) astFormat(n Node) {
-	if ft, ok := n.(formatter); ok {
+	if ft, ok := n.(nodeFormatter); ok {
 		ft.Format(t)
 	} else {
 		debug.Dump(n)
@@ -45,9 +57,9 @@ func (t *TrackedBuffer) join(n *List, sep string) {
 	}
 }
 
-func Format(n Node) string {
-	tb := NewTrackedBuffer()
-	if ft, ok := n.(formatter); ok {
+func Format(n Node, f format.Formatter) string {
+	tb := NewTrackedBuffer(f)
+	if ft, ok := n.(nodeFormatter); ok {
 		ft.Format(tb)
 	}
 	return tb.String()

internal/sql/ast/range_var.go

@@ -19,11 +19,11 @@ func (n *RangeVar) Format(buf *TrackedBuffer) {
 		return
 	}
 	if n.Schemaname != nil {
-		buf.WriteString(quoteIdent(*n.Schemaname))
+		buf.WriteString(buf.QuoteIdent(*n.Schemaname))
 		buf.WriteString(".")
 	}
 	if n.Relname != nil {
-		buf.WriteString(quoteIdent(*n.Relname))
+		buf.WriteString(buf.QuoteIdent(*n.Relname))
 	}
 	if n.Alias != nil {
 		buf.WriteString(" ")

internal/sql/ast/res_target.go

@@ -19,11 +19,11 @@ func (n *ResTarget) Format(buf *TrackedBuffer) {
 		buf.astFormat(n.Val)
 		if n.Name != nil {
 			buf.WriteString(" AS ")
-			buf.WriteString(quoteIdent(*n.Name))
+			buf.WriteString(buf.QuoteIdent(*n.Name))
 		}
 	} else {
 		if n.Name != nil {
-			buf.WriteString(quoteIdent(*n.Name))
+			buf.WriteString(buf.QuoteIdent(*n.Name))
 		}
 	}
 }

internal/sql/ast/update_stmt.go

@@ -79,7 +79,7 @@ func (n *UpdateStmt) Format(buf *TrackedBuffer) {
 				switch nn := item.(type) {
 				case *ResTarget:
 					if nn.Name != nil {
-						buf.WriteString(quoteIdent(*nn.Name))
+						buf.WriteString(buf.QuoteIdent(*nn.Name))
 					}
 					// Handle array subscript indirection (e.g., names[$1])
 					if items(nn.Indirection) {

internal/sql/format/format.go

@@ -0,0 +1,8 @@
+package format
+
+// Formatter provides SQL dialect-specific formatting behavior
+type Formatter interface {
+	// QuoteIdent returns a quoted identifier if it needs quoting
+	// (e.g., reserved words, mixed case identifiers)
+	QuoteIdent(s string) string
+}