Joins and includes in Ruby on Rails - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to eager load the associated posts for users.

Ruby on Rails

User.[1](:posts)

Drag options to blanks, or click blank then click option'

Aselect

Bjoins

Cincludes

Dwhere

Attempts:

3 left

💡 Hint

Common Mistakes

Using joins instead of includes causes N+1 queries.

Using select does not load associations.

The includes method loads associated records to avoid N+1 queries.

2fill in blank

medium

Complete the code to join users with their posts in a query.

Ruby on Rails

User.[1](:posts).where(posts: { published: true })

Drag options to blanks, or click blank then click option'

Ajoins

Bincludes

Cpreload

Deager_load

Attempts:

3 left

💡 Hint

Common Mistakes

Using includes instead of joins does not add SQL JOINs.

Using preload does not allow filtering on joined tables.

The joins method creates an INNER JOIN in SQL to filter records based on associated tables.

3fill in blank

hard

Fix the error in the code to eager load comments for posts.

Ruby on Rails

Post.[1](:comments).where('comments.approved = ?', true)

Drag options to blanks, or click blank then click option'

Ajoins

Bgroup

Cselect

Dincludes

Attempts:

3 left

💡 Hint

Common Mistakes

Using includes causes errors when filtering on associated table columns.

Using select does not load associations.

Using joins allows filtering on associated tables in the WHERE clause; includes alone may not work with conditions on the joined table.

4fill in blank

hard

Fill both blanks to join authors and eager load their books.

Ruby on Rails

Author.[1](:books).[2](:books)

Drag options to blanks, or click blank then click option'

Ajoins

Bincludes

Cpreload

Dselect

Attempts:

3 left

💡 Hint

Common Mistakes

Using includes before joins may not filter correctly.

Using select does not eager load associations.

First joins creates the SQL join, then includes eager loads the books to avoid extra queries.

5fill in blank

hard

Fill all three blanks to create a hash of book titles and their authors' names for published books.

Ruby on Rails

Book.[1](:author).where(published: true).pluck('books.title', 'authors.name').to_h.transform_keys { |k| k.[2] }.transform_values { |v| v.[3] }

Drag options to blanks, or click blank then click option'

Ajoins

Bupcase

Cdowncase

Dincludes

Attempts:

3 left

💡 Hint

Common Mistakes

Using includes instead of joins will cause a SQL error as authors.name won't be available without a join.

Mixing up upcase and downcase for keys and values.

joins creates the SQL join necessary to select authors.name alongside books.title in the pluck query, upcase makes titles uppercase, and downcase makes author names lowercase.

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