N+1 sorgularını nasıl düzeltir ve Eloquent'i optimize edersiniz?

Question

Accepted Answer

**N+1 sorgu problemi** — bir döngüde ilişkilere erişildiğinde her kayıt için ayrı bir sorgu tetiklenmesi — en yaygın Eloquent performans sorunudur. **Eager loading** (`with()` ile), sütun seçimi, chunking ve indexing gibi diğer optimizasyonlarla birlikte ana çözümdür.

## N+1 problemi ve çözümü

```php
// ❌ N+1: 1 query for posts + 1 query PER post to load its author
$posts = Post::all();                         // 1 query
foreach ($posts as $post) {
    echo $post->author->name;                  // +1 query EACH → 100 posts = 101 queries!
}

// ✅ eager load with with() → 2 queries total (posts + all authors)
$posts = Post::with('author')->get();
foreach ($posts as $post) {
    echo $post->author->name;                  // no extra queries — authors prefetched
}
```

**`with()`** ilişkileri önceden eager-loads (her ilişki için kayıt başına bir sorgu yerine bir ek sorgu), 101 sorguyu 2'ye dönüştürerek dramatik bir iyileştirme sağlar. Bu, temel Eloquent optimizasyonudur.

## Eager loading varyasyonları

```php
Post::with(['author', 'comments'])->get();        // multiple relationships
Post::with('comments.user')->get();                // nested
Post::with(['comments' => fn($q) => $q->latest()])->get();   // constrained
User::withCount('posts')->get();                   // count without loading (post_count)
```

## N+1'i otomatik olarak yakalama

```php
// in development, make lazy loading THROW so you catch N+1 problems early
Model::preventLazyLoading();    // in a service provider (dev)
// or use Laravel Debugbar / Telescope to see query counts per request
```

**Debugbar/Telescope** gibi araçlar sayfa başına sorgu sayısını gösterir (N+1'i görsel olarak tespit edin) ve `preventLazyLoading()`, geliştirme sırasında kazara yapılan lazy loads'u hatalara dönüştürür.

## Diğer Eloquent optimizasyonları

```php
User::select('id', 'name')->get();             // fetch only needed columns
User::chunk(1000, fn($users) => ...);           // process huge sets in batches (memory)
User::cursor();                                  // lazy iteration — constant memory
// + add database INDEXES on filtered/joined columns (the biggest DB-level win)
// + use the query builder / database aggregation instead of PHP loops over collections
```

## Neden önemli

N+1 sorgularını düzeltmek ve Eloquent'i optimize etmek, Laravel uygulamaları için kritik performans bilgisidir — **N+1 sorgu problemi Laravel'de en yaygın ve etkili performans sorununun tek başına kendisidir** ve bunu nasıl önleyeceğinizi bilmek gereklidir.

Sorun sinsi bir niteliğe sahiptir çünkü Eloquent'in uygun ilişki erişimi (`$post->author`) her seferinde sessizce bir veritabanı sorgusu tetikler, bu yüzden az veri ile iyi çalışan kod, veri büyüdükçe çöküşe uğrar (100 kayıt 101 sorgu haline gelir) ve genellikle yük altındaki prodüksiyonda keşfedilir. **`with()` ile eager loading**, ilişkileri önceden bir çift sorguda yükleyen temel çözümdür — kayıt başına bir sorgu yerine — ve varyasyonlarını bilmek (çoklu, nested, constrained eager loads, `withCount`) genel ihtiyaçları karşılar.

Eşit derecede değerli olan, **N+1 problemlerini yakalamayı bilmektir** (sorgu sayısını görmek için Debugbar/Telescope, geliştirmede kazara lazy loads'u hatalara dönüştürmek için `preventLazyLoading()`), böylece üretimde keşfetmeden önce bulabilirsiniz.

N+1 dışında, diğer optimizasyonlar — sadece gerekli sütunları seçme, büyük veri setlerini belleği tüketmeden işlemek için **chunking/cursors**, veritabanı tarafında agregasyon yapmak PHP tarafında koleksiyon işlemesi yerine, ve çok önemlisi **filtrelenen/birleştirilen sütunları indexleme** (genellikle en büyük veritabanı düzeyinde kazanç) — araç setini tamamlar.

Bunları anlamak — özellikle N+1'i eager loading ile tanımayı ve düzeltmeyi — performanslı Laravel uygulamaları yazan geliştiricileri, verileri büyüdükçe uygulamalar ağırlaşan geliştiricilerden ayıran, üst düzey bilgidir ve ölçeklenebilir uygulamalar oluştururken sık ilgili, yüksek değerli bir konu haline gelir.