Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk

Blog / Performa / Mengatasi Masalah N+1 Query di...
Performa

Mengatasi Masalah N+1 Query di Laravel Menggunakan Eager Loading

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
6 min read
30 views

Cara mendeteksi, memahami, dan menghilangkan N+1 query di Eloquent, lengkap dengan pengaman otomatis agar tidak terulang.

Pendahuluan

Aplikasi Laravel yang terasa cepat di laptop sering menjadi lambat di production. Salah satu penyebab paling umum adalah N+1 query: satu query untuk mengambil daftar data, lalu N query tambahan untuk mengambil relasi tiap barisnya. Dengan 10 data tidak terasa. Dengan 1.000 data, halaman bisa memicu lebih dari seribu query.

Artikel ini membahas apa itu N+1, cara mendeteksinya, dan cara memperbaikinya dengan eager loading.

Memahami N+1 dengan Contoh

Misalkan ada tiga model: User, Post, dan Comment.

// app/Models/Post.php
class Post extends Model
{
    public function user()     { return $this->belongsTo(User::class); }
    public function comments() { return $this->hasMany(Comment::class); }
}

Controller berikut tampak wajar:

public function index()
{
    $posts = Post::latest()->take(50)->get();

    return view('posts.index', compact('posts'));
}
@foreach ($posts as $post)
    <h2>{{ $post->title }}</h2>
    <small>oleh {{ $post->user->name }}</small>
    <span>{{ $post->comments->count() }} komentar</span>
@endforeach

Masalahnya ada di $post->user dan $post->comments. Relasi tersebut belum dimuat, sehingga Eloquent mengambilnya satu per satu ketika diakses di dalam loop (lazy loading).

select * from `posts` order by `created_at` desc limit 50          -- 1 query
select * from `users` where `users`.`id` = 1 limit 1               -- query ke-2
select * from `comments` where `comments`.`post_id` = 1            -- query ke-3
select * from `users` where `users`.`id` = 2 limit 1               -- query ke-4
select * from `comments` where `comments`.`post_id` = 2            -- query ke-5
... dan seterusnya

Untuk 50 post, totalnya sekitar 101 query: 1 query utama + 50 query user + 50 query komentar. Itulah N+1 (dalam kasus ini, dua relasi sekaligus).

Cara Mendeteksi N+1

1. Laravel Debugbar

composer require barryvdh/laravel-debugbar --dev

Tab Queries menampilkan jumlah query beserta peringatan untuk query duplikat. Gunakan hanya di lingkungan lokal.

2. Query log manual

Berguna untuk pengecekan cepat atau saat menulis test.

use Illuminate\Support\Facades\DB;

DB::enableQueryLog();

$posts = Post::take(50)->get();
foreach ($posts as $post) {
    $post->user->name;
}

dump(count(DB::getQueryLog()));   // 51

3. Listener query

// app/Providers/AppServiceProvider.php
use Illuminate\Support\Facades\DB;

public function boot(): void
{
    if (app()->isLocal()) {
        DB::listen(function ($query) {
            logger()->debug($query->sql, ['time_ms' => $query->time]);
        });
    }
}

Kemudian pantau log secara langsung:

tail -f storage/logs/laravel.log

Solusi Utama: Eager Loading dengan with()

Muat relasi di depan lewat satu query tambahan per relasi.

$posts = Post::with(['user', 'comments'])
    ->latest()
    ->take(50)
    ->get();
select * from `posts` order by `created_at` desc limit 50
select * from `users` where `users`.`id` in (1, 2, 3, ...)
select * from `comments` where `comments`.`post_id` in (1, 2, 3, ...)

Dari 101 query menjadi 3 query, berapa pun jumlah post-nya. Eloquent mengumpulkan semua ID lalu memakai WHERE IN, dan mencocokkan hasilnya di memori.

Variasi Eager Loading

Memilih kolom tertentu

Kurangi data yang ditarik. Wajib menyertakan kolom kunci (id dan foreign key), kalau tidak relasi tidak bisa dicocokkan.

$posts = Post::with([
    'user:id,name',
    'comments:id,post_id,body',
])->get();

Relasi bersarang

$posts = Post::with('comments.user')->get();   // post -> komentar -> penulis komentar

Eager loading dengan kondisi

$posts = Post::with(['comments' => function ($query) {
    $query->where('is_approved', true)->latest()->limit(5);
}])->get();

Hati-hati: limit() di dalam eager loading berlaku untuk seluruh hasil query relasi, bukan per post. Untuk "5 komentar terbaru per post", gunakan pendekatan lain seperti relasi latestOfMany atau paket pendukung.

load() dan loadMissing() untuk data yang sudah ada

Berguna ketika model sudah terlanjur diambil, misalnya dari route model binding.

public function show(Post $post)
{
    $post->load(['user', 'comments.user']);

    return view('posts.show', compact('post'));
}

