SQL Correlated Subqueries

In SQL, correlated subqueries are powerful tools that allow us to perform row-by-row comparisons and retrieve complex data. Unlike regular subqueries, correlated subqueries depend on values from the outer query, making them dynamic and highly effective for solving complex database problems.

In this article, we will explain SQL Correlated Subqueries, discussing their syntax, examples, and real-world applications. By the end of this article, we will understand how to effectively use correlated subqueries in our SQL queries.

What Are SQL Correlated Subqueries?

A correlated subquery is a subquery in SQL that refers to values from the outer query. The key difference between a correlated subquery and a regular subquery is that a correlated subquery is evaluated for each row processed by the outer query. This makes it dynamic, as it can return different results for each row depending on the values of the outer query.

Key characteristics

• Row-by-Row Evaluation: The subquery is executed once for each row in the outer query.
  
• Dynamic and Dependent: The inner query uses values from the outer query, making it dependent on the outer query.
  
• Used for Complex Filtering: Correlated subqueries are commonly used for row-specific filtering, ranking, or calculations based on other related data.

The syntax of a correlated subquery allows you to reference columns from the outer query inside the subquery. Here’s the basic structure:

Syntax:

SELECT column1, column2, ....
FROM table1 outer
WHERE column1 operator
(SELECT column1, column2
FROM table2
WHERE expr1 = outer.expr2);

A correlated subquery is one way of reading every row in a table and comparing values in each row against related data. It is used whenever a subquery must return a different result or set of results for each candidate row considered by the main query. In other words, we can use a correlated subquery to answer a multipart question whose answer depends on the value in each row processed by the parent statement. 

Nested Subqueries Versus Correlated Subqueries

With a normal nested subquery, the inner SELECT query runs first and executes once, returning values to be used by the main query. A correlated subquery, however, executes once for each candidate row considered by the outer query. In other words, the inner query is driven by the outer query.

1. Fetching Data Based on Row-Specific Conditions

Correlated subqueries are often used when you need to filter data based on a condition that involves comparing values from the outer query.

 Example: Fetch Employees Who Earn More Than Their Department's Average Salary

SELECT last_name, salary, department_id
 FROM employees outer
 WHERE salary >
                (SELECT AVG(salary)
                 FROM employees
                 WHERE department_id =
                        outer.department_id group by department_id);

Explanation:

In this example, the subquery calculates the average salary for each department, and for each employee, the outer query checks if their salary is greater than the average for their department.

2. Using Correlated Subqueries with UPDATE

Correlated subqueries can also be used with UPDATE statements to modify data based on related information from another table.

Example: Update Employee Salary Based on Department Average

UPDATE employees e
SET salary = (SELECT AVG(salary)
              FROM employees
              WHERE department_id = e.department_id)
WHERE department_id = 101;

Explanation:

This query updates the salaries of employees in department 101 based on the average salary for that department. The subquery is evaluated for each row in the employees table.

3. Using Correlated Subqueries with DELETE

We can use a correlated subquery within a DELETE statement to remove rows from one table based on conditions in another table. 

Example: Delete Employees Who Do Not Belong to Department 101

DELETE FROM table1 alias1
 WHERE column1 operator
               (SELECT expression
                FROM table2 alias2
                WHERE alias1.column = alias2.column);

Explanation:

This query deletes employees who do not belong to the 'HR' department by using a correlated subquery in the NOT EXISTS clause.

4. Using EXISTS with Correlated Subqueries

The EXISTS operator is often used in correlated subqueries to test if a subquery returns any rows. It returns TRUE if the subquery has at least one row.

Example: Find Employees Who Have at Least One Person Reporting to Them

SELECT employee_id, last_name, job_id, department_id
FROM employees outer
WHERE EXISTS ( SELECT ’X’
FROM employees
WHERE manager_id =
outer.employee_id);

Output

5. Using NOT EXISTS with Correlated Subqueries

The NOT EXISTS operator is used to check if a subquery does not return any rows. This is useful for finding records that do not match specific criteria.

Example: Find Departments Without Any Employees

SELECT department_id, department_name
FROM departments d
WHERE NOT EXISTS (SELECT ’X’
FROM employees
WHERE department_id
= d.department_id);

Output

Explanation:

This query retrieves departments that do not have any employees assigned to them. The NOT EXISTS clause ensures that only those departments without employees are selected.

Conclusion

SQL correlated subqueries provide a powerful way to perform row-by-row comparisons and manipulate data based on dynamic conditions. By using correlated subqueries in SELECT, UPDATE, DELETE, and INSERT statements, we can handle complex filtering, ranking, and calculations that require data from other rows or tables. Understanding the key differences between correlated and non-correlated subqueries is essential for optimizing SQL queries and ensuring efficient data retrieval and modification.

SQL Correlated Subqueries

Visit Course