Laravel, sebagai salah satu framework PHP paling populer, menawarkan berbagai fitur untuk memudahkan pengembangan aplikasi web. Salah satu fitur yang paling menonjol adalah Eloquent ORM (Object Relational Mapper). Eloquent ORM memungkinkan kita berinteraksi dengan database secara lebih intuitif dan efisien dengan memanfaatkan konsep Object-Oriented Programming (OOP). Artikel ini akan membahas secara mendalam tentang Laravel Eloquent ORM contoh penggunaan, dan bagaimana Anda dapat memanfaatkannya untuk manipulasi database efisien. Mari kita mulai!

Apa Itu Laravel Eloquent ORM dan Mengapa Penting?

Eloquent ORM adalah implementasi ActiveRecord yang disediakan oleh Laravel. Sederhananya, Eloquent memungkinkan kita berinteraksi dengan tabel database sebagai objek PHP. Setiap tabel direpresentasikan sebagai sebuah model (class), dan setiap baris dalam tabel direpresentasikan sebagai sebuah instance dari model tersebut.

Mengapa Eloquent penting? Berikut beberapa alasannya:

• Kemudahan Penggunaan: Dengan Eloquent, kita tidak perlu menulis query SQL secara manual. Eloquent menyediakan method-method yang intuitif untuk melakukan operasi CRUD (Create, Read, Update, Delete) pada database.
• Keamanan: Eloquent secara otomatis melindungi aplikasi kita dari serangan SQL injection dengan melakukan escaping data sebelum dikirim ke database.
• Kode Lebih Bersih dan Terstruktur: Eloquent membantu kita memisahkan logika database dari kode aplikasi, sehingga kode menjadi lebih bersih, terstruktur, dan mudah dipelihara.
• Relasi Database yang Mudah Dikelola: Eloquent menyediakan fitur untuk mendefinisikan dan mengelola relasi antar tabel (one-to-one, one-to-many, many-to-many) dengan mudah.
• Abstraksi Database: Eloquent memberikan abstraksi terhadap database yang digunakan. Artinya, jika kita ingin mengganti database (misalnya dari MySQL ke PostgreSQL), kita hanya perlu mengubah konfigurasi database tanpa perlu mengubah banyak kode.

Persiapan Awal: Konfigurasi Database Laravel

Sebelum kita mulai dengan contoh penggunaan Laravel Eloquent ORM, pastikan Anda telah mengkonfigurasi database Laravel Anda. Buka file .env pada direktori proyek Anda dan sesuaikan konfigurasi database berikut:

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

Pastikan Anda mengganti nilai-nilai di atas dengan konfigurasi database Anda yang sebenarnya. Jika Anda menggunakan database selain MySQL, ubah nilai DB_CONNECTION sesuai dengan database yang Anda gunakan (misalnya pgsql untuk PostgreSQL, sqlite untuk SQLite).

Setelah mengkonfigurasi database, Anda perlu membuat migration untuk membuat tabel yang akan kita gunakan.

Membuat Model dan Migration: Definisi Tabel Database

Mari kita buat sebuah model Post dan migration yang sesuai. Model Post akan merepresentasikan tabel posts di database kita.

Jalankan perintah berikut di terminal:

php artisan make:model Post -m

Perintah ini akan membuat dua file:

• app/Models/Post.php: Model Post
• database/migrations/[tanggal]_create_posts_table.php: Migration untuk tabel posts

Buka file migration database/migrations/[tanggal]_create_posts_table.php dan definisikan skema tabel posts seperti berikut:

<?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->string('title');
            $table->text('content');
            $table->string('slug')->unique();
            $table->timestamps();
        });
    }

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

Kode di atas mendefinisikan tabel posts dengan kolom-kolom berikut:

• id: Primary key (auto-incrementing integer)
• title: Judul postingan (string)
• content: Isi postingan (text)
• slug: Slug postingan (string, unique) – digunakan untuk URL yang SEO-friendly
• created_at: Timestamp saat postingan dibuat
• updated_at: Timestamp saat postingan terakhir diperbarui

Setelah mendefinisikan skema tabel, jalankan migration untuk membuat tabel posts di database:

php artisan migrate

Sekarang kita memiliki tabel posts di database kita, dan kita siap untuk menggunakan Eloquent ORM untuk berinteraksi dengan tabel ini.

Contoh Penggunaan Eloquent ORM: Operasi CRUD (Create, Read, Update, Delete)

