PHP Academy · Lezione

Prestazioni: N+1 e DataLoader

Raggruppi e memorizzi nella cache la risoluzione dei campi per mantenere alte le prestazioni

Prestazioni: N+1 e DataLoader è una lezione PHP Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento PHP Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso PHP Academy include 4 lezioni in totale.

Il killer silenzioso: N+1

La più grande trappola delle prestazioni di GraphQL è il problema delle query N+1. È insidioso perché ogni resolver sembra innocuo preso singolarmente, ma inserisca una lista e un campo per elemento e verrà eseguita una query per la lista più una query per ogni elemento. Con 100 elementi sono 101 round trip. Questa lezione mostra come ridurli a poche query eseguite in batch con DataLoader.

N+1 in pratica

Consideri { posts { author { name } } }. Il resolver di posts esegue una query. Poi, per ogni post, il resolver di author esegue una query propria. Il codice ingenuo riportato di seguito rende evidente il costo.

<?php
// 1 query for posts...
$posts = [['id'=>1,'author_id'=>7],['id'=>2,'author_id'=>7],['id'=>3,'author_id'=>9]];

$queries = 1;
foreach ($posts as $post) {
    // ...then 1 query PER post to fetch its author
    $queries++;
    // SELECT * FROM users WHERE id = $post['author_id']
}
echo "Total DB queries: {$queries}\n"; // Total DB queries: 4

L'intuizione: raggruppare per livello

GraphQL risolve i campi livello per livello. Tutti i resolver di author per l'elenco dei post vengono eseguiti nello stesso tick. Se possiamo rimandare ogni ricerca dell'autore, raccogliere gli ID richiesti ed eseguire poi un unico WHERE id IN (...), trasformiamo N query in una sola. È esattamente ciò che fornisce GraphQL\Deferred.

<?php
$ids = [7, 7, 9];
$unique = array_values(array_unique($ids));
// One query instead of three:
echo 'SELECT * FROM users WHERE id IN (' . implode(',', $unique) . ")\n";
// SELECT * FROM users WHERE id IN (7,9)

Un buffer/loader minimale

Questa è l'essenza di un DataLoader: un buffer che accumula gli ID, li carica una sola volta tramite una funzione batch e fornisce i risultati dalla cache. La stessa chiave richiesta due volte viene caricata una sola volta: deduplicazione automatica.

<?php
class UserLoader {
    private array $queue = [];
    private array $cache = [];
    public function __construct(private \Closure $batchFn) {}

    public function add(int $id): void { $this->queue[$id] = true; }

    public function loadOnce(): void {
        $missing = array_diff(array_keys($this->queue), array_keys($this->cache));
        if ($missing) {
            foreach (($this->batchFn)(array_values($missing)) as $id => $row) {
                $this->cache[$id] = $row;
            }
        }
        $this->queue = [];
    }

    public function get(int $id): mixed { return $this->cache[$id] ?? null; }
}

Collegarlo a un resolver

Il resolver di author mette in coda l'ID e restituisce un Deferred. graphql-php esegue tutti i deferred dopo il livello corrente, quindi quando la closure viene eseguita tutti gli ID degli autori dell'intera lista sono già stati messi in coda. Una chiamata a loadOnce() attiva una singola query batch.

<?php
use GraphQL\Deferred;

$authorField = [
    'type' => $userType,
    'resolve' => function ($post, $args, $context) {
        /** @var UserLoader $loader */
        $loader = $context['userLoader'];
        $loader->add($post['author_id']);
        return new Deferred(function () use ($loader, $post) {
            $loader->loadOnce();              // batches across all posts
            return $loader->get($post['author_id']);
        });
    },
];

Usare la libreria overblog/dataloader

Raramente è necessario implementare tutto da zero. overblog/dataloader-php è il port consolidato del DataLoader di Facebook. Gli si fornisce una funzione batch che riceve un array di chiavi e deve restituire una promise di valori nello stesso ordine. La libreria gestisce caching, deduplicazione e risoluzione delle promise.

composer require overblog/dataloader-php

Costruire un DataLoader

Il contratto della funzione batch è rigoroso: dato [k1, k2, k3], deve risolvere in [v1, v2, v3], mantenendo le posizioni. Indicizzi le righe del database per chiave e ricostruisca l'ordine dell'input, in modo che le chiavi mancanti diventino null.

<?php
use Overblog\DataLoader\DataLoader;
use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
use Overblog\PromiseAdapter\Adapter\WebonyxGraphQLSyncPromiseAdapter;

$adapter = new WebonyxGraphQLSyncPromiseAdapter(new SyncPromiseAdapter());

