Named Subqueries

Nested subqueries everywhere? Can’t understand your own query? CTEs (WITH clause) create temporary named result sets. Makes complex queries readable.

The Subquery Nightmare

--  Nested subqueries - Unreadable!
SELECT 
  customer_name,
  total_orders,
  avg_order_value
FROM (
  SELECT 
    c.name AS customer_name,
    COUNT(o.id) AS total_orders,
    AVG(o.total) AS avg_order_value
  FROM customers c
  JOIN (
    SELECT * 
    FROM orders 
    WHERE status = 'completed'
  ) o ON c.id = o.customer_id
  WHERE c.created_at > '2024-01-01'
  GROUP BY c.id, c.name
) customer_stats
WHERE total_orders > 5
ORDER BY avg_order_value DESC;

-- Hard to read, maintain, debug

CTE Solution – Clean & Readable

--  CTE - Step by step, readable
WITH completed_orders AS (
  SELECT * 
  FROM orders 
  WHERE status = 'completed'
),
recent_customers AS (
  SELECT * 
  FROM customers 
  WHERE created_at > '2024-01-01'
),
customer_stats AS (
  SELECT 
    c.id,
    c.name AS customer_name,
    COUNT(o.id) AS total_orders,
    AVG(o.total) AS avg_order_value
  FROM recent_customers c
  JOIN completed_orders o ON c.id = o.customer_id
  GROUP BY c.id, c.name
)
SELECT 
  customer_name,
  total_orders,
  avg_order_value
FROM customer_stats
WHERE total_orders > 5
ORDER BY avg_order_value DESC;

-- Each step has a name!
-- Easy to understand flow
-- Easy to debug each CTE separately

-- Define multiple CTEs with comma separation
WITH 
-- CTE 1: Sales by product
product_sales AS (
  SELECT 
    product_id,
    SUM(quantity) AS total_quantity,
    SUM(total_price) AS total_revenue
  FROM order_items
  WHERE order_date >= '2024-01-01'
  GROUP BY product_id
),
-- CTE 2: Top products
top_products AS (
  SELECT 
    product_id,
    total_revenue
  FROM product_sales
  WHERE total_revenue > 10000
),
-- CTE 3: Product details
product_details AS (
  SELECT 
    p.id,
    p.name,
    p.category,
    tp.total_revenue
  FROM products p
  JOIN top_products tp ON p.id = tp.product_id
)
-- Final query uses all CTEs
SELECT 
  category,
  COUNT(*) AS product_count,
  SUM(total_revenue) AS category_revenue
FROM product_details
GROUP BY category
ORDER BY category_revenue DESC;

Recursive CTEs

-- Hierarchical data: Employee org chart
WITH RECURSIVE employee_hierarchy AS (
  -- Base case: Top-level managers (no manager)
  SELECT 
    id,
    name,
    manager_id,
    1 AS level,
    name AS path
  FROM employees
  WHERE manager_id IS NULL
  
  UNION ALL
  
  -- Recursive case: Employees with managers
  SELECT 
    e.id,
    e.name,
    e.manager_id,
    eh.level + 1,
    eh.path || ' > ' || e.name
  FROM employees e
  JOIN employee_hierarchy eh ON e.manager_id = eh.id
)
SELECT 
  id,
  name,
  level,
  path
FROM employee_hierarchy
ORDER BY level, name;

-- Result:
-- id | name    | level | path
-- 1  | CEO     | 1     | CEO
-- 2  | CTO     | 2     | CEO > CTO
-- 3  | CFO     | 2     | CEO > CFO
-- 4  | Dev1    | 3     | CEO > CTO > Dev1
-- 5  | Dev2    | 3     | CEO > CTO > Dev2

-- Generate numbers 1 to 100
WITH RECURSIVE numbers AS (
  SELECT 1 AS n
  UNION ALL
  SELECT n + 1
  FROM numbers
  WHERE n < 100
)
SELECT n FROM numbers;

-- Generate date range
WITH RECURSIVE date_range AS (
  SELECT DATE('2024-01-01') AS date
  UNION ALL
  SELECT DATE(date, '+1 day')
  FROM date_range
  WHERE date < '2024-12-31'
)
SELECT date FROM date_range;