Berikut adalah beberapa contoh penggunaan Laravel Eloquent ORM untuk melakukan operasi CRUD (Create, Read, Update, Delete) pada tabel posts.

1. Membuat Data Baru (Create)

Untuk membuat data baru, kita dapat menggunakan method create() pada model Post.

use AppModelsPost;

$post = Post::create([
    'title' => 'Judul Postingan Baru',
    'content' => 'Isi postingan baru yang menarik.',
    'slug' => Str::slug('Judul Postingan Baru'), // Generate slug otomatis
]);

echo "Postingan berhasil dibuat dengan ID: " . $post->id;

Perhatikan bahwa kita menggunakan Str::slug() untuk membuat slug otomatis dari judul postingan. Pastikan Anda mengimport class IlluminateSupportStr di bagian atas file Anda. Method create() akan secara otomatis menyimpan data ke database dan mengembalikan instance dari model Post yang baru dibuat.

Alternatif lain adalah menggunakan instance model:

use AppModelsPost;
use IlluminateSupportStr;

$post = new Post();
$post->title = 'Judul Postingan Baru Lainnya';
$post->content = 'Isi postingan yang berbeda.';
$post->slug = Str::slug('Judul Postingan Baru Lainnya');
$post->save();

echo "Postingan berhasil dibuat dengan ID: " . $post->id;

Kedua cara di atas akan menghasilkan hasil yang sama.

2. Membaca Data (Read)

Eloquent menyediakan berbagai cara untuk membaca data dari database.

• Mengambil Semua Data:

  use AppModelsPost;
  
  $posts = Post::all();
  
  foreach ($posts as $post) {
      echo "Judul: " . $post->title . "<br>";
      echo "Isi: " . $post->content . "<br>";
      echo "<br>";
  }

  Method all() akan mengembalikan koleksi dari semua data pada tabel posts.

• Mengambil Data Berdasarkan ID:

  use AppModelsPost;
  
  $post = Post::find(1); // Mengambil postingan dengan ID 1
  
  if ($post) {
      echo "Judul: " . $post->title . "<br>";
      echo "Isi: " . $post->content . "<br>";
  } else {
      echo "Postingan tidak ditemukan.";
  }

  Method find() akan mengembalikan instance dari model Post dengan ID yang sesuai. Jika ID tidak ditemukan, method find() akan mengembalikan null.

• Mengambil Data Menggunakan where():

  use AppModelsPost;
  
  $posts = Post::where('title', 'like', '%Judul%')->get(); // Mengambil semua postingan yang judulnya mengandung kata "Judul"
  
  foreach ($posts as $post) {
      echo "Judul: " . $post->title . "<br>";
      echo "Isi: " . $post->content . "<br>";
      echo "<br>";
  }

  Method where() memungkinkan kita untuk menambahkan kondisi WHERE ke query. Method get() akan mengeksekusi query dan mengembalikan koleksi dari data yang sesuai. Kita bisa menggunakan berbagai operator pada method where(), seperti =, !=, >, <, like, dan lain-lain.

• Mengambil Data Pertama yang Sesuai:

  use AppModelsPost;
  
  $post = Post::where('slug', 'judul-postingan-baru')->first(); // Mengambil postingan pertama yang memiliki slug "judul-postingan-baru"
  
  if ($post) {
      echo "Judul: " . $post->title . "<br>";
      echo "Isi: " . $post->content . "<br>";
  } else {
      echo "Postingan tidak ditemukan.";
  }

  Method first() akan mengembalikan instance dari model Post pertama yang sesuai dengan kondisi WHERE. Jika tidak ada data yang sesuai, method first() akan mengembalikan null.

3. Memperbarui Data (Update)

Untuk memperbarui data, kita perlu mengambil data yang ingin kita perbarui terlebih dahulu, kemudian mengubah properti-properti yang sesuai, dan terakhir memanggil method save().

use AppModelsPost;

$post = Post::find(1); // Mengambil postingan dengan ID 1

if ($post) {
    $post->title = 'Judul Postingan yang Diperbarui';
    $post->content = 'Isi postingan yang telah diubah.';
    $post->slug = Str::slug('Judul Postingan yang Diperbarui');
    $post->save();

    echo "Postingan berhasil diperbarui.";
} else {
    echo "Postingan tidak ditemukan.";
}

Kita juga dapat menggunakan method update() secara langsung pada query builder:

use AppModelsPost;

