SQL Cheat Sheet: Commands, Queries, and Window Functions Reference

Having an authoritative sql cheat sheet at your fingertips accelerates query drafting, eliminates syntax lookup interruptions, and reinforces relational database fundamentals. While database engines like PostgreSQL, MySQL, Snowflake, BigQuery, and SQL Server offer vendor-specific dialects, standard ANSI SQL forms the universal backbone across all analytical platforms.

Data analysts write SQL to answer high-stakes business questions: identifying customer churn cohorts, calculating 30-day rolling sales, joining transaction logs with marketing touchpoints, and auditing ledger anomalies. But when writing nested joins or complex window functions under pressure, syntax details—such as whether HAVING accepts aliases or whether NULL = NULL evaluates to true—frequently cause silent query bugs.

In this comprehensive sql cheat sheet, you will find clear syntax blueprints, visual join summaries, aggregation templates, and execution order diagrams. For deeper practice, solve live problems on our interactive SQL practice platform and explore our complete SQL interview questions guide.

SQL Cheat Sheet: Query Structure and Order of Execution

The single most common conceptual error in SQL is confusing the written syntax order with the database engine's logical execution order.

Written Order vs Execution Order

-- How you WRITE a query:             -- How the database EXECUTES it:
1. SELECT                              1. FROM & JOIN
2. FROM & JOIN                         2. WHERE (row filter)
3. WHERE                               3. GROUP BY (aggregation)
4. GROUP BY                            4. HAVING (aggregate filter)
5. HAVING                               5. SELECT (expressions & aliases)
6. ORDER BY                            6. DISTINCT
7. LIMIT / OFFSET                      7. ORDER BY
                                       8. LIMIT / OFFSET

Because SELECT runs in step 5, you cannot reference a column alias created in SELECT inside your WHERE or GROUP BY clause in standard SQL.

Essential SQL Commands Reference

1. Basic Querying and Filtering

-- Retrieve specific columns and filter
SELECT 
    customer_id, 
    first_name, 
    email,
    created_at
FROM customers
WHERE country = 'India'
  AND status = 'active'
  AND signup_date >= '2026-01-01'
ORDER BY created_at DESC
LIMIT 50;

Common Filtering Operators

For a full breakdown of three-valued logic and COALESCE, read our dedicated SQL NULL guide.

2. Aggregations and GROUP BY

Aggregations collapse multiple rows into single summary metrics.

SELECT 
    department,
    COUNT(*) AS total_employees,
    AVG(salary) AS average_salary,
    MIN(salary) AS lowest_salary,
    MAX(salary) AS highest_salary,
    SUM(bonus) AS total_bonuses
FROM employees
WHERE is_active = TRUE
GROUP BY department
HAVING COUNT(*) >= 5
ORDER BY average_salary DESC;

For more nuances between pre-aggregation and post-aggregation filtering, see our SQL GROUP BY vs HAVING guide.

3. SQL Joins Summary

Joins combine columns from two or more tables based on a related matching key.

-- INNER JOIN: Only customers who have placed orders
SELECT c.customer_name, o.order_id, o.amount
FROM customers c
INNER JOIN orders o ON c.customer_id = o.customer_id;
 
-- LEFT JOIN: All customers, including those with zero orders
SELECT c.customer_name, o.order_id, COALESCE(o.amount, 0) AS amount
FROM customers c
LEFT JOIN orders o ON c.customer_id = o.customer_id;

To avoid accidental row explosions, read our deep-dive on SQL JOIN Fan-Out and review SQL Joins Explained with Examples.

4. Window Functions Reference

Window functions calculate metrics across a partition of rows while retaining the original row count (unlike GROUP BY, which collapses rows).

