Tips and Tricks

SQL subqueries: [Step-By-Step] Guide

Among the most powerful tools in this realm are SQL subqueries, a feature that, when mastered, significantly amplifies your ability to extract insights from data. The article is written to describe the concept of subqueries, making them accessible and practical for anyone looking to enhance their data engineering skills.

Subqueries, or queries within queries, offer a dynamic approach to handling complex data retrieval tasks. They allow you to nest logic, perform operations in stages, and reference the results of one query within another. Whether preparing for a job interview, working on a data project, or simply looking to broaden your SQL knowledge, understanding subqueries is essential.

In this guide, we’ll start from the basics, explaining what subqueries are and where they fit into the SQL landscape. We’ll then progress through different types of subqueries, from simple single-level examples to more complex, nested scenarios. Each section will be packed with examples, best practices, and tips to understand subqueries and use them effectively in your work.

What is SQL Subqueries

SQL subqueries, a fundamental concept in the realm of database management and data analysis, are essentially queries within queries. They enable a more nuanced and powerful approach to data retrieval, allowing for sophisticated operations that go beyond the capabilities of a single standard SQL query. Understanding subqueries is pivotal for anyone looking to deepen their SQL proficiency and leverage the full potential of SQL for complex data tasks.

Defining SQL Subqueries

At its core, a subquery is an SQL query nested inside another SQL query. The main query, often called the outer query, can incorporate a subquery in its SELECT, FROM, or WHERE clauses, among others. This nesting allows the result of the subquery to serve as a condition or data source for the outer query, enabling operations that rely on intermediate results or the dynamic generation of criteria for data filtering, aggregation, or manipulation.

How Subqueries Differ from Regular Queries

Unlike regular queries that operate independently to retrieve data directly from tables within a database, subqueries provide a layer of abstraction and flexibility. They allow for the execution of queries that depend on the outcomes of other queries, enabling a sequential approach to data retrieval. This capability is beneficial for complex data analysis tasks where the answer to one question depends on the answers to several underlying questions.

Types of Subqueries

Subqueries can be broadly categorized based on their return values and relationship with the outer query. Understanding these categories is crucial for effectively employing subqueries in your SQL toolkit.

  • Single-Row Subqueries: These return a single row and are typically used in conditions that compare scalar values. They’re often found in WHERE clauses, comparing a column value against the result of the subquery.
  • Multi-Row Subqueries: As the name suggests, these can return multiple rows and are used when the outer query’s condition needs to be compared against a set of values. Operators like IN, ANY, and ALL are commonly used with multi-row subqueries to evaluate conditions against the returned set.
  • Correlated Subqueries: A correlated subquery references columns from the outer query, creating a dependency between the two. Each time the outer query is evaluated, the correlated subquery is re-executed, allowing for dynamic comparisons based on the data currently being processed by the outer query.
  • Non-Correlated Subqueries: These operate independently of the outer query, meaning they do not reference any elements of the outer query and can be executed on their own. The result of a non-correlated subquery can be used by the outer query but does not change based on the outer query’s current row.

Basic Syntax of Subqueries

Subqueries can be used in various parts of an SQL statement, including SELECT, FROM, and WHERE clauses, each serving different purposes and offering unique benefits. Let’s delve into the syntax and practical applications of subqueries across these clauses, enhancing your SQL toolkit with powerful querying techniques. Mastering these techniques is not just about improving your SQL skills; it’s about preparing yourself for the challenging scenarios you’ll face in data engineering interviews and on the job.

For those who are beginning their journey into the world of SQL or looking to solidify their foundational knowledge, DE Academy offers a SQL Tutorial Course. This course provides a step-by-step guide through the basics of SQL, gradually advancing to more complex concepts and operations, including subqueries. It’s an ideal starting point for aspiring data engineers committed to building a strong foundation in SQL.

By combining the practical, real-world applications covered in our SQL Data Engineer Interview Course with the foundational skills taught in our SQL Tutorial Course, you’re setting yourself up for success. You’ll not only be prepared to tackle any SQL challenges thrown your way during interviews but also be well-equipped to handle the demands of a data engineering role.

Basic Syntax of Subqueries

The basic syntax of a subquery involves nesting an SQL SELECT statement inside another SQL statement. The nested SELECT statement, or the subquery, is enclosed in parentheses, distinguishing it from the main, or outer, query.

SELECT column_name(s)

FROM table_name

WHERE column_name OPERATOR

    (SELECT column_name FROM table_name WHERE condition);

Using Subqueries in SELECT 

Subqueries within SELECT clauses allow you to perform calculations or aggregate data for each row returned by the outer query. This is particularly useful for incorporating dynamic values into your result set that are dependent on conditions evaluated per row.

SELECT employee_id, 

       (SELECT AVG(salary) 

        FROM salaries 

        WHERE department = employee.department) AS avg_department_salary

