# Belajar Laravel Eloquent ORM: Interaksi Database Lebih Mudah & Efisien

Laravel, framework PHP yang populer, menawarkan berbagai fitur yang memudahkan pengembangan aplikasi web. Salah satu fitur andalannya adalah Eloquent ORM (Object Relational Mapper), yang membuat interaksi dengan database menjadi jauh lebih mudah dan efisien. Artikel ini akan memandu Anda dalam **belajar Laravel Eloquent ORM** secara komprehensif, mulai dari dasar hingga penggunaan yang lebih lanjut. Siap? Mari kita mulai!

## Apa Itu Eloquent ORM dan Mengapa Penting dalam Laravel?

Eloquent ORM adalah implementasi ActiveRecord untuk bekerja dengan database. Sederhananya, Eloquent memungkinkan Anda berinteraksi dengan tabel database Anda sebagai objek PHP. Bayangkan memiliki representasi PHP dari setiap baris dalam tabel Anda. Anda bisa memanipulasi data tersebut menggunakan metode-metode yang disediakan oleh Eloquent.

**Mengapa Eloquent penting?**

*   **Kemudahan Penggunaan:** Eloquent menyediakan sintaks yang sederhana dan intuitif, sehingga mengurangi kompleksitas dalam query database.
*   **Keamanan:** Eloquent membantu mencegah SQL Injection dengan menggunakan parameter binding secara otomatis.
*   **Maintainability:** Kode yang lebih bersih dan terstruktur dengan Eloquent memudahkan pemeliharaan dan pengembangan aplikasi.
*   **Abstraksi Database:** Eloquent memungkinkan Anda mengganti database backend tanpa mengubah kode aplikasi secara signifikan. Ini karena Eloquent menyediakan abstraksi dari sistem manajemen basis data (DBMS) yang mendasarinya.
*   **Relasi Database:** Eloquent mempermudah definisi dan pengelolaan relasi antar tabel (one-to-one, one-to-many, many-to-many).

## Konfigurasi Database di Laravel untuk Eloquent

Sebelum mulai menggunakan Eloquent, pastikan konfigurasi database Anda sudah benar. Buka file `.env` di root direktori proyek Laravel Anda dan sesuaikan nilai-nilai berikut:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nama_database_anda
DB_USERNAME=username_database_anda
DB_PASSWORD=password_database_anda

Pastikan `DB_CONNECTION` sesuai dengan database yang Anda gunakan (misalnya, `mysql`, `pgsql`, `sqlite`). Setelah mengubah file `.env`, jangan lupa untuk menjalankan perintah `php artisan config:cache` untuk memperbarui konfigurasi aplikasi.

## Membuat Model Eloquent: Representasi Tabel Database

Setiap model Eloquent mewakili sebuah tabel di database Anda. Untuk membuat model baru, Anda bisa menggunakan Artisan command:

