Learn analytical SQL, from filtering and aggregation to joins and analytical window functions with practical query examples. For analytical SQL, the examples stay small enough for you to predict the result before execution.
Editorial note: Publication metadata for SQL for Data Science is intentionally unset until this URL is actually released; the lesson already includes its own examples, CSV and notebook.
Start with the table grain before writing analytical SQL
Suppose an ecommerce team stores customers, orders and products in separate tables. SQL can build one clean customer-level dataset containing total spend, last order date and order frequency before Python or a BI tool is used.
- SQL lets analysts filter, aggregate and join data close to where it is stored, reducing unnecessary movement into Python.
- A strong SQL workflow starts by confirming table grain and key uniqueness before writing joins.
- CTEs and window functions often make analytical queries easier to audit than deeply nested subqueries.
- Query correctness matters more than clever syntax: validate row counts and totals against a simpler baseline.
Work through a query with row-count checks
For analytical SQL, predict one visible result before each snippet runs—a row count, shape, statistic, ranking or error pattern—then compare it with the printed checkpoint.
-- analytical SQL · example 1
SELECT customer_id,
COUNT(*) AS orders,
SUM(order_total) AS revenue,
MAX(order_date) AS last_order
FROM orders
GROUP BY customer_id
ORDER BY revenue DESC;analytical SQL checkpoint 1: Run the cell and inspect the printed values before changing anything.
-- analytical SQL · example 2
SELECT COUNT(*) AS rows, COUNT(DISTINCT customer_id) AS customers
FROM practice_orders;analytical SQL checkpoint 2: rows | customers 30 | 12
-- analytical SQL · example 3
SELECT customer_id, COUNT(*) AS n
FROM practice_orders
GROUP BY customer_id
HAVING COUNT(*) > 1
ORDER BY n DESC;analytical SQL checkpoint 3: Customers with more than one row are listed before any join or aggregation.
-- analytical SQL · example 4
SELECT region, COUNT(*) AS orders, ROUND(SUM(amount),2) AS revenue
FROM practice_orders
GROUP BY region
ORDER BY revenue DESC;analytical SQL checkpoint 4: region | orders | revenue West | ... | ...
-- analytical SQL · example 5
WITH x AS (
SELECT amount FROM practice_orders WHERE amount IS NOT NULL
)
SELECT ROUND(SUM(amount),2) AS detail_total,
ROUND((SELECT SUM(amount) FROM x),2) AS check_total
FROM x;analytical SQL checkpoint 5: detail_total and check_total should match exactly.
Test duplicates, NULLs and unmatched keys
CTEs and window functions often make analytical queries easier to audit than deeply nested subqueries.
Query correctness matters more than clever syntax: validate row counts and totals against a simpler baseline.
Self-check with answers
For analytical SQL, what result should you be able to explain without the code?
SQL lets analysts filter, aggregate and join data close to where it is stored, reducing unnecessary movement into Python.
Which assumption matters most in this analytical SQL exercise?
CTEs and window functions often make analytical queries easier to audit than deeply nested subqueries.
What failure mode would make this analytical SQL result untrustworthy?
Query correctness matters more than clever syntax: validate row counts and totals against a simpler baseline.
Practise with a reproducible SQLite-style dataset
Try it yourself workspace
Edit this analytical SQL starter, copy it, and run it in the downloadable notebook or your local Jupyter environment.
Questions specific to this lesson
When should I use analytical SQL in an analysis?
SQL lets analysts filter, aggregate and join data close to where it is stored, reducing unnecessary movement into Python.
What row-count check should I do before trusting the result?
CTEs and window functions often make analytical queries easier to audit than deeply nested subqueries.
What is the most common beginner mistake here?
Query correctness matters more than clever syntax: validate row counts and totals against a simpler baseline.
How can I practise this without a production database?
Use the CSV and notebook in this lesson, load the file into SQLite or pandas, predict the row count first, then compare your result with a simpler query.
Primary references and further reading
For analytical SQL, use these primary references when exact syntax, defaults or formal definitions matter beyond the examples on this page.





















































































































































