# Belajar Laravel Eloquent Relationship: Panduan Lengkap dengan Contoh Kasus

Eloquent ORM merupakan salah satu fitur paling *powerfull* di Laravel. Salah satu kekuatan Eloquent terletak pada kemampuannya untuk mendefinisikan *relationship* atau relasi antar tabel database. Memahami dan menguasai *Eloquent Relationship* akan sangat membantu Anda dalam membangun aplikasi web yang kompleks dan efisien. Artikel ini akan menjadi **panduan lengkap belajar Laravel Eloquent Relationship dengan contoh kasus** yang mudah dipahami. Siap untuk mendalami relasi di Laravel? Yuk, kita mulai!

## Apa Itu Eloquent Relationship dan Mengapa Penting?

Eloquent Relationship adalah cara mendefinisikan bagaimana tabel-tabel di database Anda saling berhubungan.  Alih-alih menulis query SQL yang rumit untuk menggabungkan (join) tabel, Anda bisa menggunakan Eloquent Relationship untuk mengakses data terkait dengan cara yang lebih intuitif dan *object-oriented*.

**Mengapa Eloquent Relationship Penting?**

*   **Mempermudah Pengelolaan Data:** Anda tidak perlu menulis query SQL yang panjang dan rumit untuk mendapatkan data yang saling berhubungan.
*   **Kode Lebih Bersih dan Mudah Dibaca:**  Relasi didefinisikan dalam model, sehingga kode menjadi lebih terstruktur dan mudah dipahami.
*   **Meningkatkan Produktivitas:**  Eloquent Relationship memungkinkan Anda fokus pada logika aplikasi, bukan pada detail implementasi database.
*   **Maintenance Lebih Mudah:**  Perubahan struktur database akan lebih mudah dikelola karena relasi didefinisikan di satu tempat (model).
*   **Performa yang Lebih Baik:**  Eloquent dapat mengoptimalkan query yang dihasilkan, sehingga meningkatkan performa aplikasi.

## Jenis-Jenis Eloquent Relationship: Memahami Relasi Utama

Laravel Eloquent menyediakan beberapa jenis relasi yang umum digunakan. Memahami setiap jenis relasi ini sangat penting untuk mendesain database dan model yang tepat.  Berikut adalah beberapa jenis relasi utama yang akan kita bahas:

*   **One To One (Satu ke Satu):**  Satu record di tabel A terhubung dengan satu record di tabel B.
*   **One To Many (Satu ke Banyak):**  Satu record di tabel A terhubung dengan banyak record di tabel B.
*   **Many To One (Banyak ke Satu):**  Banyak record di tabel A terhubung dengan satu record di tabel B (kebalikan dari One To Many).
*   **Many To Many (Banyak ke Banyak):**  Banyak record di tabel A terhubung dengan banyak record di tabel B, biasanya melalui tabel *pivot*.
*   **Has One Through (Melalui):**  Mengakses relasi *one-to-one* melalui relasi lain.
*   **Has Many Through (Melalui):** Mengakses relasi *one-to-many* melalui relasi lain.
*   **Polymorphic Relations:** Memungkinkan sebuah model terhubung ke model lain dengan berbagai jenis relasi.
*   **Many To Many Polymorphic Relations:** Kombinasi dari *many-to-many* dan *polymorphic relations*.

Mari kita bahas masing-masing relasi ini lebih detail dengan contoh kasus.

## Belajar Relasi One To One: Contoh Kasus `User` dan `Profile`

Relasi *One to One* adalah relasi paling sederhana.  Misalnya, setiap `User` memiliki satu `Profile`.  Database yang digunakan adalah MySQL. Kita akan membuat 2 tabel, yaitu `users` dan `profiles`.

**Struktur Tabel:**

**Tabel `users`:**

