SQL Formatter, Beautifier & Optimizer
Format messy SQL queries instantly, detect non-SARGable bottlenecks, and generate high-performance composite indexes.
Query Health & Anti-Pattern Audit
95/100 CleanRecommended Performance Indexes
DDL Index Generation-- Recommended Index Definition:
CREATE INDEX idx_orders_user_created
ON orders (user_id, created_at DESC)
INCLUDE (total_amount);AST Clause & Table Extraction
Click "Run AI Query Audit" to generate deep index tuning advice, EXPLAIN plan cost estimates, and subquery refactoring. Your SQL and schema are 100% private to you—zero server access.
Zero Data Access: All query formatting and AST inspections happen 100% locally on your device. Zero Server Access
Fixing the 42-Second Sequential Scan: How an EXPLAIN ANALYZE Audit & Composite Index Slashed Postgres Query Latency to 4ms
A real-world engineering deep-dive on SARGable predicates, covering indexes, and eliminating redundant nested loops.
The Cost of Non-SARGable Queries
A query is non-SARGable when an operation prevents the database engine from using existing B-Tree index structures. Common culprits include wrapping columns in scalar functions (e.g. WHERE DATE(created_at) = '2026-08-17'), leading wildcards (WHERE email LIKE '%@gmail.com'), or implicit type conversions. This forces the query planner to perform a Sequential Table Scan across millions of disk blocks, saturating I/O and spiking latency from milliseconds to tens of seconds.
The Scenario: SaaS Order History Bottleneck
An enterprise e-commerce platform experienced database connection pool exhaustion during peak flash sales. A dashboard query filtering customer orders was consuming 98% of database CPU:
SELECT * FROM orders WHERE DATE(created_at) = '2026-08-17' AND user_id = 48291;
Execution: 42,400 ms (Seq Scan)
SELECT id, total_amount FROM orders WHERE user_id = 48291 AND created_at >= '2026-08-17 00:00:00' AND created_at < '2026-08-18 00:00:00';
Created composite B-Tree index.
Execution Time: 4.2 ms
Latency Reduction: 99.99%
Index-Only Scan (0 Heap Fetches)
Database Index Architecture Comparison
| Index Type | Best Use Case | Time Complexity | Index Storage Overhead |
|---|---|---|---|
| B-Tree (Standard Default) | Equality, Range (<, >, BETWEEN), ORDER BY | O(log N) | Moderate (10% - 30% of table) |
| GIN (Generalized Inverted) | JSONB keys, Array containment (@>), Full-Text Search | O(log N) | High (Can exceed table size) |
| BRIN (Block Range Index) | Time-series append-only logs (billions of rows) | O(log N) + Block Scan | Ultra-Low (<1% of table size!) |
Golden Rules of Production SQL Performance
Always order composite index columns by Equality First, Range Second (e.g. (user_id, status, created_at)). Use covering indexes (INCLUDE clause) to avoid expensive heap page lookups, and always test with EXPLAIN (ANALYZE, BUFFERS) before promoting queries to production.
Frequently Asked Questions (SQL Optimization)
What makes a SQL query SARGable?
A SARGable (Search Argument Able) query uses predicates in the WHERE clause that allow the database engine to utilize B-Tree index seeks rather than scanning the entire table. Wrapping indexed columns inside functions (e.g., WHERE YEAR(created_at) = 2026) breaks SARGability, whereas range bounds (WHERE created_at >= '2026-01-01' AND created_at < '2027-01-01') maintain full index utilization.
Why is 'SELECT *' considered a SQL anti-pattern?
Using SELECT * forces the database engine to perform heap fetches for unneeded columns (increasing I/O and memory saturation), prevents covering index optimizations (Index-Only Scans), and breaks application caching when new columns are added.
What is the difference between a B-Tree index and a GIN index?
B-Tree indexes are optimized for scalar equality and range queries (=, <, >, BETWEEN, ORDER BY). GIN (Generalized Inverted Index) indexes are designed for composite multi-value data structures like JSONB documents, arrays, and full-text search vectors.