Laravel Relationships In Eloquent

What are relationships in Eloquent?

Relationships in Eloquent allow you to define the relationships between different models (tables) in your database. Eloquent supports relationships like one-to-one, one-to-many, many-to-many, has-many-through, and polymorphic. These relationships make it easy to retrieve related records without writing complex SQL queries.

How do you define a one-to-one relationship in Eloquent?

A one-to-one relationship is used when one record in a model is associated with exactly one record in another model. You define this relationship using the hasOne() and belongsTo() methods in the respective models.

Example of a one-to-one relationship:

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

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

In this example, a User model has one related Profile model, and a Profile belongs to one User.

How do you define a one-to-many relationship in Eloquent?

A one-to-many relationship is used when one record in a model can be associated with many records in another model. This is defined using the hasMany() method in the parent model and the belongsTo() method in the child model.

Example of a one-to-many relationship:

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

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

In this example, a User can have many Post models, and each Post belongs to one User.

How do you define a many-to-many relationship in Eloquent?

A many-to-many relationship is used when a model can have many related records in another model, and vice versa. This relationship is defined using the belongsToMany() method and requires a pivot table to store the relationship.

Example of a many-to-many relationship:

class User extends Model
{
    public function roles()
    {
        return $this->belongsToMany(Role::class);
    }
}

class Role extends Model
{
    public function users()
    {
        return $this->belongsToMany(User::class);
    }
}

In this example, a User can have many Role models, and a Role can belong to many User models. The relationship is stored in a pivot table like role_user.

What is a pivot table in a many-to-many relationship?

A pivot table is an intermediate table used to store the relationship between two models in a many-to-many relationship. Pivot tables typically contain the primary keys from both related tables.

Example of a pivot table:

Schema::create('role_user', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained();
    $table->foreignId('role_id')->constrained();
    $table->timestamps();
});

In this example, the pivot table role_user stores the relationship between users and roles.

How do you access additional pivot table columns in a many-to-many relationship?

You can access additional columns in a pivot table by defining them in the withPivot() method when defining the relationship. Eloquent provides access to these extra columns through the pivot model.

Example of accessing pivot table columns:

class User extends Model
{
    public function roles()
    {
        return $this->belongsToMany(Role::class)->withPivot('created_at');
    }
}

In this example, the withPivot('created_at') method allows you to access the created_at column from the pivot table in the relationship.

How do you define a has-many-through relationship in Eloquent?

A has-many-through relationship allows you to retrieve data from a distant related model via an intermediate model. For example, you can retrieve posts through users, where each user belongs to a company.

Example of a has-many-through relationship:

class Company extends Model
{
    public function posts()
    {
        return $this->hasManyThrough(Post::class, User::class);
    }
}

In this example, the Company model has many Post models through the User model.

How do you define polymorphic relationships in Eloquent?

Polymorphic relationships allow a model to belong to more than one other model on a single association. For example, a comment can belong to both a post and a video.

Example of a polymorphic relationship:

class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

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

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

In this example, the Comment model can belong to either a Post or a Video model. Both the Post and Video models can have many comments.

How do you define a many-to-many polymorphic relationship in Eloquent?

A many-to-many polymorphic relationship allows you to define a relationship where a model can belong to more than one other model, and those models can have multiple related models. For example, a tag can belong to both a post and a video, and each post and video can have many tags.

Example of a many-to-many polymorphic relationship:

class Tag extends Model
{
    public function posts()
    {
        return $this->morphedByMany(Post::class, 'taggable');
    }

    public function videos()
    {
        return $this->morphedByMany(Video::class, 'taggable');
    }
}

class Post extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

class Video extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

In this example, the Tag model can be associated with both Post and Video models, and each post or video can have multiple tags.

How do you eager load relationships in Eloquent?

Eager loading is used to load relationships alongside the main model query to avoid the "N+1" problem, which can result in inefficient queries. You can use the with() method to eager load relationships.

Example of eager loading relationships:

$users = User::with('posts')->get();

In this example, all users are retrieved along with their related posts in a single query.

What is lazy eager loading in Eloquent?

Lazy eager loading allows you to load relationships after the initial model query has been executed. You can use the load() method to perform lazy eager loading on an existing collection or model instance.

Example of lazy eager loading:

$users = User::all();
$users->load('posts');

In this example, all users are retrieved first, and then their related posts are loaded with a separate query.

What is the touch method in Eloquent relationships?

The touch() method in Eloquent relationships updates the updated_at timestamp on the parent model when the child model is updated. This is useful when you want to track changes on related models.

Example of using the touch method:

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

In this example, the touch() method updates the updated_at timestamp on the Post model.

How do you delete related models in Eloquent?

When deleting a model, you may want to delete its related models as well. You can use the delete() method on the related models or define cascading deletes using database foreign key constraints.

Example of deleting related models:

$user = User::find(1);
$user->posts()->delete(); // Delete related posts
$user->delete(); // Delete the user

In this example, all related posts are deleted before deleting the user.