Cara Menggunakan Eloquent Relationship di Laravel (One to Many & Many to Many)

Di aplikasi nyata, data jarang berdiri sendiri: satu user punya banyak artikel, satu artikel punya banyak tag. Menangani hubungan antar-tabel ini secara manual dengan query JOIN bisa melelahkan. Eloquent Relationship di Laravel membuatnya jauh lebih ringkas dan mudah dibaca. Artikel ini membahas dua relasi yang paling sering dipakai — One to Many dan Many to Many — beserta cara menghindari jebakan performa yang umum.

Apa Itu Eloquent Relationship?

Eloquent adalah ORM (Object Relational Mapping) Laravel. Alih-alih menulis SQL JOIN, kamu mendefinisikan hubungan antar-model sebagai method, lalu mengaksesnya seperti properti biasa. Kode jadi lebih deklaratif dan mudah dirawat.

One to Many (Satu ke Banyak)

Contoh klasik: satu User menulis banyak Post. Di model User, tambahkan method posts():

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

Sebaliknya, satu Post dimiliki satu User. Di model Post:

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

Syaratnya, tabel posts punya kolom user_id (foreign key). Sekarang kamu bisa mengakses relasinya:

$user = User::find(1);

foreach ($user->posts as $post) {   // semua post milik user
    echo $post->title;
}

$post = Post::find(5);
echo $post->user->name;             // nama penulis post

Many to Many (Banyak ke Banyak)

Contoh: satu Post punya banyak Tag, dan satu Tag dipakai banyak Post. Relasi ini butuh tabel pivot (misalnya post_tag) berisi post_id dan tag_id.

// app/Models/Post.php
public function tags()
{
    return $this->belongsToMany(Tag::class);
}

// app/Models/Tag.php
public function posts()
{
    return $this->belongsToMany(Post::class);
}

Menambah dan melepas relasi jadi sangat mudah dengan attach, detach, dan sync:

$post->tags()->attach($tagId);        // tambah satu relasi
$post->tags()->detach($tagId);        // hapus satu relasi
$post->tags()->sync([1, 2, 3]);       // set persis jadi tag 1,2,3

Jebakan N+1 dan Eager Loading

Ini masalah performa yang paling sering menimpa pemula. Perhatikan kode ini:

$posts = Post::all();
foreach ($posts as $post) {
    echo $post->user->name;   // 1 query TAMBAHAN per post!
}

Kalau ada 100 post, Laravel menjalankan 1 query untuk post + 100 query untuk user = 101 query. Solusinya eager loading dengan with():

$posts = Post::with('user')->get();   // cukup 2 query total

Selalu pakai with() saat kamu tahu relasi akan diakses di dalam perulangan. Ini salah satu optimasi paling berdampak di aplikasi Laravel.

Pertanyaan yang Sering Diajukan (FAQ)

Kapan pakai hasMany vs belongsTo?

hasMany dipasang di model "induk" (yang memiliki banyak), belongsTo di model "anak" (yang dimiliki). Foreign key selalu ada di tabel milik model belongsTo.

Apa itu tabel pivot?

Tabel perantara pada relasi Many to Many yang menyimpan pasangan foreign key kedua tabel. Laravel menebak namanya dari gabungan dua nama model (urut alfabet), misalnya post_tag.

Bagaimana mengambil data dari tabel pivot?

Tambahkan ->withPivot('kolom') pada definisi relasi, lalu akses lewat $post->tags[0]->pivot->kolom.

Kesimpulan

Eloquent Relationship membuat pengelolaan data antar-tabel jadi jauh lebih ringkas: One to Many dengan hasMany/belongsTo, dan Many to Many dengan belongsToMany + tabel pivot. Jangan lupa gunakan with() untuk menghindari masalah N+1 yang diam-diam memperlambat aplikasi.

Ingin memahami fondasinya lebih dulu? Baca Cara Membuat Relasi Tabel di MySQL dengan Foreign Key dan Cara Membuat Migration dan Seeder di Laravel untuk menyiapkan struktur tabelnya.