Laravel 13 #9: Relasi Eloquent One to Many & Many to Many

Relasi database adalah jantung dari aplikasi yang serius. Tanpa pemahaman yang solid tentang bagaimana tabel-tabel terhubung, kamu akan terjebak menulis query SQL yang kompleks dan sulit di-maintain.

Series "Belajar Laravel 13 dari Nol sampai Deploy" kamu sudah capai milestone penting di episode #6 tentang Eloquent ORM dan Migration. Sekarang, kita akan menggunakan pengetahuan itu untuk memahami relasi yang membuat data aplikasi benar-benar hidup.

Mengapa Kamu Butuh Memahami Relasi Database?

Bayangkan aplikasi blog sederhana: satu user bisa menulis banyak post, dan satu post bisa ditag dengan banyak kategori. Tanpa relasi yang benar, kamu akan:

• Menyimpan user_id berulang di tabel posts (redundansi data)
• Menulis JOIN query yang panjang hanya untuk ambil posts beserta author-nya
• Kesulitan ketika butuh update nama author — harus jaga konsistensi di multiple rows
• Performa query akan menurun seiring pertambuhan data

Dengan Eloquent relationship, semua itu menjadi sederhana. Kamu cukup menulis $user->posts() dan Laravel otomatis handle query di belakang layar.

One to Many: User dan Posts

One to Many adalah relasi paling umum. Artinya: satu record di tabel A punya banyak record di tabel B. Contohnya, satu user punya banyak posts.

Setup Database

Pertama, buat migration untuk tabel posts jika belum ada:

php artisan make:migration create_posts_table

Di file migration, definisikan foreign key ke tabel users:

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

Clause constrained() secara otomatis mereferensi tabel users dan kolom id. onDelete('cascade') berarti jika user dihapus, semua posts-nya juga otomatis terhapus.

Model Relationship

Sekarang, di model User.php, definisikan relasi ke posts:

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

Metode hasMany() mengatakan: "User ini punya banyak posts." Laravel secara otomatis mencari foreign key user_id di tabel posts.

Menggunakan Relationship

Sekarang kamu bisa akses posts user seperti ini:

$user = User::find(1);
$posts = $user->posts; // Akses sebagai property
$posts = $user->posts()->get(); // Atau panggil sebagai method

Kode di atas jauh lebih bersih daripada: Post::where('user_id', 1)->get()

Inverse Relationship: belongsTo

Sekarang kita lihat dari sisi Post. Satu post punya satu author (user). Di model Post.php, gunakan belongsTo():

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

Sekarang kamu bisa akses author dari post:

$post = Post::find(1);
echo $post->author->name; // "Budi Santoso"

Hubungan ini adalah "inverse" dari hasMany — kebalikan arah. Jika dari User ke Posts adalah "punya banyak", maka dari Post ke User adalah "punya satu" atau "milik dari".

Many to Many: Posts dan Tags

Relasi Many to Many lebih kompleks: satu post bisa punya banyak tags, dan satu tag bisa dipakai di banyak posts. Untuk ini, kita butuh tabel pivot (perantara).

Setup Pivot Table

Pertama, buat tabel tags:

php artisan make:migration create_tags_table

Lalu, buat tabel pivot post_tag (nama harus alphabetical):

php artisan make:migration create_post_tag_table

Di tabel pivot, letakkan foreign keys ke kedua tabel:

Schema::create('post_tag', function (Blueprint $table) {
    $table->id();
    $table->foreignId('post_id')->constrained()->onDelete('cascade');
    $table->foreignId('tag_id')->constrained()->onDelete('cascade');
    $table->timestamps();
});

Model Relationship untuk Many to Many

Di model Post.php, tambahkan relasi:

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

Dan di model Tag.php:

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

Sekarang kamu bisa akses tags dari post, dan posts dari tag:

$post = Post::find(1);
foreach ($post->tags as $tag) {
    echo $tag->name; // "Laravel", "Database", dll
}

$tag = Tag::find(1);
$posts = $tag->posts; // Semua posts dengan tag ini

Eager Loading vs Lazy Loading

Sekarang kita masuk ke konsep penting: N+1 query problem. Bayangkan kamu punya 100 posts dan ingin tampilkan author setiap post:

$posts = Post::all(); // 1 query
foreach ($posts as $post) {
    echo $post->author->name; // 100 queries! Total 101.
}

Ini disebut "lazy loading" — data relasi dimuat saat diakses. Untuk menghindarinya, gunakan with() (eager loading):

$posts = Post::with('author')->get(); // 2 queries total
foreach ($posts as $post) {
    echo $post->author->name; // Sudah di-cache
}

Dengan eager loading, hanya 2 queries dijalankan: satu untuk posts, satu untuk authors. Jauh lebih efisien!

Jika ingin load multiple relations:

$posts = Post::with('author', 'tags')->get();

Latihan: Tampilkan Posts Beserta Author dan Tags

Mari kita gabungkan semua yang sudah dipelajari. Buat controller untuk menampilkan daftar posts:

class PostController extends Controller {
    public function index() {
        $posts = Post::with('author', 'tags')->paginate(10);
        return view('posts.index', compact('posts'));
    }
}

Di view Blade:

@foreach ($posts as $post)
    

        
{{ $post->title }}
        
By {{ $post->author->name }}
        
{{ $post->content }}
        

            @foreach ($post->tags as $tag)
                {{ $tag->name }}
            @endforeach
        
    
@endforeach

Simple, elegant, dan efficient — ini adalah power Eloquent relationship!

Tips Praktis

• Naming Convention: Gunakan singular untuk nama method relationship (author, bukan authors) dan plural untuk collection
• Constraint Query: Kamu bisa chain where() pada relationship: $user->posts()->where('published', true)->get()
• Load Related Models Secara Selective: Gunakan loadMissing() untuk eager load hanya jika belum di-cache
• Pelajari ER Model: Pahami Entity-Relationship Model sebelum design database

Kesimpulan

Relasi database di Laravel dengan Eloquent adalah game-changer. One to Many dan Many to Many adalah dua jenis relasi paling sering digunakan, dan dengan memahami keduanya, kamu sudah bisa handle 80% use case di aplikasi real-world.

Key points yang harus kamu ingat: hasMany untuk "punya banyak", belongsTo untuk "milik dari", belongsToMany untuk many-to-many, dan selalu gunakan eager loading dengan with() untuk menghindari N+1 problem. Untuk eksplorasi lebih lanjut, baca dokumentasi resmi Eloquent Relationships di Laravel docs.

Di episode #10, kita akan membahas advanced topics seperti polymorphic relationships dan relationship caching. Stay tuned, dan jangan lupa praktik dengan membuat model-model sendiri!