$userLoader = new DataLoader(function (array $ids) use ($adapter, $db) {
    $rows = $db->usersByIds($ids);          // SELECT ... WHERE id IN (...)
    $byId = [];
    foreach ($rows as $r) { $byId[$r['id']] = $r; }
    // MUST return values in the SAME ORDER as $ids
    $ordered = array_map(fn($id) => $byId[$id] ?? null, $ids);
    return $adapter->createFulfilled($ordered);
}, $adapter);

Risolvere tramite il loader

Nel resolver è sufficiente chiamare $loader->load($id), che restituisce una promise. graphql-php, tramite l'adapter, raccoglie queste promise e attiva automaticamente il batch alla fine del tick. Non è necessario alcun buffering manuale.

<?php
$authorField = [
    'type' => $userType,
    'resolve' => fn($post, $args, $context) =>
        $context['userLoader']->load($post['author_id']),
];

La durata per richiesta è fondamentale

I DataLoader memorizzano i risultati nella cache in base alla chiave, quindi devono essere creati da zero per ogni richiesta. Un loader condiviso tra più richieste restituirebbe dati obsoleti e causerebbe una perdita di memoria. Costruisca i loader quando compone il $context della richiesta e li elimini al termine della richiesta.

<?php
// Per request: brand new loaders, attached to context
function buildContext($db, $currentUser): array {
    return [
        'db' => $db,
        'user' => $currentUser,
        'userLoader' => makeUserLoader($db),  // fresh, not a singleton
        'postLoader' => makePostLoader($db),
    ];
}

Altre protezioni dalle limitazioni di prestazioni

DataLoader risolve il problema delle letture N+1, ma una query ostile o scritta senza attenzione può comunque danneggiare il sistema. Aggiunga:

Limitazione della profondità delle query — la regola QueryDepth rifiuta le query annidate in modo patologico.
Complessità delle query — QueryComplexity assegna un budget di costo a ogni campo.
Query persistenti — consenta solo le operazioni presenti in una allow-list nota.
Paginazione — non risolva mai elenchi senza limiti; utilizzi connessioni basate su cursore.

<?php
use GraphQL\Validator\Rules\QueryDepth;
use GraphQL\Validator\Rules\QueryComplexity;
use GraphQL\Validator\DocumentValidator;

DocumentValidator::addRule(new QueryDepth(10));
DocumentValidator::addRule(new QueryComplexity(200));

Misurare il miglioramento

Quantifichi sempre il miglioramento. Avvolga il livello di accesso al database per contare le query in un test, quindi verifichi che la versione con batch esegua un numero limitato di query indipendentemente dalla dimensione dell'elenco. In questo modo è possibile individuare regressioni in cui qualcuno aggiunge un resolver annidato ingenuo e reintroduce silenziosamente N+1.

<?php
class CountingDb {
    public int $queries = 0;
    public function usersByIds(array $ids): array {
        $this->queries++;            // one batched call
        return array_map(fn($id) => ['id' => $id], $ids);
    }
}

$db = new CountingDb();
$db->usersByIds([7, 9, 11, 13]);     // 4 authors
echo "Queries for 4 authors: {$db->queries}\n"; // Queries for 4 authors: 1

Controllo rapido

Perché i DataLoader devono essere creati per ogni richiesta?

Riepilogo

Ha eliminato la peggiore trappola delle prestazioni di GraphQL:

I campi di elenchi annidati causano N+1: una query per ogni elemento.
graphql-php risolve i campi livello per livello, quindi rimandare le operazioni consente di raggruppare tutte le chiavi in un'unica query IN (...).
GraphQL\Deferred è il costrutto di base; overblog/dataloader-php riunisce batching, caching per chiave e deduplicazione.
La funzione batch deve restituire i valori nello stesso ordine delle chiavi di input.
I loader hanno durata pari a una richiesta; aggiunga limiti di profondità e complessità, oltre alla paginazione, come ulteriori protezioni.

Domande Frequenti

La lezione «Prestazioni: N+1 e DataLoader» è gratuita?

Sì — il testo completo di «Prestazioni: N+1 e DataLoader» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso PHP Academy, passa a CoddyKit PRO. Il corso PHP Academy include 4 lezioni in totale.

Cosa imparerò in «Prestazioni: N+1 e DataLoader»?

Raggruppi e memorizzi nella cache la risoluzione dei campi per mantenere alte le prestazioni Eserciti PHP Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare PHP Academy?

Non è richiesta alcuna esperienza precedente. PHP Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Prestazioni: N+1 e DataLoader»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione PHP Academy?

Sì. Ogni lezione PHP Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a PHP Academy