FROM employee;

This query calculates the average salary for each employee’s department, displaying it alongside employee IDs.

Subqueries in the FROM

In the FROM clause, subqueries act as derived tables, providing a temporary table from which the outer query can select. This technique is useful for simplifying complex queries by breaking them down into manageable parts.

`SELECT a.employee_name, b.avg_salary

FROM employee a

JOIN (SELECT department, AVG(salary) AS avg_salary FROM salaries GROUP BY department) b

ON a.department = b.department;

Here, the subquery creates a temporary table of average salaries by department, which is then joined to the employee table.

Subqueries in the WHERE 

When used in the WHERE clause, subqueries filter the rows returned by the outer query based on a condition that matches a set of values returned by the subquery.

SELECT employee_name

FROM employee

WHERE department IN 

    (SELECT department FROM departments WHERE head = 'John Doe');

This query selects employees who are in departments headed by John Doe.

Correlated Subqueries

Correlated subqueries reference column(s) from the outer query, making the subquery’s execution dependent on the outer query. They are powerful tools for row-by-row operations.

SELECT e.employee_name, e.salary

FROM employee e

WHERE e.salary > 

    (SELECT AVG(salary) FROM employee WHERE department = e.department);

This correlated subquery compares each employee’s salary against the average salary of their department, selecting those who earn above the average.

Understanding and utilizing subqueries across SELECT, FROM, and WHERE clauses, including mastering the intricacies of correlated subqueries, significantly enhances your ability to write complex, efficient SQL queries. By breaking down data retrieval tasks into simpler, logical components, subqueries empower you to tackle sophisticated data analysis challenges with ease.

Advanced Subquery Techniques

These sophisticated techniques allow for dynamic data manipulation and can significantly enhance the efficiency and power of your SQL operations. Understanding how to effectively implement subqueries with aggregate functions or within INSERT, UPDATE, and DELETE statements opens up a new level of database interaction.

Using Subqueries with Aggregate Functions

Subqueries can be incredibly powerful when combined with aggregate functions like SUM, AVG, MAX, and COUNT. They allow you to perform calculations on a subset of data that is dynamically determined within your query.

SELECT employee_id, salary,

       (SELECT AVG(salary) FROM employees) AS company_avg_salary

FROM employees

WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = 'Engineering');

This query uses a subquery to calculate the average salary across the company and then filters employees in the Engineering department who earn more than this average. It showcases the power of subqueries to perform complex comparisons and calculations within a single query.

Subqueries in Data Manipulation Statements

Advanced subquery techniques also come into play in data manipulation statements, providing a method to dynamically insert, update, or delete records based on conditions evaluated through a subquery.

INSERT INTO high_earners (employee_id, salary)

SELECT employee_id, salary

FROM employees

WHERE salary > (SELECT AVG(salary) * 1.5 FROM employees);

This example inserts records into a high_earners table for employees whose salaries are above 150% of the company average, showcasing how subqueries can dynamically define the data set for insertion.

UPDATE employees

SET salary = salary * 1.1

WHERE department IN 

    (SELECT department FROM departments WHERE budget > 1000000);

Here, salaries are increased by 10% for employees in departments with budgets over $1,000,000, illustrating the use of subqueries to identify records for conditional updates based on related data.

DELETE FROM employees

WHERE employee_id IN 

    (SELECT employee_id FROM project_assignments WHERE project_end < CURRENT_DATE);

This command deletes employees from the table who are assigned to projects that have ended, demonstrating how subqueries can specify records for deletion based on criteria evaluated through a related dataset.

Best Practices

When employing advanced subquery techniques, it’s important to keep performance considerations in mind. Subqueries, especially correlated ones, can significantly impact query execution time. Always test your queries and consider alternatives, such as joins or temporary tables, if performance is a concern.

Understanding these advanced subquery techniques can dramatically increase the sophistication and effectiveness of your SQL queries. They offer a versatile toolset for navigating and manipulating complex datasets, reinforcing the importance of subqueries in any data engineer’s arsenal.


As we wrap up our exploration of SQL subqueries, it’s clear that mastering these techniques is pivotal for anyone looking to excel in data engineering. The ability to craft efficient and powerful subqueries not only elevates your SQL skills but also enhances your capability to tackle complex data challenges with confidence.
Continuous learning and practice are key to unlocking the full potential of SQL as a tool for data manipulation and analysis. Whether you’re preparing for a data engineering interview, working on data-intensive projects, or aiming to advance your career, honing your SQL skills is essential.

To support you, DE Academy offers comprehensive SQL courses tailored to meet the needs of aspiring and experienced data engineers alike. Furthermore, for those seeking personalized guidance, DE Academy’s coaching program offers one-on-one mentorship with industry experts.

Our coaches are dedicated to helping you refine your technical skills, prepare for interviews, and navigate the challenges of the data engineering landscape.