| Column       | Type         |
|--------------|--------------|
| id           | BIGINT       |
| name         | VARCHAR(255) |
| email        | VARCHAR(255) |
| password     | VARCHAR(255) |
| created_at   | TIMESTAMP    |
| updated_at   | TIMESTAMP    |

**Tabel `profiles`:**

| Column       | Type         |
|--------------|--------------|
| id           | BIGINT       |
| user_id      | BIGINT       |
| address      | TEXT         |
| phone_number | VARCHAR(20)  |
| created_at   | TIMESTAMP    |
| updated_at   | TIMESTAMP    |

Perhatikan bahwa kolom `user_id` di tabel `profiles` adalah *foreign key* yang merujuk ke kolom `id` di tabel `users`.

**Model:**

Buat dua model menggunakan Artisan:

```bash
php artisan make:model User
php artisan make:model Profile

Model User (app/Models/User.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;

class User extends Authenticatable
{
    use HasFactory, Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    /**
     * The attributes that should be hidden for arrays.
     *
     * @var array
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * The attributes that should be cast to native types.
     *
     * @var array
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];

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

Model Profile (app/Models/Profile.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Profile extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'address',
        'phone_number',
    ];

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

Penjelasan:

• Di model User, kita menggunakan method hasOne() untuk mendefinisikan relasi One to One dengan model Profile. Parameter pertama adalah nama model yang berelasi (Profile::class).
• Di model Profile, kita menggunakan method belongsTo() untuk mendefinisikan relasi One to One (dari sisi Profile ke User) dengan model User. Parameter pertama adalah nama model yang berelasi (User::class).

Mengakses Data:

// Mendapatkan profile dari user dengan ID 1
$user = User::find(1);
$profile = $user->profile;

echo $profile->address; // Menampilkan alamat user

// Mendapatkan user dari profile dengan ID 1
$profile = Profile::find(1);
$user = $profile->user;

echo $user->name; // Menampilkan nama user

Creating Data:

// Cara 1: Membuat Profile melalui User
$user = User::find(1);
$profile = new Profile([
    'address' => 'Jalan Kebon Jeruk',
    'phone_number' => '081234567890',
]);

$user->profile()->save($profile);

// Cara 2: Membuat User dan Profile sekaligus
$user = User::create([
    'name' => 'John Doe',
    'email' => '[email protected]',
    'password' => bcrypt('password'),
]);

$profile = $user->profile()->create([
    'address' => 'Jalan Sudirman',
    'phone_number' => '087777777777',
]);

Belajar Relasi One To Many: Contoh Kasus User dan Posts

Relasi One to Many digunakan ketika satu record di tabel A terhubung dengan banyak record di tabel B. Contohnya, satu User bisa memiliki banyak Post.

Struktur Tabel:

Tabel users: (Sama seperti sebelumnya)

Tabel posts:

Kolom user_id di tabel posts adalah foreign key yang merujuk ke kolom id di tabel users.

Model:

Buat model Post menggunakan Artisan:

php artisan make:model Post

Model User (app/Models/User.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;

class User extends Authenticatable
{
    use HasFactory, Notifiable;

    // ... (kode lainnya)

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

Model Post (app/Models/Post.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Post extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'title',
        'content',
    ];


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

Penjelasan:

• Di model User, kita menggunakan method hasMany() untuk mendefinisikan relasi One to Many dengan model Post. Parameter pertama adalah nama model yang berelasi (Post::class).
• Di model Post, kita menggunakan method belongsTo() untuk mendefinisikan relasi Many to One (dari sisi Post ke User) dengan model User. Parameter pertama adalah nama model yang berelasi (User::class).

Mengakses Data:

// Mendapatkan semua post dari user dengan ID 1
$user = User::find(1);
$posts = $user->posts;

foreach ($posts as $post) {
    echo $post->title . "<br>";
}

// Mendapatkan user dari post dengan ID 1
$post = Post::find(1);
$user = $post->user;

echo $user->name; // Menampilkan nama user yang membuat post

Creating Data:

// Cara 1: Membuat Post melalui User
$user = User::find(1);
$post = new Post([
    'title' => 'Judul Post Baru',
    'content' => 'Isi post baru...',
]);

$user->posts()->save($post);

// Cara 2:  Menggunakan create()
$user = User::find(1);
$post = $user->posts()->create([
    'title' => 'Judul Post Lain',
    'content' => 'Isi post lainnya...',
]);

Belajar Relasi Many To Many: Contoh Kasus Post dan Tag

Relasi Many to Many digunakan ketika banyak record di tabel A terhubung dengan banyak record di tabel B. Contohnya, satu Post bisa memiliki banyak Tag, dan satu Tag bisa dimiliki oleh banyak Post. Relasi ini membutuhkan tabel pivot.

Struktur Tabel:

Tabel posts: (Sama seperti sebelumnya)

Tabel tags:

Tabel post_tag (Tabel Pivot):

Perhatikan bahwa tabel post_tag memiliki dua foreign key: post_id yang merujuk ke tabel posts, dan tag_id yang merujuk ke tabel tags.

Model:

Buat model Tag menggunakan Artisan:

php artisan make:model Tag

Model Post (app/Models/Post.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Post extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'title',
        'content',
    ];

    public function tags()
    {
        return $this->belongsToMany(Tag::class);
    }
}

Model Tag (app/Models/Tag.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Tag extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
    ];

    public function posts()
    {
        return $this->belongsToMany(Post::class);
    }
}

Penjelasan:

• Di model Post dan Tag, kita menggunakan method belongsToMany() untuk mendefinisikan relasi Many to Many. Parameter pertama adalah nama model yang berelasi. Secara default, Eloquent akan mencari tabel pivot dengan nama yang diurutkan secara alfabet dari nama model (misalnya, post_tag untuk Post dan Tag). Anda bisa menentukan nama tabel pivot secara eksplisit sebagai parameter kedua: return $this->belongsToMany(Tag::class, 'nama_tabel_pivot');.

Mengakses Data:

// Mendapatkan semua tag dari post dengan ID 1
$post = Post::find(1);
$tags = $post->tags;

foreach ($tags as $tag) {
    echo $tag->name . "<br>";
}

// Mendapatkan semua post dari tag dengan ID 1
$tag = Tag::find(1);
$posts = $tag->posts;

foreach ($posts as $post) {
    echo $post->title . "<br>";
}

Attaching dan Detaching:

Eloquent menyediakan method attach() dan detach() untuk menambahkan dan menghapus relasi di tabel pivot.

// Menambahkan tag ke post
$post = Post::find(1);
$tag = Tag::find(1);

$post->tags()->attach($tag->id);

// Menghapus tag dari post
$post = Post::find(1);
$tag = Tag::find(1);

$post->tags()->detach($tag->id);

// Menambahkan beberapa tag sekaligus
$post = Post::find(1);
$tagIds = [1, 2, 3]; // Array berisi ID tag yang ingin ditambahkan

$post->tags()->attach($tagIds);

// Sinkronisasi: Menghapus semua tag yang ada dan menambahkan tag baru
$post = Post::find(1);
$tagIds = [2, 4, 5];

$post->tags()->sync($tagIds);

Eager Loading: Mengoptimalkan Query dengan with()

Secara default, Laravel Eloquent menggunakan lazy loading. Artinya, relasi baru dimuat ketika Anda mencoba mengaksesnya. Jika Anda mengakses banyak relasi sekaligus, ini bisa menyebabkan banyak query database dieksekusi (N+1 query problem).

Untuk mengatasi masalah ini, Anda bisa menggunakan eager loading dengan method with(). Eager loading akan memuat semua relasi yang dibutuhkan dalam satu query.

Contoh:

// Tanpa Eager Loading (Lazy Loading)
$users = User::all();

foreach ($users as $user) {
    echo $user->profile->address; // Setiap iterasi akan memicu query baru
}

// Dengan Eager Loading
$users = User::with('profile')->get();

foreach ($users as $user) {
    echo $user->profile->address; // Hanya 1 query database
}

Dengan User::with('profile')->get(), Laravel akan memuat semua data User dan data Profile yang terkait dalam satu query. Ini akan meningkatkan performa aplikasi Anda secara signifikan. Anda bisa menggunakan with() untuk memuat banyak relasi sekaligus: User::with(['profile', 'posts', 'posts.tags'])->get();

Belajar Relasi Has One Through dan Has Many Through

Relasi Has One Through dan Has Many Through menyediakan cara mudah untuk mengakses relasi melalui relasi lain.

Contoh Kasus Has One Through:

Misalkan kita punya tabel Country, User, dan Address. Setiap Country memiliki banyak User, dan setiap User memiliki satu Address. Kita ingin mengakses Address melalui Country.

Struktur Tabel:

Tabel countries:

Tabel users:

Tabel addresses:

Model:

// app/Models/Country.php
namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Country extends Model
{
    use HasFactory;

    public function address()
    {
        return $this->hasOneThrough(Address::class, User::class);
    }
}

// app/Models/User.php
namespace AppModels;

use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class User extends Authenticatable
{
    use HasFactory;

    public function address()
    {
        return $this->hasOne(Address::class);
    }

    public function country()
    {
        return $this->belongsTo(Country::class);
    }
}

// app/Models/Address.php
namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Address extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'address',
    ];

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

Mengakses Data:

$country = Country::find(1);
$address = $country->address;

echo $address->address;

Contoh Kasus Has Many Through:

Misalkan kita ingin mendapatkan semua Post dari semua User yang berada di Country tertentu.

Model:

// app/Models/Country.php
namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Country extends Model
{
    use HasFactory;

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

// app/Models/User.php (Sama seperti sebelumnya, ditambah relasi ke Post)
namespace AppModels;

use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class User extends Authenticatable
{
    use HasFactory;

     public function address()
    {
        return $this->hasOne(Address::class);
    }

    public function country()
    {
        return $this->belongsTo(Country::class);
    }

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


// app/Models/Post.php (Sama seperti sebelumnya)
namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Post extends Model
{
    use HasFactory;

    protected $fillable = [
        'user_id',
        'title',
        'content',
    ];


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

Mengakses Data:

$country = Country::find(1);
$posts = $country->posts;

foreach ($posts as $post) {
    echo $post->title . "<br>";
}

Kesimpulan dan Tips Belajar Laravel Eloquent Relationship Lebih Lanjut

Eloquent Relationship adalah fitur yang sangat penting dalam Laravel. Dengan memahaminya, Anda dapat membangun aplikasi yang lebih terstruktur, mudah dipelihara, dan memiliki performa yang lebih baik.

Tips Belajar Lebih Lanjut:

• Praktik Langsung: Cara terbaik untuk belajar adalah dengan mempraktikkan langsung. Buat proyek kecil yang menggunakan berbagai jenis Eloquent Relationship.
• Baca Dokumentasi Laravel: Dokumentasi Laravel adalah sumber informasi terlengkap dan terakurat.
• Eksplorasi Contoh Kasus: Cari contoh kasus penggunaan Eloquent Relationship di internet atau di proyek-proyek open source.
• Gunakan Debugbar: Laravel Debugbar dapat membantu Anda memahami query yang dieksekusi oleh Eloquent. Ini sangat berguna untuk mengidentifikasi masalah performa.
• Pelajari Konsep Database: Memahami konsep dasar database (seperti foreign key, indexing, dan normalisasi) akan sangat membantu Anda dalam mendesain relasi yang tepat.

Semoga panduan lengkap belajar Laravel Eloquent Relationship ini bermanfaat. Selamat belajar dan semoga sukses!