Joins and includes in Ruby on Rails - Mini Project: Build & Apply

Joins and includes

📖 Scenario: You are building a simple blog application where each Post has many Comments. You want to fetch posts along with their comments efficiently.

🎯 Goal: Learn how to use joins and includes in Rails ActiveRecord to query posts and their comments.

📋 What You'll Learn

Create a Post model with a title attribute

Create a Comment model with a content attribute and a post_id foreign key

Use joins to find posts that have comments

Use includes to load posts with their comments to avoid N+1 queries

💡 Why This Matters

🌍 Real World

Fetching related data efficiently is common in web apps to improve speed and reduce database load.

💼 Career

Understanding joins and includes is essential for Rails developers to write performant database queries and avoid common pitfalls like N+1 queries.

1

Create Post and Comment models with sample data

Create a Post model with a title attribute and a Comment model with a content attribute and a post_id foreign key. Then create two posts: one with title 'First Post' and another with title 'Second Post'. Create two comments for the first post with contents 'Great post!' and 'Thanks for sharing.'.

Ruby on Rails

# Define Post and Comment models and create sample posts and comments
# Your code here

Hint

Define the models with associations and create posts and comments exactly as described.

2

Set a variable to hold posts with comments using joins

Create a variable called posts_with_comments and assign it the result of using joins(:comments) on the Post model to find posts that have at least one comment.

Ruby on Rails

class Post < ApplicationRecord
  has_many :comments
end

class Comment < ApplicationRecord
  belongs_to :post
end

Post.create!(title: 'First Post')
Post.create!(title: 'Second Post')

post1 = Post.find_by(title: 'First Post')
post1.comments.create!(content: 'Great post!')
post1.comments.create!(content: 'Thanks for sharing.')

# Create posts_with_comments using joins
# Your code here

Hint

Use Post.joins(:comments).distinct to get posts that have comments.

3

Use includes to load posts with comments to avoid N+1 queries

Create a variable called posts_with_includes and assign it the result of using includes(:comments) on the Post model to load posts with their comments efficiently.

Ruby on Rails

class Post < ApplicationRecord
  has_many :comments
end

class Comment < ApplicationRecord
  belongs_to :post
end

Post.create!(title: 'First Post')
Post.create!(title: 'Second Post')

post1 = Post.find_by(title: 'First Post')
post1.comments.create!(content: 'Great post!')
post1.comments.create!(content: 'Thanks for sharing.')

posts_with_comments = Post.joins(:comments).distinct

# Create posts_with_includes using includes
# Your code here

Hint

Use Post.includes(:comments) to load posts with their comments efficiently.

4

Access comments from posts_with_includes to complete the example

Add a loop that iterates over posts_with_includes and for each post, access its comments association to demonstrate that comments are loaded without extra queries.

Ruby on Rails

class Post < ApplicationRecord
  has_many :comments
end

class Comment < ApplicationRecord
  belongs_to :post
end

Post.create!(title: 'First Post')
Post.create!(title: 'Second Post')

post1 = Post.find_by(title: 'First Post')
post1.comments.create!(content: 'Great post!')
post1.comments.create!(content: 'Thanks for sharing.')

posts_with_comments = Post.joins(:comments).distinct

posts_with_includes = Post.includes(:comments)

# Iterate over posts_with_includes and access comments
# Your code here

Hint

Use a loop with posts_with_includes.each do |post| ... end and call post.comments.load inside to access comments.

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