Many-to-many with has_many through in Ruby on Rails - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a many-to-many association using has_many through in a Rails model.

Ruby on Rails

class Author < ApplicationRecord
  has_many :author_books
  has_many :books, [1]: :author_books
end

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

Athrough

Bclass_name

Cdependent

Dsource

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'source' instead of 'through' causes Rails to look for a different association.

Forgetting the 'through' option breaks the many-to-many link.

The has_many association uses the through option to specify the join model for many-to-many relationships.

2fill in blank

medium

Complete the join model declaration to set up the many-to-many relationship.

Ruby on Rails

class AuthorBook < ApplicationRecord
  belongs_to :author
  belongs_to [1]
end

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

Abook

Bbooks

Cauthor

Dauthors

Attempts:

3 left

💡 Hint

Common Mistakes

Using plural form like 'books' causes errors.

Using the wrong model name breaks the association.

The join model belongs to both associated models. Here, it belongs to book (singular).

3fill in blank

hard

Fix the error in the Book model to correctly set up the many-to-many association.

Ruby on Rails

class Book < ApplicationRecord
  has_many :author_books
  has_many :authors, [1]: :author_books
end

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

Asource

Bthrough

Cdependent

Dclass_name

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'source' instead of 'through' causes Rails to fail to find the join model.

Omitting the option breaks the association.

The has_many association must use through to specify the join model for many-to-many relations.

4fill in blank

hard

Fill both blanks to complete the migration for the join table.

Ruby on Rails

class CreateAuthorBooks < ActiveRecord::Migration[6.1]
  def change
    create_table :author_books do |t|
      t.references :[1], null: false, foreign_key: true
      t.references :[2], null: false, foreign_key: true
      t.timestamps
    end
  end
end

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

Aauthor

Bauthors

Cbook

Dbooks

Attempts:

3 left

💡 Hint

Common Mistakes

Using plural names like 'authors' or 'books' in references causes migration errors.

Forgetting foreign_key: true disables database-level integrity.

The join table references the singular model names author and book to create foreign keys.

5fill in blank

hard

Fill all three blanks to complete the Author model with dependent destroy and source options.

Ruby on Rails

class Author < ApplicationRecord
  has_many :author_books, [1]: :destroy
  has_many :books, [2]: :author_books, [3]: :book
end

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

Adependent

Bthrough

Csource

Dclass_name

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting dependent causes orphan join records.

Mixing up source and through options.

Using class_name instead of source causes errors.

dependent: :destroy ensures join records are deleted when an author is deleted. through: :author_books sets the join model. source: :book tells Rails which association to use on the join model.

Practice

1. What is the main purpose of using has_many :through in Rails models?

easy

A. To create a many-to-many relationship using a join model

B. To create a one-to-one relationship between two models

C. To validate data before saving to the database

D. To automatically generate database migrations

Solution

1. Step 1: Understand relationship types in Rails

   Rails uses associations to connect models. has_many :through is specifically for many-to-many relationships.

2. Step 2: Identify the role of join models

   It uses a join model to connect two other models, allowing extra data on the connection.

3. Final Answer:

   To create a many-to-many relationship using a join model -> Option A

4. Quick Check:

   has_many :through = many-to-many with join model [OK]

Hint: Think: many-to-many needs a join model [OK]

Common Mistakes:

• Confusing has_many :through with has_one
• Thinking it automatically creates migrations
• Using it for one-to-one relationships

2. Which of the following is the correct way to declare a many-to-many association using has_many :through in the Author model?

easy

A. has_one :books, through: :authorships

B. has_many :books, through: :authorships

C. belongs_to :books, through: :authorships

D. has_many :authorships, through: :books

Solution

1. Step 1: Identify the correct association syntax

   The model that wants to access the other through a join model uses has_many :other_model, through: :join_model.

2. Step 2: Apply to Author model

   Author has many books through authorships, so has_many :books, through: :authorships is correct.

3. Final Answer:

   has_many :books, through: :authorships -> Option B

4. Quick Check:

   has_many :books, through: :authorships = correct syntax [OK]

Hint: Remember: has_many :target, through: :join_model [OK]

Common Mistakes:

• Reversing the join and target models
• Using belongs_to instead of has_many
• Using has_one for many-to-many

3. Given these models:

class Author < ApplicationRecord
  has_many :authorships
  has_many :books, through: :authorships
end

class Authorship < ApplicationRecord
  belongs_to :author
  belongs_to :book
end

class Book < ApplicationRecord
  has_many :authorships
  has_many :authors, through: :authorships
end

What will Author.first.books.count return if the first author has 3 books linked through authorships?

medium

A. 1

B. 0

C. 3

D. An error because of missing join table

Solution

1. Step 1: Understand the association setup

   Author has many books through authorships, so calling Author.first.books fetches all books linked via authorships.

2. Step 2: Count the linked books

   If the first author has 3 books linked, Author.first.books.count returns 3.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Author.first.books.count = number of linked books [OK]

Hint: Count returns linked records through join model [OK]

Common Mistakes:

• Assuming count returns authorships count
• Expecting zero without checking data
• Confusing belongs_to with has_many effects

4. You have these models:

class Student < ApplicationRecord
  has_many :enrollments
end

class Enrollment < ApplicationRecord
  belongs_to :student
  belongs_to :course
end

class Course < ApplicationRecord
  has_many :enrollments
  has_many :students, through: :enrollments
end

But when you run Student.first.courses, you get an error: undefined method 'courses'. What is the likely cause?

medium

A. The has_many :courses, through: :enrollments line is missing in Student model

B. The Enrollment model is missing belongs_to :course

C. The Course model should use belongs_to :student instead of has_many

D. The database table for enrollments does not exist

Solution

1. Step 1: Check Student model associations

   The error says courses method is undefined, meaning Student model lacks has_many :courses, through: :enrollments.

2. Step 2: Confirm other associations

   Enrollment and Course models are correct; missing association in Student causes the error.

3. Final Answer:

   The has_many :courses, through: :enrollments line is missing in Student model -> Option A

4. Quick Check:

   Missing has_many through causes undefined method [OK]

Hint: Check if has_many :through is declared in the model [OK]

Common Mistakes:

• Assuming belongs_to missing causes undefined method
• Thinking Course model needs belongs_to Student
• Ignoring missing database tables as cause

5. You want to track the date when a User joins a Group using a many-to-many relationship with has_many :through. Which setup correctly allows storing this extra data?

hard

A. Add joined_on column directly to users table and use has_many :groups

B. Store joined_on in a separate table unrelated to the join

C. Use has_and_belongs_to_many :groups without a join model

D. Create a join model Membership with user_id, group_id, and joined_on columns, then use has_many :groups, through: :memberships in User

Solution

1. Step 1: Understand storing extra data in many-to-many

   Extra data on the connection requires a join model with its own columns.

2. Step 2: Apply to User and Group

   Create a join model Membership with user_id, group_id, and joined_on columns. Then User uses has_many :groups, through: :memberships.

3. Final Answer:

   Create a join model Membership with user_id, group_id, and joined_on columns, then use has_many :groups, through: :memberships in User -> Option D

4. Quick Check:

   Extra data needs join model with columns [OK]

Hint: Use join model to store extra data in many-to-many [OK]

Common Mistakes:

• Adding extra columns to main models instead of join model
• Using has_and_belongs_to_many which lacks extra data support
• Storing extra data in unrelated tables