Comment corriger les requêtes N+1 et optimiser Eloquent ?

Question

Accepted Answer

Le **problème des requêtes N+1** — où accéder à des relations dans une boucle déclenche une requête distincte par enregistrement — est le problème de performance Eloquent le plus courant. Le **chargement préalable** (eager loading) avec `with()` est la solution principale, aux côtés d'autres optimisations (sélection de colonnes, chunking, indexation).

## Le problème N+1 et sa solution

```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()`** charge les relations à l'avance (une requête supplémentaire par relation au lieu d'une par enregistrement), transformant 101 requêtes en 2 — une amélioration spectaculaire. C'est l'optimisation Eloquent essentielle.

## Variations du chargement préalable

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

## Détecter automatiquement N+1

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

Des outils comme **Debugbar/Telescope** affichent le nombre de requêtes par page (identifier N+1 visuellement), et `preventLazyLoading()` transforme les chargements accidentels en erreurs pendant le développement.

## Autres optimisations Eloquent

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

## Pourquoi c'est important

Corriger les requêtes N+1 et optimiser Eloquent est une connaissance critique en matière de performance pour les applications Laravel — le **problème des requêtes N+1 est l'unique problème de performance le plus courant et le plus impactant** dans Laravel, et comprendre comment le prévenir est essentiel.

Le problème est insidieux car l'accès pratique aux relations d'Eloquent (`$post->author`) déclenche silencieusement une requête de base de données à chaque fois, donc du code qui fonctionne bien avec peu de données se dégrade catastrophiquement à mesure que les données augmentent (100 enregistrements devenant 101 requêtes), souvent découvert seulement en production sous charge. Le **chargement préalable avec `with()`** est la solution essentielle — charger les relations à l'avance en quelques requêtes au lieu d'une par enregistrement — et connaître ses variations (multiples, imbriquées, chargements préalables contraints, `withCount`) couvre les besoins courants.

Également précieux est savoir comment **détecter les problèmes N+1** (Debugbar/Telescope pour voir le nombre de requêtes, `preventLazyLoading()` pour transformer les chargements accidentels en erreurs en développement), afin de les trouver avant la production.

Au-delà de N+1, d'autres optimisations — sélectionner uniquement les colonnes nécessaires, **chunking/cursors** pour traiter les grands datasets sans épuiser la mémoire, agrégation de base de données plutôt que traitement côté PHP, et cruccialement **indexation** des colonnes filtrées/jointes (souvent le plus grand gain au niveau de la base de données) — complètent la boîte à outils.

Comprendre celles-ci — en particulier reconnaître et corriger N+1 avec le chargement préalable — est une connaissance importante de niveau senior qui distingue les développeurs qui écrivent des applications Laravel performantes de ceux dont les applications ralentissent à mesure que les données augmentent, ce qui en fait un sujet fréquemment pertinent et de grande valeur pour construire des applications qui s'adaptent à la croissance.