Polymorphic relations allow a model to associate multiple different types of models in Laravel. It is implemented through morphTo and morphMany methods, such as the Comment model can belong to Post and Video at the same time; the database uses commentable_id and commentable_type fields to identify associated objects; common uses include comment system, attachment uploads and logging; when using it, you need to pay attention to class namespace, query performance and soft deletion processing.

It is actually not complicated to handle polymorphic Eloquent relationships in Laravel, but it does require understanding its application scenarios and usage methods. It is mainly used to allow a model to be associated with multiple other models, such as a "comment" function that can belong to an article, video, or user at the same time.

What is a polymorphic relationship?

Simply put, polymorphic relationships are to allow a model to flexibly establish associations with multiple different types of models. The key to this relationship is that a table can correspond to multiple parent models .

For example, you have a Comment model that can belong to either Post (article) or Video (video). At this time, it can be achieved by using polymorphic relationships.

Eloquent does this with two fields in the database:

• commentable_id : record the ID of the associated model
• commentable_type : Records the class name of the associated model (usually the full namespace of the model)

How to define a polymorphic relationship?

Definition in the model

Take the Comment model as an example:

 // Comment.php
public function commentable()
{
    return $this->morphTo();
}

Then, add the following code to Post and Video models:

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

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

In this way, whether it is an article or a video, you can have your own comment list.

How to write database migration?

When creating comments table, you need to add a polymorphic field. Laravel provides convenient methods:

 Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->text('content');
    $table->unsignedBigInteger('commentable_id');
    $table->string('commentable_type');
    $table->timestamps();
});

Or use morphs method more concisely:

 $table->morphs('commentable');

This will automatically create the two fields mentioned above.

What are the common uses of polymorphic relationships?

Polymorphic relationships are very practical in actual development, and common usage scenarios include:

• Comment System : As mentioned above, comments can belong to multiple content types.
• Attachment upload : A file upload function may need to support different types of attachments such as pictures, documents, PDFs, etc., and these attachments may belong to different models.
• Logging : When recording operation logs, the operation objects may be different models such as users, administrators, articles, etc.

What should you pay attention to when using it?

Although polymorphic relationships are convenient, there are some small details that are easy to ignore:

• Make sure that the commentable_type field stores the complete class name (with namespace).
• Be aware of performance issues when queries, especially when you want to get associated data from multiple models, N 1 query issues may occur.
• If you use soft deletion, remember to consider whether you want to include soft deletion records.

For example, query all comments belonging to a Post:

 $post = Post::find(1);
$comments = $post->comments;

If you want to load comments on multiple models at once, you can use morphMany with() to optimize:

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

Basically that's it. Polymorphic relationships are not particularly difficult, but they are prone to confuse the directions of morphTo and morphMany when they are first exposed. As long as you clarify who is the "associated" party and who is the "actively associated" party, you can use it smoothly.

The above is the detailed content of Working with Polymorphic Eloquent Relationships in Laravel?. For more information, please follow other related articles on the PHP Chinese website!