Laravel Eloquent Relationships: One to One, One to Many

Summary:
Learn Eloquent ORM relationships with examples.

Laravel’s Eloquent ORM (Object Relational Mapper) is well-known for its elegant and expressive syntax for interacting with databases. One of its most powerful features is the ability to easily define relationships between models. In this post, we’ll explore two fundamental Eloquent relationships: one to one and one to many. We’ll learn how to set them up, retrieve related data, and best practices—complete with practical examples.

Why Use Eloquent Relationships?

Eloquent provides an intuitive way to manage related data without writing complex SQL queries. With relationships defined in your models, you can:

Access and manipulate related records easily.
Maintain better-organized database queries.
Boost code reusability and maintainability.

One to One Relationships

A one to one relationship is used to define that a single model is associated with a single instance of another model. For example, a user might have only one profile.

1. Database Structure

Let’s say you have two tables: users and profiles.

users table (id, name, email, ...)
profiles table (id, user_id, address, phone, ...)

Here, user_id in the profiles table is a foreign key referencing the users.

2. Defining the Relationship

In the User Model:

class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }
}

In the Profile Model:

class Profile extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

3. Eloquent Usage Examples

Get a user's profile:

$user = User::find(1);
$profile = $user->profile;

Get the user who owns a profile:

$profile = Profile::find(1);
$user = $profile->user;

One to Many Relationships

A one to many relationship is used to relate a single model to multiple instances of another model. For example, a blog post may have many comments.

1. Database Structure

Suppose you have posts and comments tables.

posts table (id, title, body, ...)
comments table (id, post_id, body, ...)

post_id in the comments table is a foreign key referencing posts.

2. Defining the Relationship

In the Post Model:

class Post extends Model
{
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

In the Comment Model:

class Comment extends Model
{
    public function post()
    {
        return $this->belongsTo(Post::class);
    }
}

3. Eloquent Usage Examples

Get all comments for a post:

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

Get the post to which a comment belongs:

$comment = Comment::find(1);
$post = $comment->post;

Best Practices

Eager Load Relations: Use with() to avoid N+1 query problems.
```
$users = User::with('profile')->get();
```
Database Indexes: Add indexes to foreign keys for better performance.
Naming Conventions: Follow Laravel’s naming conventions for foreign keys and relationships for reduced configuration.

Conclusion

Eloquent relationships, such as one to one and one to many, allow you to handle related data with minimal configuration and clean syntax. By defining these relationships in your models, you can easily perform complex queries and maintain the integrity of your application’s logic. Start using them today to keep your Laravel codebase organized and efficient!

Further Reading: