Belajar Laravel Eloquent Relationship dengan Contoh: Relasi Database yang Efektif

by

Laravel, framework PHP yang terkenal dengan elegansi dan kemudahannya, menawarkan fitur Eloquent ORM yang sangat memudahkan interaksi dengan database. Salah satu kekuatan Eloquent terletak pada kemampuannya untuk mendefinisikan relationship atau relasi antar tabel database dengan cara yang intuitif dan mudah dipahami. Artikel ini akan menjadi panduan lengkap untuk belajar Laravel Eloquent relationship dengan contoh, sehingga Anda dapat membangun relasi database yang efektif dan efisien. Siap menyelami dunia relasi database di Laravel? Mari kita mulai!

1. Pengantar Eloquent Relationship: Memahami Dasar Relasi Database di Laravel

Sebelum kita terjun ke kode, penting untuk memahami konsep dasar relasi database. Dalam database relasional, tabel-tabel seringkali saling terhubung melalui foreign key. Eloquent Relationship di Laravel membantu kita mendefinisikan dan memanfaatkan hubungan ini dengan mudah, tanpa perlu menulis query SQL yang rumit. Eloquent memungkinkan Anda berinteraksi dengan relasi ini seolah-olah mereka adalah properti objek PHP.

Relasi yang paling umum adalah:

  • One to One (Satu ke Satu): Satu baris di tabel A terhubung ke satu baris di tabel B. Contoh: Seorang user memiliki satu profile.
  • One to Many (Satu ke Banyak): Satu baris di tabel A terhubung ke banyak baris di tabel B. Contoh: Seorang author memiliki banyak postingan blog.
  • Many to One (Banyak ke Satu): Kebalikan dari One to Many. Banyak baris di tabel A terhubung ke satu baris di tabel B. Contoh: Banyak postingan blog dimiliki oleh satu author.
  • Many to Many (Banyak ke Banyak): Banyak baris di tabel A terhubung ke banyak baris di tabel B melalui tabel pivot. Contoh: Seorang siswa mengambil banyak mata kuliah, dan satu mata kuliah diambil oleh banyak siswa.
  • Has One Through (Satu Melalui): Akses relasi one-to-one melalui relasi perantara.
  • Has Many Through (Banyak Melalui): Akses relasi one-to-many melalui relasi perantara.
  • Polymorphic Relations (Relasi Polimorfik): Memungkinkan sebuah model untuk terhubung ke lebih dari satu model lain dalam satu relasi.

Dengan memahami jenis-jenis relasi ini, Anda akan lebih mudah mendesain database dan mengimplementasikan relasi di Laravel.

2. Setup Awal: Membuat Model dan Migrasi untuk Contoh Relasi

Untuk demonstrasi, mari kita buat contoh sederhana dengan tabel users dan posts. Kita akan membuat relasi One to Many (Satu ke Banyak) antara User dan Post (seorang user bisa memiliki banyak postingan).

Langkah 1: Membuat Model User dan Post

Jalankan perintah berikut di terminal Anda:

php artisan make:model User
php artisan make:model Post

Perintah ini akan membuat file app/Models/User.php dan app/Models/Post.php.

Langkah 2: Membuat Migrasi untuk Tabel users dan posts

Jalankan perintah berikut:

php artisan make:migration create_users_table --create=users
php artisan make:migration create_posts_table --create=posts

Perintah ini akan membuat file migrasi di folder database/migrations. Edit file migrasi tersebut untuk mendefinisikan struktur tabel.

File database/migrations/[timestamp]_create_users_table.php:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('users');
    }
};

File database/migrations/[timestamp]_create_posts_table.php:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');
            $table->string('title');
            $table->text('content');
            $table->timestamps();

            $table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('posts');
    }
};

Perhatikan pada tabel posts, kita menambahkan kolom user_id sebagai foreign key yang merujuk ke id pada tabel users. onDelete('cascade') memastikan bahwa jika seorang user dihapus, semua postingannya juga akan terhapus.

Langkah 3: Menjalankan Migrasi

Jalankan perintah berikut untuk membuat tabel di database Anda:

php artisan migrate

Pastikan Anda telah mengkonfigurasi koneksi database di file .env Anda.

3. One to Many Relationship: User dan Postingan

Sekarang kita akan mendefinisikan relasi One to Many antara model User dan Post.

Di dalam app/Models/User.php:

<?php

namespace AppModels;

use IlluminateContractsAuthMustVerifyEmail;
use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateFoundationAuthUser as Authenticatable;
use IlluminateNotificationsNotifiable;
use LaravelSanctumHasApiTokens;
use IlluminateDatabaseEloquentRelationsHasMany;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

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

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * The attributes that should be cast.
     *
     * @var array<string, string>
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
        'password' => 'hashed',
    ];

    /**
     * Get all of the posts for the User
     *
     * @return IlluminateDatabaseEloquentRelationsHasMany
     */
    public function posts(): HasMany
    {
        return $this->hasMany(Post::class);
    }
}

