PostgreSQL Self-Join

Summary: in this tutorial, you will learn how to use the PostgreSQL self-join technique
to compare rows within the same table.

Introduction to PostgreSQL self-join

A self-join is a query in which a table is joined to itself. Self-joins are useful for
comparing values in a column of rows within the same table.

To form a self-join, you specify the same table twice with different aliases, set up the
comparison, and eliminate cases where a value would be equal to itself.

The following query shows how to join the table A to itself:

1 SELECT column_list
2 FROM A a1
3 INNER JOIN A b1 ON join_predicate;

In this syntax, table A is joined to itself using the INNER JOIN clause. Note that you can
also use the LEFT JOIN or RIGHT JOIN clause.

PostgreSQL self-join examples

1) Querying hierarchy data example

Let’s set up a sample table for the demonstration.

Suppose, we have the following organization structure:

The following SQL script creates the employee table and inserts some sample data:

1 CREATE TABLE employee (

2 employee_id INT PRIMARY KEY,
3 first_name VARCHAR (255) NOT NULL,
4 last_name VARCHAR (255) NOT NULL,
5 manager_id INT,
6 FOREIGN KEY (manager_id)
7 REFERENCES employee (employee_id)
8 ON DELETE CASCADE
9 );
10 INSERT INTO employee (
11 employee_id,
12 first_name,
13 last_name,
14 manager_id
15 )
16 VALUES
17 (1, 'Windy', 'Hays', NULL),
18 (2, 'Ava', 'Christensen', 1),
19 (3, 'Hassan', 'Conner', 1),
20 (4, 'Anna', 'Reeves', 2),
21 (5, 'Sau', 'Norman', 2),
22 (6, 'Kelsie', 'Hays', 3),
23 (7, 'Tory', 'Goff', 3),
24 (8, 'Salley', 'Lester', 3);

The value in the manager_id column represents the manager who the employee reports
to. If the value in the manager_id column is null, then the employee does not report to
anyone. In other words, that employee is the top manager.

To find who reports to whom, you use the following query:

1 SELECT
2 e.first_name || ' ' || e.last_name employee,
3 m .first_name || ' ' || m .last_name manager
4 FROM
5 employee e
6 INNER JOIN employee m ON m .employee_id = e.manager_id
7 ORDER BY
8 manager;

This query referenced the employees table twice, one as the employee and another as
the manager. It uses table aliases e for the employee and m for the manager.

The join predicate finds employee/manager pair by matching values in the

employee_id and manager_id columns.
As you can see from the screenshot, the top manager did not appear on the output.

To include the top manager in the result set, you use the LEFT JOIN instead of INNER
JOIN clause as shown in the following query:

1 SELECT
2 e.first_name || ' ' || e.last_name employee,
3 m .first_name || ' ' || m .last_name manager
4 FROM
5 employee e
6 LEFT JOIN employee m ON m .employee_id = e.manager_id
7 ORDER BY
8 manager;

2) Comparing the rows with the same table

See the following film table from the DVD rental database:
The following query finds all pair of films that have the same length.

1 SELECT
2 f1.title,
3 f2.title,
4 f1. length
5 FROM
6 film f1
7 INNER JOIN film f2 ON f1.film_id <> f2.film_id
8 AND f1. length = f2. length;
This query joined the film table to itself. The join predicate matches different films
specified by film_id that have the same length.

In this tutorial, you have learned how to use the PostgreSQL self-join technique to join
a table to itself.