🗄️ SQL Query Formatter & Beautifier

Format, beautify, validate and optimize SQL queries. Support for MySQL, PostgreSQL, SQL Server, Oracle, SQLite with advanced syntax highlighting.

Formatter
Validator
Examples
Syntax Guide
Tips

🔧 SQL Query Formatter

⚙️ Formatting Options

📝 Input SQL Query 0 characters
✨ Formatted SQL 0 lines

📊 Query Analysis

Validation
Valid
Characters
0
Lines
0
Tables
0
Keywords
0
Complexity
Low

🔍 SQL Validator & Analyzer

🔍 SQL Query to Validate

📚 SQL Query Examples

📊 Basic SELECT with JOIN

Simple query with LEFT JOIN and filtering

SELECT u.name, u.email, p.title, p.created_at FROM users u LEFT JOIN posts p ON u.id = p.user_id WHERE u.status = 'active' AND p.published_at IS NOT NULL ORDER BY p.created_at DESC LIMIT 10;
🔢 Complex Aggregation

Advanced query with GROUP BY and window functions

SELECT department, COUNT(*) as employee_count, AVG(salary) as avg_salary, MAX(salary) as max_salary, ROW_NUMBER() OVER (ORDER BY AVG(salary) DESC) as dept_rank FROM employees e JOIN departments d ON e.dept_id = d.id WHERE e.hire_date >= '2020-01-01' GROUP BY department HAVING COUNT(*) > 5 ORDER BY avg_salary DESC;
🔄 Subquery with CTE

Common Table Expression with recursive query

WITH RECURSIVE employee_hierarchy AS ( SELECT id, name, manager_id, 0 as level FROM employees WHERE manager_id IS NULL UNION ALL SELECT e.id, e.name, e.manager_id, eh.level + 1 FROM employees e JOIN employee_hierarchy eh ON e.manager_id = eh.id ) SELECT REPEAT(' ', level) || name as hierarchy, level FROM employee_hierarchy ORDER BY level, name;
📈 Analytics Query

Business intelligence query with multiple metrics

SELECT DATE_TRUNC('month', order_date) as month, COUNT(DISTINCT customer_id) as unique_customers, COUNT(*) as total_orders, SUM(total_amount) as revenue, AVG(total_amount) as avg_order_value, SUM(total_amount) - LAG(SUM(total_amount)) OVER (ORDER BY DATE_TRUNC('month', order_date)) as revenue_growth FROM orders WHERE order_date >= CURRENT_DATE - INTERVAL '12 months' AND status = 'completed' GROUP BY DATE_TRUNC('month', order_date) ORDER BY month DESC;
🛠️ Data Modification

UPDATE with JOIN and conditional logic

UPDATE products p SET price = CASE WHEN c.name = 'Electronics' THEN p.price * 1.1 WHEN c.name = 'Clothing' THEN p.price * 1.05 ELSE p.price * 1.03 END, updated_at = CURRENT_TIMESTAMP FROM categories c WHERE p.category_id = c.id AND p.last_updated < CURRENT_DATE - INTERVAL '30 days';
🏗️ Schema Creation

Table creation with constraints and indexes

CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(50) UNIQUE NOT NULL, email VARCHAR(100) UNIQUE NOT NULL, password_hash VARCHAR(255) NOT NULL, first_name VARCHAR(50), last_name VARCHAR(50), created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, is_active BOOLEAN DEFAULT TRUE ); CREATE INDEX idx_users_email ON users(email); CREATE INDEX idx_users_username ON users(username); CREATE INDEX idx_users_created_at ON users(created_at);

📖 SQL Syntax Reference

📊 SELECT Statement

SELECT column1, column2 FROM table_name WHERE condition GROUP BY column1 HAVING condition ORDER BY column1 ASC|DESC LIMIT number;
  • SELECT: Specifies columns to retrieve
  • FROM: Specifies source table(s)
  • WHERE: Filters rows before grouping
  • GROUP BY: Groups rows for aggregation
  • HAVING: Filters groups after aggregation
  • ORDER BY: Sorts the result set

