Why Joins and includes in Ruby on Rails? - Purpose & Use Cases

The Big Idea

Discover how a simple change can make your app lightning fast and avoid slowdowns!

The Scenario

Imagine you have a blog with posts and each post has many comments. You want to show a list of posts with their comments. So, you write code that fetches posts, then for each post, you fetch its comments separately.

The Problem

This means your app makes many database calls--one for posts, then one for each post's comments. This slows down your app and can crash it if there are too many posts. It's like going to the store for each item instead of buying all at once.

The Solution

Rails' joins and includes let you fetch related data in fewer queries. joins combines tables in one query, and includes loads associated records efficiently. This makes your app faster and smoother.

Before vs After

✗ Before

posts = Post.all
posts.each do |post|
  comments = Comment.where(post_id: post.id)
  # display post and comments
end

✓ After

posts = Post.includes(:comments).all
posts.each do |post|
  # comments already loaded
  post.comments.each do |comment|
    # display comment
  end
end

What It Enables

You can build fast, scalable apps that show related data without slowing down or crashing.

Real Life Example

On a social media site, showing a feed with posts and all their likes and comments instantly without waiting for many database calls.

Key Takeaways

Manual fetching causes many slow database calls.

joins and includes reduce queries and speed up data loading.

This makes your app faster and user-friendly.

Practice

1. What is the main purpose of using joins in Rails ActiveRecord queries?

easy

A. To update multiple tables at once

B. To preload associated records to avoid extra database queries

C. To combine tables and filter records based on matching columns

D. To delete records from multiple tables

Solution

1. Step 1: Understand what joins does

   joins connects tables in a query to filter or find records that match conditions across those tables.

2. Step 2: Compare with includes

   includes is used to preload associated data to reduce queries, not for filtering.

3. Final Answer:

   To combine tables and filter records based on matching columns -> Option C

4. Quick Check:

   joins = combine tables for filtering [OK]

Hint: Remember: joins filters by matching tables, includes preloads data [OK]

Common Mistakes:

• Confusing joins with includes
• Thinking joins preload data
• Assuming joins update or delete records

2. Which of the following is the correct syntax to use includes to preload the comments association on a Post model?

easy

A. Post.includes('comments').where(published: true)

B. Post.includes(:comments).where(published: true)

C. Post.include(:comments).where(published: true)

D. Post.joins(:comments).includes.where(published: true)

Solution

1. Step 1: Check the correct method name and argument type

   The method is includes (plural), and it accepts a symbol like :comments.

2. Step 2: Validate the chaining and syntax

   Post.includes(:comments).where(published: true) uses Post.includes(:comments).where(published: true), which is correct syntax to preload comments and filter posts.

3. Final Answer:

   Post.includes(:comments).where(published: true) -> Option B

4. Quick Check:

   Correct method and symbol argument = Post.includes(:comments).where(published: true) [OK]

Hint: Use plural includes with symbol for associations [OK]

Common Mistakes:

• Using singular include instead of includes
• Passing association as string instead of symbol
• Chaining includes incorrectly

3. Given these models: Author has_many :books and Book belongs_to :author, what will this query return?

Author.joins(:books).where(books: { published: true }).distinct

medium

A. All authors with all their books loaded

B. All books that are published

C. All authors including those without books

D. All authors who have at least one published book

Solution

1. Step 1: Analyze the joins and where clause

   The query joins authors with books and filters books where published: true.

2. Step 2: Understand the effect of distinct

   distinct ensures authors are unique even if they have multiple published books.

3. Final Answer:

   All authors who have at least one published book -> Option D

4. Quick Check:

   joins + where filters authors by published books [OK]

Hint: joins filters parents by child conditions; distinct avoids duplicates [OK]

Common Mistakes:

• Thinking it returns books instead of authors
• Assuming includes loads all books
• Ignoring distinct causing duplicates

4. Identify the error in this Rails query:

Post.joins(:comments).includes(:author).where(comments: { approved: true })

medium

A. No error; the query is valid and will work as expected

B. The where clause should reference authors instead of comments

C. Using both joins and includes together causes a syntax error

D. The includes should come before joins to avoid errors

Solution

1. Step 1: Check if using joins and includes together is allowed

   Rails allows chaining joins and includes to combine filtering and eager loading.

2. Step 2: Verify the where clause references a valid table

   The where filters on comments which is joined, so it's valid.

3. Final Answer:

   No error; the query is valid and will work as expected -> Option A

4. Quick Check:

   joins + includes + where on joined table = valid [OK]

Hint: joins and includes can be chained; where must match joined tables [OK]

Common Mistakes:

• Thinking joins and includes can't be combined
• Confusing which table to filter in where
• Assuming order of joins/includes causes errors

5. You want to fetch all Order records with their associated Customer and OrderItems, but only include orders where the customer is active and at least one order item is in stock. Which query correctly uses joins and includes to achieve this efficiently?

hard

A. Order.joins(:customer, :order_items).includes(:customer, :order_items).where(customers: { active: true }, order_items: { in_stock: true }).distinct

B. Order.includes(:customer, :order_items).where(customers: { active: true }, order_items: { in_stock: true })

C. Order.joins(:customer).includes(:order_items).where(customers: { active: true }).where(order_items: { in_stock: true })

D. Order.joins(:customer).joins(:order_items).where(customers: { active: true }, order_items: { in_stock: true })

Solution

1. Step 1: Understand filtering and eager loading needs

   We must filter orders by customer active status and order items in stock, so joins is needed to filter across tables.

2. Step 2: Use includes to preload associations for efficient access

   To avoid N+1 queries when accessing customers and order items, includes preloads them.

3. Step 3: Use distinct to avoid duplicate orders from multiple matching order items

   Because joins can cause duplicates, distinct ensures unique orders.

4. Final Answer:

   Order.joins(:customer, :order_items).includes(:customer, :order_items).where(customers: { active: true }, order_items: { in_stock: true }).distinct -> Option A

5. Quick Check:

   joins filters, includes preloads, distinct removes duplicates [OK]

Hint: Use joins to filter, includes to preload, distinct to avoid duplicates [OK]

Common Mistakes:

• Using only includes without joins for filtering
• Not using distinct causing duplicate records
• Mixing joins and includes incorrectly