HAVING vs WHERE in SQL – What is the difference?

HAVING vs WHERE in SQL – What is the difference?

Welcome to another insightful blog post on codedamn! Today, we’re diving deep into two crucial SQL clauses—WHERE and HAVING. Whether you’re writing complex queries or want to optimize your database interactions, understanding the difference between these two clauses is key. By the end of this article, you’ll know exactly when and how to use each clause, and you’ll be a step closer to mastering SQL.


Structured Query Language (SQL) is the language of databases. It allows us to manipulate, retrieve, and manage data. One of the most common tasks you’ll find yourself doing is filtering data based on certain conditions. That’s where WHERE and HAVING clauses come in. Both serve the purpose of filtering, but they are used in different contexts and can lead to significantly different results. Let’s unpack what each clause does and when to use them.

Basic Definitions

Before diving into the deep end, let’s understand what these clauses are in simpler terms.

What is WHERE?

The WHERE clause filters records based on one or more conditions. This clause is used to filter records from a table, and it affects the rows that are to be retrieved, updated, or deleted. Essentially, WHERE operates on the row-level data.

What is HAVING?

The HAVING clause, on the other hand, is like WHERE but for grouped records. After you’ve used a GROUP BY clause to aggregate your data, HAVING allows you to filter the groups based on a condition. In short, it operates on grouped records, often in conjunction with aggregate functions like COUNT, SUM, AVG, etc.


Now that we know what these clauses do, let’s look at how they are implemented in SQL queries.

Basic Syntax of WHERE

Here’s how you would generally use the WHERE clause:

SELECT column1, column2
FROM table_name
WHERE condition;

For example, if you have a students table and you want to find all students who scored more than 90:

SELECT name, score
FROM students
WHERE score > 90;

Basic Syntax of HAVING

The HAVING clause often follows a GROUP BY clause. Here’s the basic syntax:

SELECT column1, aggregate_function(column2)
FROM table_name
GROUP BY column1
HAVING condition;

For instance, if you want to find departments in a employees table that have an average salary greater than $50,000:

SELECT department, AVG(salary)
FROM employees
GROUP BY department
HAVING AVG(salary) > 50000;

Syntax Comparison

Operates on rows Operates on grouped data
Comes before GROUP BY Comes after GROUP BY
Doesn’t use aggregates Often used with aggregate functions

Use Cases

Now that we understand the syntax, let’s examine where you’d typically use each clause.

Use Cases for WHERE

  1. Row-level filtering: Ideal for filtering rows based on certain conditions.
  2. Data retrieval: Excellent for SELECT queries where you need to narrow down your dataset.
  3. Data manipulation: Useful in UPDATE and DELETE queries to specify which records to modify or remove.

Use Cases for HAVING

  1. Group-level filtering: Perfect for queries that involve aggregate functions and grouping.
  2. Complex filtering: If your filtering conditions require calculations, HAVING is your go-to option.
  3. Multi-level filtering: Sometimes you may need to filter data at both the row and group levels, combining WHERE and HAVING can help in such cases.

To further strengthen your SQL skills, you can read the official SQL documentation for WHERE and HAVING. This will not only reinforce what you’ve learned here but also provide you with more advanced examples and functionalities.


Navigating SQL often means encountering the WHERE and HAVING clauses. While they may appear interchangeable to a newbie, these two clauses serve different roles. Let’s dissect the differences between them.

Operations Order

In SQL, the order of operations significantly influences the output. The WHERE clause filters rows before any grouping takes place, while the HAVING clause filters after grouping.

1-- Using WHERE
2SELECT department, COUNT(*)
3FROM employees
4WHERE salary > 50000
5GROUP BY department;
7-- Using HAVING
8SELECT department, COUNT(*)
9FROM employees
10GROUP BY department
11HAVING COUNT(*) > 5;

In the first query, only employees with salaries over 50,000 are included in the group. In the second query, groups containing fewer than 5 employees are filtered out.

Logical Comparison

WHERE is used for filtering rows based on column values. HAVING, on the other hand, filters data based on aggregated results, like COUNT, AVG, MIN, MAX, etc.

-- WHERE with column comparison
SELECT * FROM orders WHERE order_amount > 100;

-- HAVING with aggregate function
SELECT customer_id, COUNT(order_id)
FROM orders
GROUP BY customer_id
HAVING COUNT(order_id) > 2;

Column References

In WHERE, you can only refer to columns that are part of the table. With HAVING, you can refer to aggregate functions and the aliases of those functions.

1-- Incorrect
2SELECT department, AVG(salary) AS avg_salary
3FROM employees
4WHERE avg_salary > 60000 -- Error
5GROUP BY department;
7-- Correct
8SELECT department, AVG(salary) AS avg_salary
9FROM employees
10GROUP BY department
11HAVING avg_salary > 60000;


Generally, WHERE is more efficient because it filters rows before grouping, reducing the amount of data to be processed. HAVING is applied after aggregation, making it potentially slower. However, the actual performance can vary based on indexes, the specific DBMS, and the complexity of other query components.


While WHERE and HAVING have their unique roles, they do share some common ground.

Filtering Function

Both are used for filtering data—WHERE filters rows, and HAVING filters aggregated data.

Syntax Similarities

The logical operators like AND, OR, NOT, etc., can be used in both WHERE and HAVING clauses.

Advanced Scenarios

There are situations where the distinctions between WHERE and HAVING blur, or where they can be used together for more complex queries.

Combining WHERE and HAVING

You can use WHERE and HAVING in the same query to filter rows before and after the GROUP BY operation.

SELECT department, COUNT(*)
FROM employees
WHERE salary > 50000
GROUP BY department

Subqueries involving WHERE and HAVING

Both clauses can be used within subqueries for more complex operations.

SELECT department
SELECT department, AVG(salary) AS avg_salary
FROM employees
WHERE department != 'HR'
GROUP BY department
) AS subquery
WHERE avg_salary > 70000;


Though unconventional, HAVING can be used without GROUP BY to filter aggregated data over the whole table.

SELECT AVG(salary)
FROM employees
HAVING AVG(salary) > 60000;

Common Pitfalls & Best Practices

It’s easy to misuse these clauses, so let’s cover some best practices.

Incorrect Use

Using HAVING to filter rows before aggregation or using WHERE on aggregate functions can lead to errors or incorrect results.

Optimization Tips

Always filter with WHERE before using HAVING to reduce data processed. Also, use indexes for columns in WHERE for performance gains.

Real-world Examples

Understanding the theory is great, but real-world application gives life to these clauses.

Case Studies

In an e-commerce platform, WHERE can be used to fetch orders over a certain amount, while HAVING can help in identifying high-value customers based on multiple orders.


WHERE and HAVING are both essential but serve different roles in SQL queries. Knowing when and how to use them can optimize your database interactions.

Sharing is caring

Did you like what Pranav wrote? Thank them for their work by sharing it on social media.


No comments so far