What is subquery in SQL?

What is subquery in SQL?

Databases are intricate systems that enable us to store, retrieve, and manipulate data in highly efficient ways. Within the realm of SQL (Structured Query Language), there exists a powerful feature known as the “subquery”. This is a tool that gives developers the flexibility to extract complex data patterns and relationships with elegance and precision. In this article, we’ll dive deep into the world of subqueries on codedamn.


A subquery, in essence, is a query nested within another query. Think of it as a question inside a question. You might need to retrieve some data based on the result of another data retrieval, and that’s where subqueries shine. They enable you to use the outcome of one query as an input for another, making them an invaluable tool for complex data interrogation tasks in SQL.

Basic Concepts

Main queries and subqueries differ primarily in their role and placement. The main query is the outermost query you execute, while a subquery supports this main query by fetching data that it requires. Notably, subqueries can return different types of results – a single value, a row, a column, or even a full table.

Types of Subqueries

In general, subqueries can be classified as:

  1. Scalar: Returns a single value.
  2. Row: Returns a single row.
  3. Column: Returns a single column.
  4. Table: Returns a full table.

Syntax and Structure

A subquery, when written in SQL, is enclosed in parentheses and can be placed in various parts of the main query, depending on the requirement.

Basic Structure of a Subquery

The foundational syntax of a subquery follows this simple pattern:

SELECT column_name(s)
FROM table_name
WHERE column_name operator (SELECT column_name FROM table_name WHERE condition);

Placement in SQL

Subqueries can be situated in different areas of a main query:

  1. WHERE clause: Helps filter records based on the subquery’s result.
  2. FROM clause: Useful when you need to use the subquery as a table.
  3. SELECT clause: Here, the subquery can fetch a specific data column.

Types of Subqueries

Single Row Subqueries

As the name suggests, these subqueries return a single row. They use standard comparison operators such as =, <>, <, <=, >, >=. For instance:

SELECT employee_name, employee_salary
FROM employees
WHERE employee_salary > (SELECT AVG(employee_salary) FROM employees);

This query fetches employees who earn more than the average salary.

Multiple Row Subqueries

These subqueries return multiple rows and primarily use operators like IN, ANY, and ALL. For example:

SELECT product_name
FROM products
WHERE product_id IN (SELECT product_id FROM orders WHERE quantity_sold > 100);

This fetches names of products that have been sold more than 100 times.

Multiple Column Subqueries

These are beneficial when comparing multiple columns. A practical scenario might be comparing pairs of columns between tables.

SELECT student_name, student_course
FROM students
WHERE (student_name, student_course) IN
(SELECT student_name, course_name FROM enrolled_courses);

Correlated Subqueries

A correlated subquery is a unique type that references columns from the outer query. They are executed row by row for the outer query.

SELECT e1.employee_name
FROM employees e1
FROM employees e2
WHERE e1.employee_salary > e2.employee_salary);

This query, for instance, fetches the top three highest-paid employees.

Common Uses of Subqueries

Filtering Data

One of the fundamental applications of subqueries is in filtering data. When writing a SELECT statement, there might be occasions where the filtering criteria are based on the results of another SELECT statement. This is where subqueries in the WHERE clause come into play.

For instance, imagine you want to retrieve a list of products with a price greater than the average price of all products. A subquery can be used to first determine the average price and then filter the main query results.

SELECT product_name, price
FROM products
WHERE price > (SELECT AVG(price) FROM products);


Aggregate functions like SUM, AVG, COUNT, etc., often go hand-in-hand with subqueries. Subqueries can be utilized within the SELECT statement alongside these functions to provide a dynamic value for aggregation.

For instance, to get the total sales for a product category that exceeded a certain threshold:

SELECT category, SUM(sales)
FROM sales_data
WHERE category IN (SELECT category FROM sales_data GROUP BY category HAVING SUM(sales) > 10000)
GROUP BY category;

Data Manipulation

Subqueries can also be vital when performing data manipulation tasks. Consider a scenario where you need to update records based on a specific condition or another table’s data. Here’s an example where prices in a products table are updated based on a recommendation from a pricing_analysis table:

