Guida Definitiva alle Query N+1 in Laravel: Identificazione e Soluzioni

Il problema delle query N+1 è uno dei colli di bottiglia più comuni nelle applicazioni Laravel.

Questa criticità si presenta quando il codice esegue una query per ottenere una lista di record e poi una query aggiuntiva per ciascun record recuperato, rallentando notevolmente l’applicazione all’aumentare dei dati.

Cos’è il Problema delle Query N+1 in Laravel?

Un esempio classico di query N+1 si verifica quando un’applicazione ha tabelle correlate, come Articoli e Commenti. Supponiamo di avere il seguente codice nel nostro controller:

$posts = Post::all();

Con questo codice, ci aspettiamo un’unica query per ottenere tutti i post. Tuttavia, se nella vista aggiungiamo la logica per visualizzare i commenti di ogni post, Laravel eseguirà una query per ciascun post.

@foreach ($posts as $post)
    <h2>{{ $post->title }}</h2>
    <p>Commenti: {{ $post->comments->count() }}</p>
@endforeach

Questo codice apparentemente innocuo genera le seguenti query: Immaginiamo di avere:

• 10 Post (1 Query)
• 100 commenti per ogni Post (10x100=1000 Query)

Avrò quindi in totale effettuato 1000 (N) + 1 Query (l’unica che avevo preventivato).

SELECT * FROM posts;  -- Query 1
SELECT * FROM comments WHERE post_id = 1;  -- Query 2
SELECT * FROM comments WHERE post_id = 2;  -- Query 3
SELECT * FROM comments WHERE post_id = 3;  -- Query 4
-- ... e così via per ogni post

Come Identificare le Query N+1 con Laravel Debugbar

Prima installazione:

composer require barryvdh/laravel-debugbar --dev

Abilitando la modalità debug (APPDEBUG=true), la Debugbar mostrerà tutte le query eseguite, rendendo semplice l’individuazione dei pattern N+1.

Come Risolvere il Problema delle Query N+1 in Laravel

Eager Loading Base

La soluzione più comune è l’eager loading usando il metodo eloquent with():

// Invece di
$posts = Post::all();

// Puoi utilizzare il metodo esplicito
$posts = Post::with('comments')->get();

Questo genererà solo 2 query:

SELECT * FROM posts;
SELECT * FROM comments WHERE post_id IN (1, 2, 3, ...);

Questa soluzione è efficace nel 90% dei casi.

Eager Loading Base con Count

Se necessiti di una soluzione ad hoc per i conteggi, puoi utilizzare il metodo eloquent withCount.

Se riprendiamo l’eager loading base di prima, possiamo constatare che:

$posts = Post::with('comments')->get();


<ul>
    @foreach ($posts as $post)
        <li>{{ $post->title }} - Commenti: {{ $post->comments->count() }}</li>
    @endforeach
</ul>

Ti restituirà le 2 query cosi:

select * from `posts`
select * from `comments` where `comments`.`post_id` in (1, 2, 3, 4, 5, 6,...)

Utilizzando. invece, il withCount avrai ottimizzato il tutto e reso ancora piu veloce!

$posts = Post::withCount('comments')->get();
<ul>
    @foreach ($posts as $post)
        <li>{{ $post->title }} - Commenti: {{ $post->comments_count }}</li>
    @endforeach
</ul>

Avrai utilizzato 1 sola query!

 select `posts`.*, (select count(*) from `comments` where `posts`.`id` = `comments`.`post_id`) as `comments_count` from `posts`

Casi d’Uso Avanzati

1. Nested Relationships in Laravel

L’eager loading delle relazioni annidate è fondamentale quando lavori con strutture dati complesse in Laravel. Usando il metodo with(), puoi caricare più livelli di relazioni in una singola query:

  $posts = Post::with(['comments.user'])->get();

Questo approccio è particolarmente efficace quando devi accedere a dati come i commenti di un post e contemporaneamente le informazioni dell’utente che ha scritto ogni commento, riducendo drasticamente il numero di query al database.

2. Eager Loading di Campi Specifici

Per ottimizzare ulteriormente le performance, Laravel permette di selezionare solo i campi necessari durante l’eager loading:

$posts = Post::with(['user:id,name', 'comments:id,post_id,content'])->get();

Questa tecnica è particolarmente utile quando lavori con tabelle che contengono molte colonne ma ne necessiti solo alcune, riducendo così il consumo di memoria e migliorando i tempi di risposta.

3. Eager Loading Condizionale

Laravel offre la possibilità di applicare condizioni all’eager loading, permettendoti di caricare relazioni in base a specifici criteri:

$posts = Post::with(['comments' => function ($query) {
    $query->when(request('show_recent'), function ($q) {
        return $q->where('created_at', '>=', now()->subDays(7));
    });
}])->get();

Questo approccio è ideale per implementare filtri dinamici e personalizzare il caricamento dei dati in base alle esigenze dell’utente.

Best Practices per Evitare il Problema delle Query N+1

1. Utilizzare Resources/API Resources

Le API Resources di Laravel sono uno strumento potente per standardizzare e ottimizzare la trasformazione dei modelli in JSON:

class PostResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'comments_count' => $this->when(
                $this->comments_count !== null,
                $this->comments_count
            ),
            'comments' => CommentResource::collection(
                $this->whenLoaded('comments')
            ),
        ];
    }
}

Questo pattern garantisce consistenza nella tua API, gestisce automaticamente le relazioni eager loaded e permette una facile manutenzione del codice.

2. Global Scope per Relazioni Comuni

Implementare Global Scopes per le relazioni frequentemente utilizzate può semplificare il codice e garantire consistenza:

class Post extends Model
{
    protected static function booted()
    {
        static::addGlobalScope('withCommonRelations', function ($builder) {
            $builder->withCount('comments');
        });
    }
}

Questa pratica è particolarmente utile quando determinate relazioni sono necessarie in gran parte dell’applicazione, evitando duplicazioni di codice e potenziali dimenticanze.

3. Local Scope per Query Ottimizzate

I Local Scopes offrono un modo elegante per incapsulare query complesse e riutilizzabili:

class Post extends Model
{
    public function scopeWithFullDetails($query)
    {
        return $query->with([
            'comments' => function ($query) {
                $query->latest()->limit(5);
            },
            'users',
        ])->withCount('comments');
    }
}

Questo approccio migliora la manutenibilità del codice e permette di standardizzare le query più comuni all’interno dell’applicazione.

4. Monitoraggio Continuo e Ottimizzazione

Per mantenere alte le prestazioni, è essenziale monitorare e ottimizzare costantemente il codice: • Utilizza Laravel Debugbar per individuare query lente. • Implementa la cache dove necessario. • Aggiungi indici alle colonne usate frequentemente nelle relazioni. • Effettua un’analisi periodica delle performance.

Conclusione

Evitare il problema delle query N+1 in Laravel è fondamentale per migliorare le performance della tua applicazione e garantire un’esperienza utente fluida. Con le giuste tecniche di eager loading e un monitoraggio costante, è possibile ottimizzare drasticamente la velocità delle query, riducendo il carico sul database e offrendo una maggiore scalabilità al progetto.