// hanya memuat relasi yang belum dimuat
$post->loadMissing('comments');

Hanya butuh jumlah? Pakai withCount()

Di contoh awal, $post->comments->count() memuat seluruh komentar hanya untuk dihitung. Jauh lebih efisien dengan withCount:

$posts = Post::with('user:id,name')
    ->withCount('comments')
    ->get();
<span>{{ $post->comments_count }} komentar</span>

Variasi lain: withSum, withAvg, withMin, withMax, dan withExists.

$posts = Post::withCount([
    'comments',
    'comments as approved_comments_count' => fn ($q) => $q->where('is_approved', true),
])->get();

Eager Loading Otomatis dengan $with

Jika sebuah relasi hampir selalu dibutuhkan, tetapkan di model.

class Post extends Model
{
    protected $with = ['user'];
}

Gunakan dengan hati-hati: relasi itu akan dimuat di setiap query model tersebut, termasuk yang tidak membutuhkannya. Untuk melepasnya pada query tertentu, pakai Post::without('user').

Pengaman Otomatis: preventLazyLoading

Cara terbaik mencegah N+1 adalah membuat aplikasi gagal keras saat terjadi lazy loading di lingkungan non-production.

// app/Providers/AppServiceProvider.php
use Illuminate\Database\Eloquent\Model;

public function boot(): void
{
    Model::preventLazyLoading(! app()->isProduction());
}

Sekarang, kode yang melakukan lazy loading di dalam loop akan melempar exception:

Illuminate\Database\LazyLoadingViolationException
Attempted to lazy load [user] on model [App\Models\Post] but lazy loading is disabled.

Di production, lebih baik mencatat pelanggaran ke log daripada membuat halaman error.

Model::preventLazyLoading();

Model::handleLazyLoadingViolationUsing(function ($model, $relation) {
    if (app()->isProduction()) {
        logger()->warning("N+1 terdeteksi: [{$relation}] pada ".get_class($model));
        return;
    }

    throw new \Illuminate\Database\LazyLoadingViolationException($model, $relation);
});

Menguji dengan Automated Test

Tambahkan test yang membatasi jumlah query agar regresi cepat ketahuan.

use Illuminate\Support\Facades\DB;

public function test_halaman_posts_tidak_n_plus_1(): void
{
    Post::factory()->count(30)->hasComments(3)->create();

    DB::enableQueryLog();

    $this->get('/posts')->assertOk();

    $this->assertLessThanOrEqual(5, count(DB::getQueryLog()));
}

Jika seseorang kelak menghapus with(), test ini akan gagal.

Kasus yang Sering Terlewat

Situasi Penyebab Perbaikan
Accessor di model Accessor memanggil relasi (getAuthorNameAttribute) Eager load relasinya di query yang memakai accessor
API Resource $this->user di dalam Resource with('user') di controller
Pagination paginate() tanpa with() Tambahkan with() sebelum paginate()
Relasi hasOne di dalam loop Lupa eager load with('profile')
Policy/Gate di dalam loop Policy mengakses relasi Muat relasi sebelum @can di loop

Contoh Resource yang aman:

// Controller
return PostResource::collection(
    Post::with('user:id,name')->withCount('comments')->paginate(20)
);

// Resource
'author'   => $this->user->name,
'comments' => $this->comments_count,

Kapan Eager Loading Bukan Jawabannya

  • Data sangat besar: with() memuat semua relasi ke memori. Untuk pemrosesan massal, pakai chunk() atau lazy() dengan eager loading di dalamnya.
  • Hanya butuh agregat: gunakan withCount atau subquery, bukan memuat seluruh relasi.
  • Relasi jarang dipakai: jangan muat semua relasi "untuk jaga-jaga". Muat yang dibutuhkan saja.
Post::with('user:id,name')->chunkById(500, function ($posts) {
    foreach ($posts as $post) {
        // proses
    }
});

Checklist

  • ☐ Aktifkan Model::preventLazyLoading() di local dan staging.
  • ☐ Setiap loop Blade/Resource yang mengakses relasi punya with() yang sesuai.
  • ☐ Gunakan withCount() bila hanya butuh jumlah.
  • ☐ Pilih kolom dengan with('relasi:id,kolom'), dan sertakan foreign key.
  • ☐ Halaman daftar utama dilindungi test batas jumlah query.
  • ☐ Cek Debugbar atau log query sebelum rilis.

Penutup

N+1 adalah masalah yang mudah dibuat dan mudah diperbaiki, selama terdeteksi lebih awal. Kebiasaan paling berguna adalah mengaktifkan preventLazyLoading sejak awal proyek, sehingga setiap pelanggaran langsung terlihat saat pengembangan dan tidak menunggu keluhan pengguna di production.

Bagikan artikel:

Artikel lainnya