¿Cómo solucionas consultas N+1 y optimizas Eloquent?

Question

Accepted Answer

El **problema de consultas N+1** — donde acceder a relaciones en un bucle desencadena una consulta separada por registro — es el problema de rendimiento más común en Eloquent. La **carga ansiosa** con `with()` es la solución principal, junto con otras optimizaciones (seleccionar columnas, chunking, indexación).

## Por qué es importante

```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()`** carga relaciones de forma ansiosa por adelantado (una consulta adicional por relación en lugar de una por registro), convirtiendo 101 consultas en 2 — una mejora dramática. Esta es la optimización esencial en Eloquent.

## Variaciones de carga ansiosa

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

## Detectar N+1 automáticamente

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

Herramientas como **Debugbar/Telescope** muestran el número de consultas por página (detectar N+1 visualmente), y `preventLazyLoading()` convierte cargas perezosas accidentales en errores durante el desarrollo.

## Otras optimizaciones en 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
```

## Por qué es importante

Solucionar consultas N+1 y optimizar Eloquent es conocimiento crítico de rendimiento para aplicaciones Laravel — el **problema de consultas N+1 es el problema de rendimiento más común e impactante** en Laravel, y entender cómo prevenirlo es esencial.

El problema es insidioso porque el acceso conveniente a relaciones de Eloquent (`$post->author`) desencadena silenciosamente una consulta de base de datos cada vez, por lo que el código que funciona bien con pocos datos se degrada catastróficamente a medida que crecen los datos (100 registros convirtiéndose en 101 consultas), a menudo solo se descubre en producción bajo carga. La **carga ansiosa con `with()`** es la solución esencial — cargar relaciones por adelantado en un par de consultas en lugar de una por registro — y conocer sus variaciones (múltiples, anidadas, cargas ansiosas restringidas, `withCount`) cubre las necesidades comunes.

Igualmente valioso es saber cómo **detectar problemas N+1** (Debugbar/Telescope para ver el número de consultas, `preventLazyLoading()` para convertir cargas perezosas accidentales en errores en el desarrollo), para que los encuentres antes de la producción.

Más allá de N+1, otras optimizaciones — seleccionar solo las columnas necesarias, **chunking/cursors** para procesar grandes conjuntos de datos sin agotar la memoria, agregación de base de datos sobre procesamiento de colecciones del lado de PHP, e indexación crucial de columnas filtradas/unidas (a menudo la mayor ganancia a nivel de base de datos) — complementan el conjunto de herramientas.

Entender estos — especialmente reconocer y solucionar N+1 con carga ansiosa — es conocimiento importante a nivel senior que distingue a los desarrolladores que escriben aplicaciones Laravel performantes de aquellos cuyas aplicaciones se ralentizan mientras los datos crecen, lo que lo convierte en un tema frecuentemente relevante y de alto valor para construir aplicaciones que se escalen.