SQL Formatter: Make Your Queries Readable

Why SQL Formatting Matters

SQL queries from ORMs, log dumps, or copy-pasted snippets are often a single compressed line. Debugging a 200-character SELECT with five joins and three subqueries is an exercise in frustration. A SQL formatter transforms this into readable, properly indented code.

Whether you're reviewing query performance, sharing code with teammates, or learning SQL, readability directly impacts productivity. Our SQL Formatter handles MySQL, PostgreSQL, SQL Server, and SQLite dialects.

Before and After

-- Before: unreadable
SELECT u.id,u.name,o.total,o.created_at FROM users u JOIN orders o ON u.id=o.user_id WHERE o.total>100 AND o.created_at>'2026-01-01' ORDER BY o.total DESC LIMIT 20;

-- After: clean and readable
SELECT
  u.id,
  u.name,
  o.total,
  o.created_at
FROM users u
JOIN orders o
  ON u.id = o.user_id
WHERE o.total > 100
  AND o.created_at > '2026-01-01'
ORDER BY o.total DESC
LIMIT 20;

SQL Formatting Conventions

Keyword Casing

Consistent keyword casing improves scannability. Most teams choose one style:

• UPPERCASE: SELECT, FROM, WHERE — stands out against column names
• lowercase: select, from, where — cleaner in some editors

Pick one and stick with it. Our formatter lets you choose your preferred casing.

Indentation and Line Breaks

Standard conventions:

• Each column on its own line in SELECT clauses
• JOIN conditions indented under the JOIN line
• AND/OR conditions indented under WHERE
• Subqueries indented one additional level

Formatting Complex Queries

Subqueries

SELECT
  department,
  avg_salary
FROM (
  SELECT
    department,
    AVG(salary) AS avg_salary
  FROM employees
  GROUP BY department
) AS dept_stats
WHERE avg_salary > 75000;

CTEs (Common Table Expressions)

WITH active_users AS (
  SELECT
    user_id,
    COUNT(*) AS order_count
  FROM orders
  WHERE created_at > CURRENT_DATE - INTERVAL '30 days'
  GROUP BY user_id
)
SELECT
  u.name,
  au.order_count
FROM users u
INNER JOIN active_users au
  ON u.id = au.user_id
ORDER BY au.order_count DESC;

Window Functions

SELECT
  name,
  department,
  salary,
  RANK() OVER (
    PARTITION BY department
    ORDER BY salary DESC
  ) AS dept_rank
FROM employees;

Formatting SQL in Different Contexts

# Python: SQL in code
query = """
SELECT
  u.name,
  COUNT(o.id) AS total_orders
FROM users u
LEFT JOIN orders o
  ON u.id = o.user_id
GROUP BY u.name
HAVING COUNT(o.id) > 5;
"""

// JavaScript: Template literals
const query = sql`
  SELECT id, name, email
  FROM users
  WHERE active = true
  ORDER BY created_at DESC
  LIMIT 10
`;

SQL Formatting Tools Comparison

• Browser-based (like ours): Quick formatting, no installation, works offline. Best for one-off queries.
• Editor extensions: Format on save, consistent within a project. Best for daily development.
• CLI tools: Integrate into CI/CD and git hooks. Best for team enforcement.

# sql-formatter CLI
npm install -g sql-formatter
sql-formatter -l postgresql query.sql

# pgFormatter (PostgreSQL-specific)
sudo apt install pgformatter
pg_format query.sql

SQL Dialect Differences

Different databases have subtle syntax variations. A good formatter recognizes these:

• MySQL: Backtick quoting, LIMIT without OFFSET
• PostgreSQL: ::type casting, LIMIT/OFFSET
• SQL Server: TOP N instead of LIMIT, square bracket quoting
• SQLite: Minimal syntax, fewest features

-- PostgreSQL-specific
SELECT name, created_at::date
FROM users
WHERE email LIKE '%@example.com'
LIMIT 10 OFFSET 20;

-- SQL Server equivalent
SELECT TOP 10 name, CAST(created_at AS DATE)
FROM users
WHERE email LIKE '%@example.com';

FAQ

Does formatting affect SQL performance?

No. The database parses your query into the same execution plan regardless of whitespace. Formatting is purely for humans.

Which SQL dialect does the formatter support?

Our SQL Formatter supports MySQL, PostgreSQL, SQL Server, and SQLite. It auto-detects common patterns and formats appropriately.

Can it handle very long queries?

Yes. The formatter processes queries of any length entirely in your browser. For extremely complex queries (1000+ lines), it may take a few seconds.

Is my query data private?

Yes. All formatting happens client-side — your SQL queries never leave your browser.

Conclusion

Readable SQL is maintainable SQL. A formatter turns compressed query blobs into structured, navigable code — whether you're debugging, reviewing, or learning. Try our SQL Formatter for instant, dialect-aware formatting with customizable style options.