$updated = Post::where('id', 1)->update([
    'title' => 'Judul Postingan yang Diperbarui Langsung',
    'content' => 'Isi postingan yang telah diubah langsung.',
    'slug' => Str::slug('Judul Postingan yang Diperbarui Langsung'),
]);

if ($updated) {
    echo "Postingan berhasil diperbarui.";
} else {
    echo "Postingan tidak ditemukan.";
}

Perbedaan utama adalah bahwa method update() pada query builder tidak menjalankan event model (seperti saving dan saved), sedangkan method save() menjalankan event model. Pilih metode yang sesuai dengan kebutuhan Anda.

4. Menghapus Data (Delete)

Untuk menghapus data, kita perlu mengambil data yang ingin kita hapus terlebih dahulu, kemudian memanggil method delete().

use AppModelsPost;

$post = Post::find(1); // Mengambil postingan dengan ID 1

if ($post) {
    $post->delete();

    echo "Postingan berhasil dihapus.";
} else {
    echo "Postingan tidak ditemukan.";
}

Kita juga dapat menggunakan method destroy() untuk menghapus data berdasarkan ID:

use AppModelsPost;

$deleted = Post::destroy(1); // Menghapus postingan dengan ID 1

if ($deleted) {
    echo "Postingan berhasil dihapus.";
} else {
    echo "Postingan tidak ditemukan.";
}

Atau, kita bisa menggunakan method delete() pada query builder:

use AppModelsPost;

$deleted = Post::where('title', 'Judul Postingan yang Diperbarui Langsung')->delete();

if ($deleted) {
    echo "Postingan berhasil dihapus.";
} else {
    echo "Postingan tidak ditemukan.";
}

Sama seperti update(), method delete() pada query builder tidak menjalankan event model.

Relasi Database dengan Eloquent ORM: Mengelola Hubungan Antar Tabel

Salah satu kekuatan Eloquent ORM adalah kemampuannya untuk mendefinisikan dan mengelola relasi antar tabel dengan mudah. Misalnya, kita ingin menambahkan relasi antara tabel posts dan tabel comments (setiap postingan dapat memiliki banyak komentar).

Pertama, buat model dan migration untuk tabel comments:

php artisan make:model Comment -m

Buka file migration database/migrations/[tanggal]_create_comments_table.php dan definisikan skema tabel comments seperti berikut:

<?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->foreignId('post_id')->constrained()->onDelete('cascade');
            $table->string('author');
            $table->text('content');
            $table->timestamps();
        });
    }

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

Perhatikan kolom post_id yang merupakan foreign key yang merujuk ke tabel posts. Kita juga menggunakan ->constrained()->onDelete('cascade') untuk memastikan bahwa jika sebuah postingan dihapus, semua komentar yang terkait dengan postingan tersebut juga akan dihapus secara otomatis.

Jalankan migration:

php artisan migrate

Sekarang, definisikan relasi di model Post dan Comment.

Di file app/Models/Post.php, tambahkan method comments():

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsHasMany;

class Post extends Model
{
    use HasFactory;

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

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

Method comments() mendefinisikan relasi one-to-many (satu postingan memiliki banyak komentar) antara model Post dan model Comment.

Di file app/Models/Comment.php, tambahkan method post():

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsBelongsTo;

class Comment extends Model
{
    use HasFactory;

