fmt: keep the author's operator spellings and join syntax; lowercase coalesce

SQLite gives several constructs more than one spelling, and the
formatter was silently picking one: != printed as <> and == as =, a
comma-separated FROM item printed as JOIN, and a bare JOIN with no ON
printed as CROSS JOIN — a planner hint in SQLite the author did not
write.

Operators keep pg_query's shape: A_Expr.Name is the operator as the
engine's parser saw it, and since meyer's tree keeps only the operator
kind, the sqlite converter reads the author's spelling back out of the
source between the operands. The compiler already recognizes every
spelling, as it must for MySQL, whose canonical != flows through the
same lists.

Joins that SQLite treats distinctly become distinct: JoinType gains
JoinTypeCross (the planner hint) and JoinTypeComma (its own syntax)
beyond the libpg_query set, the sqlite converter maps to them, and the
printer spells each as itself — which retires the printer's guess that
an inner join with no condition must be a CROSS JOIN. PostgreSQL,
whose grammar really does mean CROSS JOIN by that shape (a bare JOIN
without ON is a syntax error there), now says so in its converter.
Redundant spellings still normalize: INNER JOIN prints as JOIN and
LEFT OUTER JOIN as LEFT JOIN, which mean exactly the same thing.

COALESCE also drops to lower case: it printed upper-case only because
sqlc special-cases it into a dedicated node for nullability inference
whose Format hardcoded the spelling, while every other function call
prints through FuncCall with its identifier folded lower. The fmt
endtoend case pins all of it.

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

Author: claude

internal/compiler/output_columns.go

@@ -453,7 +453,7 @@ func isTableRequired(n ast.Node, col *Column, prior int) int {
 			return helper(tableOptional, tableRequired)
 		case ast.JoinTypeFull:
 			return helper(tableOptional, tableOptional)
-		case ast.JoinTypeInner:
+		case ast.JoinTypeInner, ast.JoinTypeCross, ast.JoinTypeComma:
 			return helper(tableRequired, tableRequired)
 		}
 	case *ast.List:

internal/endtoend/testdata/fmt/sqlite/query.sql

@@ -65,3 +65,19 @@ CREATE VIRTUAL TABLE recipes_fts USING fts5(
   name,
   ingredients
 );
+
+-- name: LoginName :one
+SELECT COALESCE(bio, '') AS login FROM authors WHERE id = ? LIMIT 1;
+
+-- name: SpelledJoins :many
+SELECT a.id
+FROM authors AS a
+INNER JOIN authors AS b ON a.id = b.id
+LEFT OUTER JOIN authors AS c ON a.id = c.id
+WHERE a.id != ? AND b.id == ? AND c.id <> ?;
+
+-- name: CommaJoin :one
+SELECT count(*) FROM authors AS a, authors AS b WHERE a.id = b.id;
+
+-- name: PlannerHint :many
+SELECT a.id FROM authors AS a CROSS JOIN authors AS b;

internal/endtoend/testdata/fmt/sqlite/stdout.txt

@@ -64,3 +64,21 @@
 
  -- name: MakeRecipeIndex :exec
  CREATE VIRTUAL TABLE recipes_fts USING fts5(
+@@ -67,7 +74,7 @@
+ );
+ 
+ -- name: LoginName :one
++SELECT coalesce(bio, '') AS login FROM authors WHERE id = ? LIMIT 1;
+-SELECT COALESCE(bio, '') AS login FROM authors WHERE id = ? LIMIT 1;
+ 
+ -- name: SpelledJoins :many
+ SELECT a.id
+@@ -74,6 +81,6 @@
+ FROM authors AS a
++JOIN authors AS b ON a.id = b.id
++LEFT JOIN authors AS c ON a.id = c.id
+-INNER JOIN authors AS b ON a.id = b.id
+-LEFT OUTER JOIN authors AS c ON a.id = c.id
+ WHERE a.id != ? AND b.id == ? AND c.id <> ?;
+ 
+ -- name: CommaJoin :one

internal/engine/postgresql/convert.go

@@ -1868,8 +1868,16 @@ func convertJoinExpr(n *pg.JoinExpr) *ast.JoinExpr {
 	if n == nil {
 		return nil
 	}
+	jointype := ast.JoinType(n.Jointype)
+	// PostgreSQL parses CROSS JOIN as an inner join with no condition —
+	// the only inner join its grammar allows without one — so that shape
+	// is CROSS JOIN, and must print as it: a bare JOIN with no ON or
+	// USING is a syntax error in PostgreSQL.
+	if jointype == ast.JoinTypeInner && !n.IsNatural && n.Quals == nil && len(n.UsingClause) == 0 {
+		jointype = ast.JoinTypeCross
+	}
 	return &ast.JoinExpr{
-		Jointype:    ast.JoinType(n.Jointype),
+		Jointype:    jointype,
 		IsNatural:   n.IsNatural,
 		Larg:        convertNode(n.Larg),
 		Rarg:        convertNode(n.Rarg),

internal/engine/sqlite/convert.go

@@ -770,7 +770,11 @@ func (c *cc) convertFrom(refs []*meyer.TableRef) []ast.Node {
 				join.Jointype = ast.JoinTypeLeft
 			case right:
 				join.Jointype = ast.JoinTypeRight
-			case op.Type&meyer.JoinComma == 0:
+			case op.Type&meyer.JoinComma != 0:
+				join.Jointype = ast.JoinTypeComma
+			case op.Type&meyer.JoinCross != 0:
+				join.Jointype = ast.JoinTypeCross
+			default:
 				join.Jointype = ast.JoinTypeInner
 			}
 		}
@@ -960,14 +964,38 @@ func (c *cc) convertBinaryExpr(n *meyer.BinaryExpr) ast.Node {
 			Location: n.Pos(),
 		}
 	}
