Laravel Eloquent Relationship One to Many: Contoh Kode & Implementasi

by

Laravel Eloquent ORM adalah salah satu fitur paling powerful di framework Laravel. Dengan Eloquent, interaksi dengan database menjadi lebih mudah, efisien, dan readable. Salah satu aspek kunci dari Eloquent adalah relationships, dan dalam artikel ini, kita akan membahas secara mendalam tentang Laravel Eloquent Relationship One to Many: Contoh Kode & Implementasi. Kita akan kupas tuntas konsep ini, memberikan contoh kode yang praktis, dan membahas berbagai implementasi yang bisa Anda gunakan dalam proyek Laravel Anda. Siap? Mari kita mulai!

1. Memahami Konsep One-to-Many Relationship di Laravel Eloquent

Sebelum masuk ke contoh kode, penting untuk memahami dasar dari one-to-many relationship. Secara sederhana, relasi ini menggambarkan situasi di mana satu record di satu tabel terhubung dengan banyak record di tabel lain. Ambil contoh sederhana:

  • Satu User (pengguna) bisa memiliki banyak Post (artikel).

Dalam kasus ini, tabel users akan menjadi parent dan tabel posts akan menjadi child. Setiap Post akan memiliki foreign key yang mengacu pada primary key di tabel users. Dengan menggunakan Eloquent, kita bisa dengan mudah mengambil semua Post yang dimiliki oleh seorang User tertentu. Ini adalah fondasi penting untuk membangun aplikasi yang kompleks dan terstruktur.

2. Konfigurasi Database dan Migrasi untuk Relasi One-to-Many

Langkah pertama dalam mengimplementasikan relasi ini adalah memastikan database Anda siap. Kita akan membuat dua tabel: users dan posts. Berikut adalah contoh migration yang bisa Anda gunakan:

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');
    }
};

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'); // Foreign Key
            $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 create_posts_table.php, kita menambahkan kolom user_id yang merupakan foreign key yang mengacu pada kolom id di tabel users. Kode $table->foreign('user_id')->references('id')->on('users')->onDelete('cascade'); penting karena:

  • $table->foreign('user_id'): Menentukan bahwa kolom user_id adalah foreign key.
  • ->references('id'): Menentukan bahwa foreign key ini mengacu pada kolom id di tabel users.
  • ->on('users'): Menentukan bahwa foreign key ini mengacu pada tabel users.
  • ->onDelete('cascade'): Ini sangat penting. Artinya, jika seorang User dihapus, semua Post yang terkait dengan User tersebut juga akan dihapus secara otomatis. Ini membantu menjaga integritas data Anda.

Setelah membuat migration, jalankan perintah php artisan migrate untuk membuat tabel di database Anda.

3. Definisi Relationship di Model Eloquent: User dan Post

Setelah database siap, kita perlu mendefinisikan relationship di model Eloquent. Buat dua model: User dan Post (jika belum ada).

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',
    ];

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

app/Models/Post.php:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsBelongsTo;

class Post extends Model
{
    use HasFactory;

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

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

Perhatikan metode posts() di model User. Metode ini menggunakan hasMany() untuk mendefinisikan relasi one-to-many. Artinya, satu User bisa memiliki banyak Post. Sebaliknya, metode user() di model Post menggunakan belongsTo() untuk mendefinisikan relasi inverse dari one-to-many, yaitu setiap Post belong to (dimiliki oleh) satu User.

4. Contoh Kode: Mengambil Data dengan Eloquent Relationship

Sekarang, mari kita lihat contoh kode untuk mengambil data menggunakan relationship yang sudah kita definisikan.

Mengambil semua Post milik seorang User tertentu:

$user = User::find(1); // Mengambil user dengan ID 1
$posts = $user->posts; // Mengambil semua post milik user tersebut

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

Kode di atas akan mengambil seorang User dengan ID 1, kemudian menggunakan relationship posts untuk mengambil semua Post yang terkait dengan User tersebut. Perhatikan betapa mudahnya! Eloquent menangani query database yang kompleks di balik layar.

Mengambil User yang memiliki Post tertentu:

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

echo $user->name;

Kode di atas akan mengambil sebuah Post dengan ID 1, kemudian menggunakan relationship user untuk mengambil User yang membuat Post tersebut.

5. Eager Loading: Meningkatkan Performa dengan N+1 Problem Prevention

Salah satu masalah umum saat menggunakan Eloquent relationships adalah N+1 problem. Ini terjadi ketika Anda mengambil data dari parent table (misalnya, Users) dan kemudian, dalam loop, mengambil data dari child table (misalnya, Posts) untuk setiap parent record. Ini menghasilkan satu query untuk parent table dan N query untuk child table, di mana N adalah jumlah parent records.

Untuk mengatasi ini, kita bisa menggunakan eager loading. Eager loading memungkinkan kita untuk mengambil data dari related tables dalam satu query, sehingga mengurangi jumlah query yang diperlukan.

Contoh Eager Loading:

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

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

Dengan User::with('posts'), kita memberitahu Eloquent untuk mengambil semua User bersama dengan semua Post yang terkait dengan mereka dalam satu query. Ini secara signifikan meningkatkan performa, terutama jika Anda memiliki banyak record.

6. Lazy Eager Loading: Eager Loading Bersyarat

Terkadang, Anda mungkin hanya ingin menggunakan eager loading dalam kondisi tertentu. Inilah gunanya lazy eager loading. Anda bisa menggunakan lazy eager loading untuk menambahkan relationship ke query yang sudah ada.

Contoh Lazy Eager Loading:

$users = User::all(); // Mengambil semua user tanpa post

// Kondisi tertentu untuk eager loading
if (true) {
    $users = $users->load('posts'); // Eager load posts hanya jika kondisi terpenuhi
}

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

Dalam contoh ini, posts hanya akan di-eager load jika kondisi true terpenuhi. Ini memberikan fleksibilitas lebih dalam mengontrol query Anda.

7. Querying Relationships: Filtering Berdasarkan Data Terkait

Selain mengambil data terkait, Anda juga bisa menggunakan relationships untuk memfilter data. Misalnya, Anda ingin mengambil semua User yang memiliki setidaknya satu Post.

Contoh Querying Relationships (Has):

$users = User::has('posts')->get(); // Mengambil semua user yang memiliki minimal 1 post

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

Metode has('posts') akan memfilter User hanya yang memiliki setidaknya satu Post yang terkait dengan mereka.

Contoh Querying Relationships (WhereHas):

Anda juga bisa menambahkan kondisi pada relationship. Misalnya, Anda ingin mengambil semua User yang memiliki setidaknya satu Post dengan judul yang mengandung kata “Laravel”.

$users = User::whereHas('posts', function ($query) {
    $query->where('title', 'like', '%Laravel%');
})->get();

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

Metode whereHas('posts', function ($query) { ... }) memungkinkan Anda untuk menambahkan kondisi where pada query yang terkait dengan relationship posts.

8. Insert dan Update Data Melalui Relationship

Eloquent juga memudahkan untuk menyimpan dan memperbarui data melalui relationships.

Membuat Post baru untuk seorang User:

$user = User::find(1);

$post = new Post([
    'title' => 'Post Baru dari User 1',
    'content' => 'Isi post baru ini...'
]);

$user->posts()->save($post); // Menyimpan post melalui relationship

Metode posts() mengembalikan query builder yang memungkinkan kita untuk menggunakan metode save() untuk menyimpan Post baru. Eloquent akan secara otomatis mengisi kolom user_id dengan ID User yang terkait.

Membuat beberapa Post sekaligus:

$user = User::find(1);

$posts = [
    ['title' => 'Post 1', 'content' => 'Isi post 1'],
    ['title' => 'Post 2', 'content' => 'Isi post 2'],
];

$user->posts()->createMany($posts);

Metode createMany() memungkinkan Anda untuk membuat beberapa Post sekaligus.

9. Menggunakan withCount() untuk Mendapatkan Jumlah Data Terkait

Seringkali, Anda mungkin perlu mendapatkan jumlah record terkait tanpa harus mengambil semua data. Eloquent menyediakan metode withCount() untuk melakukan ini secara efisien.

Contoh Menggunakan withCount():

$users = User::withCount('posts')->get(); // Mengambil semua user beserta jumlah post mereka

foreach ($users as $user) {
    echo $user->name . " (Jumlah Post: " . $user->posts_count . ")<br>";
}

Dengan User::withCount('posts'), Eloquent akan menambahkan atribut posts_count ke setiap User, yang berisi jumlah Post yang terkait dengan User tersebut.

10. Custom Foreign Keys dan Local Keys

Secara default, Eloquent mengasumsikan bahwa foreign key adalah nama tabel yang di-singularize diikuti dengan _id (misalnya, user_id untuk tabel users). Namun, Anda bisa mengubah ini jika diperlukan.

Contoh Custom Foreign Key:

public function posts(): HasMany
{
    return $this->hasMany(Post::class, 'author_id'); // Menggunakan 'author_id' sebagai foreign key
}

Dalam contoh ini, kita memberitahu Eloquent bahwa foreign key untuk relationship posts adalah author_id, bukan user_id.

Contoh Custom Local Key:

Anda juga bisa mengubah local key (primary key tabel parent) yang digunakan dalam relationship.

public function posts(): HasMany
{
    return $this->hasMany(Post::class, 'author_id', 'custom_id'); // Menggunakan 'custom_id' sebagai local key
}

Dalam contoh ini, kita memberitahu Eloquent bahwa local key untuk relationship posts adalah custom_id, bukan id.

11. Polymorphic Relationships: One-to-Many Relasi yang Lebih Fleksibel

Walaupun artikel ini fokus pada one-to-many relationship standar, penting untuk mengetahui bahwa ada konsep yang lebih fleksibel yang disebut polymorphic relationships. Dengan polymorphic relationships, satu model dapat berhubungan dengan banyak model lain melalui satu interface. Ini berguna jika Anda memiliki situasi di mana model yang sama (misalnya, Comment) dapat terkait dengan berbagai jenis model lain (misalnya, Post, Video, Article). Ini adalah topik yang lebih lanjut, tetapi penting untuk Anda ketahui sebagai opsi.

12. Kesimpulan: Menguasai One-to-Many Relationship di Laravel Eloquent

Laravel Eloquent Relationship One to Many: Contoh Kode & Implementasi adalah fondasi penting dalam pengembangan aplikasi Laravel. Dengan memahami konsep dan implementasi yang telah kita bahas, Anda akan dapat membangun aplikasi yang lebih terstruktur, efisien, dan maintainable. Ingatlah untuk selalu memperhatikan performa, terutama dengan menggunakan eager loading untuk menghindari N+1 problem. Teruslah berlatih dan bereksperimen dengan berbagai contoh kode yang ada. Selamat mencoba!