SQL Formatter
Format, beautify and minify SQL with support for multiple database dialects, configurable indentation and keyword casing directly in your browser.
Format or Minify SQL
Beautify SQL for readability or compact it while preserving quoted strings, comments and dialect-specific syntax where supported.
Choose the dialect that matches the database or SQL engine that will actually run the query.
Controls spacing between multiple SQL statements.
Operation
Format
Dialect
Standard SQL
Indentation
2 Spaces
Keyword Case
Uppercase
Shortcut: Ctrl/Cmd + Enter to process SQL
Query Overview
Lightweight lexical information about the SQL you entered.
Statements
—
Comments
—
Parameters
—
Size Change
0.0%
SQL Keyword Statistics
Counts are lexical indicators and are not a substitute for full SQL parsing.
SELECT
—
INSERT
—
UPDATE
—
DELETE
—
JOIN
—
WHERE
—
GROUP BY
—
ORDER BY
—
WITH
—
SQL Size Comparison
Input
0
Lines
0
Characters
0
Bytes
Output
0
Lines
0
Characters
0
Bytes
SQL Formatting Example
Compact SQL
select u.id,u.name,o.total from users u left join orders o on o.user_id=u.id where u.active=1 and o.total>100 order by o.total desc;
Formatted SQL
SELECT
u.id,
u.name,
o.total
FROM
users u
LEFT JOIN orders o ON o.user_id = u.id
WHERE
u.active = 1
AND o.total > 100
ORDER BY
o.total DESC;
Common SQL Clauses
| Clause | Purpose |
|---|---|
SELECT
|
Choose columns or expressions to return. |
FROM
|
Specify tables, views or query sources. |
JOIN
|
Combine rows from multiple data sources. |
WHERE
|
Filter rows before grouping or aggregation. |
GROUP BY
|
Group rows for aggregate calculations. |
HAVING
|
Filter grouped results after aggregation. |
ORDER BY
|
Control the order of returned rows. |
WITH
|
Define common table expressions. |
Common SQL Parameter Styles
Different libraries and database systems use different placeholder styles.
?
Positional placeholder
:email
Named parameter
$1
PostgreSQL-style parameter
@userId
T-SQL-style variable
SQL and Laravel
Laravel normally generates parameterized SQL through the query builder or Eloquent.
$users = DB::table('users')
->where('active', true)
->where('role', 'admin')
->orderBy('name')
->get();
When debugging generated SQL, formatting the query can make joins, filters and nested conditions much easier to inspect.
SQL Dialects Are Not Interchangeable
MySQL, PostgreSQL, SQL Server, SQLite, BigQuery and other systems share many SQL concepts, but they do not implement exactly the same grammar, functions, data types or extensions.
Select the dialect that matches the actual database whenever possible.
Formatting Is Not Full SQL Validation
A query may format successfully and still fail when executed. The formatter cannot know whether tables, columns, functions, permissions or database-specific objects actually exist.
Important SQL should still be tested against the intended database engine and schema.
SQL Minification Is Not Query Optimization
Removing formatting whitespace makes SQL text smaller, but it does not normally make the database execute the query faster.
Query performance depends on factors such as execution plans, indexing, joins, filters, data volume and database configuration.
Formatting Does Not Prevent SQL Injection
SQL injection is a query-construction security problem, not a formatting problem.
Applications should use parameterized queries, prepared statements, framework query builders and appropriate input handling rather than concatenating untrusted values directly into SQL.
Private Browser-Based SQL Formatting
SQL formatting and minification happen directly inside your browser during normal interactive use.
- No database connection is required.
- No SQL statement is executed.
- No file upload is required.
- SQL text does not need to be sent to SwiftVecto's server.
- Dialect-aware formatting uses the installed sql-formatter package locally.
Continue with These Tools
Finished using SQL Formatter? Here are some related tools that people commonly use next to complete their workflow faster.
JSON Formatter & Validator
Format, beautify, minify and validate JSON online instantly. Detect invalid JSON, organise nested data and create clean, readable JSON directly in your browser.
XML Formatter & Validator
Format, minify and validate XML instantly. Beautify XML with configurable indentation, detect malformed markup and inspect document statistics directly in your browser.
YAML Formatter & Validator
Format and validate YAML, convert YAML to JSON, inspect nested structure and catch syntax errors using reliable YAML parsing directly in your browser.
Unix Timestamp Converter
Convert Unix timestamps to readable dates or convert dates back to Unix time. Work with seconds, milliseconds, UTC, ISO 8601 and timezones directly in your browser.
Regex Tester
Test JavaScript regular expressions online with live match highlighting, capturing groups, named groups, flags and replacement previews directly in your browser.
How to Format and Minify SQL
Use the SwiftVecto SQL Formatter to turn compact or inconsistently formatted SQL into readable queries. Choose the SQL dialect, indentation style and keyword case, or minify SQL when you need a compact representation.
Overview
SQL is used by relational databases to query and manipulate structured data, but SQL syntax varies between database systems. MySQL, PostgreSQL, SQLite, MariaDB, Microsoft SQL Server, BigQuery and other platforms share common SQL concepts while also introducing dialect-specific keywords and syntax. The SwiftVecto SQL Formatter uses a dedicated SQL formatting library in the browser so queries can be formatted according to the selected dialect rather than relying on fragile regular-expression replacements. The formatter can restructure SELECT lists, JOIN clauses, WHERE conditions, GROUP BY expressions, ORDER BY clauses, INSERT statements, UPDATE statements and other common SQL constructs while preserving the query itself.
Benefits
How It Works
Paste or type SQL into the input editor.
Choose the SQL dialect that most closely matches the database system using the query.
Choose Format SQL to restructure the query for readability.
Choose Minify SQL to reduce unnecessary formatting whitespace.
Select the preferred indentation width.
Choose whether SQL keywords should be uppercased, lowercased or left unchanged.
The browser passes the SQL and formatting configuration to the installed SQL formatting library.
The formatter tokenizes the query and applies dialect-aware formatting rules.
The resulting SQL is displayed without executing it against any database.
Basic document statistics are calculated locally.
The formatted or compact query can then be copied directly.
How to Use This Tool
-
1Paste SQL into the input area.
-
2Choose Format SQL or Minify SQL.
-
3Select the correct database dialect.
-
4Choose your indentation style.
-
5Choose the preferred SQL keyword case.
-
6Run the formatter.
-
7Review the resulting SQL.
-
8Copy the output when required.
-
9Use Load Sample to test the tool quickly.
-
10Use Clear before starting an unrelated query.
Helpful Tips
- Choose the dialect that matches the database that will actually execute the query.
- MySQL and PostgreSQL share much SQL syntax but are not identical.
- T-SQL includes Microsoft SQL Server-specific syntax.
- BigQuery has syntax and data types not found in ordinary SQL implementations.
- Formatting changes presentation, not database semantics.
- Always test modified SQL against the target database before production use.
- The formatter does not execute queries.
- Formatting SQL is not the same as validating SQL against a database schema.
- A formatter cannot know whether a table or column actually exists.
- A query can be syntactically plausible but still fail when executed.
- Use uppercase keywords if you prefer SELECT, FROM and WHERE to stand out visually.
- Preserving keyword case is useful when working with an existing code style.
- Formatting is especially useful for long JOIN chains and nested subqueries.
- Common table expressions are easier to inspect when consistently indented.
- Do not paste database passwords or other secrets into SQL comments unnecessarily.
- Parameter placeholders should normally remain placeholders rather than being replaced with sensitive values for formatting.
Common Uses
Format a long SELECT query.
Beautify an SQL statement copied from application logs.
Format a Laravel query log statement.
Format MySQL JOIN queries.
Format PostgreSQL common table expressions.
Format SQL Server T-SQL.
Format SQLite schema queries.
Format BigQuery SQL.
Minify SQL embedded in test fixtures.
Normalize keyword casing across a query.
Make nested subqueries easier to read.
Inspect a generated SQL query while debugging an application.
Worked Examples
The following examples demonstrate how this tool can be used in realistic scenarios.
Formatting a SELECT Query
The compact query SELECT id,name,email FROM users WHERE active=1 ORDER BY name can be expanded so SELECT columns, FROM, WHERE and ORDER BY clauses are visually separated.
Formatting a JOIN
A query joining users and orders can be reformatted so JOIN conditions are clearly separated from filtering conditions in the WHERE clause.
Formatting a Nested Query
Subqueries can be indented relative to the outer query, making nested SQL logic significantly easier to follow.
Keyword Case
A query written using select, from and where can be reformatted with uppercase keywords as SELECT, FROM and WHERE without changing the query structure.
Formatting Multiple Statements
Multiple SQL statements separated by semicolons can be formatted with consistent spacing so each statement is easier to distinguish.
Common Mistakes
Avoid these common mistakes to achieve the most accurate results.
- Assuming formatting proves a query is valid SQL.
- Selecting the wrong SQL dialect.
- Assuming all SQL databases support identical syntax.
- Expecting the formatter to verify that tables exist.
- Expecting the formatter to verify that columns exist.
- Expecting the formatter to execute the query.
- Treating formatting changes as database schema changes.
- Assuming formatted SQL is automatically safe from SQL injection.
- Pasting interpolated user input into SQL instead of using parameterized queries.
- Confusing SQL minification with database query optimization.
- Assuming fewer characters means a faster SQL query.
- Using MySQL-specific syntax with PostgreSQL.
- Using PostgreSQL-specific syntax with SQL Server.
- Changing query text manually after formatting without retesting it.
- Expecting comments and unusual vendor-specific syntax to behave identically across every dialect.
Glossary
Definitions of the most important terms used by this tool.
SQL
Structured Query Language, used to define, query and manipulate data in relational database systems.
SQL Dialect
A database-specific variation of SQL syntax and features.
SQL Formatter
A tool that restructures SQL whitespace, indentation and keyword presentation to improve readability.
SQL Minifier
A tool that reduces non-essential formatting whitespace in SQL.
SELECT
An SQL statement used to retrieve data.
FROM
A clause identifying the tables or sources from which data is retrieved.
WHERE
A clause used to filter rows according to conditions.
JOIN
An SQL operation combining rows from multiple tables or query sources.
GROUP BY
An SQL clause that groups rows for aggregation.
ORDER BY
An SQL clause controlling result ordering.
CTE
Common Table Expression, a named temporary query result commonly introduced using WITH.
Subquery
An SQL query nested inside another SQL statement.
T-SQL
Transact-SQL, Microsoft SQL Server's extended SQL dialect.
DDL
Data Definition Language statements such as CREATE, ALTER and DROP.
DML
Data Manipulation Language statements such as INSERT, UPDATE and DELETE.
Parameterized Query
A query that sends values separately from SQL syntax, helping prevent SQL injection and improve query handling.
Frequently Asked Questions
What is an SQL formatter?
An SQL formatter restructures query whitespace, indentation and keyword presentation to make SQL easier to read.
Does formatting SQL change what the query does?
A formatter is intended to change presentation rather than query semantics. Important queries should still be tested against the target database after formatting.
Can this tool format MySQL?
Yes. The browser formatter supports MySQL-oriented SQL formatting.
Can this tool format PostgreSQL?
Yes. PostgreSQL can be selected as the SQL dialect.
Can this tool format SQLite queries?
Yes. SQLite is supported as a selectable SQL dialect.
Can this tool format SQL Server queries?
Yes. Microsoft SQL Server and T-SQL style formatting can be selected where supported by the formatter.
Can this tool format BigQuery SQL?
Yes. BigQuery can be exposed as a selectable dialect in the browser formatter.
Can I format multiple SQL statements at once?
Yes. SQL statements separated by semicolons can be processed together.
Can this tool uppercase SQL keywords?
Yes. The interface supports keyword casing options so keywords can be uppercased, lowercased or preserved.
Does the SQL formatter execute queries?
No. The formatter only processes SQL text and does not connect to or execute against a database.
Does this tool validate SQL?
The formatter may detect certain malformed input while processing, but it is not a complete database validator. True SQL validation depends on the database dialect, schema, tables, columns, functions and server version.
Can a formatted query still contain an error?
Yes. A query may format successfully but still contain invalid table names, invalid columns, type errors or application-specific problems.
Does formatting SQL prevent SQL injection?
No. SQL injection is prevented through proper parameterization, validation and secure database access patterns rather than formatting.
Does minifying SQL make it run faster?
Normally no meaningful database performance improvement comes from reducing formatting whitespace. Query performance depends on execution plans, indexes, data volume, query design and database configuration.
Can this formatter handle JOIN queries?
Yes. JOIN clauses and their conditions can be formatted for readability.
Can this formatter handle subqueries?
Yes. Nested queries are a major use case for SQL formatting.
Can this formatter handle common table expressions?
Yes, depending on the selected SQL dialect and syntax supported by the formatter library.
Why do SQL dialects matter?
Database systems extend SQL differently. Selecting the correct dialect helps the formatter understand keywords and syntax specific to that platform.
What SQL dialect should I choose for Laravel?
Choose the database engine used by the Laravel application, such as MySQL, PostgreSQL, SQLite or SQL Server. Laravel itself does not define a separate SQL dialect.
Can I format SQL copied from Laravel query logs?
Yes. SQL generated or logged by Laravel can be pasted into the formatter for easier inspection.
Does SwiftVecto upload my SQL?
The interactive SQL Formatter is designed to format ordinary SQL directly inside your browser.
Is the SQL Formatter free?
Yes. SwiftVecto provides this developer utility for formatting and inspecting SQL queries.
Things to Know
- The browser implementation uses the installed sql-formatter JavaScript package.
- The SQL formatter is browser-first and does not require a database connection.
- No SQL is executed by the tool.
- Formatting should not be represented as full SQL validation.
- Dialect selection affects formatting behaviour.
- Supported dialect options should reflect the actual installed sql-formatter package version.
- Keyword casing can be configured independently of indentation.
- The formatter can process multiple statements when supported by the selected dialect.
- Normal interactive processing is intended to happen directly inside the browser.
Disclaimer
Successful formatting does not guarantee that a query is valid for a database server.
The formatter does not verify database schemas, table names, column names, functions, permissions or server versions.
Formatting does not protect applications from SQL injection.
Database-specific extensions may require the correct SQL dialect to be selected.
Users should test important SQL against the intended database environment before production use.
Official References
The following official resources were used when developing this tool and are useful for further reading.