How to Join 3 Tables in SQL: Simplified Techniques for Efficient Queries

By Cristian G. Guasch • Updated: 06/02/23 • 19 min read

When working with databases, it’s not uncommon to have data spread across multiple tables. In these cases, leveraging the power of SQL becomes crucial in retrieving and analyzing that information. A popular method of combining data from different tables is by using SQL joins. More specifically, to join 3 tables in SQL, one needs to utilize multiple join statements to establish a clear relationship among the tables involved.

The process of joining three tables can be approached in various ways, depending on the type of relationship between them. Generally, it involves using INNER JOIN, LEFT JOIN, or RIGHT JOIN statements to define the interaction between pairs of tables. The key to successfully joining tables lies in understanding the connections between columns and how they can be used to match rows from different tables.

While the concept of joining 3 tables in SQL might seem intimidating at first, with practice and a good grasp of database relationships, it becomes second nature. Various SQL join techniques will facilitate data retrieval and analysis, helping users create more effective and insightful queries.

Understanding SQL Table Joins

When working with databases, it’s often necessary to join 3 tables in SQL to retrieve information from multiple sources. In this section, we’ll explore the different types of SQL table joins, how to use them effectively, and essential tips when joining three tables.

To join tables in SQL, three main types of joins can be utilized:


An INNER JOIN combines rows from two or more tables based on a related column. Only rows with matching values in both tables are returned:

SELECT a.column1, b.column2, c.column3
FROM table1 AS a
INNER JOIN table2 AS b ON a.key = b.key
INNER JOIN table3 AS c ON a.key = c.key;

A LEFT JOIN returns all rows from the left table, along with matching rows from the right table. If no match is found, NULL values are returned for right table columns:

SELECT a.column1, b.column2, c.column3
FROM table1 AS a
LEFT JOIN table2 AS b ON a.key = b.key
LEFT JOIN table3 AS c ON a.key = c.key;

A RIGHT JOIN works similarly to the LEFT JOIN but returns all rows from the right table. If no match is found, NULL values are returned for left table columns:

SELECT a.column1, b.column2, c.column3
FROM table1 AS a
RIGHT JOIN table2 AS b ON a.key = b.key
RIGHT JOIN table3 AS c ON a.key = c.key;

Here are some essential tips for joining three tables:

  • Ensure to use the proper alias for each table to maintain readability and avoid confusion
  • Avoid using SELECT * to minimize the amount of data retrieved and improve query performance
  • Utilize indexes to speed up query execution. Ensure that indexes cover the columns needed in the join condition
  • Be cautious when using multiple outer joins, as it may lead to incorrect results. When joining three tables with outer joins, it’s typically recommended to use LEFT JOINs only to ensure predictable results

By understanding the different types of SQL table joins and using them appropriately, one can effectively join 3 tables in SQL and retrieve data from multiple sources. With this knowledge, database professionals can create more efficient and accurate queries to unlock valuable insights.

Types of SQL Table Joins

When working with databases, one common task is to join 3 tables in SQL. Joining tables allows us to efficiently combine data from multiple sources in a single query. There are several types of SQL table joins, and understanding each type is essential for efficiently retrieving data.

Inner Join

An inner join returns only the rows from each table where a match occurs based on the specified join condition. If no matches are found, no rows are returned. This type of join is often used when we need to combine data from tables with a strict relationship.

Left Join

A left join, or left outer join, returns all rows from the left table, and the matched rows from the right table. If no match is found on the right table, NULL values are returned for the right table’s columns. Left joins are useful for retrieving data from the main table and including any related data from another table, even if a match doesn’t exist.

Right Join

A right join, or right outer join, works like a left join but in the opposite direction. It returns all rows from the right table and any matched rows from the left table. If no matches are found on the left table, NULL values are returned for the left table’s columns. This join type is often used when you need to focus on the right table’s data.

Full Outer Join

