When to Use Subquery In SQL

Subqueries can be used in SQL in various scenarios to achieve different objectives. Below are 10 common situations when using subqueries can be beneficial.

  1. Filtering Data: Subqueries are often used to filter data based on specific criteria from another table. For example, you can use a subquery to retrieve rows from one table that match certain conditions in another table.
  2. Data Comparison: Subqueries can be handy when you need to compare values between tables. You can use a subquery to compare a value from the main query with the results of a subquery, allowing for more complex and precise conditions.
  3. Aggregating Data: When you need to perform aggregate functions like SUM, AVG, COUNT, etc., on a subset of data, subqueries can be used to calculate the aggregated values before joining them with the main query.
  4. IN and NOT IN Operations: Subqueries are commonly used with the IN and NOT IN operators to filter data based on whether it exists or does not exist in another table.
  5. EXISTS and NOT EXISTS Operations: Subqueries can be used with the EXISTS and NOT EXISTS operators to check for the existence of rows in another table, allowing you to conditionally perform actions based on the result.
  6. Correlated Subqueries: In cases where the subquery relies on values from the outer query, correlated subqueries can be used to perform row-by-row processing.
  7. Data Modification: Subqueries can also be employed in UPDATE and DELETE statements to modify or remove rows based on conditions from another table.
  8. Dynamic Conditions: When you have dynamic conditions that depend on the data or user input, subqueries can help you build flexible and adaptable queries.
  9. Nested Joins: Subqueries can be used within JOIN statements to join multiple tables based on specific conditions, particularly when dealing with complex data relationships.
  10. Restricting Results: Subqueries can help limit the number of results returned by a query, especially when you need only the top N records or a specific range of data.

It’s essential to use subqueries judiciously, considering the size of your data, database performance, and readability of the code. In some cases, alternative approaches like JOINs or common table expressions (CTEs) may be more efficient or easier to understand. Always test and optimize your queries to ensure they perform well in your specific database environment.

SQL Subquery: Syntax, Types & Examples  :  

A subquery is a query nested inside another query such as SELECT, INSERT, DELETE and UPDATE. In this tutorial, we are focusing on the SELECT statement only.
To construct a subquery, we put the second query in brackets and use it in the WHERE clause as an expression:


SELECT film_id, title, rental_rate
FROM film
WHERE rental_rate > ( SELECT AVG (rental_rate)
FROM film );

Order of Operations :

The query inside the brackets is called a subquery or an inner query. The query that contains the subquery is known as an outer query.

PostgreSQL executes the query that contains a subquery in the following sequence:

  • First, executes the subquery. (Very Important)
  • Second, gets the result and passes it to the outer query.
  • Third, executes the outer query.


SQL subqueries are a versatile tool that can significantly enhance the capabilities of SQL queries, allowing developers to create more sophisticated and precise data retrievals and manipulations. By understanding the syntax and exploring practical examples, you can harness the power of subqueries and become a more proficient SQL developer. Always keep in mind that the performance of subqueries can vary depending on the specific use case, and optimizing your queries is crucial for achieving efficient database operations. Happy coding!

The Data School
Author: The Data School