Beginner’s Guide to Laravel Eloquent Relationships

Posted on January 13th, 2025

Laravel’s Eloquent ORM (Object-Relational Mapping) is a powerful tool for managing and interacting with your database. One of its most impressive features is the ability to define relationships between your models. Understanding these relationships is crucial for building applications that efficiently manage and retrieve related data. This comprehensive guide explores the fundamental types of Eloquent relationships with detailed examples and explanations.In Laravel, Eloquent relationships allow you to define and manage connections between different models, simplifying data retrieval and manipulation. This guide covers critical types of relationships, including one-to-one, one-to-many, many-to-many, and more advanced relationships like polymorphic relationships.

Why Eloquent Relationships Matter

  • Data Organization: Relationships help structure and connect related data across tables.
  • Simplified Queries: Define relationships to make complex queries easier and more readable.
  • Efficient Data Retrieval: Using Eloquent’s relationship methods to retrieve related data efficiently.

Prerequisites

Before diving into Eloquent relationships, ensure you have the following:

  • Basic Understanding of Laravel: Familiarity with setting up and running a Laravel project.
  • Basic Eloquent Knowledge: Experience with creating and using Eloquent models.

If you’re new to Laravel or Eloquent, ensure you have a Laravel project running and are comfortable with basic model operations.

Types of Eloquent Relationships

Laravel supports several types of relationships. Here’s a detailed look at the most common ones:

1. One-to-One Relationship

A one-to-one relationship links one model to another. For example, each user might have one profile.

Step-by-Step:

  1. Define the Models
    User Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }
}

    Profile Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Profile extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}
  2. Create the Migration Files Create the migrations for the users and profiles tables: 
    // Create users table
Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->timestamps();
});

// Create profiles table
Schema::create('profiles', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->onDelete('cascade');
    $table->string('bio')->nullable();
    $table->timestamps();
});
  3. Querying Data Retrieve a user’s profile: 
    $user = User::find(1);
$profile = $user->profile;
  4. Inserting Data Create a new user and profile: 
    $user = new User;
$user->name = 'John Doe';
$user->save();
$profile = new Profile;
$profile->user_id = $user->id;
$profile->bio = 'Software Developer';
$profile->save();

2. One-to-Many Relationship

A one-to-many relationship connects one model to many other models. For example, a blog post may have many comments.

Step-by-Step:

  1. Define the Models
    Post Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Post extends Model
{
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

    Comment Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Comment extends Model
{
    public function post()
    {
        return $this->belongsTo(Post::class);
    }
}
  2. Create the Migration Files Create the migrations for the posts and comments tables: 
    // Create posts table
Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->timestamps();
});

// Create comments table
Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->foreignId('post_id')->constrained()->onDelete('cascade');
    $table->text('comment');
    $table->timestamps();
});
  3. Querying Data Retrieve all comments for a post: 
    $post = Post::find(1);
$comments = $post->comments;
  4. Inserting Data Create a new post and comments: 
    $post = new Post;
$post->title = 'My First Post';
$post->content = 'This is the content of my first post.';
$post->save();
$comment = new Comment;
$comment->post_id = $post->id;
$comment->comment = 'Great post!';
$comment->save();

3. Many-to-Many Relationship

A many-to-many relationship connects multiple models to multiple other models. For example, students and courses.

Step-by-Step:

  1. Define the Models
    Student Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Student extends Model
{
    public function courses()
    {
        return $this->belongsToMany(Course::class);
    }
}

    Course Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Course extends Model
{
    public function students()
    {
        return $this->belongsToMany(Student::class);
    }
}
  2. Create the Pivot Table Migration Create a pivot table for the many-to-many relationship: 
    Schema::create('course_student', function (Blueprint $table) {
    $table->id();
    $table->foreignId('course_id')->constrained()->onDelete('cascade');
    $table->foreignId('student_id')->constrained()->onDelete('cascade');
    $table->timestamps();
});
  3. Querying Data Retrieve courses for a student: 
    $student = Student::find(1);
$courses = $student->courses;
  4. Inserting Data Attach courses to a student: 
    $student = Student::find(1);
$student->courses()->attach([1, 2]); // Attaches course IDs 1 and 2 to the student
$student->courses()->detach(1); // Detaches course ID 1 from the student

4. Polymorphic Relationships

Polymorphic relationships allow a model to belong to more than one other model through a single association. For example, comments that can belong to both posts and videos.

Step-by-Step:

  1. Define the Models
    Comment Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

    Post Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

    Video Model:

    namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class Video extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}
  2. Create the Migration Files Create the migrations for the posts, videos, and comments tables: 
    // Create posts table
Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->timestamps();
});

// Create videos table
Schema::create('videos', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->string('url');
    $table->timestamps();
});

// Create comments table
Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->unsignedBigInteger('commentable_id');
    $table->string('commentable_type');
    $table->text('comment');
    $table->timestamps();
});
  3. Querying Data Retrieve comments for a post: 
    $post = Post::find(1);
$comments = $post->comments;
  4. Inserting Data Create a comment for a post: 
    $post = Post::find(1);
$comment = new Comment;
$comment->comment = 'Great post!';
$comment->commentable()->associate($post);
$comment->save();

    Create a comment for a video:

    $video = Video::find(1);
$comment = new Comment;
$comment->comment = 'Amazing video!';
$comment->commentable()->associate($video);
$comment->save();

Conclusion

Laravel’s Eloquent ORM relationships are essential for managing data in a structured and efficient manner. Understanding the types of relationships, one-to-one, one-to-many, many-to-many, and polymorphic, allows you to build robust applications with clean, maintainable code. By following the examples and practices outlined in this guide, you’ll be well-equipped to leverage the full power of Eloquent relationships in your Laravel projects.

Additional Resources

Leave a Reply