[ajitpratap0]

Summary

#599 cli: gosqlx format silently corrupts many expressions; switch the CLI to pkg/formatter

gosqlx format no longer has its own renderer. cmd/gosqlx/cmd/sql_formatter.go is now a thin adapter over pkg/formatter.FormatStatement, and the exported SQLFormatter, NewSQLFormatter, FormatterOptions and Format API is unchanged apart from an additive Dialect field. Before this change the CLI silently corrupted CAST, ::, EXTRACT, INTERVAL, ANY/ALL, tuples, subscripts and ARRAY, ROLLUP/CUBE/GROUPING SETS, WITHIN GROUP, set-operation subqueries, ON CONFLICT, RETURNING, PIVOT and ALTER TABLE with exit 0. They now format correctly and round-trip, and pkg/formatter gains full ALTER TABLE operation rendering (one new switch case in render.go). A new safety net re-parses the formatted output with the same dialect and compares the statement count and SQL(). If they differ the command errors, and -i/-o never write corrupted SQL. On this branch alone, NOT EXISTS (#601) and quoted identifiers (#611) therefore error until the ast-render chain lands, so merge after it. Verified with a full -race gate, task test:cbinding, vet and golangci-lint (0 issues). An independent before/after CLI comparison covered all 25 scout cases. The new regression tests fail on the parent: 22 TestFormatSQL_Issue599 subtests plus the corpus and ALTER render tests. A 134-file corpus round-trip runs in 3 modes. Still open, with the CLI inheriting each fix automatically: #600, #603 and #604, plus follow-ups for MySQL-style backslash escaping in every dialect, CROSS/OUTER APPLY rendered as ... APPLY JOIN, MATCH ... AGAINST, Oracle CONNECT BY, Snowflake QUALIFY, ALTER ROLE/POLICY/CONNECTOR, the no-op --no-uppercase flag, and lowercase keywords the parser rejects. A newly observed pre-existing parser bug also needs its own issue: lowercase any(...) is parsed as ALL.

Commits (2), one implementation commit per issue plus test-only follow-ups:

• 9c5a127 fix(cli): drop duplicated "formatting failed" prefix in gosqlx format errors (cli: gosqlx format silently corrupts many expressions; switch the CLI to pkg/formatter #599)
• b4b76f2 fix(cli): render gosqlx format through pkg/formatter and refuse non-round-tripping output (cli: gosqlx format silently corrupts many expressions; switch the CLI to pkg/formatter #599)

9 files changed, 772 insertions(+), 1435 deletions(-)

Test Plan

• Each issue's reproduction cases were run against main before the fix (Haiku scout), and a failing regression test was written before the code change.
• Independent review (Opus, or Sonnet on small chains) with a bounded fix loop.
• Independent Opus validator ran the repository race gate (CGO_ENABLED=1 go test -race -timeout 300s $(go list ./... | grep -v /cbinding)), go vet, golangci-lint, re-ran the reproduction cases on HEAD, and confirmed the new tests fail on the parent commit.
• Perf items: benchstat -count=6 before/after on the same machine.

#599 evidence (validator)

Not a perf item, so no benchstat. Reproduction evidence comes from two CLI builds, HEAD and its parent (git archive b4b76f2^), fed all 25 scout cases plus 12 extra probes in compact mode. Outputs are in scratchpad/b3/599/head_cases.txt and parent_cases.txt.

Parent output, showing the bug:
- `SELECT CAST, CAST FROM t`
- `SELECT EXTRACT FROM t`
- `d + INTERVAL FROM t`
- `RANGE BETWEEN INTERVAL PRECEDING`
- `WHERE ANY AND ALL`
- `WHERE TUPLE IN (TUPLE, TUPLE)`
- `SELECT [], [:], ARRAY`
- `GROUP BY ROLLUP` / `GROUP BY CUBE` / `GROUP BY GROUPING SETS`
- PERCENTILE_CONT loses its WITHIN GROUP
- `EXISTS ()` and `a IN ()`
- ON CONFLICT and RETURNING dropped
- PIVOT becomes `FROM s AS p`
- ALTER renders as `ADD c INT`, a bare `DROP`, or `...`
- `"Weird Col"` renders as `Weird Col`

All of those exit 0.

HEAD output, every case exit 0 and matching the expected text:
- `SELECT CAST(a AS INT), CAST(b AS text) FROM t`
- `EXTRACT(YEAR FROM d)`
- `d + INTERVAL '1 day'`
- `RANGE BETWEEN INTERVAL '1 day' PRECEDING AND CURRENT ROW`
- `a = ANY (SELECT x FROM u) AND b > ALL (SELECT x FROM u)`
- `(a, b) IN ((1, 2), (3, 4))`
- `arr[1], arr[1:2], ARRAY[1, 2]`
- `ROLLUP(a, b)` / `CUBE(a, b)` / `GROUPING SETS((a), (b), ())`
- `WITHIN GROUP (ORDER BY x)`
- `EXISTS (SELECT 1 UNION SELECT 2)` and `a IN (SELECT 1 UNION SELECT 2)`
- ON CONFLICT ... DO UPDATE SET a = 2 and RETURNING id are kept
- SQL Server `PIVOT (SUM(amt) FOR q IN ([Q1], [Q2])) AS p` is kept
- ALTER TABLE ADD COLUMN, DROP COLUMN ... CASCADE, RENAME TO, RENAME COLUMN, ADD CONSTRAINT ... PRIMARY KEY, DROP CONSTRAINT, ALTER COLUMN SET NOT NULL / TYPE BIGINT / DROP NOT NULL are all exact

The cases blocked on the library (#600 named argument, IGNORE NULLS, SETTINGS, ON DUPLICATE KEY UPDATE, OUTPUT; #603 USING; #604 NOLOCK) produce the same output as pkg/formatter.

NOT EXISTS and quoted aliases now exit 1 with "formatted output does not re-parse". `format -i` on NOT EXISTS input exits 1 and leaves the file byte-identical (checked 

#599 race gate: PASS. CGO_ENABLED=1 go test -race -timeout 300s $(go list ./... | grep -v /cbinding) on HEAD b4b76f2 exited 0. 44 packages reported ok with no FAIL, panic or DATA RACE; cmd/gosqlx/cmd (2.3s) and pkg/formatter (2.2s) ran fresh, not cached. task test:cbinding reported ok (cached). Log: /private/tmp/claude-501/-Users-ajitpratapsingh-dev-GoSQLX/b99cd3cf-cb92-4294-a0db-d6a7c9a86253/scratchpad/b3/599/race_validator.txt

Breaking Changes

• cli: gosqlx format silently corrupts many expressions; switch the CLI to pkg/formatter #599: Go API: additive only.
• cmd/gosqlx/cmd keeps SQLFormatter, NewSQLFormatter(FormatterOptions), FormatterOptions{Indent, Compact, UppercaseKw, AlignColumns} and (*SQLFormatter).Format(*ast.AST) (string, error). FormatterOptions gains a new Dialect string field. AlignColumns is retained but documented as ignored. Unexported render helpers are removed.
• pkg/formatter: no signature changes. FormatStatement/FormatAST now render *ast.AlterStatement ALTER TABLE operations where they used to return the bare token ALTER, so output only improves. Other ALTER types are unchanged.

Observable CLI behaviour:

• gosqlx format output layout now matches pkg/formatter (readable or compact, CLI separators ;\n\n / ; , no trailing semicolon).
• When the formatted output would not re-parse, or would change the query, the command now returns an error (non-zero exit, file untouched) instead of exiting 0 with corrupted SQL.

The PR must describe both CLI changes under Breaking Changes (CLI output and exit behaviour only).

Notes

• CHANGELOG.md is intentionally not touched; the consolidated CHANGELOG PR docs: consolidate CHANGELOG for the perf audit and batch-2/batch-3 fixes; refresh performance baselines (#566) #598 gets the entries for this batch before it merges.
• Part of the batch-3 merge train (follow-ups cli: gosqlx format silently corrupts many expressions; switch the CLI to pkg/formatter #599-schema/postgres: loader misreports index columns and key flags (column order, INCLUDE, expression and partitioned indexes, read-only roles) #620); later PRs in the train are rebased onto this one after it merges.
• Base: main.

Fixes #599
Follow-up to #566

🤖 Generated with Claude Code

https://claude.ai/code/session_01UZSk1292jPc8ipDboNxeve

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated
gosqlx-website	Ready	Preview	Oct 14, 2026 11:50am UTC

[github-actions]

Claude finished @ajitpratap0's task in 25s —— View job

---

Review of PR #624 (gosqlx format via pkg/formatter)

I read the diff for the non-test code: sql_formatter.go, formatter.go, render_alter.go, render.go and doc.go. I did not run the tests or the linter.

Overall: this is a sound change. It replaces about 1,400 lines of duplicated renderer with a thin adapter. It also adds a re-parse safety net, so corrupted SQL is never written. The exported API stays the same, and the one addition is the Dialect field.

Strengths

• The adapter is small, and the AlignColumns-is-ignored decision is documented.
• verifyFormattedSQL checks statement count and SQL() after a re-parse, and the AST is released with defer, as CLAUDE.md requires.
• Failing closed for -i and -o is the right behaviour.
• The ALTER TABLE rendering is isolated in its own file with tests.

Issues and suggestions

1. Case-insensitive comparison (formatter.go, verifyFormattedSQL).
   • strings.EqualFold on the whole SQL() string also ignores case differences inside string literals and identifiers.
   • A formatter bug that changed 'Abc' to 'abc' would pass verification.
   • If only some nodes keep the source keyword case, such as set operators, normalising just those would be safer. Otherwise this is a known gap, and I'd note it in a comment.
2. Lowercase verification (formatter.go).
   • With --no-uppercase, the code verifies an uppercase rendering instead of the text that is actually written.
   • The lowercase output is therefore never re-parsed.
   • The PR acknowledges this because the parser rejects some lowercase keyword sequences. The consequence is that the lowercase path can emit text that does not re-parse (for example any(...) parsed as ALL), with no error. A short doc note on this limitation would help users.
3. Double formatting.
   • Lowercase mode renders the tree twice, and every run does a full tokenize and parse again.
   • That is fine for a CLI, but it is worth a benchmark on large files.
4. ALTER TABLE (render_alter.go).
   • Operation types that the parser does not produce, such as DropColumn variants beyond those handled, silently render as nothing after ALTER TABLE name. The safety net catches this in the CLI, but library users of pkg/formatter get truncated SQL.
   • Falling back to stmtSQL(a) in the default: case would be more conservative.
   • ADD COLUMN always emits COLUMN, and IF EXISTS / IF NOT EXISTS flags are not rendered. If the AST carries those flags, they would be dropped and the safety net would catch it. Please confirm the AST has no such field.
5. Separator handling.
   • AddSemicolon = false is set, and Format appends no trailing semicolon. This is a behaviour change from before and is already listed under Breaking Changes. It is worth a mention in the release notes, since scripts may rely on the trailing ;.
6. Merge ordering. The PR says NOT EXISTS (ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601) and quoted identifiers (ast/formatter: quoted identifiers that are keywords or case-sensitive lose their quotes on render (SELECT "select", CTE/view column lists, table names) #611) error on this branch alone. Please make sure the merge train enforces that order. Merging this first would be a user-visible regression, although a loud one.
7. CHANGELOG. It is not updated here, which is intentional per the description. Please keep it on the checklist for docs: consolidate CHANGELOG for the perf audit and batch-2/batch-3 fixes; refresh performance baselines (#566) #598.

Tests: the regression and corpus round-trip tests look thorough. I'd add a test that a case-only change inside a string literal is caught by verification (relates to point 1).

Nothing here blocks the merge. Points 1 and 4 are the ones worth addressing.

[ajitpratap0]

Rebased onto main (1be0808, includes #622, #623, #628–#631) to clear conflicts.

• Included the previously unpushed local commit 404f291 ("address adversarial review for fix(cli): render gosqlx format through pkg/formatter and refuse non-round-tripping output (#599) #624").
• Conflict in cmd/gosqlx/cmd/sql_formatter.go: resolved to this PR's pkg/formatter adapter.
• New commit updates two tests that landed on main meanwhile (parser/ast: JOIN ... USING (cols) is stored as a plain condition and renders as ON cols #603 JOIN USING, parser: INSERT gaps: RETURNING after INSERT ... SELECT, DEFAULT VALUES, MySQL INSERT ... SET, INSERT INTO t (SELECT ...) #610 UPDATE ... FROM) to the pkg/formatter layout (SELECT * on one line, u v without AS).
• task check passes.

Note for whoever owns GoSQLX-worktrees/fix-cli-format-use-pkg-formatter: it still has uncommitted WIP (formatter.go, ast/sql.go unary-minus fix, 4 new tests) that was NOT included because it doesn't compile yet (verifyFormattedSQL signature). Rebase it onto the new head 701763d before pushing.

[github-actions]

Claude finished @ajitpratap0's task in 24s —— View job

---

Review of PR #624 (gosqlx format via pkg/formatter)

I read the diff for formatter.go, sql_formatter.go, render_alter.go and render.go. I did not run the tests or the linter. This review covers the same ground as the earlier one, and I checked its claims against the code.

Overall: this is a good change. About 1,500 lines of duplicate renderer become a thin adapter, and the re-parse safety net stops -i and -o from writing corrupted SQL.

Checked and fine

• ALTER TABLE ... RENAME TO uses op.NewTableName.String(). NewTableName is a value ObjectName (pkg/sql/ast/alter.go:145), so there is no nil dereference.
• AddColumn and AlterColumn guard ColumnDef != nil, and Constraint is guarded as well.
• Both ASTs are released with defer, so the pooling rules in CLAUDE.md are followed.

Issues

1. strings.EqualFold on the whole SQL() string (formatter.go, verifyFormattedSQL).
   • It also ignores case changes inside string literals and quoted identifiers. A formatter bug turning 'Abc' into 'abc' would pass verification. The doc comment says the fold is there for set-operator case, but the code applies it to everything.
   • Suggestion: normalise the set-operator case at the source, or compare token-wise with literals and identifiers compared exactly. If neither is done, document it as a known gap.
   • Add a test for a case-only change inside a literal.
2. Lowercase output is never re-parsed.
   • With --no-uppercase, the check runs on the uppercase rendering, and the text that gets written is not verified. This is reasonable given the parser's lowercase gaps, but the bytes written are unchecked.
   • Suggestion: mention it in the flag help or doc.go. A cheap extra check is to tokenize the lowercase output and compare the token count with the uppercase one.
3. writeAlterTableOperation silently emits nothing for unhandled operation types (render_alter.go).
   • There is no default:. ALTER TABLE t would render with no operation, and library users of pkg/formatter get truncated SQL. The CLI net catches this, but library callers do not benefit.
   • Suggestion: add default: return stmtSQL(a) at the statement level, or render the whole statement through the old path when the op type is unknown.
   • ADD COLUMN always prints COLUMN and drops IF [NOT] EXISTS. If AlterTableOperation has such fields, they are lost. I did not find them rendered here, so please confirm they cannot be set.
4. Cost. In lowercase mode the tree is rendered twice, and every run does a full tokenize and parse of the output. That is acceptable for a CLI. A quick benchmark on a large file would settle it.
5. Behaviour changes. The trailing semicolon is gone, and NOT EXISTS (ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601) and quoted identifiers (ast/formatter: quoted identifiers that are keywords or case-sensitive lose their quotes on render (SELECT "select", CTE/view column lists, table names) #611) now error until those PRs land. The PR description calls both out. Please make sure the merge train enforces that order, and put both items in the release notes.
6. CHANGELOG. Not updated here, which is intentional. Keep it on the docs: consolidate CHANGELOG for the perf audit and batch-2/batch-3 fixes; refresh performance baselines (#566) #598 checklist.

Tests: the issue-599 regression tests, the corpus round-trip and the ALTER render tests give good coverage. The missing piece is the case-in-literal test from point 1.

Nothing here blocks the merge. Points 1 and 3 are the ones worth addressing.

[github-actions]

Claude finished @ajitpratap0's task in 31s —— View job

---

Review of PR #624 (gosqlx format via pkg/formatter)

I read cmd/gosqlx/cmd/formatter.go (verifyFormattedSQL) and pkg/formatter/render_alter.go on the current head. I did not run the tests or the linter.

Overall: this is a good change. It replaces about 1,500 lines of duplicate renderer with a thin adapter. The re-parse safety net keeps -i and -o from writing corrupted SQL.

Two points from the earlier automated reviews no longer apply to the current head:

• The safety net now also compares quoted tokens, so string literals and quoted identifiers are checked. This is done in checkQuotedTokens and checkMySQLDoubleQuotes, and the comment at formatter.go:295-299 explains the split.
• The ALTER rendering covers ALTER COLUMN and RENAME COLUMN fully.

Remaining issues

1. Case-insensitive SQL comparison (formatter.go:330, :337).

   • strings.EqualFold runs on the whole SQL() string and on the per-statement rendering.
   • The token check covers string-literal values and quoted identifiers.
   • Case changes inside an unquoted identifier go unseen, for example Abc becoming abc. That is probably harmless in most dialects.
   • A case-only change inside a literal is covered only by the token check. Please add an explicit test for this. The fold can only hide that kind of bug if the token check misses it.

2. --no-uppercase output is not verified directly.

   • The check runs on the form of the output that is verified, not on the bytes that get written. If that is still the case, say so in the flag help or doc.go.
   • A cheap extra check is to re-tokenize the lowercase output and compare its tokens with the uppercase tokens, folding case.

3. Silent truncation in writeAlterTableOperation (render_alter.go:54).

   • The switch has no default:. The doc comment says unproduced types are "left empty".
   • For library users of pkg/formatter, an unhandled op.Type renders as ALTER TABLE t with nothing after it. The CLI net catches it, but library callers do not benefit.
   • Suggestion: in renderAlterStatement, fall back to stmtSQL(a) when the operation type is not handled. Alternatively, add a default: that does the same.
   • Please also confirm that AlterTableOperation has no IF [NOT] EXISTS fields. ADD COLUMN and DROP COLUMN never print them, so they would be dropped.

4. op.NewTableName.String() (render_alter.go:93). This is fine, since the field is a value type. I'd still add one test with a schema-qualified new name.

5. Cost. Every run tokenizes and parses the output again, and renders each statement twice more for the canonical comparison. That is fine for a CLI. A quick benchmark on a large file would settle it.

6. Merge order and release notes.

   • NOT EXISTS (ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601) and quoted identifiers (ast/formatter: quoted identifiers that are keywords or case-sensitive lose their quotes on render (SELECT "select", CTE/view column lists, table names) #611) error on this branch alone, so the merge train must land those first.
   • The trailing-semicolon removal and the new non-zero exit on non-round-tripping output belong in the release notes.
   • CHANGELOG stays on the docs: consolidate CHANGELOG for the perf audit and batch-2/batch-3 fixes; refresh performance baselines (#566) #598 checklist.

Tests: the issue-599 regression tests, the corpus round-trip, the guard tests and the ALTER render tests give good coverage. The missing pieces are the case-in-literal test (point 1) and the lowercase verification (point 2).

Nothing here blocks the merge. Points 1 and 3 are the ones worth addressing.

[github-actions]

Claude finished @ajitpratap0's task in 21s —— View job

---

Review of PR #624 (gosqlx format via pkg/formatter)

I read pkg/formatter/render_alter.go and the function list of cmd/gosqlx/cmd/formatter.go on head 38b2982. I did not run the tests or the linter.

Overall: this is a good change. About 1,500 lines of duplicate renderer become a thin adapter. The re-parse safety net keeps -i and -o from writing corrupted SQL. The latest commits tighten it with quoted-token and MySQL double-quote checks, which resolves the literal and quoted-identifier concern from earlier reviews.

Remaining issues

1. No default: in writeAlterTableOperation (render_alter.go:54).

   • The doc comment says unproduced operation types are "left empty".
   • A library caller of pkg/formatter gets ALTER TABLE t with nothing after it if an unhandled op.Type ever reaches it. The CLI net catches this, but library callers don't benefit.
   • Suggestion: fall back to stmtSQL(a) for unhandled types.
   • Please confirm that AlterTableOperation has no IF [NOT] EXISTS field. ADD COLUMN and DROP COLUMN never print one.

2. strings.EqualFold on the whole SQL() string (formatter.go:330, :337).

   • It hides case-only changes in unquoted identifiers. That is probably harmless.
   • Literals and quoted identifiers are covered by checkQuotedTokens. Add an explicit test that a case-only change inside a literal fails verification, so the fold can't mask a later regression.

3. --no-uppercase output is verified on its uppercase rendering, not on the bytes written.

   • A cheap extra check: re-tokenize the lowercase output and compare its tokens with the uppercase ones, folding case.
   • Otherwise, state the limitation in the flag help or doc.go.

4. Schema-qualified RENAME TO (render_alter.go:93). op.NewTableName.String() is fine because the field is a value type. A test with a qualified new name would pin it.

5. Cost. Each run re-tokenizes and re-parses the output and renders each statement again. That is fine for a CLI. A quick benchmark on a large file would settle it.

6. Merge order and release notes.

   • NOT EXISTS (ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601) and quoted identifiers (ast/formatter: quoted identifiers that are keywords or case-sensitive lose their quotes on render (SELECT "select", CTE/view column lists, table names) #611) are listed as erroring on this branch alone. The recent commits suggest ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601 has landed. Please confirm the train order for ast/formatter: quoted identifiers that are keywords or case-sensitive lose their quotes on render (SELECT "select", CTE/view column lists, table names) #611 before merging.
   • The trailing-semicolon removal and the new non-zero exit on non-round-tripping output belong in the release notes. CHANGELOG stays on the docs: consolidate CHANGELOG for the perf audit and batch-2/batch-3 fixes; refresh performance baselines (#566) #598 checklist.

Tests: the issue-599 regressions, the corpus round-trip, the guard tests and the ALTER render tests give good coverage. The missing pieces are the case-in-literal test (point 2) and lowercase verification (point 3).

Nothing here blocks the merge. Point 1 is the one worth addressing.

[ajitpratap0]

Merge train (batch 3): #624 (last code PR of the train)

• Rebase: onto main 728c544, which now includes fix(parser): linear qualified-name joining and correct E2002 error context (#613, #616) #627 and fix(ast,formatter): NOT EXISTS, quoted identifiers, table hints and PIVOT render correctly (#601, #611, #604) #632. cmd/gosqlx/cmd/sql_formatter.go conflicted; rerere resolved it to this PR's thin adapter. The WINDOW, set-op parens, DEFAULT VALUES and JOIN USING additions that main had made to the old hand-written renderer drop out with it. Their tests from main (named_window_format_test.go, paren_setop_format_test.go, insert_update_forms_format_test.go, join_using_format_test.go) all pass through pkg/formatter.
• Integration commits:
  • 29385e0: JOIN USING readable-layout expectation (parser/ast: JOIN ... USING (cols) is stored as a plain condition and renders as ON cols #603 × cli: gosqlx format silently corrupts many expressions; switch the CLI to pkg/formatter #599).
  • a52ba3d: corpus known gaps, measured on this head. Six files still refuse correctly: gorm_joins "Company" (case-only quoting), CROSS/OUTER APPLY, MATCH AGAINST, CONNECT BY, Oracle regexp backslashes. The ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601/ast/formatter: quoted identifiers that are keywords or case-sensitive lose their quotes on render (SELECT "select", CTE/view column lists, table names) #611/PIVOT gaps are fixed and removed.
  • 50cb701 and 38b2982: MySQL/MariaDB double-quote guard.
    • In MySQL, "..." is a string, but the parser reads it as an identifier. So WHERE name = "bob" → name = bob used to pass the round-trip check while changing meaning. fix(ast,formatter): NOT EXISTS, quoted identifiers, table hints and PIVOT render correctly (#601, #611, #604) #632's quoting would likewise turn `select` into "select".
    • The CLI now requires MySQL/MariaDB output to keep exactly the input's double-quoted tokens.
    • ANSI_QUOTES-style input ("users"."id", FROM "users") is left alone.
    • 0 of the MySQL/MariaDB corpus files are refused.
  • Also: the stale ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601 Skipf now fails instead. The corpus test fails if a known-gap file starts formatting.
• Verification:
  • Gate: local gate on 38b2982 is green (go vet ./..., golangci-lint 0 issues, go test -race on all packages except cbinding, pre-commit hook). CI 28/28 green.
  • Independent Opus review of the rebase: pass, no must-fix. Its one should-fix, the MySQL string issue and the count bypass of the first guard, is fixed in 38b2982.
  • Its hostile-name probe ran 8 dialects × 14 names × 7 templates through gosqlx format. 0 outputs had extra statements or failed to re-parse; the old CLI got 974 of these wrong.
• Bot review on this head:
  1. writeAlterTableOperation has no default:. Every op type the ALTER parser produces is handled. An unhandled type can only come from a hand-built AST; the CLI refuses that output and the doc comment states it. Kept as is.
  2. AlterTableOperation does have IfNotExists / IfExists, but the parser rejects IF [NOT] EXISTS in ALTER (ADD COLUMN IF NOT EXISTS is E2002 on main), so they are never set from parsed SQL. Parsing them is a follow-up.
  3. Case-folded SQL() comparison and lowercase output: literals and quoted identifiers are compared exactly by checkQuotedTokens. Lowercase output is verified through its uppercase twin and must differ from it only in case.
  4. Train order: ast/formatter: NOT EXISTS (subquery) renders as NOT (EXISTS (...) NOT ), which does not re-parse #601, ast/formatter: quoted identifiers that are keywords or case-sensitive lose their quotes on render (SELECT "select", CTE/view column lists, table names) #611 and ast/formatter: SQL Server table hints WITH (NOLOCK) are never rendered; SQL() also drops PIVOT #604 are on main via fix(ast,formatter): NOT EXISTS, quoted identifiers, table hints and PIVOT render correctly (#601, #611, #604) #632, which merged before this PR.
  5. CHANGELOG: docs: consolidate CHANGELOG for the perf audit and batch-2/batch-3 fixes; refresh performance baselines (#566) #598 records the trailing-semicolon layout, the non-zero exit and the new refusals.