A full outer join returns all rows when there’s a match in either the left or right table. If there’s no match, NULL values are returned for the missing columns. This join is useful when you want to ensure that all data is retained from both tables, regardless of matching conditions.

Cross Join

A cross join generates a Cartesian product of the tables being joined. In other words, it returns all possible combinations of rows from the tables. This join type is less frequently used and may not be supported by all database systems.

In order to join 3 tables in SQL, you must use a combination of the above join types. When joining multiple tables, it’s important to choose the right type of join to ensure accurate and efficient results. For example, when retrieving data from 3 tables in a single query, you might use an inner join for the first two tables and a left join for the third one, depending on the required result.

In conclusion, understanding these types of SQL table joins is vital when working with multiple tables in a database system. By carefully selecting the appropriate join type and efficiently combining tables, you can obtain accurate results and optimize your queries.

Preparation: Gathering Data

Joining 3 tables in SQL can be an efficient way to extract and combine information from multiple sources. Before diving into the actual process, it’s essential to gather and organize the relevant data. This section will guide you through the necessary preparation steps, ensuring a smooth and streamlined workflow.

Initially, identify the three tables you’re planning to join, and take note of their columns, data types, and relationships. Understanding these elements is crucial for selecting the appropriate joining technique and crafting accurate queries. If possible, make a list or sketch a diagram showing the tables and their connections.

Next, consider the purpose of your query. Are you aiming to retrieve specific data points or create a comprehensive report? Knowing your objective will help you focus on the relevant columns and avoid including unnecessary information. For instance, you might concentrate on columns related to sales, customer data, or inventory management.

Once you have a clear picture of your goal, determine the type of join necessary to achieve it. In SQL, there are several join types, including:


Each has its strengths and limitations, so it’s vital to choose the one that best suits your needs. As a quick reference, here’s a brief overview of the different join types:

  • INNER JOIN: returns rows from both tables where there’s a match between specified columns.
  • LEFT JOIN: returns all rows from the left (first) table and matching rows from the right (second) table. If no match exists, NULL values are displayed for the right table columns.
  • RIGHT JOIN: works similarly to LEFT JOIN, but focuses on the right table, displaying all its rows and returning NULL values for any unmatching left table columns.
  • FULL OUTER JOIN: returns all rows from both tables, matching them whenever possible. If no match exists, NULL values are displayed for the columns from the table without a match.
  • CROSS JOIN: generates a Cartesian product, combining every row from the first table with every row from the second table.

Keep in mind that performance can be affected when working with large datasets. It’s always a good idea to optimize your queries by adding appropriate indexes to the tables and using specific conditions in WHERE and ON clauses to filter data.

In summary, successful preparation involves identifying the tables and columns, understanding their relationships, defining your query’s purpose, selecting the right join type, and considering optimization measures. By carefully following these steps, you’ll lay a solid foundation for efficiently joining 3 tables in SQL.

Setting Up the Environment

Joining three tables in SQL is a common task that individuals may face when working with databases. In order to effectively join three tables, it’s critical to set up a proper SQL environment. The process consists of several steps, including installing the necessary software, creating a database, and setting up tables with sample data.

First and foremost, it’s essential to have the appropriate software installed on the user’s computer. The SQL environment can be set up using a variety of database management systems (DBMS), such as MySQL, PostgreSQL, or SQL Server. Users should select the DBMS that best suits their needs and install the system by following the vendor’s instructions.

To create a new database, users need to log into the installed DBMS and use the appropriate command. For instance, the following SQL commands can be utilized:

  • MySQL: CREATE DATABASE database_name;
  • PostgreSQL: CREATE DATABASE database_name;
  • SQL Server: CREATE DATABASE database_name;

After creating the database, it’s time to set up the tables with sample data that will be used for joining. As an example, consider a scenario where a user wants to join three tables – Employees, Departments, and Titles – based on specific criteria. The table structure could be as follows:

TableColumnData Type

With the tables created, users need to insert some sample data. Here is an example for each table:

  • Employees: INSERT INTO Employees (EmployeeID, FirstName, LastName, DepartmentID) VALUES (1, 'John', 'Doe', 1), (2, 'Jane', 'Smith', 2), (3, 'Mark', 'Brown', 1);
  • Departments: INSERT INTO Departments (DepartmentID, DepartmentName) VALUES (1, 'HR'), (2, 'Finance');
  • Titles: INSERT INTO Titles (TitleID, EmployeeID, JobTitle) VALUES (1, 1, 'HR Manager'), (2, 2, 'Accountant'), (3, 3, 'HR Assistant');

With software installed, a database created, and tables populated with sample data, the environment is now set up for performing the task of joining three tables in SQL. Users can start crafting SQL queries to retrieve meaningful insights from the interconnected data.

Creating a Sample Database

Before diving into the process of joining 3 tables in SQL, it’s essential to create a sample database to work with. In this section, we’ll cover how to set up a sample database with three tables and fill them with some data.

To begin, let’s create three tables: employees, departments, and projects. The employees table will store information about each employee, such as their ID, name, and department. The departments table will contain information about each department, such as its ID and name. Finally, the projects table will store data about each project, including its ID, name, and the department responsible for it.

Here’s the SQL code to create these three tables:

CREATE TABLE employees (
  emp_name VARCHAR(50),
  dept_id INT

CREATE TABLE departments (
  dept_id INT PRIMARY KEY,
  dept_name VARCHAR(50)

CREATE TABLE projects (
  project_id INT PRIMARY KEY,
  project_name VARCHAR(50),
  dept_id INT

Now that we’ve set up the tables, let’s add some sample data to each one:

INSERT INTO employees (emp_id, emp_name, dept_id)
VALUES (1, 'John Doe', 1),
(2, 'Jane Smith', 1),
(3, 'Steve Johnson', 2),
(4, 'Samantha Brown', 3);

INSERT INTO departments (dept_id, dept_name)
VALUES (1, 'Marketing'),
(2, 'Sales'),
(3, 'HR');

INSERT INTO projects (project_id, project_name, dept_id)
VALUES (1, 'Ad Campaign', 1),
(2, 'Sales Strategy', 2),
(3, 'Recruitment', 3);

After adding this sample data, our tables will look like this:


1John Doe1
2Jane Smith1
3Steve Johnson2
4Samantha Brown3




1Ad Campaign1
2Sales Strategy2

With these tables set up and populated, we’re now ready to learn how to join 3 tables in SQL in the next sections of this article.

Joining 3 Tables: The Concept

Joining 3 tables in SQL is a common requirement when working with relational databases. It’s essential to understand the concept behind it to effectively combine information from multiple tables and get the desired output.

To join 3 tables in SQL, you’d generally follow these steps:

  1. Identify the key columns used to relate the tables.
  2. Determine the type of join needed (inner join, outer join, or cross join).
  3. Write the SQL query with the appropriate syntax and join conditions.

It’s important to note that the number of tables you’re joining isn’t limited to 3; SQL allows you to join multiple tables. However, in this section, we’ll focus on joining 3 tables.

Identifying Key Columns

When joining tables, the tables are usually related through key columns. These are columns containing unique identifiers allowing you to match records in one table with those in another. Examples of key columns include:

  • Primary key: a unique identifier for each record in a table
  • Foreign key: a field in one table that refers to the primary key in another table

For example, imagine you have 3 tables: customers, orders, and products. The primary key in the customers table is customer_id, in the orders table – order_id, and in the products table – product_id. The customer_id is a foreign key in the orders table while product_id is a foreign key in a fourth table called order_details, containing information about each product in an order.

Determining the Type of Join

There are three main types of joins you’ll be employing to join 3 tables in SQL:

  • Inner join: returns rows where there’s a match in both tables
  • Outer join: returns rows from one table where there’s no match in the second table, along with the matched rows
  • Cross join: returns the Cartesian product of rows from both tables

The type of join you choose depends on your desired outcome and the relationships between the tables.

Writing the SQL Query

Once you’ve identified the key columns and determined the type of join, you can write your SQL query. Here’s an example using the earlier mentioned tables and inner join:

SELECT customers.customer_name, orders.order_date, products.product_name
FROM customers
JOIN orders ON customers.customer_id = orders.customer_id
JOIN order_details ON orders.order_id = order_details.order_id
JOIN products ON order_details.product_id = products.product_id;

This query returns the customer name, order date, and product name of all orders. It’s joining the customers table with the orders table and the order_details table with the products table using the appropriate key columns.

Understanding the concept of joining 3 tables in SQL is vital for effectively working with relational databases and extracting the information you need.

Step-by-Step Guide to Join 3 Tables

Joining three tables in SQL may seem like a daunting challenge, but it’s not as difficult as it appears. The key is understanding the relationships between the tables and using the appropriate SQL JOIN statements. This guide will walk you through the process step-by-step.

The first step in joining 3 tables consists of identifying the relationships between them. In most cases, you’ll be dealing with primary and foreign keys, which establish a link between two tables. It’s crucial to understand the relationships before proceeding, as they’ll determine how the data from the tables will be combined.

Once the relationships have been identified, it’s time to tackle the SQL query. Start by using the SELECT statement to specify the columns you want to retrieve from the tables. Remember to include the table names and their respective prefixes to avoid ambiguity. For example:

SELECT table1.column1, table2.column2, table3.column3

Next, you’ll need to perform two JOIN operations to combine the three tables. Begin by joining the first two tables using a common column, typically a primary or foreign key. You can use an INNER JOIN, OUTER JOIN, or other relevant JOIN type depending on your data requirements. Here’s an example of an INNER JOIN:

FROM table1
ON table1.column1 = table2.column1

After performing the first JOIN, you can now join the third table using another common column. Just like before, choose the appropriate JOIN type for the desired output. Here’s an example of how to join the third table using another INNER JOIN:

ON table2.column2 = table3.column2

Finally, you may need to include a WHERE clause to filter the results further. This step is optional and depends entirely on your query requirements. For instance, you might want to retrieve only rows that meet specific criteria:

WHERE table1.column3 > 100

With all the elements in place, your completed query to join 3 tables in SQL should look something like this:

SELECT table1.columnA, table2.columnB, table3.columnC
FROM table1
ON table1.column1 = table2.column1
ON table2.column2 = table3.column2
WHERE table1.column3 > 100;

Keep in mind that this is just one example, and different scenarios may require adjustments to the JOIN types and other query components. Nonetheless, this guide provides a solid foundation for joining 3 tables in SQL.

Working with Alias in SQL

When attempting to join 3 tables in SQL, it’s often helpful to use aliases. Alias is a temporary name given to a table or a column for a specific query. They can simplify complex queries and make them easier to read. Let’s consider the benefits of using aliases and some examples of how they work.

Aliases provide several advantages:

  • They shorten lengthy table and column names, which can make code more readable.
  • They can prevent ambiguity when joining tables with similar column names.
  • They improve the query’s overall organization and structure.

To illustrate how aliases work, let’s imagine a scenario where you have three tables: Customers, Orders, and Products.


1John Doe
2Jane Smith




1Product A
2Product B

Now you want to join all three tables to display information about the customers who have made purchases and which products they have ordered. Here’s a SQL query that utilizes aliases to make the code more compact and easier to understand:

SELECT c.CustomerName, p.ProductName
FROM Customers AS c
JOIN Orders AS o ON c.CustomerID = o.CustomerID
JOIN Products AS p ON o.ProductID = p.ProductID;

In this example, we have assigned the following aliases:

  • c for the Customers table
  • o for the Orders table
  • p for the Products table

These aliases make the query more concise, especially when dealing with numerous tables. The shorter syntax is beneficial when creating complex queries, as it allows for improved readability and reduced chance of syntax errors.

In conclusion, when working with queries that join 3 tables in SQL, using aliases can greatly improve both the readability and the structure of your code. Utilizing aliases can be an excellent way to simplify complex queries and make them more comprehensible, especially when dealing with tables that have similar column names.

Common Mistakes and How to Avoid Them

When attempting to join 3 tables in SQL, there are some common mistakes that often crop up. By understanding these errors and learning how to avoid them, you’ll be better equipped to execute complex queries with ease.

One typical error involves forgetting to mention the correct join condition. When joining three tables, you’ll need two join conditions. It’s crucial to specify the proper relationships between the tables in these conditions. To avoid this mistake, double-check that you have written the correct join conditions before running your query.

Another common issue is using the wrong type of join. SQL offers different join types, such as INNER JOIN, LEFT JOIN, RIGHT JOIN, and FULL OUTER JOIN. Choosing the wrong type can lead to incorrect results. Before executing the query, ensure that you’ve selected the appropriate join type for your specific situation.

In some cases, SQL developers might accidentally:

  • Introduce a cartesian product in the query, leading to an excessive amount of data in the result set.
  • Use the wrong alias for the table names, causing confusion and unexpected results.
  • Fail to optimize the query correctly, negatively affecting performance.

The following best practices will aid in avoiding these common mistakes when you join 3 tables in SQL:

  • Always use table aliases to keep your query concise and improve readability.
  • When selecting columns from different tables, specify the table alias for clarity.
  • Use INNER JOIN if a result set must contain entries from all tables in the join condition. Utilize LEFT JOIN, RIGHT JOIN, or FULL OUTER JOIN when you need to preserve one or more tables’ data while retrieving related data from the other tables.
  • Optimize your queries by applying appropriate indexing strategies and periodically analyzing your database’s performance.

It’s essential to carefully review and test your queries to ensure that your SQL commands yield the desired outcome. Below is an example of a properly formatted query that joins three tables (table1, table2, table3) based on two conditions:

SELECT t1.column_name1, t2.column_name2, t3.column_name3
FROM table1 t1
INNER JOIN table2 t2 ON t1.column_nameA = t2.column_nameA
INNER JOIN table3 t3 ON t2.column_nameB = t3.column_nameB;

In conclusion, becoming proficient in joining 3 tables in SQL entails being mindful of common mistakes and best practices. By focusing on these areas and adhering to the suggestions in this guide, you can confidently and effectively execute complex queries that join multiple tables.

Conclusion: Mastering 3-Table Joins

Mastering the art of joining three tables in SQL can elevate one’s database management skills. It’s essential to understand the different techniques for combining data from multiple tables, as it allows for more complex and informative queries. Remembering these key points can help maximize the benefits of using 3-table joins:

  • Joining three tables requires an understanding of the relationships between them, whether they’re one-to-one, one-to-many, or many-to-many.
  • There are various types of joins available in SQL, including INNER JOIN, LEFT JOIN, RIGHT JOIN, and FULL OUTER JOIN. These types of joins make it possible to combine data from multiple tables effectively.
  • Utilizing aliases while joining tables can simplify the queries and improve their readability.

Applying these concepts in practice is equally important. Ensuring efficiency and accuracy can be achieved through regular practice and by analyzing different datasets. Here are a few practical tips to keep in mind:

  1. Make sure to identify and define the relationships between tables clearly before executing the join.
  2. Select the appropriate type of join depending on the desired outcome.
  3. Use aliases to simplify queries and keep them organized.
  4. Test your queries on various datasets to ensure effectiveness.

By incorporating these tips and diligently practicing, anyone can effectively join three tables in SQL and greatly enhance their data analysis capabilities.

Related articles