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.