Polymorphic relationships in Laravel allow a model to belong to multiple other models through a single association, enabling shared resources like comments or images to be attached to various model types such as posts and videos. 1. A polymorphic relationship requires two database columns: {model}_id (e.g., commentable_id) to store the related model's ID, and {model}_type (e.g., commentable_type) to store the fully qualified class name of the related model. 2. In the migration, create the polymorphic table with these two fields and index them together for performance, as shown in the comments table with commentable_id and commentable_type. 3. In the models, use morphTo() in the polymorphic model (e.g., Comment) to define the relationship, and use morphMany() in the owners (e.g., Post and Video) to allow multiple comments. 4. When creating a comment via $post->comments()->create(), Laravel automatically sets the commentable_id and commentable_type; accessing the owner model is done via $comment->commentable, and type checking can be performed using instanceof. 5. For one-to-one polymorphic relationships, such as an image belonging to either a post or user, use morphOne() in the owner model and morphTo() in the image model, with corresponding imageable_id and imageable_type fields. 6. Polymorphic relationships can be queried using whereHas() to filter by type or eager-loaded using with(). 7. Optionally, customize the stored type using Relation::morphMap() in a service provider to map short strings to model classes, improving readability and reducing storage size, but ensure the map is consistently registered across all environments.

Polymorphic relationships in Laravel allow a model to belong to more than one other model on a single association. This is useful when you want a shared resource (like comments, likes, or images) to be attached to multiple types of models — for example, both posts and videos can have comments.

Here’s how to use polymorphic relationships effectively in Laravel.

1. Understanding Polymorphic Relationships

A polymorphic relationship requires two columns in the database:

• {model}_id (e.g., commentable_id)
• {model}_type (e.g., commentable_type)

The _id stores the ID of the related model, and the _type stores the class name of the related model (e.g., App\Models\Post or App\Models\Video).

2. Setting Up the Database Migrations

Let’s say you want both Post and Video models to have comments.

First, create the comments table with polymorphic fields:

// CreateCommentsTable migration
Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->text('body');
    $table->unsignedBigInteger('commentable_id');
    $table->string('commentable_type');
    $table->timestamps();

    $table->index(['commentable_id', 'commentable_type']);
});

This setup allows the comments table to reference any model.

3. Defining the Models

In the Comment model (the polymorphic one):

Use the morphTo() method:

// app/Models/Comment.php
class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

In the Post and Video models:

Use morphMany() to define the inverse:

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

// app/Models/Video.php
class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Now both Post and Video can have many comments.

4. Using the Relationship

Creating a comment on a post:

$post = Post::find(1);
$comment = $post->comments()->create([
    'body' => 'Great post!'
]);

Laravel automatically sets commentable_id to the post’s ID and commentable_type to App\Models\Post.

Accessing the commentable model:

$comment = Comment::with('commentable')->find(1);
$owner = $comment->commentable; // Returns the Post or Video instance

You can even check which type it is:

if ($comment->commentable instanceof Post) {
    // It's a comment on a post
}

5. One-to-One Polymorphic Relationship

For a one-to-one relationship (e.g., an Image that belongs to either a Post or User):

Migration:

Schema::create('images', function (Blueprint $table) {
    $table->id();
    $table->string('url');
    $table->unsignedBigInteger('imageable_id');
    $table->string('imageable_type');
    $table->timestamps();

    $table->index(['imageable_id', 'imageable_type']);
});

Models:

// Image.php
class Image extends Model
{
    public function imageable()
    {
        return $this->morphTo();
    }
}

// Post.php
class Post extends Model
{
    public function image()
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

Use morphOne() for one-to-one, and morphMany() for one-to-many.

6. Querying Polymorphic Relationships

You can query models based on their polymorphic relation:

// Get all comments on posts
$comments = Comment::whereHas('commentable', function ($query) {
    $query->where('commentable_type', Post::class);
})->get();

Or eager load with specific types:

$posts = Post::with('comments')->get();

7. Custom Polymorphic Types (Optional)

By default, Laravel uses the fully qualified class name. You can customize this using morphMap() in a service provider (e.g., AppServiceProvider@boot):

Relation::morphMap([
    'post' => 'App\Models\Post',
    'video' => 'App\Models\Video',
]);

Now, instead of storing App\Models\Post, Laravel stores just post in the commentable_type field.

?? If you use morphMap, make sure to register it in every environment and keep it consistent.

Basically, polymorphic relationships are a clean way to make your models reusable across different types. Just remember the naming convention, set up the correct migration fields, and use morphTo and morphOne/morphMany correctly. It’s not complex once you’ve done it once or twice.

The above is the detailed content of How to use polymorphic relationships in Laravel?. For more information, please follow other related articles on the PHP Chinese website!