{"id":271,"date":"2025-08-27T18:25:40","date_gmt":"2025-08-27T18:25:40","guid":{"rendered":"https:\/\/1v0.net\/blog\/?p=271"},"modified":"2025-08-27T18:25:42","modified_gmt":"2025-08-27T18:25:42","slug":"laravel-eloquent-relationships-explained-with-examples","status":"publish","type":"post","link":"https:\/\/1v0.net\/blog\/laravel-eloquent-relationships-explained-with-examples\/","title":{"rendered":"Laravel Eloquent Relationships Explained with Examples"},"content":{"rendered":"\n

One of the most powerful features of Laravel 12<\/strong> is its Eloquent ORM<\/strong>. With Eloquent, you don\u2019t have to write complex SQL joins to connect your data models. Instead, you define relationships<\/strong> between models, and Laravel makes querying related data simple and expressive.<\/p>\n\n\n\n

In this guide, we\u2019ll cover the five major Eloquent relationships \u2014 one-to-one<\/strong>, one-to-many<\/strong>, many-to-many<\/strong>, has-many-through<\/strong>, and polymorphic<\/strong> \u2014 with full examples including migrations, model methods, queries, and Blade UI snippets. After each code block, you\u2019ll find a clear explanation so beginners won\u2019t get lost.<\/p>\n\n\n\n

<\/p>\n\n\n\n

<\/div>\n\n\n\n\n

1 – One to One Relationship<\/strong><\/h2>\n\n\n\n

A one-to-one<\/strong> relationship means one record in a table is related to exactly one record in another table. Example: every User<\/code> has exactly one Profile<\/code>.<\/p>\n\n\n

\/\/ Migration: create_profiles_table.php<\/span>\nSchema::create('profiles'<\/span>, function<\/span> (Blueprint $table)<\/span> <\/span>{\n    $table->id();\n    $table->foreignId('user_id'<\/span>)->constrained()->onDelete('cascade'<\/span>);\n    $table->string('bio'<\/span>)->nullable();\n    $table->timestamps();\n});<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
This migration creates a profiles<\/code> table with a user_id<\/code> foreign key. constrained()<\/code> sets the reference to users.id<\/code>. onDelete('cascade')<\/code> removes the profile when its user is deleted to keep data consistent.<\/p>\n\n\n
\/\/ app\/Models\/User.php<\/span>\npublic<\/span> function<\/span> profile<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->hasOne(Profile::class);\n}\n\n\/\/ app\/Models\/Profile.php<\/span>\npublic<\/span> function<\/span> user<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->belongsTo(User::class);\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
hasOne<\/code> defines the \u201cowner\u201d side (User \u2192 Profile). belongsTo<\/code> defines the inverse (Profile \u2192 User). Eloquent infers the foreign key user_id<\/code> from the model names.<\/p>\n\n\n
\/\/ Query + Blade<\/span>\n$user = User::with('profile'<\/span>)->find(1<\/span>);\n$bio = optional($user->profile)->bio;\n\n\/\/ Blade<\/span>\n<p>Bio: {{ optional($user->profile)->bio }}<\/p><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
with('profile')<\/code> eager-loads the related profile to avoid N+1 queries. optional()<\/code> prevents errors if a user has no profile yet.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/div>\n\n\n\n\n
2 – One to Many Relationship<\/strong><\/h2>\n\n\n\n
A one-to-many<\/strong> relationship is when one record can have multiple related records. Example: a Post<\/code> has many Comment<\/code> entries.<\/p>\n\n\n
\/\/ Migration: create_comments_table.php<\/span>\nSchema::create('comments'<\/span>, function<\/span> (Blueprint $table)<\/span> <\/span>{\n    $table->id();\n    $table->foreignId('post_id'<\/span>)->constrained()->onDelete('cascade'<\/span>);\n    $table->text('body'<\/span>);\n    $table->timestamps();\n});<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Each comment points to its post using post_id<\/code>. When a post is deleted, its comments are cleaned up automatically.<\/p>\n\n\n
\/\/ app\/Models\/Post.php<\/span>\npublic<\/span> function<\/span> comments<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->hasMany(Comment::class);\n}\n\n\/\/ app\/Models\/Comment.php<\/span>\npublic<\/span> function<\/span> post<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->belongsTo(Post::class);\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
hasMany<\/code> indicates a parent with multiple children. belongsTo<\/code> defines the child pointing back to the parent. Eloquent assumes post_id<\/code> as the foreign key.<\/p>\n\n\n
\/\/ Query + Blade<\/span>\n$post = Post::with('comments'<\/span>)->find(1<\/span>);\n\n@foreach<\/span>($post->comments as<\/span> $comment)\n  <p>{{ $comment->body }}<\/p>\n@endforeach<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
We eager-load comments to avoid a query per comment. The Blade loop renders all related comments efficiently.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/div>\n\n\n\n\n
3 – Many to Many Relationship<\/strong><\/h2>\n\n\n\n
A many-to-many<\/strong> relationship allows multiple records on both sides to be related. Classic example: Post<\/code> \u2194 Tag<\/code>. A post can have many tags, and a tag can belong to many posts, typically using a pivot table post_tag<\/code>.<\/p>\n\n\n
\/\/ Migration: create_tags_and_post_tag_tables.php<\/span>\nSchema::create('tags'<\/span>, function<\/span> (Blueprint $table)<\/span> <\/span>{\n    $table->id();\n    $table->string('name'<\/span>)->unique();\n    $table->timestamps();\n});\n\nSchema::create('post_tag'<\/span>, function<\/span> (Blueprint $table)<\/span> <\/span>{\n    $table->id();\n    $table->foreignId('post_id'<\/span>)->constrained()->onDelete('cascade'<\/span>);\n    $table->foreignId('tag_id'<\/span>)->constrained()->onDelete('cascade'<\/span>);\n    $table->timestamps();\n});<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
We create the tags<\/code> table and a pivot table post_tag<\/code> that references both posts<\/code> and tags<\/code>. The pivot holds the relationships.<\/p>\n\n\n
\/\/ app\/Models\/Post.php<\/span>\npublic<\/span> function<\/span> tags<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->belongsToMany(Tag::class);\n}\n\n\/\/ app\/Models\/Tag.php<\/span>\npublic<\/span> function<\/span> posts<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->belongsToMany(Post::class);\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
belongsToMany<\/code> tells Eloquent to use a pivot table. By convention it expects post_tag<\/code>. If you use a different name, pass it as the second argument.<\/p>\n\n\n
\/\/ Attaching \/ syncing tags\n$post = Post::find(1);\n$post->tags()->attach([1, 3]);       \/\/ add relationships\n$post->tags()->sync([2, 3, 5]);      \/\/ make the set exactly [2,3,5]\n$post->tags()->detach([1]);          \/\/ remove relationships\n\n\/\/ Query + Blade\n$post = Post::with('tags')->find(1);\n\n@foreach($post->tags as $tag)\n  <span<\/span> class<\/span>=\"badge bg-secondary\"<\/span>><\/span>{{ $tag->name }}<\/span<\/span>><\/span>\n@endforeach<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
attach<\/code> adds new pivot rows; detach<\/code> removes them; sync<\/code> replaces the entire set. Eager-loading keeps queries minimal.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/div>\n\n\n\n\n
4 – Has Many Through<\/strong><\/h2>\n\n\n\n
Has-many-through<\/strong> lets you access a distant relationship through an intermediate model. Example: a Country<\/code> has many Posts<\/code> through<\/em> User<\/code> (Country \u2192 Users \u2192 Posts). You can fetch all posts for a country without manually joining users.<\/p>\n\n\n
\/\/ Example tables<\/span>\n\/\/ countries: id, name<\/span>\n\/\/ users: id, country_id, name, ...<\/span>\n\/\/ posts: id, user_id, title, ...<\/span>\n\n\/\/ app\/Models\/Country.php<\/span>\npublic<\/span> function<\/span> posts<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->hasManyThrough(\n        Post::class,   \/\/ final model<\/span>\n        User::class,   \/\/ through \/ intermediate model<\/span>\n        'country_id'<\/span>,  \/\/ Foreign key on users table...<\/span>\n        'user_id'<\/span>,     \/\/ Foreign key on posts table...<\/span>\n        'id'<\/span>,          \/\/ Local key on countries table...<\/span>\n        'id'<\/span>           \/\/ Local key on users table...<\/span>\n    );\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
hasManyThrough<\/code> signature is (Final, Through, throughKey, finalKey, localKey, throughLocalKey)<\/code>. Here, a country\u2019s id<\/code> matches users\u2019 country_id<\/code>, and users\u2019 id<\/code> matches posts\u2019 user_id<\/code>.<\/p>\n\n\n
\/\/ Query + Blade<\/span>\n$country = Country::with('posts'<\/span>)->find(1<\/span>);\n\n<h3>Posts from {{ $country->name }}<\/h3>\n@foreach<\/span>($country->posts as<\/span> $post)\n  <p>{{ $post->title }} by {{ $post->user->name }}<\/p>\n@endforeach<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
With one relationship method, you jump across the users<\/code> table to get all posts for a country. This keeps your controllers simple.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/div>\n\n\n\n\n
5 – Polymorphic Relationships<\/strong><\/h2>\n\n\n\n
Polymorphic<\/strong> relationships allow a model to belong to more than one type of model using a single association. Common use cases: a universal Comment<\/code> or Like<\/code> model that can attach to Post<\/code>, Video<\/code>, Photo<\/code>, etc.<\/p>\n\n\n\n
5.1 – One-to-Many Polymorphic (comments on posts & videos)<\/strong><\/h3>\n\n\n
\/\/ Migration: create_comments_table.php<\/span>\nSchema::create('comments'<\/span>, function<\/span> (Blueprint $table)<\/span> <\/span>{\n    $table->id();\n    $table->morphs('commentable'<\/span>); \/\/ creates commentable_id (bigint) & commentable_type (string)<\/span>\n    $table->text('body'<\/span>);\n    $table->timestamps();\n});<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
morphs('commentable')<\/code> creates two columns that together define the parent model (e.g., Post or Video) and the parent id. The same table can store comments for multiple models.<\/p>\n\n\n
\/\/ app\/Models\/Comment.php<\/span>\npublic<\/span> function<\/span> commentable<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->morphTo();\n}\n\n\/\/ app\/Models\/Post.php<\/span>\npublic<\/span> function<\/span> comments<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->morphMany(Comment::class, 'commentable'<\/span>);\n}\n\n\/\/ app\/Models\/Video.php<\/span>\npublic<\/span> function<\/span> comments<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->morphMany(Comment::class, 'commentable'<\/span>);\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
morphTo<\/code> is used on the child (Comment<\/code>) to point to any parent. Each possible parent model (Post<\/code>, Video<\/code>) declares morphMany<\/code> with the same \u201cmorph name\u201d (commentable<\/code>).<\/p>\n\n\n
\/\/ Usage + Blade<\/span>\n$post = Post::with('comments'<\/span>)->find(1<\/span>);\n$video = Video::with('comments'<\/span>)->find(5<\/span>);\n\n@foreach<\/span>($post->comments as<\/span> $c)\n  <p>Post comment: {{ $c->body }}<\/p>\n@endforeach<\/span>\n\n@foreach<\/span>($video->comments as<\/span> $c)\n  <p>Video comment: {{ $c->body }}<\/p>\n@endforeach<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Same comments<\/code> table, two different parents. Eloquent keeps it consistent with the commentable_type<\/code> and commentable_id<\/code> columns.<\/p>\n\n\n\n
5.2 – Many-to-Many Polymorphic (tags for posts & videos)<\/strong><\/h3>\n\n\n
\/\/ Migration: create_tags_and_taggables.php<\/span>\nSchema::create('tags'<\/span>, function<\/span> (Blueprint $table)<\/span> <\/span>{\n    $table->id();\n    $table->string('name'<\/span>)->unique();\n    $table->timestamps();\n});\n\nSchema::create('taggables'<\/span>, function<\/span> (Blueprint $table)<\/span> <\/span>{\n    $table->id();\n    $table->foreignId('tag_id'<\/span>)->constrained()->onDelete('cascade'<\/span>);\n    $table->morphs('taggable'<\/span>); \/\/ taggable_id + taggable_type<\/span>\n    $table->timestamps();\n});<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
The taggables<\/code> table connects a tag to any taggable model (post, video, etc.). This lets you reuse one tagging system application-wide.<\/p>\n\n\n
\/\/ app\/Models\/Tag.php<\/span>\npublic<\/span> function<\/span> posts<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->morphedByMany(Post::class, 'taggable'<\/span>);\n}\n\npublic<\/span> function<\/span> videos<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->morphedByMany(Video::class, 'taggable'<\/span>);\n}\n\n\/\/ app\/Models\/Post.php<\/span>\npublic<\/span> function<\/span> tags<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->morphToMany(Tag::class, 'taggable'<\/span>);\n}\n\n\/\/ app\/Models\/Video.php<\/span>\npublic<\/span> function<\/span> tags<\/span>()<\/span>\n<\/span>{\n    return<\/span> $this<\/span>->morphToMany(Tag::class, 'taggable'<\/span>);\n}<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
On the \u201cthing being tagged\u201d (Post\/Video), use morphToMany<\/code>. On the Tag side, use morphedByMany<\/code> for each taggable type. Eloquent handles the morph columns automatically.<\/p>\n\n\n
\/\/ Usage + Blade\n$post = Post::with('tags')->find(1);\n$video = Video::with('tags')->find(1);\n\n@foreach($post->tags as $tag)\n  <span<\/span> class<\/span>=\"badge bg-info\"<\/span>><\/span>#{{ $tag->name }}<\/span<\/span>><\/span>\n@endforeach\n\n@foreach($video->tags as $tag)\n  <span<\/span> class<\/span>=\"badge bg-warning\"<\/span>><\/span>#{{ $tag->name }}<\/span<\/span>><\/span>\n@endforeach<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
You can attach\/detach\/sync tags using the relationship just like a normal many-to-many, but now polymorphic across different models.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/div>\n\n\n\n\n
Wrapping Up<\/h2>\n\n\n\n
You\u2019ve learned the essential Eloquent relationships in Laravel 12 with practical, copy-paste examples: one-to-one<\/strong> (User\u2013Profile), one-to-many<\/strong> (Post\u2013Comments), many-to-many<\/strong> (Post\u2013Tags), has-many-through<\/strong> (Country\u2013Posts through Users), and polymorphic<\/strong> (Comments\/Tags across multiple models). With these in your toolbox, you can model most real-world data cleanly and query it efficiently \u2014 while keeping your controllers and views simple.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/div>\n\n\n\n\n
What\u2019s Next<\/h2>\n\n\n\n