SQL Formatter

Upload

0 chars

Upload

🐬 MYSQL

Enter SQL on the left to start formatting

Ready

GeekFormat SQL Formatter quickly beautifies and organizes messy SQL query statements. Supports 20 database dialects including MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc., with customizable formatting options such as keyword case, indent style, operator newline position, and expression width. Offers 4 one-click preset styles with built-in SQL minification and syntax validation functions, supporting file upload/download, URL sharing, and keyboard shortcuts. Provides syntax highlighting and adjustable panel layout based on CodeMirror 6 editor with real-time auto-formatting after input. All processing happens locally in your browser—SQL statements are never uploaded to servers.

SQL Builder

SQL Converter

JSON to SQL

JSON Formatter

Diff Checker

JavaScript Formatter

About SQL Formatting

SQL formatting (SQL Formatting / SQL Beautification) refers to adjusting whitespace characters (newlines, indentation, spaces) and keyword case of SQL statements through automated tools to give them consistent, highly readable layout structure. As a declarative query language, a complex SQL query often involves multiple clauses such as multi-table JOIN, nested subqueries, multiple WHERE conditions, GROUP BY grouping, HAVING filtering, ORDER BY sorting, etc. Without formatting, all content crammed into one line or with chaotic indentation severely impacts readability and maintenance efficiency. Formatted SQL places each clause on its own line through reasonable newlines and indentation, expressing nesting levels through indentation, enabling readers to quickly understand query structure.

Why is SQL formatting important? In team collaboration environments, different developers have different coding style preferences—some prefer uppercase keywords, others lowercase; some use 2-space indentation, others 4 spaces or Tab; some place AND at line beginnings, others at line endings. These style differences themselves do not affect SQL execution but generate large amounts of meaningless diff during Code Review, requiring reviewers to distinguish between real logical changes and mere formatting adjustments. Unified SQL formatting standards and automated formatting tools eliminate style debates, allowing teams to focus on business logic itself.

Core rules of SQL formatting usually include the following aspects: First, keyword case—SQL reserved words such as SELECT, FROM, WHERE, JOIN, ON, GROUP BY, ORDER BY, HAVING, LIMIT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP are usually uppercase for distinction from identifiers (or uniformly lowercase per team standards); Second, clause newlines—each major clause (SELECT/FROM/WHERE/GROUP BY/ORDER BY, etc.) on its own line; Third, column name alignment—multiple column names in SELECT lists each occupy one line and vertically aligned; Fourth, indentation levels—subqueries, JOIN conditions, nested CASE expressions, etc., reflect hierarchy through increased indentation; Fifth, operator position—logical operators like AND/OR uniformly placed at line beginnings or endings.

