O problema de consultas N+1 — onde acessar relacionamentos em um loop dispara uma consulta separada por registro — é o problema de desempenho mais comum do Eloquent. Eager loading com with() é a correção principal, juntamente com outras otimizações (selecionar colunas, chunking, indexação).
= ::();
( ) {
->author->name;
}
= ::()->();
( ) {
->author->name;
}
with() carrega relacionamentos antecipadamente (uma consulta extra por relacionamento em vez de uma por registro), transformando 101 consultas em 2 — uma melhoria dramática. Esta é a otimização essencial do Eloquent.
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)
// 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
Ferramentas como Debugbar/Telescope mostram contagens de consultas por página (visualize N+1 visualmente), e preventLazyLoading() transforma carregamentos lazy acidentais em erros durante o desenvolvimento.
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
Corrigir consultas N+1 e otimizar Eloquent é conhecimento de desempenho crítico para aplicações Laravel — o problema de consultas N+1 é o único problema de desempenho mais comum e impactante no Laravel, e compreender como evitá-lo é essencial.
O problema é insidioso porque o acesso conveniente a relacionamentos do Eloquent ($post->author) dispara silenciosamente uma consulta ao banco de dados cada vez, então código que funciona bem com poucos dados se degrada catastroficamente conforme os dados crescem (100 registros se tornando 101 consultas), frequentemente descoberto apenas em produção sob carga. Eager loading com with() é a solução essencial — carregando relacionamentos antecipadamente em um par de consultas em vez de uma por registro — e conhecer suas variações (múltiplas, aninhadas, eager loads restritos, withCount) cobre as necessidades comuns.
Igualmente valioso é saber como detectar problemas N+1 (Debugbar/Telescope para ver contagens de consultas, preventLazyLoading() para transformar carregamentos lazy acidentais em erros no desenvolvimento), para que você os encontre antes da produção.
Além de N+1, outras otimizações — selecionar apenas colunas necessárias, chunking/cursors para processar grandes conjuntos de dados sem esgotar a memória, agregação em banco de dados sobre processamento de coleção no PHP, e crucialmente indexação de colunas filtradas/unidas (frequentemente a maior vitória em nível de banco de dados) — completam o conjunto de ferramentas.
Compreender essas questões — especialmente reconhecer e corrigir N+1 com eager loading — é conhecimento importante de nível sênior que distingue desenvolvedores que escrevem aplicações Laravel performáticas daqueles cujos aplicativos desaceleram conforme os dados crescem, tornando-se um tópico altamente relevante e valioso para construir aplicações que escalam.