    protected $fillable = [
        'post_id',
        'author',
        'content',
    ];

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

Method post() mendefinisikan relasi belongs-to (satu komentar termasuk ke satu postingan) antara model Comment dan model Post.

Sekarang kita dapat mengakses komentar-komentar dari sebuah postingan dengan mudah:

use AppModelsPost;

$post = Post::find(1);

if ($post) {
    foreach ($post->comments as $comment) {
        echo "Author: " . $comment->author . "<br>";
        echo "Content: " . $comment->content . "<br>";
        echo "<br>";
    }
} else {
    echo "Postingan tidak ditemukan.";
}

Atau, kita dapat mengakses postingan dari sebuah komentar:

use AppModelsComment;

$comment = Comment::find(1);

if ($comment) {
    echo "Judul Postingan: " . $comment->post->title . "<br>";
    echo "Isi Postingan: " . $comment->post->content . "<br>";
} else {
    echo "Komentar tidak ditemukan.";
}

Eloquent ORM menyediakan berbagai jenis relasi, seperti:

• hasOne(): One-to-one
• hasMany(): One-to-many
• belongsTo(): Belongs-to
• belongsToMany(): Many-to-many

Eager Loading: Meningkatkan Performa dengan Mengurangi Jumlah Query

Saat kita mengakses relasi database, Eloquent ORM secara default melakukan lazy loading. Artinya, relasi akan di-load hanya saat kita mengaksesnya. Hal ini dapat menyebabkan masalah performa jika kita mengakses banyak relasi sekaligus, karena akan ada banyak query yang dieksekusi.

Untuk mengatasi masalah ini, kita dapat menggunakan eager loading. Eager loading memungkinkan kita untuk me-load relasi bersamaan dengan model utama, sehingga kita hanya perlu menjalankan satu query.

Untuk menggunakan eager loading, kita dapat menggunakan method with():

use AppModelsPost;

$posts = Post::with('comments')->get(); // Me-load postingan beserta komentarnya

foreach ($posts as $post) {
    echo "Judul: " . $post->title . "<br>";
    foreach ($post->comments as $comment) {
        echo "Author: " . $comment->author . "<br>";
        echo "Content: " . $comment->content . "<br>";
        echo "<br>";
    }
}

Dengan menggunakan with('comments'), kita memberitahu Eloquent untuk me-load relasi comments bersamaan dengan model Post, sehingga hanya ada dua query yang dieksekusi (satu untuk mengambil semua postingan, dan satu untuk mengambil semua komentar dari postingan-postingan tersebut). Tanpa eager loading, akan ada N+1 query yang dieksekusi (satu untuk mengambil semua postingan, dan N query untuk mengambil komentar dari setiap postingan).

Query Scopes: Kode yang Lebih Bersih dan Reusable

Query scopes memungkinkan kita untuk mendefinisikan query yang sering digunakan sebagai method di model kita. Hal ini membuat kode kita lebih bersih, reusable, dan mudah dibaca.

Misalnya, kita ingin mendefinisikan scope untuk mengambil semua postingan yang dipublikasikan (misalnya, memiliki status published dengan nilai true).

Di file app/Models/Post.php, tambahkan method scopePublished():

<?php

namespace AppModels;

use IlluminateDatabaseEloquentFactoriesHasFactory;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsHasMany;
use IlluminateDatabaseEloquentBuilder;

class Post extends Model
{
    use HasFactory;

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

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

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

Sekarang kita dapat menggunakan scope published() untuk mengambil semua postingan yang dipublikasikan:

use AppModelsPost;

$posts = Post::published()->get(); // Mengambil semua postingan yang dipublikasikan

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

Kita juga dapat menggabungkan scope dengan query lainnya:

use AppModelsPost;

$posts = Post::published()->where('title', 'like', '%Judul%')->get(); // Mengambil semua postingan yang dipublikasikan dan judulnya mengandung kata "Judul"

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

Mass Assignment: Keamanan dan fillable / guarded

Mass assignment adalah proses mengisi properti-properti model dengan data dari array. Laravel secara default melindungi aplikasi kita dari mass assignment vulnerability dengan membatasi properti-properti mana saja yang boleh diisi secara massal.

Untuk mengizinkan properti-properti diisi secara massal, kita perlu mendefinisikan properti $fillable atau $guarded di model kita.

• $fillable: Berisi daftar nama properti yang boleh diisi secara massal.

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

• $guarded: Berisi daftar nama properti yang tidak boleh diisi secara massal. Jika kita ingin mengizinkan semua properti diisi secara massal, kita dapat menggunakan $guarded = [].

  protected $guarded = [
      'id',
  ];

Pilih salah satu dari $fillable atau $guarded sesuai dengan kebutuhan Anda. Disarankan untuk menggunakan $fillable dan mendefinisikan properti-properti mana saja yang boleh diisi secara massal.

Kesimpulan: Laravel Eloquent ORM untuk Pengembangan Aplikasi Web Efisien

Laravel Eloquent ORM adalah alat yang ampuh untuk manipulasi database efisien dalam pengembangan aplikasi web dengan Laravel. Dengan Eloquent, kita dapat berinteraksi dengan database secara lebih intuitif, aman, dan terstruktur. Artikel ini telah memberikan contoh penggunaan Laravel Eloquent ORM yang komprehensif, mulai dari operasi CRUD dasar hingga pengelolaan relasi database, eager loading, query scopes, dan mass assignment.

Dengan memahami dan memanfaatkan fitur-fitur yang ditawarkan oleh Eloquent ORM, Anda dapat mengembangkan aplikasi web Laravel yang lebih efisien, mudah dipelihara, dan aman. Selamat mencoba dan semoga artikel ini bermanfaat!