Polymorphic relationships in Laravel - Step-by-Step Execution

Concept Flow - Polymorphic relationships

Define polymorphic relation in Model A

↓

Define polymorphic relation in Model B

↓

Create tables with morph columns

↓

Save related models

↓

Query polymorphic relation

↓

Access related models polymorphically

This flow shows how Laravel sets up and uses polymorphic relationships by defining relations, creating tables, saving data, and querying related models.

Execution Sample

Laravel

class Comment extends Model {
  public function commentable() {
    return $this->morphTo();
  }
}

class Post extends Model {
  public function comments() {
    return $this->morphMany(Comment::class, 'commentable');
  }
}

Defines a polymorphic relation where comments can belong to multiple models like posts or videos.

Execution Table

Step	Action	Model State	Database Action	Result
1	Define Comment model with morphTo relation	Comment model ready with commentable()	No DB action	Relation method set
2	Define Post model with morphMany relation	Post model ready with comments()	No DB action	Relation method set
3	Create posts table and comments table with commentable_id and commentable_type	Tables created	DB tables created	Tables ready for polymorphic data
4	Create Post instance and save	Post instance saved with id=1	Insert into posts	Post record created
5	Create Comment instance and associate with Post	Comment instance with commentable_id=1, commentable_type='App\Models\Post'	Insert into comments	Comment linked to Post
6	Query Post comments	Post model queried	Select comments where commentable_id=1 and commentable_type='App\Models\Post'	Returns comments for Post
7	Query Comment's parent	Comment model queried	Select model where id=commentable_id and type=commentable_type	Returns Post model
8	Exit	No further actions	No DB action	Polymorphic relation works bidirectionally

💡 All polymorphic relations defined, data saved, and queries return expected related models.

Variable Tracker

Variable	Start	After Step 4	After Step 5	After Step 6	Final
Post instance	null	Post{id=1}	Post{id=1}	Post{id=1}	Post{id=1}
Comment instance	null	null	Comment{commentable_id=1, commentable_type='App\Models\Post'}	Comment{...}	Comment{...}
comments collection	empty	empty	empty	[Comment{...}]	[Comment{...}]
commentable parent	null	null	null	null	Post{id=1}

Key Moments - 3 Insights

Why do we need both commentable_id and commentable_type in the comments table?

Because polymorphic relations can link to different models, commentable_type stores the model class, and commentable_id stores the record id. See execution_table step 3 and 5.

How does Laravel know which model a comment belongs to when querying?

Laravel uses commentable_type to know the model class and commentable_id to find the record. This is shown in execution_table step 7.

Can a comment belong to both a Post and a Video at the same time?

No, each comment belongs to one model instance at a time, but the relation can point to different model types. This is clear from the morphTo relation in step 1.

Visual Quiz - 3 Questions

Look at the execution table, what is the commentable_type value stored in the Comment instance after step 5?

A 'commentable'

B 'App\Models\Post'

C 'Post'

D 1

💡 Hint

Check the 'Model State' column in step 5 of the execution_table.

At which step does the database insert the comment linked to the post?

A Step 6

B Step 4

C Step 5

D Step 3

💡 Hint

Look for the step where commentable_id and commentable_type are set and inserted.

If we add a Video model with comments, which part of the execution flow changes?

A Step 2: Define morphMany relation in Video model

B Step 4: Create posts table

C Step 7: Query Comment's parent will fail

D Step 3: Remove commentable_type column

💡 Hint

Adding a new polymorphic model requires defining the relation method like in step 2.

Concept Snapshot

Polymorphic relationships let one model belong to multiple other models using a single association.
Use morphTo() in the child model and morphMany() or morphOne() in parent models.
Database tables need 'morph' columns: *_id and *_type to store related model info.
This allows flexible relations like comments belonging to posts or videos.
Querying uses these columns to fetch related models dynamically.

Full Transcript

Polymorphic relationships in Laravel allow a model to belong to more than one other model on a single association. The child model uses morphTo() to define the relation, while parent models use morphMany() or morphOne() to define their side. The database tables include columns like commentable_id and commentable_type to store the related model's id and class name. When saving a comment linked to a post, Laravel stores the post's id and class in these columns. Queries use this information to retrieve related models dynamically. This setup enables flexible relations such as comments belonging to posts or videos without needing separate foreign keys for each model type.