-- Use case: Fill gaps in data
WITH RECURSIVE all_months AS (
  SELECT DATE('2024-01-01') AS month
  UNION ALL
  SELECT DATE(month, '+1 month')
  FROM all_months
  WHERE month < '2024-12-01'
)
SELECT 
  am.month,
  COALESCE(s.revenue, 0) AS revenue
FROM all_months am
LEFT JOIN monthly_sales s ON am.month = s.month;

Real-World Examples

WITH 
-- Today's sales
today_sales AS (
  SELECT SUM(total) AS today_total
  FROM orders
  WHERE DATE(created_at) = CURRENT_DATE
),
-- Yesterday's sales
yesterday_sales AS (
  SELECT SUM(total) AS yesterday_total
  FROM orders
  WHERE DATE(created_at) = CURRENT_DATE - INTERVAL '1 day'
),
-- This month's sales
month_sales AS (
  SELECT SUM(total) AS month_total
  FROM orders
  WHERE DATE_TRUNC('month', created_at) = DATE_TRUNC('month', CURRENT_DATE)
),
-- Active users today
active_users AS (
  SELECT COUNT(DISTINCT user_id) AS active_count
  FROM user_sessions
  WHERE DATE(created_at) = CURRENT_DATE
)
-- Combine all metrics
SELECT 
  ts.today_total,
  ys.yesterday_total,
  ts.today_total - ys.yesterday_total AS daily_change,
  ms.month_total,
  au.active_count
FROM today_sales ts, yesterday_sales ys, month_sales ms, active_users au;

"Inherited 200-line query with 7 levels of nested subqueries. Couldn't understand it. Rewrote with CTEs. Now 15 named steps, crystal clear. Junior dev understood it immediately."

SQL Superpowers

Need row numbers? Running totals? Rankings? Window functions perform calculations across table rows without GROUP BY. Game-changing for analytics.

ROW_NUMBER() – Assign Row Numbers

--  Old way: Can't number rows easily
SELECT name, salary, department
FROM employees
ORDER BY salary DESC;

--  Window function: Add row numbers
SELECT 
  ROW_NUMBER() OVER (ORDER BY salary DESC) AS row_num,
  name,
  salary,
  department
FROM employees;

-- Result:
-- row_num | name    | salary | department
-- 1       | Alice   | 120000 | Engineering
-- 2       | Bob     | 110000 | Engineering
-- 3       | Charlie | 100000 | Sales
-- 4       | David   | 95000  | Marketing

-- Row number per department
SELECT 
  ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank,
  name,
  salary,
  department
FROM employees;

-- Result: Separate numbering per department
-- dept_rank | name    | salary | department
-- 1         | Alice   | 120000 | Engineering
-- 2         | Bob     | 110000 | Engineering
-- 1         | Charlie | 100000 | Sales
-- 1         | David   | 95000  | Marketing

-- RANK() - Gaps in ranking for ties
SELECT 
  RANK() OVER (ORDER BY score DESC) AS rank,
  name,
  score
FROM students;

-- score: 100, 100, 95, 90
-- rank:  1,   1,   3,  4  (gap at 2!)

-- DENSE_RANK() - No gaps
SELECT 
  DENSE_RANK() OVER (ORDER BY score DESC) AS rank,
  name,
  score
FROM students;

-- score: 100, 100, 95, 90
-- rank:  1,   1,   2,  3  (no gap)

-- Top 3 salaries per department
SELECT *
FROM (
  SELECT 
    name,
    salary,
    department,
    RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank
  FROM employees
) ranked
WHERE dept_rank <= 3;

Running Totals with SUM()

-- Running total of sales
SELECT 
  order_date,
  amount,
  SUM(amount) OVER (ORDER BY order_date) AS running_total
FROM orders;

-- Result:
-- order_date | amount | running_total
-- 2024-01-01 | 100    | 100
-- 2024-01-02 | 150    | 250  (100 + 150)
-- 2024-01-03 | 200    | 450  (100 + 150 + 200)

-- Running total per customer
SELECT 
  customer_id,
  order_date,
  amount,
  SUM(amount) OVER (
    PARTITION BY customer_id 
    ORDER BY order_date
  ) AS customer_running_total
FROM orders;

-- Separate running total for each customer

