Kaida za ka warware N+1 jerin buhattu da ka optimize Eloquent?

Question

Accepted Answer

The **N+1 query problem** — where accessing relationships in a loop triggers a separate query per record — is the most common Eloquent performance issue. **Eager loading** with `with()` is the primary fix, alongside other optimizations (selecting columns, chunking, indexing).

## Matsalar N+1 da gyaranta ta

```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()`** eager-loads relationships up front (one extra query per relationship instead of one per record), turning 101 queries into 2 — a dramatic improvement. This is the essential Eloquent optimization.

## Eager loading variations

```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)
```

## Kamata ka sami N+1 kai-kai

```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
```

Kayan aiki kamar **Debugbar/Telescope** suna nuna adadin buhattu per page (gani N+1 a gida), da `preventLazyLoading()` yana juya rashin son rai lazy loads zuwa kuskure a lokaci na ci gaba.

## Sauran Eloquent inganta

```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
```

## Me ya sa haka yake matukar mahimmanci

Warwarang buhattu N+1 da optimize Eloquent yana da mahimmanci performance ilimi ga Laravel aikace-aikace — the **N+1 query problem is the single most common and impactful performance issue** a cikin Laravel, da fahimtar yadda za ka hana shi yana da dole.

Matsoalar ta isa a saboda Eloquent da hankalin halin mu lauya **relationship access** (`$post->author`) ke fuskanta jiran buhattu database kowane lokaci, don haka lambar ta aiki da amfani a karamin bayanai suka rage sosai yayin bayani ya tarea (100 bayani suka zama 101 buhattu), sau da yawa ana gani cikin sakamakon a karkatar. **Eager loading da `with()`** shine mahimmancin gyaranta — karawa relationships a gida a jerin buhattu kaɗan a madadin gida ɗaya — da fahimtar sakarankiyarsa (marami, ciki cikin ciki, sakoye eager loads, `withCount`) yana rufe bukatun gida.
\'Sakamatsu mahimmanci shine fahimtar yadda ka sami **N+1 buhattu** (Debugbar/Telescope don gani adadin buhattu, `preventLazyLoading()` don juya rashin son rai lazy loads zuwa kuskure a ci gaba), don haka ka sami su kafin sakamakon.
\'Waje da N+1, sauran inganta — zaɓin ginshikin da ake bukata kawai, **chunking/cursors** don yin aiki da manyan bayanai ba tare da ɓata kumfa ba, database aggregation akan gida koleshan gida, da mahimmanci **indexing** dabarun bayanai/haɗa ginshikin (sau da yawa dabara ta database shine babbar nasara) — yana kammala kayan aiki.

Fahimtar waɗannan — musamman fahimtar da warwarang N+1 da `with()` eager loading — yana da mahimmanci babbar mataki ilimi da ya raba ƴan aiki waɗanda ke rubuta aikace-aikace na Laravel da iko daga waɗanda aikace-aikacen su suka rallewa yayin bayanai ya tarea, yana sa shi karɗa abubuwa masu mahimmanci na aiki.