SQL formatting for different database dialects has its particularities. MySQL uses backticks (`) to quote identifiers, PostgreSQL uses double quotes ("), SQL Server uses square brackets ([]); MySQL uses LIMIT for pagination, PostgreSQL supports LIMIT/OFFSET, SQL Server uses TOP or OFFSET/FETCH, Oracle uses ROWNUM; PostgreSQL has :: type cast operator, MySQL has backtick escaping, SQL Server has square bracket identifiers. These dialect differences require formatters to recognize syntax elements specific to particular databases, otherwise special syntax may be misjudged as errors or keywords incorrectly split. This tool is implemented based on sql-formatter library, providing specialized syntax support for 20 mainstream SQL dialects.

SQL minification (SQL Minification) is the reverse of formatting and very useful in certain scenarios. SQL printed in application logs, SQL generated by ORM frameworks (such as Hibernate, MyBatis, Django ORM, SQLAlchemy), SQL captured by database performance monitoring tools—these are often in newline-free single-line compressed format, which is very unfriendly for troubleshooting—formatting is required first for readability. Conversely, when needing to embed SQL into code strings (such as string concatenation in Java/Python/JavaScript), write to configuration files, pass via URL parameters, or share in chat tools that don't support multi-line text, compressing to single line avoids formatting issues caused by newlines and indentation.

Choosing appropriate formatting style requires consideration of team standards and usage scenarios. Uppercase keyword style is SQL's traditional convention—during the printing era, uppercase keywords made handwritten or typewriter-output SQL more readable, and many teams and organizations still use it today. Lowercase keyword style is increasingly popular on modern code platforms like GitHub because lowercase is visually softer and, with syntax highlighting in modern editors, no longer requires case to distinguish keywords. 2-space indent width is more common among frontend developers, 4-space more prevalent among backend Java/C# developers. Tab indentation allows different developers to customize display width in editors. Placing logical operators AND/OR at line beginnings makes scanning each condition easier when reading long condition lists; placing at line endings is more consistent with English reading habits.

Implementation principles of SQL formatting tools are mainly based on lexical analysis (Tokenization) and syntax parsing. Libraries like sql-formatter first decompose SQL strings into a series of tokens (keywords, identifiers, literals, operators, punctuation, comments, etc.), then rearrange these tokens according to syntax rules (different dialects have different rule sets), inserting newlines and indentation at appropriate positions. Unlike general code formatters (such as Prettier), SQL formatters need to understand SQL's specific grammatical structures (such as JOIN...ON conditions, CASE WHEN...END expressions, subquery parenthesis nesting) for correct indentation, not just relying on brace or parenthesis matching.

The following points should be noted when using SQL formatting tools: First, formatting does not verify semantic correctness of SQL—SQL with correct syntax but logical errors (such as wrong JOIN conditions, missing WHERE conditions) remains incorrect after formatting; formatting only improves layout, not logic; Second, formatting tools may in rare edge cases produce results different from original SQL in whitespace-sensitive scenarios (such as spaces within string constants, specific comment positions); simple verification after formatting is recommended; Third, do not execute SQL generated by formatting tools directly in production without testing, especially SQL containing dynamic parameters; Fourth, for SQL containing sensitive data (passwords, keys, PII), use local formatting tools (like this tool) rather than online tools to avoid data leakage risks.

Use Cases

Organize large unformatted SQL stored procedures and complex JOIN queries when taking over legacy projects to quickly understand business logic
Standardize SQL style before team code reviews to eliminate diff noise caused by personal formatting preferences and focus on logic review
Format compressed single-line SQL copied from logs or consoles for easier reading and troubleshooting
Format SQL examples when writing technical documentation and blogs for enhanced professionalism and readability when embedded in documents
Reformat SQL exported from database clients with messy formatting to team-standard style before committing code
Format SQL demonstration statements for use in PPTs and whiteboard explanations when preparing for interviews or technical presentations
Format messy nested subqueries to locate structural issues like mismatched parentheses or missing keywords when troubleshooting SQL errors
SQL logs generated by ORM frameworks are often in newline-free compressed format; format them for easier analysis of actual executed queries
Format CREATE TABLE and INSERT statements for improved maintainability when developing data migration scripts
Standardize formatting before comparing SQL versions across different versions to avoid pure formatting differences interfering with code review
Format sample queries when learning SQL to understand hierarchical relationships of JOIN, subqueries, and GROUP BY through clear indentation and newlines
Format SQL snippets before sharing with colleagues via URL links—recipients see identical formatted results immediately upon opening

How to Use

Select a database dialect (MySQL by default, supporting 20 SQL dialects) to ensure the formatter correctly recognizes syntax
Paste the SQL statements to be formatted into the left editor area, or click the upload button to import .sql/.txt files, or load sample SQL from the samples menu
Click the format button (Shift+Cmd/Ctrl+F) or wait for auto-formatting (automatically triggered 800ms after input), with formatted results displayed instantly on the right
To adjust formatting, click the settings button to expand the configuration panel, adjust options such as keyword case, indentation, and newlines, or select a preset style; for single-line minification, click the minify button
Click the copy button to copy results, or click the download button to save as .sql file, or click the share button to generate a URL link containing SQL content

Features

20 database dialect compatibility: Supports syntax recognition and formatting for 20 SQL dialects including Standard SQL, MySQL, MariaDB, TiDB, PostgreSQL, SQLite, BigQuery, Snowflake, Redshift, DB2, PL/SQL (Oracle), T-SQL (SQL Server), Spark SQL, Hive, Trino, ClickHouse, DuckDB, and more
Keyword case control: Three modes for keywords like SELECT/FROM/WHERE/JOIN: uppercase (UPPER), lowercase (lower), or preserve original case (preserve), with separate configuration for data types and function names
Identifier case control: Identifiers such as table names, column names, and aliases support uppercase, lowercase, or preserve original case, adapting to different team coding standards
Selectable indent styles: Three indent styles available: standard indent, tabular left alignment (tabularLeft), and tabular right alignment (tabularRight) to suit different reading preferences
Flexible indent configuration: Choose indent width from 2 spaces, 4 spaces, or Tab character; set number of blank lines between query statements to 0/1/2 lines
Logical operator newline: Configure whether logical operators like AND/OR break before (before) or after (after) the operator to match your team's code style
Expression width control: Adjustable line width threshold for expression wrapping (20-200 characters), automatically wrapping lines exceeding this width to control single-line code length
Dense operators mode: When enabled, no extra spaces around operators for more compact formatting results, suitable for embedded SQL scenarios
Newline before semicolon: Optionally insert a newline before the statement-ending semicolon, placing the semicolon on its own line for quick statement boundary identification
4 preset styles: One-click switching between Default (UPPER keywords + 2-space indent), Lowercase (all lowercase keywords), Compact (tabular alignment + dense operators), and Spacious (4-space indent + double blank lines) presets without manual adjustment
SQL minification: One-click compression of SQL to a single line, automatically removing comments, extra whitespace, and newlines—ideal for log output, code concatenation, and document embedding
Syntax validation: Basic SQL syntax validation, displaying error messages when formatting fails to help locate syntax issues
Built-in sample SQL: Four sample SQL sets provided: basic queries, complex JOIN queries, multi-statement batches, and CREATE TABLE statements for quick formatting experience
File upload/download: Upload .sql/.txt files to import SQL directly; download formatted results as .sql files for saving
URL sharing: Encode SQL into URL hash using LZ-String compression—copy the link to share formatting configuration and SQL content
Real-time auto-formatting: Auto-format with 800ms debounce after SQL input, showing results instantly without repeated button clicks
Keyboard shortcuts: Shift+Cmd/Ctrl+F for format, Shift+Cmd/Ctrl+C for minify, Shift+Cmd/Ctrl+V for validate, Shift+Cmd/Ctrl+O for upload, Shift+Cmd/Ctrl+D for download, Shift+Cmd/Ctrl+K for clear
CodeMirror editor: SQL syntax-highlighted editor based on CodeMirror 6 with draggable left/right panel width adjustment, font size adjustment, and history panel
One-click copy results: Copy formatted or minified SQL to clipboard with one click for direct pasting into database clients or code
Pure browser-local processing: All SQL formatting completed in browser JavaScript based on sql-formatter library; SQL statements are never uploaded to any server, ensuring data security

FAQ

Does SQL formatting change query logic? Can formatted SQL be executed directly?

It does not change query logic. SQL formatting only adjusts whitespace characters (newlines, indentation, spaces) and keyword case; it does not modify identifiers, values, operators, function calls, or query structure in SQL. Formatted SQL is semantically equivalent to the original SQL and can be copied directly to database clients such as MySQL Workbench, pgAdmin, DBeaver, Navicat for execution. However, verification in a test environment is recommended before execution in production.

Which database dialects are supported? What about SQL syntax differences between databases?

Supports 20 SQL dialects: Standard SQL, MySQL, MariaDB, TiDB, PostgreSQL, SQLite, BigQuery, Snowflake, Redshift, DB2, DB2i, PL/SQL (Oracle), T-SQL (SQL Server), Spark SQL, Hive, Trino, ClickHouse, SingleStoreDB, DuckDB, N1QL (Couchbase). Different databases have differences in pagination syntax (LIMIT vs LIMIT/OFFSET vs TOP vs ROWNUM), string concatenation, date functions, identifier quoting (backticks vs double quotes vs square brackets), etc. Selecting the correct dialect ensures the formatter correctly identifies keywords and function names and avoids misformatting dialect-specific functions.

What is SQL minification? How does it differ from formatting?

SQL minification (Minify) is the reverse of formatting: removes all comments (including /* */ multi-line comments and -- single-line comments), merges consecutive whitespace characters into single spaces, removes extra spaces around parentheses/commas/semicolons/operators, outputting compact single-line SQL. Minification is suitable for scenarios such as embedding SQL in code strings, writing to log files, passing via URL parameters, sharing in chat windows to avoid newline confusion. Formatting, on the other hand, adds appropriate newlines and indentation to improve readability.

When does auto-formatting trigger? Can it be disabled?

After inputting or modifying SQL in the left editor area, formatting is automatically triggered after an 800ms debounce delay (provided the previous formatting had no syntax errors). This is to show formatting results instantly after you stop typing. If you prefer manual control, simply click the format button in the toolbar without waiting for auto-trigger. There is currently no separate switch to disable auto-formatting, but it will not trigger repeatedly as long as input content is not modified.

What to do when formatting fails with a syntax error prompt?

The formatter reports errors when encountering unparseable SQL syntax. Common causes include: 1) Mismatched parentheses—check if left and right parentheses counts match; 2) Unclosed strings—check if single quotes/double quotes appear in pairs, quotes within strings need escaping (like '' or \'); 3) Incorrect database dialect selection—e.g., using PostgreSQL-specific :: type cast syntax but selecting MySQL dialect; 4) Incomplete SQL fragments—e.g., only WHERE conditions without SELECT FROM. Error messages show problem location and reason reported by the parser, which can be used to locate issues. You can also click the validate button (Shift+Cmd/Ctrl+V) first to check syntax.

How to choose between uppercase, lowercase, and preserve keyword case modes?

Uppercase keywords (UPPER) is the most traditional and popular SQL coding style—uppercase keywords like SELECT/FROM/WHERE/JOIN create visual distinction from table/column names, enabling quick location of SQL structure in large codebases. Lowercase keywords are more suitable for modern IDE environments (modern editors have syntax highlighting, no longer relying on case distinction) with more uniform visual appearance. Preserve (preserve) leaves your input case unchanged, suitable for minimal formatting adjustments to existing code. Case strategies for keywords, identifiers (table/column names), data types (VARCHAR/INT/BIGINT), and function names (COUNT/SUM/COALESCE) can be independently configured.

What is the difference between Tabular alignment mode and standard indentation?

Standard indentation (standard) uses traditional hierarchical indentation with fixed space counts for each clause. Tabular left/right alignment modes align column names in SELECT lists, expressions in WHERE conditions, etc., by columns, creating a table-like visual effect. For example, multiple column names after SELECT are vertically aligned, and AS aliases are also aligned to the same column position. This mode is very intuitive when reading multi-column queries on widescreen monitors but may lead to excessively long lines on narrow screens.

How to quickly switch between team-standard SQL style and personal preference?

Use the preset buttons in the settings panel: Default (UPPER keywords + 2-space standard indent), Lowercase (all lowercase keywords), Compact (tabularLeft alignment + dense operators), Spacious (4-space indent + double blank lines between queries). If your team has specific standards, manually adjust options and format. Custom preset saving is not currently supported, but with limited configuration options, quick adjustments are convenient.

Do formatted SQL lose comments?

Format (Format) operation preserves comments—both -- single-line comments and /* */ multi-line comments are retained near their original positions (specific positions depend on comment processing logic of sql-formatter library). However, Compress (Compress) operation removes all comments to generate the most compact single-line SQL; copy formatted results first if comments need to be retained before compression.

Which keyboard shortcuts are supported? What is the difference between Mac and Windows/Linux?

Supports the following shortcuts (use Cmd key on Mac, Ctrl key on Windows/Linux, all require holding Shift simultaneously): Shift+Cmd/Ctrl+F Format; Shift+Cmd/Ctrl+C Minify; Shift+Cmd/Ctrl+V Syntax validation; Shift+Cmd/Ctrl+O Upload file; Shift+Cmd/Ctrl+D Download file; Shift+Cmd/Ctrl+K Clear content. Click the question mark icon in the toolbar to view shortcut list anytime.

Is there a size limit for SQL file uploads? Which file formats are supported?

Supports uploading text files in .sql and .txt formats. There is theoretically no hard limit on file size, but browser processing of very large files (e.g., SQL dump files exceeding 1MB) may have performance issues. Processing individual queries or small-scale script files is recommended. For very large SQL files (e.g., complete database dumps), split into smaller segments before formatting. File content is read via browser FileReader API and never uploaded to servers.

Is the URL sharing feature secure? Can servers see SQL content?

The URL sharing feature compresses SQL content using LZ-String and encodes it into the hash part of the URL (content after #). The URL hash part has the characteristic that it is never sent to servers with HTTP requests and is only processed locally in the browser. When you copy a share link to others, their browser parses the hash and decompresses it to display SQL content—SQL never passes through any servers throughout the process. However, note that share links contain complete SQL content; if SQL contains sensitive information (such as passwords, keys, personal data), do not share links in public channels.

Can scripts containing multiple SQL statements be formatted?

Yes. The tool supports batch formatting of multiple SQL statements (e.g., multiple SELECT/INSERT/UPDATE/CREATE TABLE statements separated by semicolons). You can control spacing between statements (0/1/2 lines) via the "Lines Between Queries" option in the settings panel. Load the "Multi-statement" sample SQL to experience multi-statement formatting. Each statement is independently indented and formatted, separated between statements by configured blank line count.

What size of SQL statements causes lag?

Based on pure JavaScript implementation of sql-formatter library, processing SQL within a few hundred lines usually responds in milliseconds in modern browsers without noticeable lag. Even stored procedures or complex queries of thousands of lines complete within 1 second. All calculations complete on browser main thread; very large files (e.g., SQL dumps exceeding 10,000 lines) may cause brief interface freezing—batch processing is recommended.

Does the tool require internet access? Is SQL data secure?

Works offline after page loads; SQL formatting, minification, and validation all complete in browser-local JavaScript without sending your input SQL statements to any external servers. Does not use Cookie tracking or collect user-input SQL content. Implemented based on mature open-source sql-formatter library with transparent and auditable code logic.

Troubleshooting

What to do about formatting errors "Parse error" or "SQL formatting failed"?

The formatter performs SQL parsing based on sql-formatter library and reports errors when encountering unrecognized syntax. Common causes and solutions: 1) Mismatched parentheses—check if left and right parentheses counts match, use editor's parenthesis matching highlight feature to assist checking; 2) Unclosed string quotes—check if single quotes, double quotes appear in pairs, quotes within strings need escaping (like '' or \'); 3) Wrong database dialect selection—e.g., using PostgreSQL's :: operator but selecting MySQL dialect, switch to correct dialect; 4) Incomplete SQL statements—e.g., only WHERE clause without SELECT FROM; 5) Using very special database-specific syntax (such as certain stored procedure control flows), try switching to closest dialect, or simplify SQL fragments before formatting.

Garbled Chinese or special characters after formatting?

This tool fully supports UTF-8 encoding; Chinese and Unicode characters remain unchanged during formatting. If garbled characters appear, it is usually because pasted SQL itself comes from files with incorrect encoding (such as copying from GBK-encoded files). Ensure source files are saved using UTF-8 encoding, or convert files to UTF-8 encoding before pasting. Browser-side CodeMirror editor defaults to UTF-8 and does not introduce encoding conversion.

No response or empty display after uploading SQL file?

File upload only supports text files with .sql and .txt extensions. If files are binary format (such as .sqlite database files, .doc documents), they display garbled or empty after upload. In addition, some browsers have security restrictions on reading local files via JavaScript—ensure you select files by actively clicking the upload button rather than drag-and-drop (drag-and-drop upload currently unsupported). File size recommended not exceeding 1MB; exceeding may cause slow browser parsing.

Some keywords become lowercase/uppercase after formatting, inconsistent with original input?

This is normal formatting behavior. The keyword case (keywordCase) option defaults to UPPER, which uniformly converts SQL keywords to uppercase. If you wish to preserve original case unchanged, set case options for keywords, identifiers, data types, functions to "preserve (preserve)" in the settings panel—this way the formatter only adjusts newlines and indentation without changing any letter case.

Glossary

SQL Dialect: Extensions and variants of Standard SQL by different database management systems (DBMS). For example, MySQL's LIMIT, PostgreSQL's :: type cast, SQL Server's TOP, Oracle's ROWNUM are all dialect-specific syntax. Correct dialect selection during formatting ensures correct syntax parsing.
Keyword Case: Case strategy for SQL reserved words (SELECT/FROM/WHERE/JOIN, etc.). Uppercase (UPPER) is traditional style, lowercase (lower) increasingly popular in modern development, preserve (preserve) for minimal changes.
Identifier: Database object names in SQL, including database names, table names, column names, aliases, index names, view names, stored procedure names, etc. Different databases quote identifiers differently: MySQL uses backticks, PostgreSQL uses double quotes, SQL Server uses square brackets.
Indent Style: Controls indentation alignment during SQL formatting. Standard indent uses hierarchical progression; tabularLeft/tabularRight align column names and aliases in tabular form, better readability on widescreen but may produce longer lines.
Logical Operator Newline: Newline position of logical operators like AND/OR in multi-line conditions. before means operator at beginning of next line, after means operator at end of current line. Different teams have different preferences.
Expression Width: Single-line character count threshold triggering wrapping (20-200 characters). Expressions exceeding this width are wrapped, similar to printWidth/ruler settings in code editors.
Dense Operators: A formatting option that, when enabled, leaves no extra spaces around operators (=, <, >, +, -, etc.), such as `WHERE id=1 AND status='active'` instead of `WHERE id = 1 AND status = 'active'`, producing more compact output.
Lines Between Queries: Number of blank lines between multiple SQL statements. 0 means contiguous arrangement, 1 means one blank line separation (common), 2 means two blank lines (spacious style), affecting readability of multi-statement scripts.
SQL Minify/Compress: Removes all comments and extra whitespace from formatted SQL, merging into single-line compact format. Suitable for log output, code embedding, URL passing, etc.—reverse operation of formatting.
Pretty Print: Output of code or data in highly readable format through automatic indentation and newlines. SQL Pretty Print is SQL formatting beautification, opposite to Minify (compression).
CodeMirror: Browser-side code editor component (version 6) used by this tool, providing SQL syntax highlighting, line number display, code folding and other editing enhancements—industry widely used Web code editor solution.
sql-formatter: Open-source SQL formatting library used at the core of this tool, supporting lexical analysis and formatted output for multiple SQL dialects—one of the most popular SQL formatting libraries in frontend ecosystem.

Supported SQL Dialects List

The tool supports 20 SQL database dialects—selecting the dialect matching your database yields optimal formatting results:

Dialect	Database	Description
Standard SQL	Standard SQL	ANSI SQL standard syntax, suitable for general scenarios and unknown dialects
MySQL	MySQL / TiDB	Most popular open-source relational database, backtick identifiers, LIMIT pagination
MariaDB	MariaDB	MySQL fork, MySQL-compatible syntax with extended functions
PostgreSQL	PostgreSQL	Feature-rich open-source database, double-quote identifiers, :: type casting
SQLite	SQLite	Embedded lightweight database, commonly used in mobile applications and browsers
T-SQL	SQL Server / Azure	Microsoft SQL Server's Transact-SQL, square bracket identifiers, TOP pagination
PL/SQL	Oracle	Oracle's procedural SQL extension, ROWNUM pagination, rich built-in packages
BigQuery	Google BigQuery	Google cloud data warehouse, supports nested types like STRUCT/ARRAY
Snowflake	Snowflake	Cloud-native data warehouse with strong semi-structured data processing capabilities
Redshift	AWS Redshift	Amazon Web Services data warehouse, PostgreSQL-based but with proprietary syntax

Formatting Preset Style Comparison

4 one-click preset styles for different usage scenarios:

Preset	Keywords	Indentation	Operators	Query Spacing
Default	`UPPER`	`2 spaces Standard`	Normal spacing	1 blank line
Lowercase	`lower`	`2 spaces Standard`	Normal spacing	1 blank line
Compact	`UPPER`	`Tabular Left`	Dense mode	1 blank line
Spacious	`UPPER`	`4 spaces Standard`	Normal spacing	2 blank lines

Keyboard Shortcuts Overview

All shortcuts require holding modifier key + Shift + corresponding letter key simultaneously:

Action	Mac	Windows/Linux	Description
Format	`⇧⌘F`	`Shift+Ctrl+F`	Beautify SQL statements, add newlines and indentation
Minify	`⇧⌘C`	`Shift+Ctrl+C`	Compress SQL to single line, remove comments and whitespace
Validate	`⇧⌘V`	`Shift+Ctrl+V`	Check SQL syntax correctness
Upload	`⇧⌘O`	`Shift+Ctrl+O`	Load .sql/.txt from local file
Download	`⇧⌘D`	`Shift+Ctrl+D`	Save results as .sql file
Clear	`⇧⌘K`	`Shift+Ctrl+K`	Clear input and output content

Privacy & Security

All operations of this SQL formatter are completed entirely locally in your browser: SQL statements you input, selected dialect, and formatting configuration are all processed in browser JavaScript through sql-formatter library without sending any SQL content or configuration to external servers over the network. File upload reads local file content via HTML5 FileReader API without network transmission. URL sharing feature encodes compressed SQL in URL hash part (content after # is never sent to servers with HTTP requests), only decompressed and displayed locally in browser. Does not use Cookie tracking or collect user-input SQL content or usage behavior data. After closing or refreshing the page, input content and configuration state automatically reset (history records only saved in local localStorage).

Authoritative References

GitHubsql-formatter Official Documentation
codemirror.netCodeMirror 6 Official Website
WikipediaWikipedia - SQL Syntax