LAG() and LEAD() - Previous/Next Row

-- Compare with previous day
SELECT 
  order_date,
  revenue,
  LAG(revenue) OVER (ORDER BY order_date) AS prev_day_revenue,
  revenue - LAG(revenue) OVER (ORDER BY order_date) AS daily_change
FROM daily_revenue;

-- Result:
-- order_date | revenue | prev_day_revenue | daily_change
-- 2024-01-01 | 1000    | NULL             | NULL
-- 2024-01-02 | 1200    | 1000             | 200
-- 2024-01-03 | 950     | 1200             | -250

-- LEAD() for next row
SELECT 
  order_date,
  revenue,
  LEAD(revenue) OVER (ORDER BY order_date) AS next_day_revenue
FROM daily_revenue;

-- LAG with offset (2 days ago)
SELECT 
  order_date,
  revenue,
  LAG(revenue, 2) OVER (ORDER BY order_date) AS two_days_ago
FROM daily_revenue;

-- 7-day moving average
SELECT 
  order_date,
  revenue,
  AVG(revenue) OVER (
    ORDER BY order_date
    ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
  ) AS moving_avg_7day
FROM daily_revenue;

-- 3-month moving average
SELECT 
  month,
  total_sales,
  AVG(total_sales) OVER (
    ORDER BY month
    ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
  ) AS moving_avg_3month
FROM monthly_sales;

NTILE() - Divide into Buckets

-- Divide customers into 4 quartiles by spend
SELECT 
  customer_id,
  total_spend,
  NTILE(4) OVER (ORDER BY total_spend DESC) AS quartile
FROM customer_totals;

-- Result:
-- customer_id | total_spend | quartile
-- 101         | 50000       | 1  (top 25%)
-- 102         | 48000       | 1
-- 103         | 30000       | 2
-- 104         | 28000       | 2
-- 105         | 15000       | 3
-- 106         | 12000       | 3
-- 107         | 5000        | 4  (bottom 25%)
-- 108         | 3000        | 4

-- Use case: Segment customers
SELECT quartile, COUNT(*) as customer_count
FROM (
  SELECT NTILE(4) OVER (ORDER BY total_spend DESC) AS quartile
  FROM customer_totals
) quartiles
GROUP BY quartile;

-- Page 2, 10 items per page
SELECT *
FROM (
  SELECT 
    ROW_NUMBER() OVER (ORDER BY created_at DESC) AS row_num,
    *
  FROM posts
) numbered
WHERE row_num BETWEEN 11 AND 20;

-- Top 5 products per category by sales
SELECT category, product_name, total_sales
FROM (
  SELECT 
    category,
    product_name,
    total_sales,
    ROW_NUMBER() OVER (
      PARTITION BY category 
      ORDER BY total_sales DESC
    ) AS rank
  FROM product_sales
) ranked
WHERE rank <= 5;

SELECT 
  product,
  sales,
  sales * 100.0 / SUM(sales) OVER () AS pct_of_total
FROM product_sales;

-- Result:
-- product | sales | pct_of_total
-- A       | 5000  | 50.0
-- B       | 3000  | 30.0
-- C       | 2000  | 20.0

 OVER (
  [PARTITION BY column]   -- Optional: Group by
  [ORDER BY column]       -- Optional: Sort order
  [ROWS/RANGE clause]     -- Optional: Frame specification
)

-- Common functions:
-- ROW_NUMBER(), RANK(), DENSE_RANK()
-- SUM(), AVG(), MIN(), MAX(), COUNT()
-- LAG(), LEAD()
-- FIRST_VALUE(), LAST_VALUE()
-- NTILE()

"Dashboard needed top 10 products per category. Was using subqueries and JOINs. Switched to window functions with ROW_NUMBER(). Query went from 2 seconds to 0.1 seconds. Code so much cleaner."

See What Database Actually Does

Query slow? Don’t guess. Execution plans show exactly how database executes query. Find bottlenecks, fix performance.

Get Execution Plan

-- SQL Server
SET STATISTICS IO ON;
SET STATISTICS TIME ON;

