Many-to-many (belongsToMany) in Laravel - Step-by-Step Execution

Concept Flow - Many-to-many (belongsToMany)

Define Models

↓

Create Pivot Table

↓

Set belongsToMany in Model A

↓

Set belongsToMany in Model B

↓

Attach/Detach/Sync Relations

↓

Query Related Models

↓

Use Data in App

This flow shows how Laravel sets up and uses many-to-many relationships between two models using a pivot table.

Execution Sample

Laravel

class User extends Model {
  public function roles() {
    return $this->belongsToMany(Role::class);
  }
}

$user = User::find(1);
$roles = $user->roles;

This code defines a many-to-many relation from User to Role and fetches roles for user with ID 1.

Execution Table

Step	Action	Evaluation	Result
1	Call User::find(1)	User with ID 1 exists	User object loaded
2	Call $user->roles()	belongsToMany relation method runs	Query builder built to get roles linked to user 1
3	Execute SQL query on pivot table	Pivot table joins users and roles	Collection of Role objects returned
4	Assign roles to $roles variable	Roles fetched successfully	Roles collection ready for use
5	Use $roles in app	Iterate or display roles	Roles data shown or processed
6	End	No more actions	Execution stops

💡 All related roles for user 1 fetched; no further steps.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
$user	null	User object with ID 1	User object	User object	User object	User object
$roles	null	null	Collection of Role objects	Collection of Role objects	Collection of Role objects	Collection of Role objects

Key Moments - 3 Insights

Why do we need a pivot table in many-to-many relationships?

The pivot table stores the links between two models. Without it, Laravel cannot know which records relate to each other. See execution_table step 3 where the pivot table is queried.

What does belongsToMany() return when called?

It returns a query builder for the related model. The actual data is fetched when you access or iterate the relation, as shown in execution_table step 3.

How does Laravel know which pivot table to use?

By default, Laravel uses the two model names in alphabetical order joined by an underscore. You can specify a custom table name in belongsToMany() if needed.

Visual Quiz - 3 Questions

Look at the execution table, what is stored in $roles after step 3?

A A SQL query string

B A collection of Role objects related to the user

C A User object

D Null

💡 Hint

Check the 'Result' column in step 3 of the execution_table.

At which step does Laravel query the pivot table to get related roles?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Evaluation' columns in the execution_table for the pivot table query.

If the pivot table name was customized, where would you specify it?

A Inside the belongsToMany() method call

B In the User::find() method

C In the Role model's constructor

D In the database seeders

💡 Hint

belongsToMany() accepts the pivot table name as an optional second argument.

Concept Snapshot

Many-to-many relationships link two models via a pivot table.
Use belongsToMany() in both models to define the relation.
Laravel queries the pivot table to find related records.
Attach, detach, or sync methods manage links.
Access related models via the relation property or method.

Full Transcript

In Laravel, many-to-many relationships connect two models through a pivot table. You define this by adding a belongsToMany() method in both models. When you fetch a model and call this relation, Laravel builds a query joining the pivot table to get related records. The pivot table stores the links between the two models. You can manage these links with attach, detach, or sync methods. This example shows fetching roles related to a user by calling $user->roles(). The execution steps trace loading the user, building the query, querying the pivot table, and returning the related roles collection.

Practice

1. What does the belongsToMany() method define in a Laravel model?

easy

A. A polymorphic relationship between models

B. A one-to-one relationship between two models

C. A one-to-many relationship from one model to another

D. A many-to-many relationship between two models

Solution

1. Step 1: Understand relationship types in Laravel

   Laravel provides different methods to define relationships: one-to-one, one-to-many, many-to-many, and polymorphic.

2. Step 2: Identify the purpose of belongsToMany()

   The belongsToMany() method specifically defines a many-to-many relationship where both models can have multiple related models.

3. Final Answer:

   A many-to-many relationship between two models -> Option D

4. Quick Check:

   belongsToMany() = many-to-many [OK]

Hint: belongsToMany means many-to-many link between models [OK]

Common Mistakes:

• Confusing belongsToMany with hasOne or hasMany
• Thinking it defines one-to-one relationships
• Assuming it creates a polymorphic relation

2. Which of the following is the correct syntax to define a many-to-many relationship in a Laravel model named Post related to Tag?

easy

A. public function tags() { return $this->belongsToMany(Tag::class); }

B. public function tags() { return $this->hasMany(Tag::class); }

C. public function tags() { return $this->hasOne(Tag::class); }

