Laravel, framework PHP yang populer, dikenal karena sintaksnya yang elegan dan fitur-fiturnya yang kuat. Salah satu fitur yang paling banyak digunakan adalah Eloquent ORM (Object-Relational Mapper). Eloquent ORM menyederhanakan interaksi dengan database, memungkinkan Anda memanipulasi data dengan cara yang lebih intuitif dan efisien. Dalam artikel ini, kita akan belajar Laravel Eloquent ORM dengan mudah, membahas dasar-dasarnya, dan menunjukkan bagaimana Anda dapat memanipulasi data lebih efisien dalam aplikasi Laravel Anda. Siap untuk meningkatkan kemampuan pengembangan aplikasi Anda? Mari kita mulai!

1. Apa Itu Eloquent ORM dan Mengapa Penting?

Sebelum kita menyelami lebih dalam, mari kita pahami terlebih dahulu apa itu Eloquent ORM dan mengapa begitu penting dalam pengembangan Laravel.

Eloquent ORM adalah implementasi ORM yang disediakan oleh Laravel. ORM adalah teknik yang memungkinkan Anda berinteraksi dengan database menggunakan objek PHP, bukan dengan menulis query SQL secara langsung. Bayangkan memiliki jembatan yang menerjemahkan bahasa PHP Anda ke dalam bahasa SQL, dan sebaliknya. Ini sangat membantu karena:

• Kode Lebih Bersih dan Mudah Dibaca: Dengan Eloquent, kode Anda menjadi lebih deskriptif dan mudah dipahami, karena Anda bekerja dengan objek dan metode yang lebih alami daripada baris SQL yang kompleks.
• Keamanan yang Ditingkatkan: Eloquent membantu melindungi aplikasi Anda dari serangan SQL injection dengan secara otomatis melakukan escaping terhadap data.
• Portabilitas yang Lebih Baik: Eloquent menyediakan abstraksi database, yang berarti Anda dapat lebih mudah beralih antar sistem database yang berbeda (misalnya, dari MySQL ke PostgreSQL) tanpa mengubah banyak kode aplikasi Anda.
• Peningkatan Produktivitas: Dengan Eloquent, Anda dapat melakukan operasi database umum dengan cepat dan efisien, menghemat waktu dan tenaga.

Singkatnya, Eloquent ORM adalah alat yang sangat penting untuk pengembangan Laravel karena mempermudah interaksi dengan database, meningkatkan keamanan, dan meningkatkan produktivitas.

2. Konfigurasi Database untuk Eloquent ORM

Sebelum kita dapat menggunakan Eloquent ORM, kita perlu memastikan bahwa konfigurasi database kita sudah benar. Laravel menyimpan konfigurasi database di file .env dan config/database.php.

Langkah 1: Konfigurasi di .env

Buka file .env di direktori proyek Anda. Cari bagian yang berkaitan dengan konfigurasi database (biasanya dimulai dengan DB_). Ubah nilai-nilai berikut sesuai dengan pengaturan database Anda:

DB_CONNECTION=mysql  # Atau postgres, sqlite, sqlsrv, dll.
DB_HOST=127.0.0.1  # Atau alamat server database Anda
DB_PORT=3306       # Atau port database Anda
DB_DATABASE=nama_database  # Nama database Anda
DB_USERNAME=username_database  # Username database Anda
DB_PASSWORD=password_database  # Password database Anda

Pastikan untuk menyimpan perubahan setelah Anda selesai.

Langkah 2: Verifikasi Konfigurasi di config/database.php (Opsional)

Secara umum, Anda tidak perlu mengubah file config/database.php secara langsung. File ini berisi konfigurasi default untuk berbagai koneksi database. Namun, Anda dapat memeriksanya untuk memastikan bahwa konfigurasi default sesuai dengan kebutuhan Anda.

Setelah konfigurasi selesai, Anda dapat mencoba terhubung ke database menggunakan perintah php artisan migrate. Jika migrasi berhasil dijalankan, berarti konfigurasi database Anda sudah benar.

3. Membuat Model Eloquent: Representasi Tabel Database

Model Eloquent adalah kelas PHP yang merepresentasikan tabel database. Setiap instance dari model mewakili satu baris dalam tabel tersebut. Untuk membuat model Eloquent, Anda dapat menggunakan perintah Artisan:

php artisan make:model NamaModel

