Laravel Eloquent Relationships provides five main types: 1. One-to-one uses hasOne and belongsTo; 2. One-to-many uses hasMany and belongsTo; 3. Many-to-many uses belongsToMany and creates intermediate tables; 4. Indirect association uses hasManyThrough; 5. Polymorphic association uses morphTo and morphMany. Each relationship is achieved by defining methods in the model. Eloquent automatically processes underlying queries, making data access more intuitive and efficient.

Laravel Eloquent Relationships: A Practical Guide

Laravel's Eloquent ORM makes working with database relationships in PHP both intuitive and powerful. If you're building a Laravel app and need to connect models — like users to posts, orders to products, or categories to articles — Eloquent relationships are the way to go. This guide breaks down the most common relationship types with clear examples you can use right away.

1. One-to-One Relationship

Use this when one record in a table is linked to exactly one record in another table.

Example: A User has one Profile .

Database Setup

 // users table
Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email');
    $table->timestamps();
});

// profiles table
Schema::create('profiles', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->onDelete('cascade');
    $table->string('phone')->nullable();
    $table->text('bio')->nullable();
    $table->timestamps();
});

Model Definition

 // User.php
public function profile()
{
    return $this->hasOne(Profile::class);
}

// Profile.php
public function user()
{
    return $this->belongsTo(User::class);
}

Usage

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

// Create profile for user
$user->profile()->create([
    'phone' => '123-456-7890',
    'bio' => 'Laravel developer'
]);

Note: hasOne expects the foreign key on the related model ( profiles.user_id ).

2. One-to-Many Relationship

Used when a single record can have multiple related records.

Example: A User has many Posts .

Database Setup

 // posts table
Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained();
    $table->string('title');
    $table->text('body');
    $table->timestamps();
});

Model Definition

 // User.php
public function posts()
{
    return $this->hasMany(Post::class);
}

// Post.php
public function user()
{
    return $this->belongsTo(User::class);
}

Usage

 $user = User::find(1);
foreach ($user->posts as $post) {
    echo $post->title;
}

// Create a post
$user->posts()->create([
    'title' => 'My First Post',
    'body' => 'Hello World'
]);

3. Many-to-Many Relationship

Used when both sides can have multiple records from the other side. Requires a pivot table.

Example: User belongs to many Roles , and a Role can belong to many Users .

Database Setup

 // roles table
Schema::create('roles', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->timestamps();
});

// role_user pivot table (or use roles_users)
Schema::create('role_user', function (Blueprint $table) {
    $table->foreignId('user_id')->constrained()->onDelete('cascade');
    $table->foreignId('role_id')->constrained()->onDelete('cascade');
    $table->primary(['user_id', 'role_id']);
});

Model Definition

 // User.php
public function roles()
{
    return $this->belongsToMany(Role::class);
}

// Role.php
public function users()
{
    return $this->belongsToMany(User::class);
}

Usage

 $user = User::find(1);
foreach ($user->roles as $role) {
    echo $role->name;
}

// Attach a role
$user->roles()->attach($roleId);

// Sync roles (replace all)
$user->roles()->sync([1, 2, 3]);

// With pivot data (eg, timestamps or extra fields)
$user->roles()->attach($roleId, ['created_at' => now()]);

Tip: Laravel automatically infers the pivot table name from the singular models in alphabetical order ( role_user ). You can override it by passing a second argument:
belongsToMany(Role::class, 'user_roles')

4. Has Many Through

Use when you want to access distant relationships via an intermediate model.

Example: A Country has many Posts through its Users .

Model Setup

 // Country.php
public function posts()
{
    return $this->hasManyThrough(Post::class, User::class);
}

Assumes:

• countries → users (country_id) → posts (user_id)

Usage

 $country = Country::find(1);
foreach ($country->posts as $post) {
    echo $post->title;
}

5. Polymorphic Relationships

Use when a model can belong to more than one other model on a single association.

Example: Both Post and User can have Image s.

Database Setup

 // images table
Schema::create('images', function (Blueprint $table) {
    $table->id();
    $table->string('url');
    $table->morphs('imageable'); // Creates imageable_type and imageable_id
    $table->timestamps();
});

Model Definition

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

// Post.php
public function images()
{
    return $this->morphMany(Image::class, 'imageable');
}

// User.php
public function images()
{
    return $this->morphMany(Image::class, 'imageable');
}

Usage

 $post = Post::find(1);
$image = $post->images()->create(['url' => 'photo.jpg']);

// Get the owner of the image
$image = Image::find(1);
$owner = $image->imageable; // Returns Post or User instance

Bonus: Defining Custom Foreign Keys

Sometimes your column names don't follow Laravel's convention.

 // Custom foreign key
return $this->belongsTo(User::class, 'author_id');

// Custom primary key on related model
return $this->belongsTo(User::class, 'author_id', 'uuid');

Summary of Relationship Methods

Eloquent relations make your Laravel code cleaner and more expressive. Start with the basics — hasOne , hasMany , and belongsTo — then expand to belongsToMany and polymorphic types as your app grows.

Basically, define the relationship once in your model, and Eloquent handles the joins and queries for you.

The above is the detailed content of Laravel Eloquent relationships tutorial. For more information, please follow other related articles on the PHP Chinese website!