D. public function tags() { return $this->morphToMany(Tag::class); }

Solution

1. Step 1: Recall the method for many-to-many relationships

   In Laravel, many-to-many relationships use the belongsToMany() method inside the model.

2. Step 2: Match the syntax to the correct method

   The correct syntax is public function tags() { return $this->belongsToMany(Tag::class); } to link Post and Tag models.

3. Final Answer:

   public function tags() { return $this->belongsToMany(Tag::class); } -> Option A

4. Quick Check:

   belongsToMany() syntax = public function tags() { return $this->belongsToMany(Tag::class); } [OK]

Hint: Use belongsToMany() for many-to-many syntax [OK]

Common Mistakes:

• Using hasMany instead of belongsToMany
• Using hasOne which is one-to-one
• Confusing morphToMany with belongsToMany

3. Given the following code in a Laravel model User:

public function roles() {
    return $this->belongsToMany(Role::class);
}

$user = User::find(1);
$roles = $user->roles()->pluck('name');
echo $roles->toJson();

What will be the output if user 1 has roles named "admin" and "editor"?

medium

A. Syntax error

B. ["1","2"]

C. ["admin","editor"]

D. null

Solution

1. Step 1: Understand the belongsToMany relationship usage

   The roles() method returns all roles related to the user via the pivot table.

2. Step 2: Analyze the pluck and toJson methods

   The pluck('name') extracts the 'name' field from each related role, returning a collection of role names. toJson() converts this collection to a JSON string.

3. Final Answer:

   ["admin","editor"] -> Option C

4. Quick Check:

   pluck('name') + toJson() = role names JSON [OK]

Hint: pluck('name') gets names; toJson outputs JSON array [OK]

Common Mistakes:

• Expecting IDs instead of names
• Thinking roles() returns null if no roles
• Confusing pluck with get

4. What is wrong with this Laravel many-to-many relationship definition in the Product model?

public function categories() {
    return $this->hasMany(Category::class);
}

medium

A. The method name should be singular, like category()

B. It should use belongsToMany() instead of hasMany()

C. The related model class name is incorrect

D. No return statement is needed

Solution

1. Step 1: Identify the relationship type

   Products and categories usually have a many-to-many relationship, so belongsToMany() is the correct method.

2. Step 2: Check the method used

   The code uses hasMany(), which defines a one-to-many relationship, not many-to-many.

3. Final Answer:

   It should use belongsToMany() instead of hasMany() -> Option B

4. Quick Check:

   Many-to-many needs belongsToMany(), not hasMany() [OK]

Hint: Many-to-many always uses belongsToMany() [OK]

Common Mistakes:

• Using hasMany for many-to-many
• Naming method singular for plural relation
• Omitting return statement

5. You have two models, Student and Course, linked by a many-to-many relationship using a pivot table course_student. You want to attach a course with ID 5 to a student with ID 3 and also store the enrollment date in the pivot. Which code snippet correctly does this?

hard

A. $student = Student::find(3);
$student->courses()->attach(5, ['enrolled_at' => now()]);

B. $student = Student::find(3);
$student->courses()->save(5, ['enrolled_at' => now()]);

C. $student = Student::find(3);
$student->courses()->sync(5, ['enrolled_at' => now()]);

D. $student = Student::find(3);
$student->courses()->attach([5]);

Solution

1. Step 1: Understand attaching in many-to-many with pivot data

   The attach() method adds a record to the pivot table and accepts the related model ID plus an array of extra pivot data.

2. Step 2: Analyze each option

   $student = Student::find(3); $student->courses()->attach(5, ['enrolled_at' => now()]); correctly uses attach(5, ['enrolled_at' => now()]). $student = Student::find(3); $student->courses()->save(5, ['enrolled_at' => now()]); uses save() which expects a model instance, not an ID. $student = Student::find(3); $student->courses()->sync(5, ['enrolled_at' => now()]); uses sync() incorrectly with extra data. $student = Student::find(3); $student->courses()->attach([5]); attaches without pivot data.

3. Final Answer:

   $student = Student::find(3); $student->courses()->attach(5, ['enrolled_at' => now()]); -> Option A

4. Quick Check:

   attach(id, pivotData) = $student = Student::find(3); $student->courses()->attach(5, ['enrolled_at' => now()]); [OK]

Hint: Use attach(id, pivotData) to add with extra pivot info [OK]

Common Mistakes:

• Using save() with ID instead of model instance
• Using sync() incorrectly with pivot data
• Forgetting to pass pivot data array