-- Show estimated plan (doesn't run query)
SET SHOWPLAN_TEXT ON;
GO
SELECT * FROM orders WHERE user_id = 123;
GO
SET SHOWPLAN_TEXT OFF;

-- Show actual plan (runs query)
SET STATISTICS PROFILE ON;
SELECT * FROM orders WHERE user_id = 123;
SET STATISTICS PROFILE OFF;

-- Or use SSMS: Ctrl + M (actual plan)

-- PostgreSQL
EXPLAIN ANALYZE
SELECT * FROM orders WHERE user_id = 123;

-- MySQL
EXPLAIN
SELECT * FROM orders WHERE user_id = 123;

Real Example: Before & After

SELECT *
FROM orders o
INNER JOIN users u ON o.user_id = u.id
WHERE o.status = 'pending'
ORDER BY o.created_at DESC;

-- Execution Plan Shows:
-- Table Scan on orders (500,000 rows)
-- No index on status column
-- Sort operation (expensive)
-- Execution time: 8 seconds

-- Add index
CREATE INDEX idx_orders_status_date 
ON orders(status, created_at DESC);

-- Same query
SELECT *
FROM orders o
INNER JOIN users u ON o.user_id = u.id
WHERE o.status = 'pending'
ORDER BY o.created_at DESC;

-- Execution Plan Shows:
-- Index Seek (2,000 rows - only pending orders)
-- No sort needed (already sorted in index)
-- Execution time: 0.05 seconds
-- 160x faster!

Reading The Numbers

Execution Plan Output:

|--Index Seek  (Cost: 5%)
   Rows: 100
   Estimated Rows: 95
   
|--Nested Loops  (Cost: 30%)
   Rows: 10,000
   Estimated Rows: 100  ← Problem! Estimate way off
   
|--Table Scan  (Cost: 65%)  ← Most expensive operation
   Rows: 500,000

Key Metrics:
- Cost %: Higher = slower (focus on > 20%)
- Rows: Actual rows processed
- Estimated Rows: Database guess (way off = update stats)

“Query took 30 seconds. Execution plan showed table scan. Added one index. Query now takes 0.1 seconds. 300x faster. Execution plans are X-ray vision for databases.”

Name Your Subqueries

Nested subqueries everywhere? Unreadable mess? CTEs (Common Table Expressions) name intermediate results. Code becomes self-documenting.

The Subquery Nightmare

--  Nested subqueries: Hard to read
SELECT 
    u.name,
    (SELECT COUNT(*) FROM orders o WHERE o.user_id = u.id) as order_count,
    (SELECT AVG(total) FROM orders o WHERE o.user_id = u.id) as avg_order
FROM users u
WHERE u.id IN (
    SELECT user_id 
    FROM orders 
    WHERE created_at > '2024-01-01'
    GROUP BY user_id
    HAVING COUNT(*) > 5
)
AND u.country IN (
    SELECT country 
    FROM countries 
    WHERE region = 'EU'
);

-- What does this do? Hard to understand at a glance

CTE Solution: Clear and Readable

--  WITH clause: Self-documenting
WITH 
    active_users AS (
        SELECT user_id
        FROM orders
        WHERE created_at > '2024-01-01'
        GROUP BY user_id
        HAVING COUNT(*) > 5
    ),
    eu_countries AS (
        SELECT country
        FROM countries
        WHERE region = 'EU'
    ),
    user_stats AS (
        SELECT 
            user_id,
            COUNT(*) as order_count,
            AVG(total) as avg_order
        FROM orders
        GROUP BY user_id
    )
SELECT 
    u.name,
    s.order_count,
    s.avg_order
FROM users u
INNER JOIN active_users a ON u.id = a.user_id
INNER JOIN eu_countries e ON u.country = e.country
LEFT JOIN user_stats s ON u.id = s.user_id;

-- Clear logic: Filter active users, EU countries, join stats

WITH cte_name AS (
    SELECT column1, column2
    FROM table
    WHERE condition
)
SELECT *
FROM cte_name;

-- Multiple CTEs
WITH 
    cte1 AS (
        SELECT ...
    ),
    cte2 AS (
        SELECT ...
        FROM cte1  -- Can reference previous CTE
    )
SELECT *
FROM cte2;

Recursive CTE (Hierarchies)

-- Organization chart: Manager → Employee hierarchy
WITH RECURSIVE org_chart AS (
    -- Base case: Top-level managers
    SELECT 
        id,
        name,
        manager_id,
        1 as level,
        CAST(name AS VARCHAR(1000)) as path
    FROM employees
    WHERE manager_id IS NULL
    
    UNION ALL
    
    -- Recursive case: Employees under managers
    SELECT 
        e.id,
        e.name,
        e.manager_id,
        oc.level + 1,
        CAST(oc.path || ' -> ' || e.name AS VARCHAR(1000))
    FROM employees e
    INNER JOIN org_chart oc ON e.manager_id = oc.id
)
SELECT 
    REPEAT('  ', level - 1) || name as hierarchy,
    level,
    path
FROM org_chart
ORDER BY path;

-- Output:
-- CEO              1  CEO
--   VP Sales       2  CEO -> VP Sales
--     Sales Rep    3  CEO -> VP Sales -> Sales Rep
--   VP Eng         2  CEO -> VP Eng
--     Dev Lead     3  CEO -> VP Eng -> Dev Lead

WITH 
    monthly_sales AS (
        SELECT 
            DATE_TRUNC('month', order_date) as month,
            SUM(total) as revenue
        FROM orders
        WHERE order_date >= '2024-01-01'
        GROUP BY DATE_TRUNC('month', order_date)
    ),
    sales_with_growth AS (
        SELECT 
            month,
            revenue,
            LAG(revenue) OVER (ORDER BY month) as prev_month_revenue,
            revenue - LAG(revenue) OVER (ORDER BY month) as growth
        FROM monthly_sales
    )
SELECT 
    TO_CHAR(month, 'Mon YYYY') as period,
    revenue,
    prev_month_revenue,
    growth,
    ROUND((growth / NULLIF(prev_month_revenue, 0)) * 100, 2) as growth_pct
FROM sales_with_growth
ORDER BY month;

CTE vs Subquery vs Temp Table

"Inherited 500-line query with 8 levels of nested subqueries. Rewrote with CTEs in 2 hours. Same logic, 10x more readable. Junior devs can now understand and modify it."

Materialized Views in SQL Server

Complex aggregation query taking 10 seconds? Create indexed view. Query becomes instant. Data stays fresh automatically.

Problem: Slow Aggregate Query

-- This runs every time, slow on large tables
SELECT 
    CategoryId,
    COUNT(*) AS ProductCount,
    AVG(Price) AS AvgPrice,
    SUM(Stock) AS TotalStock
FROM Products
GROUP BY CategoryId;

-- 10 seconds on 10M rows

Solution: Indexed View

-- Step 1: Create view with SCHEMABINDING
CREATE VIEW dbo.ProductStats
WITH SCHEMABINDING
AS
SELECT 
    CategoryId,
    COUNT_BIG(*) AS ProductCount,
    SUM(Price) AS TotalPrice,
    SUM(Stock) AS TotalStock
FROM dbo.Products
GROUP BY CategoryId;
GO

-- Step 2: Create clustered index
CREATE UNIQUE CLUSTERED INDEX IX_ProductStats
ON dbo.ProductStats(CategoryId);
GO

-- Step 3: Query it like a table
SELECT * FROM ProductStats;

-- Now: < 0.1 seconds!

"Dashboard aggregation query took 12 seconds. Created indexed view. Now instant. Reports load in real-time. Users think we upgraded servers."

Advanced Analytics Made Easy

Need running totals, rankings, moving averages? Window functions do it in one query. No self-joins.

Running Total Example

-- Calculate cumulative sales per day
SELECT 
    SaleDate,
    Amount,
    SUM(Amount) OVER (ORDER BY SaleDate) AS RunningTotal
FROM Sales
ORDER BY SaleDate;

-- Result:
-- SaleDate    Amount  RunningTotal
-- 2024-01-01  100     100
-- 2024-01-02  150     250
-- 2024-01-03  200     450

-- ROW_NUMBER: Sequential numbering
SELECT 
    Name,
    Salary,
    ROW_NUMBER() OVER (ORDER BY Salary DESC) AS Rank
FROM Employees;

-- RANK: Ranking with gaps
SELECT 
    Name,
    Score,
    RANK() OVER (ORDER BY Score DESC) AS Rank
FROM Students;

-- DENSE_RANK: Ranking without gaps
SELECT 
    Product,
    Sales,
    DENSE_RANK() OVER (ORDER BY Sales DESC) AS Rank
FROM Products;

-- LAG/LEAD: Previous/Next row values
SELECT 
    SaleDate,
    Amount,
    LAG(Amount) OVER (ORDER BY SaleDate) AS PreviousDay,
    LEAD(Amount) OVER (ORDER BY SaleDate) AS NextDay
FROM Sales;

Partition By (Group Within Group)

-- Top 3 salaries per department
SELECT *
FROM (
    SELECT 
        Department,
        Name,
        Salary,
        ROW_NUMBER() OVER (
            PARTITION BY Department 
            ORDER BY Salary DESC
        ) AS DeptRank
    FROM Employees
) ranked
WHERE DeptRank <= 3;

-- Running total per category
SELECT 
    Category,
    Product,
    Sales,
    SUM(Sales) OVER (
        PARTITION BY Category 
        ORDER BY SaleDate
    ) AS CategoryRunningTotal
FROM Products;

-- 7-day moving average
SELECT 
    SaleDate,
    Amount,
    AVG(Amount) OVER (
        ORDER BY SaleDate 
        ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
    ) AS MovingAvg7Day
FROM Sales;

"Replaced 5 self-joins with one window function query. Execution time: 8 seconds → 0.3 seconds. Dashboard analytics became real-time. Window functions are SQL superpowers."

-- Page 1 (rows 1-10)
SELECT * FROM Products
ORDER BY ProductId
OFFSET 0 ROWS
FETCH NEXT 10 ROWS ONLY;

-- Page 2 (rows 11-20)
SELECT * FROM Products
ORDER BY ProductId
OFFSET 10 ROWS
FETCH NEXT 10 ROWS ONLY;

-- Dynamic pagination
DECLARE @PageNumber INT = 3;
DECLARE @PageSize INT = 10;

SELECT * FROM Products
ORDER BY ProductId
OFFSET (@PageNumber - 1) * @PageSize ROWS
FETCH NEXT @PageSize ROWS ONLY;

Note: ORDER BY required with OFFSET FETCH.

-- Returns first non-NULL value
SELECT COALESCE(Phone, Email, 'No contact') AS Contact
FROM Users;

-- Default values in calculations
SELECT 
  Name,
  Price * COALESCE(Quantity, 0) AS Total
FROM Orders;

-- Multiple fallbacks
SELECT COALESCE(PreferredName, FirstName, 'Unknown') AS DisplayName
FROM Users;

vs ISNULL: COALESCE is ANSI standard (works everywhere). ISNULL is SQL Server only.

vs CASE: Shorter, cleaner syntax.

Faster Correlated Queries

Correlated subqueries in SELECT run for every row. CROSS APPLY runs once.

--  SLOW (subquery runs per row)
SELECT 
  c.Name,
  (SELECT TOP 1 OrderDate 
   FROM Orders 
   WHERE CustomerId = c.CustomerId 
   ORDER BY OrderDate DESC) AS LastOrder
FROM Customers c;

--  FAST (CROSS APPLY optimized)
SELECT c.Name, o.OrderDate
FROM Customers c
CROSS APPLY (
  SELECT TOP 1 OrderDate
  FROM Orders
  WHERE CustomerId = c.CustomerId
  ORDER BY OrderDate DESC
) o;

Result: 10-100x faster on large tables.

When to Use: Need top N related rows, complex subquery logic.

Readable SQL

Nested subqueries hurt readability. CTEs (Common Table Expressions) make complex queries clear.

-- Clear, readable, step-by-step
WITH ActiveUsers AS (
  SELECT * FROM Users WHERE IsActive = 1
),
RecentOrders AS (
  SELECT * FROM Orders WHERE CreatedAt > DATEADD(month, -1, GETDATE())
)
SELECT 
  u.Name,
  COUNT(o.OrderId) AS OrderCount
FROM ActiveUsers u
LEFT JOIN RecentOrders o ON u.UserId = o.UserId
GROUP BY u.Name;

Benefit: Each CTE has a name. Easy to understand query logic. Easier to debug.

Performance: Same as subqueries. Optimizer treats them identically.