fmt: print type names and DDL as the author wrote them

Two-word type names printed squashed (VARYING CHARACTER(32) came back
as VARYINGCHARACTER(32)): the converter folds the spaces out of type
names for catalog matching, and the printer had nothing else to show.
ast.TypeName now carries the authored spelling alongside the folded
name — the sqlite converter fills it for column types and casts from
meyer's token-joined name — and the printer prefers it.

Fixing that surfaced how much of a CREATE TABLE the reprint silently
destroyed: PRIMARY KEY came back as NOT NULL, DEFAULT, UNIQUE, CHECK
and every other constraint vanished, a typeless column grew an 'any',
and IF NOT EXISTS was dropped. Column PRIMARY KEY, typeless columns
and IF NOT EXISTS are now modeled and print faithfully. Everything the
node still cannot carry — other column constraints, table constraints,
table options, TEMP, AS SELECT, and a NOT NULL next to a PRIMARY KEY
(which does not imply it in SQLite) — marks the statement Incomplete:
it renders as nothing, no verification accepts that, and sqlc fmt keeps
the statement exactly as written. ALTER TABLE ADD COLUMN gets the same
treatment. TestFormat learns that an empty rendering is that signal,
and the fmt endtoend case pins the new behavior.

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

Author: claude

internal/endtoend/fmt_test.go

@@ -169,6 +169,12 @@ func TestFormat(t *testing.T) {
 						}
 
 						out := ast.Format(stmt.Raw, formatter)
+						// An empty rendering is the formatter's signal that
+						// the statement carries syntax the AST does not
+						// model; sqlc fmt keeps such statements as written.
+						if strings.TrimSpace(strings.TrimSuffix(strings.TrimSpace(out), ";")) == "" {
+							t.Skip("statement has no faithful rendering")
+						}
 						actual, err := fingerprint(out)
 						if err != nil {
 							t.Error(err)

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

@@ -42,3 +42,17 @@ CREATE TABLE scratch (
   id INTEGER NOT NULL,
   label TEXT
 );
+
+-- name: MakeMeasurements :exec
+CREATE TABLE IF NOT EXISTS measurements (
+  id INTEGER PRIMARY KEY,
+  label VARYING  CHARACTER(120),
+  ratio DECIMAL(10,5),
+  note
+);
+
+-- name: KeepAutoinc :exec
+CREATE TABLE   counters (id INTEGER PRIMARY KEY AUTOINCREMENT, hits INTEGER DEFAULT 0);
+
+-- name: CastLabel :one
+SELECT CAST(bio AS VARYING CHARACTER(120)) FROM authors LIMIT 1;

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

@@ -46,3 +46,12 @@
  WHERE id <> @at_param AND id <> :colon_param AND id <> $dollar_param;
 
  -- name: TopAuthors :many
+@@ -46,7 +53,7 @@
+ -- name: MakeMeasurements :exec
+ CREATE TABLE IF NOT EXISTS measurements (
+   id INTEGER PRIMARY KEY,
++  label VARYING CHARACTER(120),
+-  label VARYING  CHARACTER(120),
+   ratio DECIMAL(10,5),
+   note
+ );

internal/engine/sqlite/convert.go

@@ -214,15 +214,21 @@ func (c *cc) convertAlterTableStmt(n *meyer.AlterTableStmt) ast.Node {
 		}
 		name := identifier(def.Name)
 		return &ast.AlterTableStmt{
-			Table: parseTableName(n.Table),
+			Table:      parseTableName(n.Table),
+			Incomplete: !representableColumn(def),
 			Cmds: &ast.List{Items: []ast.Node{
 				&ast.AlterTableCmd{
 					Name:    &name,
 					Subtype: ast.AT_AddColumn,
 					Def: &ast.ColumnDef{
-						Colname:   name,
-						TypeName:  &ast.TypeName{Name: columnTypeName(def.Type)},
-						IsNotNull: hasNotNullConstraint(def.Constraints),
+						Colname: name,
+						TypeName: &ast.TypeName{
+							Name:     columnTypeName(def.Type),
+							Spelling: typeSpelling(def.Type),
+						},
+						Typeless:   def.Type == nil,
+						IsNotNull:  hasNotNullConstraint(def.Constraints),
+						PrimaryKey: hasPrimaryKeyConstraint(def.Constraints),
 					},
 				},
 			}},
@@ -278,13 +284,24 @@ func (c *cc) convertCreateTableStmt(n *meyer.CreateTableStmt) ast.Node {
 	stmt := &ast.CreateTableStmt{
 		Name:        parseTableName(n.Name),
 		IfNotExists: n.IfNotExists,
+		// The node models none of these, so a statement carrying them has
+		// no faithful rendering and the formatter keeps it as written.
+		Incomplete: n.Temp || n.Select != nil || len(n.Constraints) > 0 || len(n.Options) > 0,
 	}
 	for _, def := range n.Columns {
+		if !representableColumn(def) {
+			stmt.Incomplete = true
+		}
 		stmt.Cols = append(stmt.Cols, &ast.ColumnDef{
-			Colname:   identifier(def.Name),
-			IsNotNull: hasNotNullConstraint(def.Constraints),
-			TypeName:  &ast.TypeName{Name: columnTypeName(def.Type)},
-			Location:  def.Pos(),
+			Colname:    identifier(def.Name),
+			IsNotNull:  hasNotNullConstraint(def.Constraints),
+			PrimaryKey: hasPrimaryKeyConstraint(def.Constraints),
+			TypeName: &ast.TypeName{
+				Name:     columnTypeName(def.Type),
+				Spelling: typeSpelling(def.Type),
+			},
+			Typeless: def.Type == nil,
+			Location: def.Pos(),
 		})
 	}
 	return stmt
@@ -307,7 +324,9 @@ func (c *cc) convertCreateVirtualTableFTS5(n *meyer.CreateVirtualTableStmt) ast.
 	stmt := &ast.CreateTableStmt{
 		Name:        parseTableName(n.Name),
 		IfNotExists: n.IfNotExists,
-		Virtual:     true,
+		// A virtual table's module arguments are parsed away, so the
+		// statement has no faithful rendering.
+		Incomplete: true,
 	}
 
 	// The module arguments of a virtual table are an arbitrary token
@@ -1035,6 +1054,7 @@ func (c *cc) convertCastExpr(n *meyer.CastExpr) ast.Node {
 		Arg: c.convert(n.X),
 		TypeName: &ast.TypeName{
 			Name:        name,
+			Spelling:    typeSpelling(n.Type),
 			Names:       &ast.List{Items: []ast.Node{&ast.String{Str: strings.ToLower(name)}}},
 			ArrayBounds: &ast.List{},
 		},

internal/engine/sqlite/utils.go

@@ -76,6 +76,60 @@ func typeName(n *meyer.TypeName) string {
 	return sb.String()
 }
 
+// typeSpelling returns the type as the author wrote it — identifier tokens
+// space-joined, arguments as written — for the formatter to print back.
+// typeName folds the spaces out for catalog matching.
+func typeSpelling(n *meyer.TypeName) string {
+	if n == nil {
+		return ""
+	}
+	var sb strings.Builder
+	sb.WriteString(n.Name)
+	if len(n.Args) > 0 {
+		sb.WriteString("(")
+		sb.WriteString(strings.Join(n.Args, ","))
+		sb.WriteString(")")
+	}
+	return sb.String()
+}
+
+// representableColumn reports whether a column definition round-trips
+// through the fields ast.ColumnDef models: a plain NOT NULL, a plain
+// PRIMARY KEY, or nothing. Anything else — a named constraint, a conflict
+// clause, ASC/DESC or AUTOINCREMENT, DEFAULT, UNIQUE, CHECK, COLLATE,
+// REFERENCES, GENERATED — is parsed away, so a statement printing such a
+// column would lose it. NOT NULL next to PRIMARY KEY is also beyond the
+// node: SQLite's PRIMARY KEY does not imply NOT NULL, and the printed form
+// carries only one of the pair.
+func representableColumn(def *meyer.ColumnDef) bool {
+	var notNull, primary bool
+	for _, con := range def.Constraints {
+		switch {
+		case con.Name != nil:
+			return false
+		case con.Kind == meyer.ColumnNotNull && con.OnConflict == meyer.ConflictDefault:
+			notNull = true
+		case con.Kind == meyer.ColumnPrimaryKey && con.OnConflict == meyer.ConflictDefault &&
+			con.Order == meyer.SortDefault && !con.AutoIncrement:
+			primary = true
+		default:
+			return false
+		}
+	}
+	return !(notNull && primary)
+}
+
+// hasPrimaryKeyConstraint reports whether a column definition carries a
+// PRIMARY KEY constraint.
+func hasPrimaryKeyConstraint(constraints []*meyer.ColumnConstraint) bool {
+	for _, constraint := range constraints {
+		if constraint.Kind == meyer.ColumnPrimaryKey {
+			return true
+		}
+	}
+	return false
+}
+
 // hasNotNullConstraint reports whether a column definition guarantees a
 // value. A PRIMARY KEY implies NOT NULL for the purposes of code
 // generation, matching the behavior of the previous parser.

internal/sql/ast/alter_table_stmt.go

@@ -9,6 +9,10 @@ type AlterTableStmt struct {
 	Cmds      *List
 	MissingOk bool
 	Relkind   ObjectType
+	// Incomplete marks a statement whose source carried syntax this node
+	// does not model, such as column constraints beyond plain NOT NULL and
+	// PRIMARY KEY on an added column. No faithful rendering exists for it.
+	Incomplete bool
 }
 
 func (n *AlterTableStmt) Pos() int {
@@ -19,6 +23,12 @@ func (n *AlterTableStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 	if n == nil {
 		return
 	}
+	// An incomplete statement cannot be printed back: part of its source
+	// was parsed away. Render nothing, which no verification accepts, so
+	// the formatter keeps the statement as written.
+	if n.Incomplete {
+		return
+	}
 	buf.WriteString("ALTER TABLE ")
 	buf.astFormat(n.Relation, d)
 	buf.astFormat(n.Table, d)

internal/sql/ast/column_def.go

@@ -3,8 +3,12 @@ package ast
 import "github.com/sqlc-dev/sqlc/internal/sql/format"
 
 type ColumnDef struct {
-	Colname    string
+	Colname string
+	// TypeName is the column's type for the catalog. When Typeless is set
+	// the author wrote no type at all — SQLite allows it — and the column
+	// prints without one, whatever TypeName carries.
 	TypeName   *TypeName
+	Typeless   bool
 	IsNotNull  bool
 	IsUnsigned bool
 	IsArray    bool
@@ -39,8 +43,10 @@ func (n *ColumnDef) Format(buf *TrackedBuffer, d format.Dialect) {
 		return
 	}
 	buf.WriteString(n.Colname)
-	buf.WriteString(" ")
-	buf.astFormat(n.TypeName, d)
+	if !n.Typeless {
+		buf.WriteString(" ")
+		buf.astFormat(n.TypeName, d)
+	}
 	// Use IsArray from ColumnDef since TypeName.ArrayBounds may not be set
 	// (for type resolution compatibility)
 	if n.IsArray && !items(n.TypeName.ArrayBounds) {

internal/sql/ast/create_table_stmt.go

@@ -9,10 +9,11 @@ type CreateTableStmt struct {
 	ReferTable  *TableName
 	Comment     string
 	Inherits    []*TableName
-	// Virtual marks a table backed by a module (SQLite's CREATE VIRTUAL
-	// TABLE). The statement's argument list cannot be reconstructed from
-	// this node, so it has no faithful rendering.
-	Virtual bool
+	// Incomplete marks a statement whose source carried syntax this node
+	// does not model — a virtual table's module arguments, column or table
+	// constraints beyond plain NOT NULL and PRIMARY KEY, table options,
+	// TEMP, or an AS SELECT body. No faithful rendering exists for it.
+	Incomplete bool
 }
 
 func (n *CreateTableStmt) Pos() int {
@@ -23,13 +24,16 @@ func (n *CreateTableStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 	if n == nil {
 		return
 	}
-	// A virtual table cannot be printed back: its module arguments were
-	// parsed away. Render nothing, which no verification accepts, so the
-	// formatter keeps the statement as written.
-	if n.Virtual {
+	// An incomplete statement cannot be printed back: part of its source
+	// was parsed away. Render nothing, which no verification accepts, so
+	// the formatter keeps the statement as written.
+	if n.Incomplete {
 		return
 	}
 	buf.WriteString("CREATE TABLE ")
+	if n.IfNotExists {
+		buf.WriteString("IF NOT EXISTS ")
+	}
 	buf.astFormat(n.Name, d)
 
 	buf.WriteString(" (")

internal/sql/ast/type_name.go

@@ -6,6 +6,11 @@ type TypeName struct {
 	Catalog string
 	Schema  string
 	Name    string
+	// Spelling is the type as the author wrote it, when that differs from
+	// Name: SQLite folds the spaces out of multi-word type names ("VARYING
+	// CHARACTER" resolves as "VARYINGCHARACTER" in the catalog), so the
+	// formatter prints this back instead of the folded form.
+	Spelling string
 
 	// From pg.TypeName
 	Names       *List
@@ -26,6 +31,10 @@ func (n *TypeName) Format(buf *TrackedBuffer, d format.Dialect) {
 	if n == nil {
 		return
 	}
+	if n.Spelling != "" {
+		buf.WriteString(n.Spelling)
+		goto addMods
+	}
 	if items(n.Names) {
 		// Check if this is a qualified type (e.g., pg_catalog.int4)
 		if len(n.Names.Items) == 2 {