Misalnya, untuk membuat model bernama Artikel yang merepresentasikan tabel artikels, jalankan perintah:

php artisan make:model Artikel

Perintah ini akan membuat file app/Models/Artikel.php.

Konfigurasi Model

Buka file model yang baru dibuat. Anda dapat menyesuaikan model ini untuk mencerminkan struktur tabel Anda. Beberapa properti yang umum digunakan adalah:

• $table: Menentukan nama tabel yang sesuai dengan model ini. Jika tidak ditentukan, Eloquent akan mengasumsikan nama tabel adalah plural dari nama model (dalam contoh ini, artikels). Anda dapat menimpanya jika nama tabel Anda berbeda.

  protected $table = 'nama_tabel_anda';

• $primaryKey: Menentukan nama kolom primary key. Defaultnya adalah id.

  protected $primaryKey = 'id_artikel';

• $fillable: Menentukan atribut mana yang dapat diisi (mass assignable) melalui metode create atau update. Ini adalah fitur keamanan penting untuk mencegah pengisian atribut yang tidak diinginkan.

  protected $fillable = ['judul', 'isi', 'penulis_id'];

• $guarded: Kebalikan dari $fillable. Menentukan atribut mana yang tidak boleh diisi (mass assignable). Jika Anda ingin mengizinkan semua atribut diisi, gunakan $guarded = [].

  protected $guarded = ['id']; // Kolom id tidak boleh diisi secara massal

• $timestamps: Menentukan apakah Eloquent harus secara otomatis mengelola kolom created_at dan updated_at. Defaultnya adalah true. Jika tabel Anda tidak memiliki kolom ini, atur ke false.

  public $timestamps = false;

Contoh Model Artikel:

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Artikel extends Model
{
    use HasFactory;

    protected $table = 'artikels';
    protected $primaryKey = 'id_artikel';
    protected $fillable = ['judul', 'isi', 'penulis_id'];
    public $timestamps = true;
}

4. Operasi CRUD dengan Eloquent: Membuat, Membaca, Memperbarui, dan Menghapus Data

Setelah kita memiliki model, kita dapat menggunakan Eloquent untuk melakukan operasi CRUD (Create, Read, Update, Delete) pada database.

a. Membuat Data (Create)

Ada beberapa cara untuk membuat data baru menggunakan Eloquent:

• Metode create():

  Metode create() membuat instance model baru dan menyimpannya ke database secara otomatis. Anda perlu memastikan bahwa atribut yang akan diisi terdaftar di properti $fillable pada model.

  $artikel = Artikel::create([
      'judul' => 'Judul Artikel Baru',
      'isi' => 'Isi artikel baru...',
      'penulis_id' => 1
  ]);
  
  // $artikel sekarang berisi instance model Artikel yang baru dibuat.

• Membuat instance model dan menggunakan metode save():

  Anda dapat membuat instance model terlebih dahulu, mengatur atributnya, dan kemudian menggunakan metode save() untuk menyimpannya ke database.

  $artikel = new Artikel();
  $artikel->judul = 'Judul Artikel Lain';
  $artikel->isi = 'Isi artikel lain...';
  $artikel->penulis_id = 2;
  $artikel->save();
  
  // $artikel sekarang berisi instance model Artikel yang baru dibuat.

b. Membaca Data (Read)

Eloquent menyediakan berbagai metode untuk membaca data dari database:

• Mengambil Semua Data:

  Metode all() mengembalikan semua baris dari tabel.

  $artikels = Artikel::all();
  
  // $artikels adalah koleksi (Collection) berisi semua model Artikel.

• Mengambil Data Berdasarkan ID:

  Metode find() mengembalikan model dengan ID yang sesuai.

  $artikel = Artikel::find(1); // Mengambil artikel dengan ID 1
  
  // $artikel adalah instance model Artikel dengan ID 1, atau null jika tidak ditemukan.

• Menggunakan Query Builder untuk Pencarian yang Lebih Kompleks:

  Eloquent menyediakan akses ke query builder Laravel, yang memungkinkan Anda membuat query yang lebih kompleks dengan menggunakan metode seperti where(), orderBy(), limit(), dll.

  $artikels = Artikel::where('penulis_id', 1)
                 ->orderBy('judul', 'asc')
                 ->limit(10)
                 ->get();
  
  // $artikels adalah koleksi (Collection) berisi model Artikel yang memenuhi kriteria.

  Contoh lainnya:

  $artikel = Artikel::where('judul', 'LIKE', '%Laravel%')->first(); // Mengambil artikel pertama yang judulnya mengandung kata "Laravel"