```bash
php artisan make:model NamaModel

Misalnya, untuk tabel users, Anda bisa membuat model User dengan perintah:

php artisan make:model User

Ini akan membuat file User.php di direktori app/Models. Buka file tersebut dan Anda akan melihat struktur dasar model Eloquent:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class User extends Model
{
    use HasFactory;
}

Secara default, Eloquent akan menganggap nama tabel adalah bentuk plural dari nama model (misalnya, User akan diasumsikan sebagai tabel users). Jika Anda ingin menggunakan nama tabel yang berbeda, Anda bisa mendefinisikannya dalam properti $table:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class User extends Model
{
    use HasFactory;

    protected $table = 'my_users'; // Menentukan nama tabel
}

Menggunakan Eloquent untuk CRUD (Create, Read, Update, Delete)

Eloquent menyediakan metode-metode yang mudah digunakan untuk melakukan operasi CRUD pada database. Mari kita lihat contohnya:

• Create (Membuat Data Baru):

// Metode 1: Menggunakan new Model() dan save()
$user = new User();
$user->name = 'John Doe';
$user->email = '[email protected]';
$user->password = bcrypt('password'); // Enkripsi password
$user->save();

// Metode 2: Menggunakan create()
$user = User::create([
    'name' => 'Jane Doe',
    'email' => '[email protected]',
    'password' => bcrypt('password'),
]);

Perhatikan penggunaan fungsi bcrypt() untuk mengenkripsi password. Sangat penting untuk selalu mengenkripsi password sebelum menyimpannya ke database. Pastikan properti $fillable di model Anda telah didefinisikan. Properti ini mendefinisikan kolom mana saja yang boleh diisi melalui metode create() atau update(). Contoh:

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

• Read (Membaca Data):

// Mengambil semua data
$users = User::all();

// Mengambil data berdasarkan ID
$user = User::find(1);

// Mengambil data berdasarkan kriteria (menggunakan where)
$users = User::where('name', 'like', '%Doe%')->get();

// Mengambil data berdasarkan kriteria (menggunakan first)
$user = User::where('email', '[email protected]')->first();

// Mengambil data dengan pagination
$users = User::paginate(10); // Menampilkan 10 data per halaman

Metode get() mengembalikan Collection dari hasil query. Metode first() mengembalikan satu instance model yang pertama kali cocok dengan kriteria. Metode find() secara otomatis mencari data berdasarkan primary key (biasanya kolom id).

• Update (Memperbarui Data):

// Metode 1: Menggunakan find() dan save()
$user = User::find(1);
$user->name = 'John Smith';
$user->save();

// Metode 2: Menggunakan update()
User::where('id', 1)->update(['email' => '[email protected]']);

Pastikan properti $fillable di model Anda telah didefinisikan untuk mengizinkan update massal menggunakan update().

• Delete (Menghapus Data):

// Metode 1: Menggunakan find() dan delete()
$user = User::find(1);
$user->delete();

// Metode 2: Menggunakan destroy()
User::destroy(1);

// Metode 3: Menghapus berdasarkan kriteria
User::where('email', '[email protected]')->delete();

Eloquent Relationships: Mengelola Relasi Antar Tabel

Salah satu kekuatan utama Eloquent adalah kemampuannya untuk mendefinisikan dan mengelola relasi antar tabel dengan mudah. Eloquent mendukung berbagai jenis relasi:

• One To One: Satu record di tabel A berelasi dengan satu record di tabel B. Contoh: Seorang pengguna (User) memiliki satu profil (Profile).

  // Model User
  public function profile()
  {
      return $this->hasOne(Profile::class);
  }
  
  // Model Profile
  public function user()
  {
      return $this->belongsTo(User::class);
  }
  
  // Penggunaan
  $user = User::find(1);
  $profile = $user->profile; // Mengakses profil pengguna
  $user = $profile->user; // Mengakses user dari profile

• One To Many: Satu record di tabel A berelasi dengan banyak record di tabel B. Contoh: Seorang penulis (Author) memiliki banyak buku (Book).

  // Model Author
  public function books()
  {
      return $this->hasMany(Book::class);
  }
  
  // Model Book
  public function author()
  {
      return $this->belongsTo(Author::class);
  }
  
  // Penggunaan
  $author = Author::find(1);
  $books = $author->books; // Mengakses semua buku penulis
  $author = $book->author; // Mengakses author dari book

• Many To Many: Banyak record di tabel A berelasi dengan banyak record di tabel B melalui tabel pivot. Contoh: Seorang siswa (Student) dapat mengikuti banyak kursus (Course), dan sebuah kursus dapat diikuti oleh banyak siswa.

  // Model Student
  public function courses()
  {
      return $this->belongsToMany(Course::class);
  }
  
  // Model Course
  public function students()
  {
      return $this->belongsToMany(Student::class);
  }
  
  // Penggunaan
  $student = Student::find(1);
  $courses = $student->courses; // Mengakses semua kursus yang diikuti siswa
  $students = $course->students; // Mengakses semua siswa yang mengikuti kursus

  Pada relasi belongsToMany, Eloquent secara default akan mencari tabel pivot dengan nama gabungan dari nama model dalam urutan abjad (misalnya, course_student). Anda bisa menentukan nama tabel pivot secara eksplisit dengan menambahkan argumen kedua pada metode belongsToMany:

  public function courses()
  {
      return $this->belongsToMany(Course::class, 'enrollments');
  }

  Selain itu, Anda juga bisa menambahkan kolom tambahan pada tabel pivot menggunakan metode withPivot:

  public function courses()
  {
      return $this->belongsToMany(Course::class)->withPivot('enrollment_date', 'grade');
  }

  Anda kemudian dapat mengakses kolom-kolom ini melalui properti pivot pada model yang terhubung:

  $student = Student::find(1);
  foreach ($student->courses as $course) {
      echo $course->pivot->enrollment_date;
      echo $course->pivot->grade;
  }

• Has One Through: Menyediakan cara mudah untuk mengakses relasi yang dalam melalui relasi perantara. Contoh: Sebuah negara (Country) memiliki satu pemimpin (Leader) melalui tabel penduduk (Population).

  // Model Country
  public function leader()
  {
      return $this->hasOneThrough(Leader::class, Population::class);
  }

• Has Many Through: Menyediakan cara mudah untuk mengakses banyak relasi yang dalam melalui relasi perantara. Contoh: Sebuah negara (Country) memiliki banyak pos (Post) melalui pengguna (User).

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

Eager Loading: Mengoptimalkan Query dengan Relasi

Secara default, Eloquent melakukan lazy loading untuk relasi. Ini berarti relasi hanya dimuat ketika Anda mengaksesnya untuk pertama kali. Hal ini dapat menyebabkan masalah performa, terutama jika Anda perlu mengakses relasi untuk banyak model.

Eager loading adalah teknik untuk memuat relasi sekaligus ketika Anda mengambil model utama. Ini dapat secara signifikan mengurangi jumlah query database yang dieksekusi dan meningkatkan performa aplikasi Anda.

// Tanpa Eager Loading (N+1 Query Problem)
$authors = Author::all();
foreach ($authors as $author) {
    echo $author->books->count(); // Akan menjalankan query database untuk setiap author
}

// Dengan Eager Loading
$authors = Author::with('books')->get();
foreach ($authors as $author) {
    echo $author->books->count(); // Tidak akan menjalankan query database tambahan
}

Anda juga bisa menggunakan constrained eager loading untuk memuat relasi hanya jika memenuhi kondisi tertentu:

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

Query Scopes: Kode Query yang Lebih Rapi dan Reusable

Query scopes memungkinkan Anda mendefinisikan logika query yang reusable dalam model Eloquent. Ini membantu menjaga kode query Anda tetap rapi dan mudah dibaca.

• Local Scopes: Mendefinisikan scope yang hanya berlaku untuk model tersebut.

  // Model User
  public function scopePopular($query)
  {
      return $query->where('votes', '>', 100);
  }
  
  public function scopeOfEmail($query, $email)
  {
      return $query->where('email', $email);
  }
  
  // Penggunaan
  $popularUsers = User::popular()->get();
  $specificUser = User::ofEmail('[email protected]')->first();

• Global Scopes: Mendefinisikan scope yang berlaku untuk semua query pada model tersebut. Ini berguna untuk menambahkan kondisi default, seperti filter berdasarkan status aktif atau pemilik.

  // Membuat class scope
  namespace AppScopes;
  
  use IlluminateDatabaseEloquentBuilder;
  use IlluminateDatabaseEloquentModel;
  use IlluminateDatabaseEloquentScope;
  
  class ActiveScope implements Scope
  {
      public function apply(Builder $builder, Model $model)
      {
          $builder->where('is_active', true);
      }
  }
  
  // Model User
  protected static function booted()
  {
      static::addGlobalScope(new ActiveScope);
  }
  
  // Penggunaan
  $activeUsers = User::all(); // Hanya akan mengambil user yang aktif

  Anda dapat menghapus global scope menggunakan metode withoutGlobalScope:

  $allUsers = User::withoutGlobalScope(ActiveScope::class)->get(); // Mengambil semua user, termasuk yang tidak aktif

Model Events: Melakukan Tindakan Otomatis Saat Model Dimanipulasi

Eloquent menyediakan model events yang memungkinkan Anda menjalankan kode tertentu saat model sedang dibuat, diperbarui, dihapus, atau diambil. Ini berguna untuk melakukan validasi data, mengirim notifikasi, atau memperbarui data terkait.

Beberapa event yang tersedia:

• creating: Event dijalankan sebelum model dibuat.
• created: Event dijalankan setelah model dibuat.
• updating: Event dijalankan sebelum model diperbarui.
• updated: Event dijalankan setelah model diperbarui.
• saving: Event dijalankan sebelum model disimpan (baik create maupun update).
• saved: Event dijalankan setelah model disimpan (baik create maupun update).
• deleting: Event dijalankan sebelum model dihapus.
• deleted: Event dijalankan setelah model dihapus.
• retrieved: Event dijalankan setelah model diambil.

Anda dapat mendefinisikan event listener di dalam model menggunakan metode static booted():

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class User extends Model
{
    use HasFactory;

    protected static function booted()
    {
        static::creating(function ($user) {
            $user->uuid = (string) Str::uuid(); // Men-generate UUID saat model dibuat
        });

        static::updating(function ($user) {
            // Validasi data sebelum update
            if ($user->name == 'Invalid Name') {
                throw new Exception('Nama tidak valid');
            }
        });
    }
}

Mutators dan Accessors: Memformat Data Secara Otomatis

Mutators memungkinkan Anda mengubah nilai atribut sebelum disimpan ke database. Accessors memungkinkan Anda mengubah nilai atribut saat diambil dari database. Ini berguna untuk memformat data, seperti mengubah format tanggal atau menggabungkan nama depan dan nama belakang.

• Mutators:

  // Model User
  public function setPasswordAttribute($value)
  {
      $this->attributes['password'] = bcrypt($value); // Enkripsi password sebelum disimpan
  }

• Accessors:

  // Model User
  public function getNameAttribute($value)
  {
      return ucfirst($value); // Mengubah huruf pertama menjadi huruf besar saat diambil
  }

Eloquent Collections: Bekerja dengan Kumpulan Data

Eloquent mengembalikan hasil query sebagai Collection, yang merupakan objek PHP yang menyediakan berbagai metode untuk memanipulasi kumpulan data. Beberapa metode yang berguna antara lain:

• each(): Iterasi melalui setiap item dalam collection.
• map(): Mengubah setiap item dalam collection.
• filter(): Menyaring item dalam collection berdasarkan kondisi.
• sortBy(): Mengurutkan item dalam collection.
• pluck(): Mengambil nilai kolom tertentu dari setiap item dalam collection.

$users = User::all();

// Menggunakan each()
$users->each(function ($user) {
    echo $user->name . '<br>';
});

// Menggunakan map()
$names = $users->map(function ($user) {
    return $user->name;
});

// Menggunakan filter()
$activeUsers = $users->filter(function ($user) {
    return $user->is_active;
});

// Menggunakan pluck()
$emails = $users->pluck('email');

Kesimpulan: Menguasai Eloquent untuk Pengembangan Laravel yang Efisien

Belajar Laravel Eloquent ORM adalah investasi yang berharga bagi setiap pengembang Laravel. Dengan Eloquent, Anda dapat berinteraksi dengan database secara lebih mudah, efisien, dan aman. Fitur-fitur seperti relasi database, eager loading, query scopes, model events, mutators, accessors, dan collections memberikan fleksibilitas dan kontrol yang besar atas data Anda. Teruslah berlatih dan bereksplorasi dengan Eloquent untuk meningkatkan keterampilan pengembangan Laravel Anda! Selamat mencoba!