Understanding the Key Differences Between joins and includes in Rails 5.2 ActiveRecord

Описание: Explore the differences between `joins` and `includes` in Rails 5.2 ActiveRecord, how they impact query performance, and their usage in efficient database queries.
---
This video is based on the question https://stackoverflow.com/q/65376454/ asked by the user 'Will Gutierrez' ( https://stackoverflow.com/u/10977409/ ) and on the answer https://stackoverflow.com/a/65381612/ provided by the user 'brcebn' ( https://stackoverflow.com/u/2616474/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Rails 5.2 ActiveRecord Query: Difference Between .joins and .include

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Key Differences Between joins and includes in Rails 5.2 ActiveRecord

When working with Rails 5.2 and looking to interact with your database using ActiveRecord, understanding how to effectively query related models is imperative. Two common methods to do this are joins and includes, and while they may seem similar, they serve very different purposes and can impact your application's performance significantly.

In this guide, we'll explore the differences between these two methods, providing clear examples and insights that will help you choose the right approach for your queries.

The Problem at Hand

Consider a scenario where you have a Like model that tracks user interactions with different emoji types, and a corresponding User model that holds details about the users. If you want to retrieve likes from users who are not banned (status != 0), and group them by emoji_type, you might wonder:

What are the differences between using joins and includes?

Why does the output differ between the two methods?

Is one method more efficient than the other?

Breaking Down the Solutions

Using joins

The joins method in ActiveRecord allows you to create an SQL join to fetch related models directly. This means that the data returned is only from the Like model, as the join allows you to filter and access related data without pulling in additional rows.

Example of a Query with joins

[[See Video to Reveal this Text or Code Snippet]]

In this example:

You're merging the Like and User tables, enabling you to apply conditions based on user attributes directly in your query.

Any filtering of the banned users can be seamlessly applied using the where clause.

Observations:

When using joins, if you attempt to access @ likes.username, you will receive a user name, but if you try to access @ likes.user.name, it will return nil because joins doesn't load User instances directly.

Using includes

On the other hand, the includes method is primarily designed for eager loading. It retrieves the associated records and loads them into memory, which helps avoid the N+ 1 query problem commonly encountered in ActiveRecord.

Example of a Query with includes

[[See Video to Reveal this Text or Code Snippet]]

In this case:

The includes method fetches both Likes and related User records, but it does not perform a SQL join.

This results in @ likes.username potentially returning nil since the User data isn't directly part of the Like record.

Observations:

While includes is great for reducing the number of queries executed, it can lead to performance inefficiencies if you're trying to filter on columns from the User table, as the filtering is done before the load occurs.

Combining joins and includes

Interestingly, you can also utilize both joins and includes in a single query:

[[See Video to Reveal this Text or Code Snippet]]

This blend allows you to filter on user attributes while also taking advantage of eager loading, but it should be utilized judiciously as it can complicate queries and impact performance.

Conclusion

To summarize:

joins: Efficient for filtering and directly accessing joined records in a single query, but does not eager load. Use it when you're primarily interested in data from the joined tables.

includes: Ideal for eager loading to prevent N+ 1 queries and accessing related models without dependency on SQL joins.

Selecting the right method depends on your specific use case and what you intend to achieve with the data. Understanding these differences not only helps optimize your ActiveRecord queries but also enhances the overall performance of your Rails application.

By mastering the use of joins and includes, you can b