SQL Prettify

Q: Should keywords be uppercase or lowercase?

Both are valid, but consistency matters most. Uppercase (SELECT, FROM, WHERE) is traditional and widely used in enterprise environments, while lowercase is modern and popular in newer codebases. Choose based on your team's style guide.

About SQL Query Formatting

SQL formatting transforms poorly structured SQL queries into well-organized, readable code with proper indentation, keyword capitalization, and logical structure. Essential for maintaining large codebases, code reviews, and team collaboration.

Proper indentation and line breaks
Keyword capitalization and standardization
Logical grouping of clauses and conditions
Comment preservation and formatting
Support for multiple SQL dialects

SQL Formatting Features

Structure Enhancement

Proper clause alignment (SELECT, FROM, WHERE)
Consistent indentation levels
Logical line breaking
Subquery formatting and nesting
JOIN clause organization

Style Options

Keyword capitalization (UPPER/lower/Title)
Custom indentation (spaces or tabs)
Line length control
Comma placement (leading or trailing)
Function and operator spacing

Frequently Asked Questions

Does formatting change SQL functionality?

No! SQL formatting only changes whitespace, indentation, and keyword casing. The logic, performance, and results remain exactly the same. It's purely cosmetic improvement.

What SQL dialects are supported?

Most formatters support standard SQL and popular dialects including MySQL, PostgreSQL, SQL Server, Oracle, and SQLite. Advanced features may vary by dialect.

Should keywords be uppercase or lowercase?

Both are valid, but consistency matters. Uppercase (SELECT, FROM, WHERE) is traditional, while lowercase is modern. Choose based on your team's style guide.

How should I format complex joins?

Each JOIN should be on a separate line with proper indentation. Align ON conditions consistently and consider parentheses for complex conditions to improve readability.

SQL Formatting Examples

Before Formatting (Unreadable):

select u.id,u.name,u.email,p.title,p.created_at from users u inner join posts p on u.id=p.user_id where u.active=1 and p.published=true and u.created_at>='2023-01-01' order by p.created_at desc limit 10;

Issues: No indentation, no line breaks, difficult to understand structure

After Formatting (Readable):

SELECT 
    u.id,
    u.name,
    u.email,
    p.title,
    p.created_at
FROM 
    users u
INNER JOIN 
    posts p ON u.id = p.user_id
WHERE 
    u.active = 1
    AND p.published = true
    AND u.created_at >= '2023-01-01'
ORDER BY 
    p.created_at DESC
LIMIT 10;

Improvements: Clear structure, proper alignment, easy to read and modify

SQL Formatting Styles

Compact Style:

SELECT id, name, email
FROM users u
JOIN profiles p ON u.id = p.user_id
WHERE u.active = 1
  AND p.verified = true
ORDER BY u.created_at DESC;

Less vertical space, good for simple queries

Expanded Style:

SELECT 
    id,
    name,
    email
FROM 
    users u
JOIN 
    profiles p 
    ON u.id = p.user_id
WHERE 
    u.active = 1
    AND p.verified = true
ORDER BY 
    u.created_at DESC;

More vertical space, clearer structure for complex queries

Complex Query Formatting

Subquery and CTE Formatting:

WITH active_users AS (
    SELECT 
        id,
        name,
        email
    FROM users
    WHERE active = 1
        AND created_at >= '2023-01-01'
),
user_stats AS (
    SELECT 
        user_id,
        COUNT(*) as post_count,
        MAX(created_at) as last_post
    FROM posts
    WHERE published = true
    GROUP BY user_id
)
SELECT 
    au.id,
    au.name,
    au.email,
    COALESCE(us.post_count, 0) as total_posts,
    us.last_post
FROM 
    active_users au
LEFT JOIN 
    user_stats us ON au.id = us.user_id
ORDER BY 
    total_posts DESC,
    au.name ASC;

Window Functions:

SELECT 
    employee_id,
    department_id,
    salary,
    ROW_NUMBER() OVER (
        PARTITION BY department_id 
        ORDER BY salary DESC
    ) as salary_rank,
    LAG(salary, 1) OVER (
        PARTITION BY department_id 
        ORDER BY hire_date
    ) as prev_salary,
    AVG(salary) OVER (
        PARTITION BY department_id
    ) as dept_avg_salary
FROM 
    employees
WHERE 
    status = 'active'
ORDER BY 
    department_id,
    salary_rank;

SQL Formatting Best Practices

Consistent Casing: Choose uppercase or lowercase for keywords and stick to it
Logical Indentation: Indent subqueries and nested conditions consistently
One Column Per Line: List SELECT columns vertically for easier modification
Align Related Elements: Align JOIN conditions and WHERE clauses
Use Comments: Add explanatory comments for complex logic
Group Related Conditions: Use parentheses to group logical conditions
Meaningful Aliases: Use clear, descriptive table and column aliases

SQL Formatting Tools

Popular SQL Formatters:

VS Code Extensions:

SQL Formatter
SQLTools
PostgreSQL Formatter

Command Line Tools:

sqlformat (Python)
pg_format (PostgreSQL)
sql-formatter (Node.js)

Online Tools:

SQL Pretty Printer
Format SQL
SQL Formatter Online

Database IDEs:

DBeaver
DataGrip
SQL Server Management Studio

Common Use Cases

Code review preparation
Legacy code cleanup and refactoring
Team coding standards enforcement
Database migration scripts
Query optimization and debugging
Documentation and tutorials
Automated CI/CD code formatting
Database schema maintenance