Kita menambahkan method posts() yang menggunakan relasi hasMany(). Ini menunjukkan bahwa seorang user memiliki banyak postingan.

Di dalam app/Models/Post.php:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsBelongsTo;

class Post extends Model
{
    use HasFactory;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'title',
        'content',
        'user_id',
    ];

    /**
     * Get the user that owns the Post
     *
     * @return IlluminateDatabaseEloquentRelationsBelongsTo
     */
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

Kita menambahkan method user() yang menggunakan relasi belongsTo(). Ini menunjukkan bahwa sebuah postingan dimiliki oleh seorang user.

4. Menggunakan Relasi: Mengakses Data Terkait

Sekarang setelah kita mendefinisikan relasi, mari kita lihat cara mengakses data terkait.

Contoh 1: Mendapatkan semua postingan seorang user

$user = User::find(1); // Mendapatkan user dengan ID 1
$posts = $user->posts; // Mengakses semua postingan user tersebut

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

Kode ini akan mengambil user dengan ID 1 dan kemudian mengakses semua postingannya melalui properti $user->posts. Eloquent akan secara otomatis menjalankan query yang sesuai untuk mengambil postingan yang terkait dengan user tersebut.

Contoh 2: Mendapatkan user yang memiliki sebuah postingan

$post = Post::find(1); // Mendapatkan postingan dengan ID 1
$user = $post->user; // Mengakses user yang memiliki postingan tersebut

echo $user->name;

Kode ini akan mengambil postingan dengan ID 1 dan kemudian mengakses user yang memilikinya melalui properti $post->user.

Eager Loading: Meningkatkan Performa dengan Mengurangi Jumlah Query

Secara default, Eloquent akan menjalankan query terpisah setiap kali Anda mengakses relasi. Ini bisa menyebabkan masalah performa jika Anda perlu mengakses relasi untuk banyak model. Solusinya adalah eager loading.

Contoh Eager Loading:

$users = User::with('posts')->get(); // Mengambil semua user dengan postingan mereka

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

User::with('posts')->get() akan mengambil semua user dan postingan mereka dalam satu query, mengurangi jumlah query yang dijalankan dan meningkatkan performa.

5. Relasi Many to Many: Siswa dan Mata Kuliah

Mari kita implementasikan relasi Many to Many antara Student dan Course. Pertama, kita perlu membuat model dan migrasi untuk Student dan Course, serta tabel pivot untuk menghubungkan keduanya.

Langkah 1: Membuat Model Student dan Course

php artisan make:model Student
php artisan make:model Course

Langkah 2: Membuat Migrasi untuk Tabel students, courses, dan course_student

php artisan make:migration create_students_table --create=students
php artisan make:migration create_courses_table --create=courses
php artisan make:migration create_course_student_table --create=course_student

File database/migrations/[timestamp]_create_students_table.php:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('students', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('students');
    }
};

File database/migrations/[timestamp]_create_courses_table.php:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('courses', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('description');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('courses');
    }
};

File database/migrations/[timestamp]_create_course_student_table.php:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('course_student', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('course_id');
            $table->unsignedBigInteger('student_id');
            $table->timestamps();

            $table->foreign('course_id')->references('id')->on('courses')->onDelete('cascade');
            $table->foreign('student_id')->references('id')->on('students')->onDelete('cascade');
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('course_student');
    }
};

Perhatikan bahwa nama tabel pivot adalah course_student, yang merupakan gabungan dari nama tabel dalam urutan abjad. Anda bisa mengubah nama ini jika mau, tetapi Anda harus menentukan nama tabel secara eksplisit dalam definisi relasi.

Langkah 3: Mendefinisikan Relasi di Model Student dan Course

Di dalam app/Models/Student.php:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsBelongsToMany;

class Student extends Model
{
    use HasFactory;

    protected $fillable = ['name', 'email'];

    /**
     * The courses that belong to the Student
     *
     * @return IlluminateDatabaseEloquentRelationsBelongsToMany
     */
    public function courses(): BelongsToMany
    {
        return $this->belongsToMany(Course::class);
    }
}

Di dalam app/Models/Course.php:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsBelongsToMany;

class Course extends Model
{
    use HasFactory;

    protected $fillable = ['name', 'description'];

    /**
     * The students that belong to the Course
     *
     * @return IlluminateDatabaseEloquentRelationsBelongsToMany
     */
    public function students(): BelongsToMany
    {
        return $this->belongsToMany(Student::class);
    }
}

Kita menggunakan belongsToMany() untuk mendefinisikan relasi Many to Many. Secara default, Eloquent akan menggunakan tabel pivot yang namanya sesuai dengan konvensi (nama tabel dalam urutan abjad).