SELECT 
    employee_id,
    department,
    salary,
    -- Unique rank per department
    ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS row_num,
    -- Rank with ties (1, 2, 2, 4)
    RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS rnk,
    -- Dense rank with ties (1, 2, 2, 3)
    DENSE_RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS dense_rnk,
    -- Prior row value for period-over-period comparison
    LAG(salary, 1) OVER (PARTITION BY department ORDER BY hire_date) AS prev_salary,
    -- Running total
    SUM(salary) OVER (PARTITION BY department ORDER BY hire_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS running_dept_total
FROM employees;

For comprehensive visual breakdowns, consult our SQL Window Functions Guide and SQL ROW_NUMBER vs RANK.

5. Common Table Expressions (CTEs) & Subqueries

CTEs replace messy nested subqueries with readable, top-to-bottom procedural blocks.

WITH regional_sales AS (
    SELECT 
        region,
        SUM(revenue) AS total_revenue
    FROM sales
    WHERE sale_year = 2026
    GROUP BY region
),
benchmark AS (
    SELECT AVG(total_revenue) AS avg_revenue 
    FROM regional_sales
)
SELECT 
    r.region,
    r.total_revenue,
    b.avg_revenue,
    r.total_revenue - b.avg_revenue AS variance
FROM regional_sales r
CROSS JOIN benchmark b
ORDER BY variance DESC;

Read our full guide to modular queries in the SQL CTE Guide.

6. Conditional Logic (CASE WHEN)

Implements if/then/else branching directly in SQL statements.

SELECT 
    order_id,
    amount,
    CASE 
        WHEN amount >= 50000 THEN 'Enterprise'
        WHEN amount >= 10000 THEN 'Mid-Market'
        WHEN amount > 0 THEN 'SMB'
        ELSE 'Refund/Zero'
    END AS tier
FROM orders;

For conditional aggregation patterns (such as pivoting columns without PIVOT), read SQL CASE WHEN & Conditional Aggregation.

Common SQL Pitfalls and How to Fix Them

SELECT c.name, o.status
FROM customers c
LEFT JOIN orders o ON c.id = o.customer_id
WHERE o.status = 'shipped'; -- BUG!

SELECT c.name, o.status
FROM customers c
LEFT JOIN orders o ON c.id = o.customer_id AND o.status = 'shipped';

1. Counting Rows vs Counting Values

• COUNT(*) counts every row returned, including rows containing NULL values.
• COUNT(column_name) counts only rows where column_name is non-NULL.
• COUNT(DISTINCT column_name) counts unique non-NULL values.

For complete nuances, performance benchmarks, and partition examples, explore our dedicated guide to the SQL COUNT function.

2. Division by Zero Crashes

Wrap denominators in NULLIF to prevent catastrophic query failures:

SELECT numerator / NULLIF(denominator, 0) AS safe_ratio;

If denominator is 0, NULLIF converts it to NULL, and numerator / NULL returns NULL instead of terminating the query.

When Analysts Rely on this SQL Cheat Sheet

Timed Technical Screening Rounds. Quickly verifying window function syntax (ROWS BETWEEN UNBOUNDED PRECEDING) during live coding assessments.

Data Warehouse Migrations. Ensuring ANSI SQL compatibility when transitioning legacy Oracle or MySQL scripts to Snowflake or PostgreSQL.

Ad-hoc Cohort Modeling. Stacking CTEs to compute month-over-month retention, customer lifetime value, and marketing channel attribution.

Production Query Safety and Troubleshooting Checklist

Before executing analytical queries against production read replicas or data warehouses, review this operational safety checklist:

• Enforce Limit on Unindexed Queries: Always append LIMIT 100 during exploratory query authoring to prevent memory buffer exhaustion.
• Audit Join Cardinality: Count distinct keys prior to joining: SELECT COUNT(*), COUNT(DISTINCT id) FROM table. Non-unique join keys cause silent Cartesian explosions.
• Verify Column Slicing in Analytical Warehouses: In columnar cloud warehouses (Snowflake, BigQuery), avoid SELECT *. Selecting only the 4 required columns instead of all 80 columns reduces disk scan charges and execution latency by over 90%.
• Use CTEs for Multi-Stage Readability: Break nested 4-level subqueries into modular Common Table Expressions. CTEs isolate grain changes, making queries auditable by peer reviewers.

Explore our SQL Tutorials hub and test your syntax on Topfolio Interactive Practice.

Set up a clean local PostgreSQL environment inside VS Code with our VS Code SQLTools PostgreSQL Guide.

Related SQL Tutorials

• What Is SQL? The Complete Beginner to Pro Guide
• SQL Joins Explained with Practical Examples
• SQL Window Functions Guide
• SQL for Data Analysts
• Explore All Guides in the SQL Tutorials Hub