• Menggunakan Eager Loading untuk Meningkatkan Performa:

  Eager loading adalah teknik untuk mengambil relasi model secara bersamaan dengan model utamanya. Ini menghindari masalah “N+1 query problem,” di mana aplikasi Anda melakukan banyak query kecil ke database.

  $artikels = Artikel::with('penulis')->get(); // Mengambil semua artikel beserta data penulisnya
  
  // Diasumsikan model Artikel memiliki relasi 'penulis' yang terdefinisi.

c. Memperbarui Data (Update)

Sama seperti membuat data, ada beberapa cara untuk memperbarui data menggunakan Eloquent:

• Mengambil model, mengubah atribut, dan menggunakan metode save():

  $artikel = Artikel::find(1);
  $artikel->judul = 'Judul Artikel yang Diperbarui';
  $artikel->isi = 'Isi artikel yang diperbarui...';
  $artikel->save();
  
  // Artikel dengan ID 1 sekarang telah diperbarui.

• Menggunakan metode update() pada query builder:

  Metode ini memungkinkan Anda memperbarui banyak baris sekaligus yang memenuhi kriteria tertentu.

  Artikel::where('penulis_id', 1)
         ->update(['status' => 'published']);
  
  // Semua artikel dengan penulis_id 1 sekarang memiliki status 'published'.

d. Menghapus Data (Delete)

Eloquent menyediakan beberapa cara untuk menghapus data:

• Menghapus model berdasarkan ID:

  $artikel = Artikel::find(1);
  $artikel->delete();
  
  // Artikel dengan ID 1 sekarang telah dihapus.

• Menghapus model secara langsung (jika Anda sudah memiliki instance model):

  $artikel = Artikel::find(1);
  if ($artikel) {
      $artikel->delete();
  }

• Menghapus banyak baris sekaligus menggunakan query builder:

  Artikel::where('penulis_id', 1)->delete();
  
  // Semua artikel dengan penulis_id 1 sekarang telah dihapus.

• Menggunakan Soft Deletes (Penghapusan Logis):

  Eloquent mendukung soft deletes, di mana data tidak benar-benar dihapus dari database, tetapi ditandai sebagai dihapus dengan menyimpan timestamp di kolom deleted_at. Untuk mengaktifkan soft deletes, tambahkan trait SoftDeletes ke model Anda:

  <?php
  
  namespace AppModels;
  
  use IlluminateDatabaseEloquentFactoriesHasFactory;
  use IlluminateDatabaseEloquentModel;
  use IlluminateDatabaseEloquentSoftDeletes;
  
  class Artikel extends Model
  {
      use HasFactory, SoftDeletes;
  
      // ...
  }

  Anda juga perlu menambahkan kolom deleted_at ke tabel database Anda. Anda dapat melakukannya melalui migrasi.

  Setelah soft deletes diaktifkan, metode delete() akan mengisi kolom deleted_at dengan timestamp saat ini, bukan menghapus baris secara permanen.

  Untuk mengambil hanya data yang tidak dihapus (yang kolom deleted_at bernilai null), Anda tidak perlu melakukan apa-apa. Eloquent secara otomatis akan memfilter data yang dihapus.

  Untuk mengambil data yang sudah dihapus, Anda dapat menggunakan metode withTrashed():

  $artikels = Artikel::withTrashed()->get(); // Mengambil semua artikel, termasuk yang sudah dihapus

  Untuk mengambil hanya data yang sudah dihapus, Anda dapat menggunakan metode onlyTrashed():

  $artikels = Artikel::onlyTrashed()->get(); // Mengambil hanya artikel yang sudah dihapus

  Untuk menghapus data secara permanen (setelah soft deletes diaktifkan), Anda dapat menggunakan metode forceDelete():

  $artikel = Artikel::find(1);
  $artikel->forceDelete(); // Menghapus artikel secara permanen dari database

5. Relasi Antar Model: Membangun Struktur Data yang Kompleks

Salah satu kekuatan Eloquent adalah kemampuannya untuk mendefinisikan relasi antar model. Ini memungkinkan Anda membangun struktur data yang kompleks dan mengakses data terkait dengan mudah. Beberapa jenis relasi yang umum digunakan adalah:

• One To One: Satu model memiliki satu model terkait. Contoh: Seorang pengguna memiliki satu profil.
• One To Many: Satu model memiliki banyak model terkait. Contoh: Seorang penulis memiliki banyak artikel.
• Many To One (Inverse of One To Many): Banyak model memiliki satu model terkait. Contoh: Banyak artikel dimiliki oleh satu penulis.
• Many To Many: Banyak model memiliki banyak model terkait melalui tabel perantara (pivot table). Contoh: Sebuah artikel memiliki banyak kategori, dan sebuah kategori dimiliki oleh banyak artikel.
• Has One Through: Satu model memiliki satu model terkait melalui model perantara.
• Has Many Through: Satu model memiliki banyak model terkait melalui model perantara.
• One To One Polymorphic: Satu model dapat memiliki relasi one-to-one dengan beberapa model lain menggunakan satu relasi.
• One To Many Polymorphic: Satu model dapat memiliki relasi one-to-many dengan beberapa model lain menggunakan satu relasi.
• Many To Many Polymorphic: Satu model dapat memiliki relasi many-to-many dengan beberapa model lain menggunakan satu relasi.

Contoh Relasi One To Many (Penulis dan Artikel)

Mari kita buat contoh relasi One To Many antara model Penulis dan Artikel. Seorang penulis dapat memiliki banyak artikel.