Langkah 4: Menjalankan Migrasi

php artisan migrate

Langkah 5: Menggunakan Relasi Many to Many

// Mendapatkan semua mata kuliah yang diambil oleh seorang siswa
$student = Student::find(1);
$courses = $student->courses;

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

// Mendapatkan semua siswa yang mengambil sebuah mata kuliah
$course = Course::find(1);
$students = $course->students;

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

// Menambahkan siswa ke mata kuliah
$student = Student::find(1);
$course = Course::find(2);
$student->courses()->attach($course->id);

// Melepas siswa dari mata kuliah
$student = Student::find(1);
$course = Course::find(2);
$student->courses()->detach($course->id);

// Menyinkronkan daftar mata kuliah siswa (menghapus yang lama dan menambahkan yang baru)
$student = Student::find(1);
$courseIds = [1, 3, 4]; // ID mata kuliah yang ingin disinkronkan
$student->courses()->sync($courseIds);

attach() digunakan untuk menambahkan relasi, detach() untuk menghapus relasi, dan sync() untuk menyinkronkan relasi. sync() akan menghapus semua relasi yang ada dan menggantinya dengan yang baru.

6. Relasi Polymorphic: Komentar dan Postingan/Video

Relasi polimorfik memungkinkan sebuah model untuk terhubung ke lebih dari satu model lain dalam satu relasi. Contohnya, kita ingin membuat sistem komentar yang bisa digunakan untuk postingan dan video.

Langkah 1: Membuat Model Comment, Post, dan Video (Jika Belum Ada)

Kita sudah memiliki model Post. Mari kita buat model Video dan Comment.

php artisan make:model Video
php artisan make:model Comment

Langkah 2: Membuat Migrasi untuk Tabel videos dan comments

php artisan make:migration create_videos_table --create=videos
php artisan make:migration create_comments_table --create=comments

File database/migrations/[timestamp]_create_videos_table.php:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('videos', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->text('description');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('videos');
    }
};

File database/migrations/[timestamp]_create_comments_table.php:

<?php

use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('comments', function (Blueprint $table) {
            $table->id();
            $table->text('body');
            $table->morphs('commentable'); // Penting: Menambahkan kolom polimorfik
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('comments');
    }
};

Perhatikan penggunaan morphs('commentable') di tabel comments. Ini akan membuat dua kolom: commentable_id dan commentable_type. commentable_id akan menyimpan ID dari model yang dikomentari (misalnya, ID postingan atau ID video), dan commentable_type akan menyimpan nama kelas model (misalnya, AppModelsPost atau AppModelsVideo).

Langkah 3: Mendefinisikan Relasi Polimorfik di Model Comment, Post, dan Video

Di dalam app/Models/Comment.php:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsMorphTo;

class Comment extends Model
{
    use HasFactory;

    protected $fillable = ['body', 'commentable_id', 'commentable_type'];

    /**
     * Get the parent commentable model (post or video).
     *
     * @return IlluminateDatabaseEloquentRelationsMorphTo
     */
    public function commentable(): MorphTo
    {
        return $this->morphTo();
    }
}

Di dalam app/Models/Post.php:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsMorphMany;

class Post extends Model
{
    use HasFactory;

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

    /**
     * Get all of the comments for the Post
     *
     * @return IlluminateDatabaseEloquentRelationsMorphMany
     */
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Di dalam app/Models/Video.php:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsMorphMany;

class Video extends Model
{
    use HasFactory;

    protected $fillable = ['title', 'description'];

    /**
     * Get all of the comments for the Video
     *
     * @return IlluminateDatabaseEloquentRelationsMorphMany
     */
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Kita menggunakan morphTo() di model Comment dan morphMany() di model Post dan Video. Parameter kedua pada morphMany() adalah nama relasi (dalam kasus ini, commentable).

Langkah 4: Menjalankan Migrasi

php artisan migrate

Langkah 5: Menggunakan Relasi Polimorfik

// Mendapatkan semua komentar untuk sebuah postingan
$post = Post::find(1);
$comments = $post->comments;

foreach ($comments as $comment) {
    echo $comment->body . "<br>";
}

// Mendapatkan semua komentar untuk sebuah video
$video = Video::find(1);
$comments = $video->comments;

foreach ($comments as $comment) {
    echo $comment->body . "<br>";
}

// Membuat komentar untuk sebuah postingan
$post = Post::find(1);
$comment = new Comment(['body' => 'Komentar untuk postingan ini.']);
$post->comments()->save($comment);

// Membuat komentar untuk sebuah video
$video = Video::find(1);
$comment = new Comment(['body' => 'Komentar untuk video ini.']);
$video->comments()->save($comment);

7. Tips dan Trik: Optimasi dan Praktik Terbaik dalam Eloquent Relationship

Berikut beberapa tips dan trik untuk memaksimalkan penggunaan Eloquent Relationship:

  • Gunakan Eager Loading secara Bijak: Eager loading sangat penting untuk performa, tetapi jangan berlebihan. Hanya lakukan eager loading jika Anda benar-benar membutuhkan data relasi. Gunakan with() atau load() untuk melakukan eager loading.

  • Lazy Eager Loading: Jika Anda tidak tahu apakah Anda akan membutuhkan relasi saat pertama kali mengambil model, Anda bisa menggunakan lazy eager loading.

    $users = User::all();

foreach ($users as $user) {
    if ($someCondition) {
        $user->load('posts'); // Lazy eager loading
    }
    // ...
}

  • Constraining Eager Loads: Anda dapat membatasi query saat melakukan eager loading.

    $users = User::with(['posts' => function ($query) {
    $query->where('published', true);
}])->get();

    Ini hanya akan mengambil postingan yang sudah dipublikasikan.

  • Morph To Many Relationships: Eloquent mendukung relasi morph to many, yang memungkinkan banyak model untuk terhubung ke banyak model lain melalui tabel pivot. Ini berguna untuk membuat sistem tag atau kategori yang fleksibel.

  • Indeks Database: Pastikan Anda memiliki indeks yang tepat pada foreign key dan kolom lain yang sering Anda gunakan dalam query relasi. Ini akan mempercepat query Anda secara signifikan.

  • Gunakan has() dan whereHas() untuk Memfilter Hasil: has() memungkinkan Anda memeriksa apakah sebuah model memiliki relasi. whereHas() memungkinkan Anda memfilter hasil berdasarkan kondisi pada relasi.

    // Mendapatkan semua user yang memiliki setidaknya satu postingan
$users = User::has('posts')->get();

// Mendapatkan semua user yang memiliki postingan dengan judul tertentu
$users = User::whereHas('posts', function ($query) {
    $query->where('title', 'Judul Postingan');
})->get();

  • Definisikan Inverse Relationship: Selalu definisikan relasi invers (misalnya, belongsTo() di model Post jika Anda sudah mendefinisikan hasMany() di model User). Ini akan memudahkan Anda mengakses data dari kedua sisi relasi.

  • Gunakan Relasi untuk Validasi: Anda dapat menggunakan relasi untuk melakukan validasi. Misalnya, Anda bisa memastikan bahwa user_id yang diberikan ada di tabel users sebelum membuat postingan baru.

  • Eloquent Event: Manfaatkan Eloquent event (seperti creating, created, updating, updated, deleting, deleted) untuk melakukan tindakan otomatis saat model diubah. Anda bisa menggunakan ini untuk memperbarui data relasi, mengirim notifikasi, atau melakukan tugas lain yang relevan.

8. Kesimpulan: Menguasai Relasi Database dengan Laravel Eloquent

Dengan belajar Laravel Eloquent relationship dengan contoh yang telah kita bahas, Anda sekarang memiliki dasar yang kuat untuk mengelola relasi database dengan efektif di aplikasi Laravel Anda. Ingatlah untuk selalu mempertimbangkan jenis relasi yang paling sesuai dengan kebutuhan aplikasi Anda, dan gunakan fitur-fitur seperti eager loading dan constraining eager loads untuk mengoptimalkan performa. Dengan praktik yang konsisten, Anda akan semakin mahir dalam menguasai Eloquent Relationship dan membangun aplikasi Laravel yang lebih efisien dan terstruktur. Selamat mencoba dan terus eksplorasi!

9. Sumber Daya Tambahan: Memperdalam Pengetahuan Anda

Berikut beberapa sumber daya tambahan yang bisa Anda gunakan untuk memperdalam pengetahuan Anda tentang Eloquent Relationship:

  • Dokumentasi Resmi Laravel: https://laravel.com/docs/eloquent-relationships (Sumber utama dan paling akurat)
  • Laracasts: https://laracasts.com/ (Berbagai tutorial video tentang Laravel, termasuk Eloquent Relationship)
  • Blog dan Artikel Online: Cari artikel dan tutorial tentang Eloquent Relationship di berbagai blog dan situs web pengembangan web. Pastikan untuk memilih sumber yang terpercaya dan terbaru.
  • Stack Overflow: https://stackoverflow.com/ (Tempat yang bagus untuk bertanya dan mencari solusi untuk masalah spesifik)

Jangan ragu untuk bereksperimen dengan kode, mencoba berbagai jenis relasi, dan menerapkan tips dan trik yang telah kita bahas. Semakin banyak Anda berlatih, semakin cepat Anda akan menguasai Eloquent Relationship dan menjadi pengembang Laravel yang lebih handal.