SQL Formatter & Beautifier: The Complete Guide

Why Format SQL?

SQL is the universal language for interacting with relational databases. Whether you are querying PostgreSQL, MySQL, SQLite, or SQL Server, the same fundamental syntax applies. Yet raw SQL queries — especially complex ones with multiple JOINs, subqueries, and aggregations — quickly become unreadable without proper formatting.

A well-formatted SQL query is easier to review, debug, optimize, and maintain. It reveals the query structure at a glance, making it obvious whether a JOIN condition is missing or a WHERE clause applies to the wrong scope. The SQL Formatter & Beautifier automates this process, giving you clean, consistently formatted SQL instantly.

SQL Syntax Primer

Most SQL queries follow a structured flow of clauses. Here are the core statements and their typical order:

Our formatter recognizes all major SQL keywords and structures them consistently, regardless of the input format.

SQL Formatting Rules

The formatter applies a set of logical rules to transform messy SQL into clean, readable code:

Clause Placement

Each major clause (SELECT, FROM, WHERE, JOIN, etc.) starts on a new line. This is the single most impactful formatting rule for SQL readability.

-- After formatting:
SELECT
  u.name,
  u.email,
  COUNT(o.id) AS order_count
FROM
  users u
  JOIN orders o ON u.id = o.user_id
WHERE
  u.created_at > '2025-01-01'
GROUP BY
  u.id
HAVING
  COUNT(o.id) > 5
ORDER BY
  order_count DESC;

Column Alignment

Column lists in SELECT and GROUP BY clauses are indented with one level, each on its own line with a leading comma:

SELECT
  id,
  name,
  email,
  created_at

Operator Spacing

Comparison operators (=, >, <, !=) and logical operators (AND, OR) get spaces around them:

WHERE age >= 18 AND status = 'active'

Indentation & Case Styles

Choosing an Indentation Width

The formatter supports both 2-space and 4-space indentation:

Uppercase vs. Lowercase Keywords

There is an ongoing debate in the SQL community about keyword casing. The formatter supports both:

-- Uppercase keywords (traditional style)
SELECT name FROM users WHERE status = 'active';

-- Lowercase keywords (modern style)
select name from users where status = 'active';

Toggle the "Uppercase keywords" option to match your team's convention. The formatter handles both consistently.

Syntax Highlighting

The formatted output includes color-coded syntax highlighting to make keywords, functions, strings, numbers, and comments visually distinct:

• Keywords (SELECT, FROM, WHERE) appear in purple
• Functions (COUNT, SUM, AVG) appear in blue
• Strings appear in green
• Numbers appear in orange
• Comments (-- comment) appear in muted gray italic

This highlighting makes it easy to scan a query and quickly identify its structure. The color scheme adapts to both light and dark themes.

Common SQL Patterns

SELECT with JOINs

SELECT
  p.title,
  p.content,
  u.name AS author,
  c.name AS category
FROM
  posts p
  JOIN users u ON p.author_id = u.id
  JOIN categories c ON p.category_id = c.id
WHERE
  p.published = TRUE
ORDER BY
  p.created_at DESC
LIMIT
  20;

INSERT Statement

INSERT INTO
  users (name, email, role)
VALUES
  ('Alice', 'alice@example.com', 'admin'),
  ('Bob', 'bob@example.com', 'user');

UPDATE with JOIN

UPDATE
  orders o
  JOIN payments p ON o.id = p.order_id
SET
  o.status = 'paid',
  p.paid_at = NOW()
WHERE
  o.id = 42;

Practical Examples

Debugging a Slow Query

When a query runs slowly, the first step is understanding what it does. A poorly formatted query hides its intent:

-- Raw, unformatted
SELECT u.name,count(o.id) as cnt FROM users u inner join orders o on u.id=o.user_id WHERE u.active=1 and o.total>100 group by u.id having cnt>2 order by cnt desc;

After formatting with the SQL Formatter:

SELECT
  u.name,
  COUNT(o.id) AS cnt
FROM
  users u
  INNER JOIN orders o ON u.id = o.user_id
WHERE
  u.active = 1
  AND o.total > 100
GROUP BY
  u.id
HAVING
  cnt > 2
ORDER BY
  cnt DESC;

Now the structure is clear: it is a user-order aggregation with a filter on total and a post-aggregation filter. You can immediately see the JOIN condition, the WHERE filters, and the HAVING clause.

Comparing Development vs. Production Queries

Format both versions of a query and diff them side by side. Consistent formatting means meaningful differences (different JOIN type, different WHERE condition) stand out immediately.

SQL Best Practices

• Always format before reviewing: Run every query through a formatter before code review. Clean formatting catches logical errors.
• Use meaningful aliases: Prefer u over users_aliased_table and order_count over cnt.
• Explicit JOIN syntax: Always use explicit JOIN ... ON instead of implicit joins in the FROM clause.
• Comment complex logic: Use -- comments to explain non-obvious conditions or business rules.
• Avoid SELECT *: Always list the columns you need explicitly. It makes the query self-documenting and more efficient.
• Use CTEs for complex queries: The WITH clause (Common Table Expression) breaks complex queries into named steps that are easier to reason about.
• Parameterize values: Never concatenate user input into SQL strings. Use parameterized queries to prevent SQL injection.