GROUP BY multiple columns in SQL - Time & Space Complexity
Start learning this pattern below
Jump into concepts and practice - no test required
When we use GROUP BY with multiple columns, the database groups rows by combinations of those columns.
We want to know how the work grows as the table gets bigger.
Analyze the time complexity of the following code snippet.
SELECT department, role, COUNT(*)
FROM employees
GROUP BY department, role;
This query counts employees grouped by their department and role.
Identify the loops, recursion, array traversals that repeat.
- Primary operation: Scanning all rows in the employees table once.
- How many times: Once for each row (n times).
As the number of rows grows, the database must look at each row to group it.
| Input Size (n) | Approx. Operations |
|---|---|
| 10 | About 10 row checks |
| 100 | About 100 row checks |
| 1000 | About 1000 row checks |
Pattern observation: The work grows directly with the number of rows.
Time Complexity: O(n)
This means the time to run the query grows in a straight line as the table gets bigger.
[X] Wrong: "Grouping by more columns makes the query take much longer than just one column."
[OK] Correct: The main work is still scanning each row once; grouping by more columns changes how groups form but does not multiply the scanning work.
Understanding how grouping scales helps you explain query performance clearly and shows you know how databases handle data as it grows.
"What if we added an ORDER BY after the GROUP BY? How would the time complexity change?"
Practice
GROUP BY column1, column2 do?Solution
Step 1: Understand GROUP BY purpose
The GROUP BY clause groups rows that have the same values in specified columns.Step 2: Apply to multiple columns
When multiple columns are listed, grouping happens on unique combinations of those columns' values.Final Answer:
Groups rows by unique combinations of values in column1 and column2 -> Option BQuick Check:
GROUP BY multiple columns = group by combinations [OK]
- Thinking GROUP BY sorts data
- Confusing GROUP BY with WHERE filtering
- Assuming GROUP BY joins tables
city and year?Solution
Step 1: Recall GROUP BY syntax
The correct syntax is GROUP BY followed by column names separated by commas.Step 2: Check each option
SELECT city, year FROM table GROUP BY city, year; uses correct syntax with commas. SELECT city, year FROM table ORDER BY city, year; uses ORDER BY, which is for sorting. SELECT city, year FROM table GROUP city, year; misses BY keyword. SELECT city, year FROM table GROUP BY city year; misses comma between columns.Final Answer:
SELECT city, year FROM table GROUP BY city, year; -> Option CQuick Check:
GROUP BY columns separated by commas [OK]
- Using ORDER BY instead of GROUP BY
- Omitting BY keyword after GROUP
- Missing commas between column names
sales with columns region, product, and amount, what will this query return?SELECT region, product, SUM(amount) FROM sales GROUP BY region, product;
Solution
Step 1: Analyze SELECT and GROUP BY columns
The query groups rows by both region and product, so each group is a unique pair of region and product.Step 2: Understand aggregation function SUM(amount)
SUM(amount) calculates total sales amount for each group of region and product.Final Answer:
Total sales amount for each region and product combination -> Option DQuick Check:
GROUP BY region, product + SUM = totals per pair [OK]
- Thinking it sums only by one column
- Assuming syntax error without reason
- Ignoring that all selected non-aggregated columns must be grouped
SELECT department, role, COUNT(*) FROM employees GROUP BY department;
Solution
Step 1: Check SELECT columns vs GROUP BY columns
Columns in SELECT that are not aggregated must appear in GROUP BY. Here, role is in SELECT but missing in GROUP BY.Step 2: Understand aggregation rules
COUNT(*) is valid, but all non-aggregated columns must be grouped to avoid errors.Final Answer:
Missing role column in GROUP BY clause -> Option AQuick Check:
All non-aggregated SELECT columns must be in GROUP BY [OK]
- Ignoring missing columns in GROUP BY
- Thinking COUNT(*) is invalid with GROUP BY
- Assuming GROUP BY only needs one column
transactions table with columns customer_id, month, and amount. You want to find the average transaction amount per customer per month, but only for months where the customer made more than 3 transactions. Which query correctly achieves this?Solution
Step 1: Understand filtering groups with HAVING
HAVING filters groups after grouping. To filter groups with more than 3 transactions, use HAVING COUNT(*) > 3.Step 2: Group by both customer_id and month
To get average per customer per month, group by both columns.Step 3: Check each option
SELECT customer_id, month, AVG(amount) FROM transactions GROUP BY customer_id, month HAVING COUNT(*) > 3; correctly uses GROUP BY customer_id, month and HAVING COUNT(*) > 3. SELECT customer_id, month, AVG(amount) FROM transactions WHERE COUNT(*) > 3 GROUP BY customer_id, month; misuses WHERE with COUNT(). SELECT customer_id, month, AVG(amount) FROM transactions GROUP BY customer_id HAVING COUNT(*) > 3; groups only by customer_id, missing month. SELECT customer_id, month, AVG(amount) FROM transactions GROUP BY month HAVING COUNT(*) > 3; groups only by month, missing customer_id.Final Answer:
SELECT customer_id, month, AVG(amount) FROM transactions GROUP BY customer_id, month HAVING COUNT(*) > 3; -> Option AQuick Check:
Use HAVING to filter grouped counts [OK]
- Using WHERE with aggregate functions
- Grouping by only one column when two needed
- Filtering before grouping instead of after