UPDATE products
SET price = price * 1.10
WHERE product_id IN (SELECT product_id FROM pricing_analysis WHERE recommendation = 'Increase');

Creating Derived Tables

Sometimes, subqueries can be used in the FROM clause to create what’s termed as a derived table. This table acts as a temporary set of results upon which the main query operates.

SELECT derived.avg_price, products.product_name
FROM (SELECT category, AVG(price) as avg_price FROM products GROUP BY category) AS derived
JOIN products ON derived.category = products.category;

Conditional Logic

Using the CASE statement allows for conditional logic in SQL queries. Incorporating subqueries with CASE can enhance the logic. For instance, adjusting the discount based on a product’s sales rank:

SELECT product_name,
WHEN sales_rank <= (SELECT percentile_cont(0.10) WITHIN GROUP (ORDER BY sales_rank) FROM products) THEN price * 0.90
ELSE price
END AS discounted_price
FROM products;

Performance Considerations

Common Performance Pitfalls

Subqueries, while versatile, can be performance hogs if not used judiciously. Common pitfalls include:

  1. Correlated Subqueries: These are subqueries that reference the outer query. They can slow down performance since the subquery has to be executed for each row processed by the outer query.
  2. Using Subqueries When Joins Will Do: Sometimes a join is more appropriate and efficient than a subquery.
  3. Over-Nesting: Extremely nested subqueries can lead to a performance hit and also make the SQL statement harder to read.

Optimizing Subqueries

To keep subqueries efficient:

  1. Limit Rows: When possible, use conditions to limit rows returned by the subquery.
  2. Indexes: Ensure the columns being queried have appropriate indexes.
  3. Avoid Aggregations: If possible, avoid aggregation in the subquery, especially if the data set is large.

Subqueries vs Joins

While subqueries are powerful, joins often provide a more performance-efficient way of correlating data between tables. If you find a subquery is slowing down a query, consider if the operation could be effectively rewritten using a join.

Advanced Topics

Nested Subqueries

Subqueries can also be nested within other subqueries. While this can provide solutions to complex problems, remember the potential impact on performance.

SELECT product_name
FROM products
WHERE manufacturer_id IN
(SELECT manufacturer_id FROM manufacturers WHERE country IN
(SELECT country FROM preferred_countries));

Common Table Expressions (CTEs) and Subqueries

CTEs provide a way to temporarily save the result set of a query, which can be easily referenced within the main SQL query. They can often be used as an alternative to subqueries, offering clearer syntax.

WITH TopSellers AS
(SELECT product_id FROM sales_data ORDER BY sales DESC LIMIT 10)
SELECT product_name FROM products WHERE product_id IN (SELECT product_id FROM TopSellers);


The EXISTS and NOT EXISTS keywords allow queries to be written in a manner where rows are returned based on the existence (or lack thereof) of records in the subquery.

SELECT product_name FROM products
WHERE EXISTS (SELECT 1 FROM sales_data WHERE products.product_id = sales_data.product_id AND sales > 100);

Common Errors and Troubleshooting

Subqueries can sometimes result in errors, such as:

  1. Subquery returns more than one row: This often happens when a subquery used in a scalar context (e.g., with operators like ‘=’, ‘<‘, etc.) returns multiple rows.
  2. Correlation without alias: Forgetting to use table aliases can lead to ambiguous column references, especially in correlated subqueries.

When troubleshooting, it’s beneficial to execute the subquery separately to ensure it’s returning the expected result set.

Best Practices

  1. Keep it Simple: Avoid over-complicating with excessive nesting.
  2. Test Subqueries Separately: Before embedding a subquery, test it standalone.
  3. Use Comments: Especially with complex nested subqueries, comments can help maintain clarity.


Subqueries, with their flexibility and depth, can significantly enhance SQL querying capabilities. By understanding their common use cases and being aware of potential pitfalls, one can craft efficient and effective SQL queries.

Examples and Exercises

Practical exercises will be beneficial for anyone looking to solidify their understanding. On codedamn, you can find interactive exercises related to subqueries to test and hone your skills.

Sharing is caring

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


No comments so far