Add grouping and filtering lesson

2 weeks ago · 84206d2c56
parent 9478904e4b
commit 84206d2c56
1 changed files with 279 additions and 0 deletions
--- a/src/data/courses/sql-mastery/chapters/aggregate-functions/lessons/grouping-and-filtering.md
+++ b/src/data/courses/sql-mastery/chapters/aggregate-functions/lessons/grouping-and-filtering.md
@ -0,0 +1,279 @@
+---
+title: Grouping and Filtering
+description: Learn about filtering grouped data with HAVING, DISTINCT aggregation, and conditional aggregation
+order: 130
+type: lesson-challenge
+setup: |
+  ```sql
+  CREATE TABLE sale (
+    id SERIAL PRIMARY KEY,
+    sale_date DATE,
+    amount DECIMAL(10, 2),
+    category TEXT,
+    store_location TEXT
+  );
+
+  INSERT INTO sale (sale_date, amount, category, store_location) 
+  VALUES 
+    ('2024-01-15', 29.99, 'Fiction', 'Downtown'),
+    ('2024-01-15', 19.99, 'Non-Fiction', 'Suburb'),
+    ('2024-01-16', 24.99, 'Fiction', 'Downtown'),
+    ('2024-01-16', 39.99, 'Technical', 'Suburb'),
+    ('2024-01-16', 14.99, 'Fiction', 'Downtown'),
+    ('2024-01-17', 49.99, 'Technical', 'Downtown'),
+    ('2024-01-17', 27.99, 'Non-Fiction', 'Airport'),
+    ('2024-01-17', 22.99, 'Fiction', 'Downtown'),
+    ('2024-01-18', 17.99, 'Non-Fiction', 'Suburb'),
+    ('2024-01-18', 34.99, 'Technical', 'Airport');
+  ```
+---
+
+In our previous lesson, we learned about grouping data using `GROUP BY`. While grouping is powerful on its own, it becomes even more useful when combined with filtering.
+
+In this lesson, we'll learn about filtering grouped data using the `HAVING` clause and explore other advanced grouping patterns.
+
+## The HAVING Clause
+
+The `HAVING` clause allows us to filter groups based on aggregate values. Think of it as a `WHERE` clause for grouped data.
+
+The basic syntax is:
+
+```sql
+SELECT column1, aggregate_function(column2)
+FROM table_name
+GROUP BY column1
+HAVING condition;
+```
+
+Let's look at some examples using our bookstore `sale` table:
+
+| id  | sale_date  | amount | category    | store_location |
+| --- | ---------- | ------ | ----------- | -------------- |
+| 1   | 2024-01-15 | 29.99  | Fiction     | Downtown       |
+| 2   | 2024-01-15 | 19.99  | Non-Fiction | Suburb         |
+| 3   | 2024-01-16 | 24.99  | Fiction     | Downtown       |
+| 4   | 2024-01-16 | 39.99  | Technical   | Suburb         |
+| 5   | 2024-01-16 | 14.99  | Fiction     | Downtown       |
+| 6   | 2024-01-17 | 49.99  | Technical   | Downtown       |
+| 7   | 2024-01-17 | 27.99  | Non-Fiction | Airport        |
+| 8   | 2024-01-17 | 22.99  | Fiction     | Downtown       |
+| 9   | 2024-01-18 | 17.99  | Non-Fiction | Suburb         |
+| 10  | 2024-01-18 | 34.99  | Technical   | Airport        |
+
+### Example 1: Finding Categories with High Sales
+
+Let's find categories where total sales exceed $75. Your initial instinct might to be to write the following query:
+
+```sql
+-- ERROR: WHERE cannot use aggregate functions
+SELECT
+    category,
+    SUM(amount) as total_sales
+FROM sale
+GROUP BY category
+WHERE SUM(amount) > 75;
+
+-- ERROR: SELECT aliases cannot be used in WHERE
+SELECT
+    category,
+    SUM(amount) as total_sales
+FROM sale
+GROUP BY category
+WHERE total_sales > 75;
+```
+
+Both of the above queries will result in an error because as we learned in the previous lesson, `WHERE` filters rows before they are grouped so neither `SUM(amount)` nor `total_sales` are available.
+
+To fix this, we can use the `HAVING` clause which filters groups after they are formed.
+
+```sql
+SELECT
+    category,
+    SUM(amount) as total_sales
+FROM sale
+GROUP BY category
+HAVING SUM(amount) > 75;
+```
+
+The output will be only categories with total sales greater than $75:
+
+| category  | total_sales |
+| --------- | ----------- |
+| Fiction   | 92.96       |
+| Technical | 124.97      |
+
+### Example 2: Finding Busy Store Locations
+
+Let's find store locations with more than 3 sales:
+
+```sql
+SELECT
+    store_location,
+    COUNT(*) as sale_count
+FROM sale
+GROUP BY store_location
+HAVING COUNT(*) > 3;
+```
+
+The output shows locations with more than 3 sales:
+
+| store_location | sale_count |
+| -------------- | ---------- |
+| Downtown       | 5          |
+
+## WHERE vs HAVING
+
+While both `WHERE` and `HAVING` are used for filtering, they serve different purposes:
+
+- `WHERE` filters individual rows **before** they're grouped
+- `HAVING` filters groups **after** they're formed
+
+Let's see this difference in action:
+
+### Example: Sales Above $25
+
+Using `WHERE` (filters rows **before** grouping):
+
+```sql
+SELECT
+    category,
+    COUNT(*) as sale_count,
+    SUM(amount) as total_sales
+FROM sale
+WHERE amount > 25
+GROUP BY category;
+```
+
+This shows the count and sum of only sales above $25:
+
+| category    | sale_count | total_sales |
+| ----------- | ---------- | ----------- |
+| Fiction     | 1          | 29.99       |
+| Non-Fiction | 1          | 27.99       |
+| Technical   | 3          | 124.97      |
+
+Using `HAVING` (filters groups **after** aggregation). For example, let's find the categories where the average sale amount is above $25:
+
+```sql
+SELECT
+    category,
+    COUNT(*) as sale_count,
+    SUM(amount) as total_sales
+FROM sale
+GROUP BY category
+HAVING AVG(amount) > 25;
+```
+
+This shows categories where the average sale amount is above $25:
+
+| category  | sale_count | total_sales |
+| --------- | ---------- | ----------- |
+| Technical | 3          | 124.97      |
+
+### Using Both WHERE and HAVING
+
+You can use both `WHERE` and `HAVING` in the same query. For example, let's find categories that had more than `2` sales in `Downtown` stores:
+
+```sql
+SELECT
+    category,
+    COUNT(*) as sale_count,
+    SUM(amount) as total_sales
+FROM sale
+WHERE store_location = 'Downtown'
+GROUP BY category
+HAVING COUNT(*) > 2;
+```
+
+The output shows categories with more than 2 sales in Downtown:
+
+| category | sale_count | total_sales |
+| -------- | ---------- | ----------- |
+| Fiction  | 4          | 92.96       |
+
+Let's look at another example to find the top 2 locations by total sales:
+
+```sql
+SELECT
+    store_location,
+    COUNT(*) as sale_count,
+    SUM(amount) as total_sales
+FROM sale
+GROUP BY store_location
+ORDER BY total_sales DESC
+LIMIT 2;
+```
+
+This shows the top 2 locations by total sales:
+
+| store_location | sale_count | total_sales |
+| -------------- | ---------- | ----------- |
+| Downtown       | 5          | 142.95      |
+| Suburb         | 3          | 77.97       |
+
+## Important Rules and Gotchas
+
+You should keep the following rules in mind when working with `GROUP BY` and `HAVING`:
+
+### HAVING requires GROUP BY
+
+You can't use `HAVING` without `GROUP BY` (except with window functions). For example, the following query will result in an error:
+
+```sql
+SELECT
+    category,
+    SUM(amount) as total_sales
+FROM sale
+HAVING SUM(amount) > 75;
+```
+
+This will result in an error because `HAVING` requires a `GROUP BY` clause.
+
+### NULL in Groups
+
+NULL values form their own group in `GROUP BY`.
+
+### Multiple Conditions
+
+You can combine multiple conditions in `HAVING` with `AND`/`OR`. For example, the query below finds categories with more than 3 sales:
+
+```sql
+SELECT
+    category,
+    COUNT(*) as sale_count,
+    SUM(amount) as total_sales
+FROM sale
+GROUP BY category
+HAVING COUNT(*) >= 3;
+```
+
+The output will be:
+
+| category    | sale_count | total_sales |
+| ----------- | ---------- | ----------- |
+| Fiction     | 4          | 92.96       |
+| Non-Fiction | 3          | 65.97       |
+| Technical   | 3          | 124.97      |
+
+We can use `AND` to combine multiple conditions in `HAVING`. For example, the query below finds categories with more than 3 sales and total sales above $100:
+
+```sql
+SELECT
+    category,
+    COUNT(*) as sale_count,
+    SUM(amount) as total_sales
+FROM sale
+GROUP BY category
+HAVING COUNT(*) >= 3
+AND SUM(amount) > 100;
+```
+
+The output will be:
+
+| category  | sale_count | total_sales |
+| --------- | ---------- | ----------- |
+| Technical | 3          | 124.97      |
+
+### Aggregate Functions
+
+`HAVING` can only use the columns in `GROUP BY` and aggregate functions.