SQL formatter

Format SQL

Formatted SQL appears here.

Input is capped at 100,000 characters. Longer input is cut at that point, and the result says so. Format keeps comments where they are. Minify removes them. The formatter never changes a string, a quoted name, a number, or a parameter, and it re-reads its own output to check.

How to format SQL

1. Paste the query. A one-liner from a log works, and so does a whole script with several statements.
2. Pick the dialect. Postgres, MySQL, and the rest differ in keywords and quoting, and the dialect tells the formatter which words are keywords.
3. Pick the keyword case and the indent. Uppercase keywords with two spaces is the usual house style.
4. Press Format SQL. Minify does the opposite: one line, comments removed, ready to paste into code or a config file.
5. Copy the result, or download it as a .sql file. Read the notes under the result: the formatter reports unbalanced parentheses and joins without a condition.

What the formatter changes

Formatting only moves whitespace and changes keyword case. The query means the same after formatting as it did before.

A parenthesised group stays on one line when it is short, and breaks across lines when it holds a subquery or runs long. A CASE expression breaks across lines too: WHEN and ELSE each start a line, and END lines up with CASE.

Dialects

The dialect changes which words count as keywords and how quoting is read. The shared core of SELECT, JOIN, WHERE, and GROUP BY formats the same in all of them.

Pick Standard SQL when the query has to run on more than one database. It follows the lexical rules the dialects share, and understands the common quoting styles: double quotes, backticks, square brackets, E'...' and $$...$$ strings, the :: cast, and ?, :name, @name, and $1 parameters.

Checks the formatter runs

The formatter checks structure as it formats. It does not run the query and it does not know your schema, so it can only flag what the text itself shows.

Unbalanced parentheses

An opening parenthesis with no close is reported with the line where it opens. An extra closing parenthesis is reported the same way.

Unclosed strings

A string or quoted name that never closes stops the format, and the error names the line.

Joins without a condition

A JOIN with no ON or USING after it is flagged. Without a condition, a join pairs every row with every row. CROSS JOIN is the exception: it means that on purpose.

Literal check

After formatting, the page reads its own output back and compares every string, quoted name, number, and parameter with the input. If anything changed, the original is shown instead, with a warning.

What it does not check

Column names, table names, and types are not checked. A query can format cleanly and still fail against a real database.

What it will not do

This is a pretty-printer. It does not execute SQL, connect to a database, or check a query against a schema.

Procedural code passes through: the body of a PL/pgSQL function or a T-SQL BEGIN...END block is copied as-is and may not re-indent beyond the surrounding statement. Dollar-quoted bodies are treated as one string and never split.

Input is capped at 100,000 characters. Longer input is cut at that point, and the result says so.

Format SQL in code

Use a maintained library in production. This page's own formatter is a small tokenizer written for the browser, not a full parser.

Python, with sqlparse

import sqlparse
print(sqlparse.format(sql, reindent=True, keyword_case="upper"))

JavaScript, with sql-formatter

import { format } from "sql-formatter";
format(sql, { language: "postgresql", keywordCase: "upper" });

Shell, with the sqlformat command

sqlformat --reindent --keywords upper query.sql > formatted.sql

sqlformat ships with sqlparse. It reads a file and writes the formatted query.

Sources

PostgreSQL documentation, SELECT: the SELECT syntax this page follows for Postgres, including DISTINCT ON, RETURNING, and window functions.

MySQL documentation, SELECT Statement: the SELECT syntax for MySQL, including STRAIGHT_JOIN and the LIMIT offset form.

SQLite documentation, SELECT: the SELECT syntax for SQLite.

sqlparse documentation, sqlparse: the Python SQL formatter, including the reindent and keyword_case options shown in the code section.

sql-formatter on npm, sql-formatter: the JavaScript formatter, including the language and keywordCase options shown in the code section.

More tools for builders

• llms.txt Checker
• Claude Skill Validator
• UUID v7 Generator
• ULID Generator
• Robots.txt Generator
• JWT Decoder
• Markdown Table Generator
• Chmod Calculator
• Cron Expression Generator
• Unix Timestamp Converter