+	// SQLite spells some operators two ways (<> and !=, = and ==) and the
+	// tree keeps only the kind, so read the author's choice back out of the
+	// source between the operands; the compiler recognizes every spelling.
+	op := n.Op.String()
+	switch n.Op {
+	case meyer.OpNe:
+		if strings.Contains(c.operatorText(n.X, n.Y), "!=") {
+			op = "!="
+		}
+	case meyer.OpEq:
+		if strings.Contains(c.operatorText(n.X, n.Y), "==") {
+			op = "=="
+		}
+	}
 	return &ast.A_Expr{
-		Name:     &ast.List{Items: []ast.Node{&ast.String{Str: n.Op.String()}}},
+		Name:     &ast.List{Items: []ast.Node{&ast.String{Str: op}}},
 		Lexpr:    c.convert(n.X),
 		Rexpr:    c.convert(n.Y),
 		Location: n.Pos(),
 	}
 }
 
+// operatorText returns the source text separating two adjacent operands,
+// where the operator token sits.
+func (c *cc) operatorText(x, y meyer.Expr) string {
+	start, end := x.End(), y.Pos()
+	if start < 0 || end > len(c.src) || start > end {
+		return ""
+	}
+	return c.src[start:end]
+}
+
 func (c *cc) convertUnaryExpr(n *meyer.UnaryExpr) ast.Node {
 	expr := c.convert(n.X)
 	switch n.Op {

internal/sql/ast/a_expr.go

@@ -7,7 +7,14 @@ import (
 )
 
 type A_Expr struct {
-	Kind     A_Expr_Kind
+	Kind A_Expr_Kind
+	// Name is the operator, as a list of String nodes: PostgreSQL's
+	// operator space is open (user-defined and schema-qualified operators),
+	// so the shared tree keeps pg_query's shape rather than an enum. Each
+	// engine's converter writes the operator as its parser saw it — for an
+	// engine that accepts more than one spelling of the same operator
+	// (SQLite's != for <>, == for =), that is the author's spelling, which
+	// is how the printer preserves it.
 	Name     *List
 	Lexpr    Node
 	Rexpr    Node

internal/sql/ast/coalesce_expr.go

@@ -18,7 +18,9 @@ func (n *CoalesceExpr) Format(buf *TrackedBuffer, d format.Dialect) {
 	if n == nil {
 		return
 	}
-	buf.WriteString("COALESCE(")
+	// Lower case, like every other function name: the printer upper-cases
+	// keywords, and function names are identifiers, which fold lower.
+	buf.WriteString("coalesce(")
 	buf.astFormat(n.Args, d)
 	buf.WriteString(")")
 }

internal/sql/ast/join_expr.go

@@ -22,27 +22,28 @@ func (n *JoinExpr) Format(buf *TrackedBuffer, d format.Dialect) {
 		return
 	}
 	buf.astFormat(n.Larg, d)
-	buf.beforeClause(n.Rarg, d)
-	buf.Line()
-	if n.IsNatural {
-		buf.WriteString("NATURAL ")
-	}
-	switch n.Jointype {
-	case JoinTypeLeft:
-		buf.WriteString("LEFT JOIN ")
-	case JoinTypeRight:
-		buf.WriteString("RIGHT JOIN ")
-	case JoinTypeFull:
-		buf.WriteString("FULL JOIN ")
-	case JoinTypeInner:
-		// CROSS JOIN has no ON or USING clause
-		if !items(n.UsingClause) && !set(n.Quals) {
+	if n.Jointype == JoinTypeComma {
+		buf.WriteString(",")
+		buf.beforeClause(n.Rarg, d)
+		buf.Line()
+	} else {
+		buf.beforeClause(n.Rarg, d)
+		buf.Line()
+		if n.IsNatural {
+			buf.WriteString("NATURAL ")
+		}
+		switch n.Jointype {
+		case JoinTypeLeft:
+			buf.WriteString("LEFT JOIN ")
+		case JoinTypeRight:
+			buf.WriteString("RIGHT JOIN ")
+		case JoinTypeFull:
+			buf.WriteString("FULL JOIN ")
+		case JoinTypeCross:
 			buf.WriteString("CROSS JOIN ")
-		} else {
+		default:
 			buf.WriteString("JOIN ")
 		}
-	default:
-		buf.WriteString("JOIN ")
 	}
 	buf.astFormat(n.Rarg, d)
 	if items(n.UsingClause) {

internal/sql/ast/join_type.go

@@ -12,6 +12,13 @@ const (
 	JoinTypeAnti
 	JoinTypeUniqueOuter
 	JoinTypeUniqueInner
+	// Beyond the libpg_query set: joins SQLite spells (and treats)
+	// distinctly. Both behave as inner joins, but CROSS JOIN carries a
+	// planner hint — SQLite will not reorder the pair — and a
+	// comma-separated FROM item is its own syntax, so neither may be
+	// rewritten into the other.
+	JoinTypeCross
+	JoinTypeComma
 )
 
 type JoinType uint