Many-to-many with has_many through in Ruby on Rails - Step-by-Step Execution

Concept Flow - Many-to-many with has_many through

Define Models

↓

Create Join Model

↓

Set has_many through

↓

Create Records

↓

Access Associations

↓

Use join model for extra data

This flow shows how Rails sets up two models connected by a join model, allowing many-to-many links with extra data.

Execution Sample

Ruby on Rails

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

Defines Author model linked to Books through Authorship join model.

Execution Table

Step	Action	Model State	Association State	Output/Result
1	Define Author, Book, Authorship models	Models defined	No records yet	Ready for associations
2	Author has_many :authorships	Author model knows Authorship	No records	Association set
3	Author has_many :books through :authorships	Author model knows Books via Authorship	No records	Association set
4	Create Author record (id=1)	Author(id=1)	No associations yet	Author saved
5	Create Book record (id=10)	Book(id=10)	No associations yet	Book saved
6	Create Authorship record (author_id=1, book_id=10)	Authorship links Author 1 and Book 10	Author 1 linked to Book 10	Association created
7	Access author.books	Author(id=1)	Books through Authorship	Returns [Book(id=10)]
8	Access book.authors	Book(id=10)	Authors through Authorship	Returns [Author(id=1)]
9	Add extra data to Authorship (role: 'co-author')	Authorship record updated	Association with extra info	Extra data stored
10	Access authorship.role	Authorship record	Role = 'co-author'	Returns 'co-author'
11	End of flow	All models and associations set	Associations accessible	Many-to-many works with extra data

💡 All associations created and accessible; many-to-many with extra data works

Variable Tracker

Variable	Start	After Step 4	After Step 5	After Step 6	After Step 9	Final
Author records	[]	[Author(id=1)]	[Author(id=1)]	[Author(id=1)]	[Author(id=1)]	[Author(id=1)]
Book records	[]	[]	[Book(id=10)]	[Book(id=10)]	[Book(id=10)]	[Book(id=10)]
Authorship records	[]	[]	[]	[Authorship(author_id=1, book_id=10)]	[Authorship(author_id=1, book_id=10, role='co-author')]	[Authorship(author_id=1, book_id=10, role='co-author')]
author.books	[]	[]	[]	[Book(id=10)]	[Book(id=10)]	[Book(id=10)]
book.authors	[]	[]	[]	[Author(id=1)]	[Author(id=1)]	[Author(id=1)]

Key Moments - 3 Insights

Why do we need a join model like Authorship instead of just has_and_belongs_to_many?

Because has_many through allows storing extra data (like role) on the join model, which has_and_belongs_to_many does not support. See step 9 where role is added.

How does author.books know which books belong to the author?

author.books uses the Authorship join records to find books linked to that author. See step 7 where author.books returns Book(id=10) via Authorship.

Can we access extra data on the join model from the author or book?

No, you must access the join model directly (Authorship) to get extra data like role. See step 10 where authorship.role returns 'co-author'.

Visual Quiz - 3 Questions

Look at the execution table, what does author.books return at step 7?

A [Author(id=1)]

B []

C [Book(id=10)]

D nil

💡 Hint

Check the 'Output/Result' column at step 7 in the execution_table.

At which step is extra data added to the join model?

A Step 6

B Step 9

C Step 4

D Step 10

💡 Hint

Look for when 'role: co-author' is added in the execution_table.

If we remove the has_many :authorships association from Author, what happens to author.books?

A author.books raises an error

B author.books still works normally

C author.books returns empty array

D author.books returns all books

💡 Hint

Think about how author.books depends on has_many :authorships in the model definition.

Concept Snapshot

Many-to-many with has_many through:
- Use a join model (e.g., Authorship) between two models (Author, Book)
- Define has_many :join_model and has_many :other_model, through: :join_model
- Allows storing extra data on join model
- Access associations via model.join_model or model.other_model
- Enables flexible, rich many-to-many relationships

Full Transcript

This visual execution trace shows how Rails sets up a many-to-many relationship using has_many through. First, models Author, Book, and the join model Authorship are defined. Author has many authorships and many books through authorships. Records are created for author and book, then an authorship record links them. Accessing author.books returns the linked book, and book.authors returns the linked author. Extra data like role can be stored on the authorship join model. The trace highlights key steps and variable states, clarifying how associations work and how extra data is handled 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