Follow @vlad_mihalcea Imagine having a tool that can automatically detect if you are using JPA and Hibernate properly. Hypersistence Optimizer is that tool!

Introduction

In this article, we are going to see how INNER JOIN works in SQL, and how we can use it to associate rows belonging to different tables and build compound result sets.

Database tables

Let’s consider we have two tables, post and post_comment , which form a one-to-many table relationship via the post_id Foreign Key column in the post_comment table:

The post table has the following 3 rows:

| id | title | |----|-----------| | 1 | Java | | 2 | Hibernate | | 3 | JPA |

and the post_comment table has the following 3 records:

| id | review | post_id | |----|-----------|---------| | 1 | Good | 1 | | 2 | Excellent | 1 | | 3 | Awesome | 2 |

SQL INNER JOIN

The SQL JOIN clause allows you to associate rows that belong to different tables. For instance, a CROSS JOIN will create a Cartesian Product containing all possible combinations of rows between the two joining tables.

While the CROSS JOIN is useful in certain scenarios, most of the time, you want to join tables based on a specific condition. And, that’s where INNER JOIN comes into play.

The SQL INNER JOIN allows us to filter the Cartesian Product of joining two tables based on a condition that is specified via the ON clause.

SQL INNER JOIN – ON “always true” condition

If you provide an “always true” condition, the INNER JOIN will not filter the joined records, and the result set will contain the Cartesian Product of the two joining tables.

For instance, if we execute the following SQL INNER JOIN query:

SELECT p.id AS "p.id", pc.id AS "pc.id" FROM post p INNER JOIN post_comment pc ON 1 = 1

We will get all combinations of post and post_comment records:

| p.id | pc.id | |---------|------------| | 1 | 1 | | 1 | 2 | | 1 | 3 | | 2 | 1 | | 2 | 2 | | 2 | 3 | | 3 | 1 | | 3 | 2 | | 3 | 3 |

So, if the ON clause condition is “always true”, the INNER JOIN is simply equivalent to a CROSS JOIN query:

SELECT p.id AS "p.id", pc.id AS "pc.id" FROM post p CROSS JOIN post_comment WHERE 1 = 1 ORDER BY p.id, pc.id

SQL INNER JOIN – ON “always false” condition

On the other hand, if the ON clause condition is “always false”, then all the joined records are going to be filtered out and the result set will be empty.

So, if we execute the following SQL INNER JOIN query:

SELECT p.id AS "p.id", pc.id AS "pc.id" FROM post p INNER JOIN post_comment pc ON 1 = 0 ORDER BY p.id, pc.id

We won’t get any result back:

| p.id | pc.id | |---------|------------|

That’s because the query above is equivalent to the following CROSS JOIN query:

SELECT p.id AS "p.id", pc.id AS "pc.id" FROM post p CROSS JOIN post_comment WHERE 1 = 0 ORDER BY p.id, pc.id

SQL INNER JOIN – ON clause using the Foreign Key and Primary Key columns

The most common ON clause condition is the one that matches the Foreign Key column in the child table with the Primary Key column in the parent table, as illustrated by the following query:

SELECT p.id AS "p.id", pc.post_id AS "pc.post_id", pc.id AS "pc.id", p.title AS "p.title", pc.review AS "pc.review" FROM post p INNER JOIN post_comment pc ON pc.post_id = p.id ORDER BY p.id, pc.id

When executing the above SQL INNER JOIN query, we get the following result set:

| p.id | pc.post_id | pc.id | p.title | pc.review | |---------|------------|------------|------------|-----------| | 1 | 1 | 1 | Java | Good | | 1 | 1 | 2 | Java | Excellent | | 2 | 2 | 3 | Hibernate | Awesome |

So, only the records that match the ON clause condition are included in the query result set. In our case, the result set contains all the post along with their post_comment records. The post rows that have no associated post_comment are excluded since they can not satisfy the ON Clause condition.

Again, the above SQL INNER JOIN query is equivalent to the following CROSS JOIN query:

SELECT p.id AS "p.id", pc.post_id AS "pc.post_id", pc.id AS "pc.id", p.title AS "p.title", pc.review AS "pc.review" FROM post p, post_comment pc WHERE pc.post_id = p.id

The highlighted rows are the ones that satisfy the WHERE clause, and only these records are going to be included in the result set. That’s the best way to visualize how the INNER JOIN clause works.

| p.id | pc.post_id | pc.id | p.title | pc.review | |------|------------|-------|-----------|-----------| | 1 | 1 | 1 | Java | Good | | 1 | 1 | 2 | Java | Excellent | | 1 | 2 | 3 | Java | Awesome | | 2 | 1 | 1 | Hibernate | Good | | 2 | 1 | 2 | Hibernate | Excellent | | 2 | 2 | 3 | Hibernate | Awesome | | 3 | 1 | 1 | JPA | Good | | 3 | 1 | 2 | JPA | Excellent | | 3 | 2 | 3 | JPA | Awesome |

Conclusion

The JOIN clause is a very powerful feature of SQL, allowing you to create result sets that combine records belonging to different tables.

While CROSS JOIN allows you to create a Cartesian Product of records belonging to the two joining tables, INNER JOIN allows you to filter the Cartesian Product and return only the joined records that match a given filtering condition.

Insert details about how the information is going to be processed DOWNLOAD NOW