🔗 JOIN Operations

-- Inner Join SELECT * FROM table1 t1 INNER JOIN table2 t2 ON t1.id = t2.id; -- Left Join SELECT * FROM table1 t1 LEFT JOIN table2 t2 ON t1.id = t2.id;
  • INNER JOIN: Returns matching rows only
  • LEFT JOIN: Returns all left table rows
  • RIGHT JOIN: Returns all right table rows
  • FULL OUTER JOIN: Returns all rows

📊 Aggregate Functions

SELECT COUNT(*) AS total_rows, SUM(amount) AS total_amount, AVG(price) AS avg_price, MAX(date) AS latest_date, MIN(value) AS min_value FROM table_name;
  • COUNT(): Counts rows or non-null values
  • SUM(): Calculates sum of numeric values
  • AVG(): Calculates average value
  • MAX()/MIN(): Finds maximum/minimum value

🪟 Window Functions

SELECT column1, ROW_NUMBER() OVER (ORDER BY column1) AS row_num, RANK() OVER (PARTITION BY column2 ORDER BY column3) AS rank, LAG(column1) OVER (ORDER BY date_col) AS prev_value FROM table_name;
  • ROW_NUMBER(): Assigns sequential numbers
  • RANK(): Assigns ranks with gaps
  • LAG()/LEAD(): Access previous/next row values
  • PARTITION BY: Divides result set into partitions

🔄 Common Table Expressions

WITH cte_name AS ( SELECT column1, column2 FROM table_name WHERE condition ) SELECT * FROM cte_name WHERE another_condition;
  • WITH: Defines temporary named result set
  • RECURSIVE: Enables recursive queries
  • Multiple CTEs: Separate with commas
  • Scope: Available only within the query

🛠️ Data Modification

-- Insert INSERT INTO table_name (col1, col2) VALUES ('value1', 'value2'); -- Update UPDATE table_name SET column1 = 'new_value' WHERE condition; -- Delete DELETE FROM table_name WHERE condition;
  • INSERT: Adds new rows to table
  • UPDATE: Modifies existing rows
  • DELETE: Removes rows from table
  • UPSERT: Insert or update if exists

💡 SQL Best Practices & Tips

🚀 Performance Optimization

  • Use indexes on frequently queried columns
  • Avoid SELECT * in production queries
  • Use WHERE clauses to limit result sets
  • Consider using EXPLAIN to analyze query plans
  • Use appropriate JOIN types
  • Limit subqueries and prefer JOINs when possible
  • Use pagination for large result sets

🔒 Security Best Practices

  • Always use parameterized queries
  • Validate and sanitize user inputs
  • Use principle of least privilege
  • Avoid dynamic SQL construction
  • Regularly update database software
  • Implement proper access controls
  • Use stored procedures when appropriate

📝 Code Quality Guidelines

  • Use consistent naming conventions
  • Format SQL for readability
  • Add comments for complex logic
  • Use table aliases for clarity
  • Organize clauses in logical order
  • Avoid nested subqueries when possible
  • Use meaningful column aliases

🛠️ Database Design Tips

  • Normalize tables to reduce redundancy
  • Use appropriate data types
  • Implement proper constraints
  • Design efficient indexes
  • Consider partitioning for large tables
  • Use foreign keys for data integrity
  • Plan for future scalability

⚡ Common Optimizations

  • Use EXISTS instead of IN for subqueries
  • Consider UNION ALL vs UNION
  • Use covering indexes when possible
  • Optimize WHERE clause order
  • Use appropriate aggregation functions
  • Consider materialized views for complex queries
  • Monitor query execution plans regularly

🐛 Troubleshooting Common Issues

  • Check for missing indexes on JOIN columns
  • Verify data types in comparisons
  • Look for cartesian products in JOINs
  • Check for NULL value handling
  • Verify correct use of aggregate functions
  • Review GROUP BY clause requirements
  • Test with representative data volumes