Model Penulis (app/Models/Penulis.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Penulis extends Model
{
    use HasFactory;

    protected $table = 'penulis';
    protected $fillable = ['nama', 'email'];

    public function artikels()
    {
        return $this->hasMany(Artikel::class, 'penulis_id'); // Relasi one-to-many ke model Artikel
    }
}

Model Artikel (app/Models/Artikel.php):

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Artikel extends Model
{
    use HasFactory;

    protected $table = 'artikels';
    protected $fillable = ['judul', 'isi', 'penulis_id'];

    public function penulis()
    {
        return $this->belongsTo(Penulis::class, 'penulis_id'); // Relasi many-to-one ke model Penulis
    }
}

Perhatikan bahwa kita menggunakan metode hasMany() di model Penulis untuk mendefinisikan relasi ke model Artikel, dan metode belongsTo() di model Artikel untuk mendefinisikan relasi ke model Penulis. Argumen kedua pada metode hasMany() dan belongsTo() adalah nama kolom foreign key di tabel yang terkait.

Mengakses Relasi

Setelah relasi didefinisikan, Anda dapat mengakses data terkait dengan mudah:

$penulis = Penulis::find(1);
$artikels = $penulis->artikels; // Mengambil semua artikel yang ditulis oleh penulis dengan ID 1

foreach ($artikels as $artikel) {
    echo $artikel->judul . "<br>";
}

$artikel = Artikel::find(1);
$penulis = $artikel->penulis; // Mengambil data penulis dari artikel dengan ID 1

echo $penulis->nama;

6. Eloquent Collections: Manipulasi Data yang Lebih Fleksibel

Eloquent mengembalikan data dalam bentuk Collections. Collections adalah kelas PHP yang menyediakan berbagai metode untuk memanipulasi data dengan cara yang lebih fleksibel dan mudah. Beberapa metode Collection yang umum digunakan adalah:

• map(): Mengubah setiap item dalam collection.
• filter(): Memfilter item dalam collection berdasarkan kondisi tertentu.
• each(): Melakukan iterasi pada setiap item dalam collection.
• groupBy(): Mengelompokkan item dalam collection berdasarkan atribut tertentu.
• sortBy(): Mengurutkan item dalam collection berdasarkan atribut tertentu.
• pluck(): Mengambil nilai dari atribut tertentu untuk setiap item dalam collection.
• first(): Mengembalikan item pertama dalam collection yang memenuhi kondisi tertentu.
• last(): Mengembalikan item terakhir dalam collection yang memenuhi kondisi tertentu.

Contoh Penggunaan Collection

$artikels = Artikel::all();

// Mengambil hanya judul artikel
$judul_artikels = $artikels->pluck('judul');

// Menampilkan judul artikel
foreach ($judul_artikels as $judul) {
    echo $judul . "<br>";
}

// Memfilter artikel yang diterbitkan setelah tanggal tertentu
$artikels_terbaru = $artikels->filter(function ($artikel) {
    return $artikel->created_at > now()->subDays(30);
});

7. Query Scopes: Mengorganisasikan Logika Query Anda

Query scopes memungkinkan Anda untuk mendefinisikan query yang sering digunakan sebagai metode pada model. Ini membantu Anda mengorganisasikan logika query dan membuat kode Anda lebih mudah dibaca dan dipelihara.

Global Scopes

Global scopes adalah query scopes yang diterapkan ke setiap query yang dijalankan pada model. Untuk menerapkan global scope, Anda perlu membuat kelas scope dan mengimplementasikan interface IlluminateDatabaseEloquentScope.

Local Scopes

Local scopes adalah metode yang Anda definisikan pada model yang dapat Anda gunakan untuk menambahkan batasan ke query. Nama metode harus diawali dengan scope.

Contoh Local Scope

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Artikel extends Model
{
    use HasFactory;

    protected $table = 'artikels';
    protected $fillable = ['judul', 'isi', 'penulis_id'];

    public function scopePublished($query)
    {
        return $query->where('status', 'published');
    }

    public function scopePopular($query)
    {
        return $query->orderBy('views', 'desc');
    }
}

Menggunakan Query Scopes

$artikels = Artikel::published()->popular()->get(); // Mengambil artikel yang sudah dipublikasikan dan diurutkan berdasarkan jumlah tampilan

8. Menggunakan Accessors dan Mutators untuk Memformat Data

Accessors dan mutators memungkinkan Anda memformat atribut model saat diambil dari database (accessors) dan sebelum disimpan ke database (mutators).

Accessors

Accessor adalah metode yang Anda definisikan pada model untuk memformat atribut saat diambil. Nama metode harus diawali dengan get dan diakhiri dengan nama atribut.

Mutators

Mutator adalah metode yang Anda definisikan pada model untuk memformat atribut sebelum disimpan ke database. Nama metode harus diawali dengan set dan diakhiri dengan nama atribut.

Contoh Accessor dan Mutator

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;

class Artikel extends Model
{
    use HasFactory;

    protected $table = 'artikels';
    protected $fillable = ['judul', 'isi', 'penulis_id'];

    public function getJudulAttribute($value)
    {
        return strtoupper($value); // Mengubah judul menjadi huruf besar semua
    }

    public function setIsiAttribute($value)
    {
        $this->attributes['isi'] = strip_tags($value); // Menghapus tag HTML dari isi artikel
    }
}

Menggunakan Accessors dan Mutators

$artikel = Artikel::find(1);
echo $artikel->judul; // Menampilkan judul dalam huruf besar semua

$artikel->isi = '<p>Isi artikel dengan tag HTML.</p>';
$artikel->save(); // Tag HTML akan dihapus dari isi artikel sebelum disimpan ke database

9. Tips dan Trik untuk Mengoptimalkan Penggunaan Eloquent

Berikut beberapa tips dan trik untuk mengoptimalkan penggunaan Eloquent:

• Gunakan Eager Loading: Hindari masalah N+1 query dengan menggunakan eager loading untuk mengambil relasi model secara bersamaan.
• Gunakan Query Scopes: Organisasikan logika query Anda dengan menggunakan query scopes.
• Gunakan Accessors dan Mutators: Format data Anda dengan menggunakan accessors dan mutators.
• Hindari Mengambil Data yang Tidak Diperlukan: Hanya ambil data yang Anda butuhkan dengan menggunakan metode seperti select() dan pluck().
• Gunakan Caching: Cache hasil query untuk meningkatkan performa.
• Gunakan Indexing: Pastikan tabel database Anda memiliki index yang tepat untuk kolom yang sering digunakan dalam query.
• Pertimbangkan Penggunaan Raw SQL (Jika Diperlukan): Dalam beberapa kasus, penggunaan raw SQL mungkin lebih efisien daripada menggunakan Eloquent. Namun, gunakan raw SQL dengan hati-hati untuk menghindari masalah keamanan.

Kesimpulan

Belajar Laravel Eloquent ORM dengan mudah akan sangat meningkatkan kemampuan Anda dalam mengembangkan aplikasi Laravel. Dengan memahami dasar-dasar Eloquent, operasi CRUD, relasi antar model, Collections, Query Scopes, dan Accessors/Mutators, Anda dapat memanipulasi data lebih efisien dan membangun aplikasi yang lebih kuat dan mudah dipelihara. Jangan ragu untuk terus berlatih dan bereksperimen dengan Eloquent untuk menguasainya sepenuhnya. Selamat mencoba!