SQL Academy · Lezione

Prestazioni di EXISTS e JOIN

Scelga il pattern più veloce

Lezione 4 di 413 passaggi

Prestazioni di EXISTS e JOIN è una lezione SQL 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 SQL Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso SQL Academy include 4 lezioni in totale.

Perché le prestazioni sono importanti

Quando dovete verificare se esistono righe correlate in un'altra tabella, SQL mette a disposizione diversi strumenti: EXISTS, IN e JOIN. Tutti producono risultati corretti, ma le loro prestazioni possono variare notevolmente in base alle dimensioni dei dati, agli indici e al motore del database.

In questa lezione imparerete come funziona internamente ciascun approccio e quando scegliere l'uno o l'altro.

Tabelle di esempio

In tutta la lezione useremo due tabelle: customers e orders. Un cliente può avere zero o molti ordini. Si tratta di una classica relazione uno-a-molti, ideale per mettere alla prova i pattern EXISTS e JOIN.

CREATE TABLE customers (
  id   SERIAL PRIMARY KEY,
  name VARCHAR(100)
);

CREATE TABLE orders (
  id          SERIAL PRIMARY KEY,
  customer_id INT REFERENCES customers(id),
  total       NUMERIC(10,2)
);

INSERT INTO customers (name) VALUES
  ('Alice'), ('Bob'), ('Carol'), ('Dave');

INSERT INTO orders (customer_id, total) VALUES
  (1, 120.00), (1, 85.50), (3, 200.00);

L'approccio con JOIN

Un pattern comune consiste nell'usare INNER JOIN per trovare i clienti che hanno almeno un ordine. Funziona, ma notate il problema: se un cliente ha cinque ordini, compare cinque volte nell'insieme dei risultati prima che DISTINCT elimini i duplicati.

Questa duplicazione è lavoro aggiuntivo per il database: prima costruisce il risultato completo del join e poi rimuove i duplicati.

SELECT DISTINCT c.id, c.name
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

L'approccio con EXISTS

EXISTS risponde a una domanda sì/no: esiste almeno una riga corrispondente? Nel momento in cui il motore trova la prima corrispondenza, interrompe la scansione: questa operazione si chiama valutazione a cortocircuito.

Non vengono prodotti duplicati e non è necessario usare DISTINCT, perché EXISTS non restituisce mai effettivamente le righe interne.

SELECT c.id, c.name
FROM customers c
WHERE EXISTS (
  SELECT 1
  FROM orders o
  WHERE o.customer_id = c.id
);

Il cortocircuito è fondamentale

La valutazione a cortocircuito significa che la sottoquery si interrompe non appena viene trovata una riga valida. Che un cliente abbia 1 ordine o 10.000 ordini, EXISTS legge solo fino alla prima corrispondenza.

Un JOIN deve leggere tutte le righe corrispondenti per costruire l'insieme dei risultati, anche quando vi interessa solo verificare l'esistenza. Su tabelle con molte colonne e numerose righe figlie per ogni riga padre, questa differenza cresce rapidamente.

-- EXISTS stops after finding row #1
SELECT c.name
FROM customers c
WHERE EXISTS (
  SELECT 1          -- 'SELECT 1' is conventional; the value does not matter
  FROM orders o
  WHERE o.customer_id = c.id
);

-- JOIN scans ALL matching order rows
SELECT DISTINCT c.name
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

NOT EXISTS rispetto a LEFT JOIN ... IS NULL

Per il controllo opposto, cioè trovare i clienti senza alcun ordine, potete usare NOT EXISTS oppure il pattern LEFT JOIN ... WHERE IS NULL. Entrambi sono comuni, ma NOT EXISTS è generalmente più leggibile e spesso è preferito dall'ottimizzatore.

-- NOT EXISTS
SELECT c.id, c.name
FROM customers c
WHERE NOT EXISTS (
  SELECT 1
  FROM orders o
  WHERE o.customer_id = c.id
);

-- LEFT JOIN ... IS NULL (equivalent result)
SELECT c.id, c.name
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.id IS NULL;

Il ruolo degli indici

Sia EXISTS sia JOIN traggono enormi vantaggi da un indice sulla colonna della chiave esterna. Senza un indice su orders.customer_id, ogni riga esterna attiva una scansione completa della tabella orders.

L'aggiunta di questo indice è spesso il miglior intervento singolo per le prestazioni, più importante della scelta tra EXISTS e JOIN.

-- Create an index on the foreign key
CREATE INDEX idx_orders_customer_id ON orders(customer_id);

-- Now both patterns use an index lookup instead of a full scan
EXPLAIN
SELECT c.name
FROM customers c
WHERE EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id
);

Leggere l'output di EXPLAIN

Usate EXPLAIN (oppure EXPLAIN ANALYZE per eseguire anche la query) per vedere come il database esegue una query. Cercate questi indicatori:

Index Scan: bene; l'indice viene utilizzato.
Seq Scan su una tabella di grandi dimensioni: potenziale campanello d'allarme; un indice potrebbe essere utile.
Hash Join / Nested Loop: l'algoritmo di join scelto; Nested Loop funziona bene insieme alle scansioni tramite indice.

EXPLAIN ANALYZE
SELECT c.name
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id
GROUP BY c.id, c.name
HAVING COUNT(o.id) > 0;

Quando JOIN è la scelta migliore

EXISTS è ideale per i semplici controlli di esistenza. Tuttavia, se vi servono anche dati dalla tabella correlata, come il totale o la data dell'ordine, dovete usare un JOIN. Non è possibile restituire colonne dall'interno di una sottoquery EXISTS.

Scegliete lo strumento adatto alla domanda: EXISTS per "esiste?", JOIN per "mostrami i dati di entrambe le tabelle".

-- Need order data? JOIN is the only option.
SELECT c.name, o.total, o.id AS order_id
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id
ORDER BY c.name;

IN ed EXISTS su insiemi di grandi dimensioni

IN (subquery) valuta prima l'intera sottoquery, crea un elenco di valori in memoria e poi confronta ogni riga esterna con quell'elenco. Con milioni di righe, questo elenco può esaurire la memoria.

EXISTS viene valutato riga per riga e interrompe la ricerca al primo risultato, quindi non materializza mai l'intero insieme di risultati interno. Nei controlli correlati su grandi volumi, EXISTS è quasi sempre più veloce di IN.

-- IN builds the full list first
SELECT name
FROM customers
WHERE id IN (
  SELECT customer_id FROM orders
);

-- EXISTS evaluates per-row and short-circuits
SELECT name
FROM customers c
WHERE EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id
);

Schema decisionale rapido

Ecco un riferimento rapido per scegliere il pattern corretto:

EXISTS — deve solo verificare se esiste una corrispondenza; tabelle figlie di grandi dimensioni; utilizzi NOT EXISTS per un anti-join.
JOIN — servono colonne della tabella correlata; aggregazioni su entrambe le tabelle.
IN — brevi elenchi statici di valori (WHERE status IN ('active', 'pending')); lo eviti per le sottoquery di grandi dimensioni.
Indicizzi sempre la colonna della chiave esterna: questo è più importante della scelta della sintassi.

Verifica rapida

Quale affermazione spiega meglio perché EXISTS può essere più veloce di INNER JOIN + DISTINCT quando si verifica la presenza di righe correlate?

Rispondi nella lezione interattiva

Riepilogo della lezione

In questa lezione ha imparato a scegliere tra EXISTS e JOIN per scrivere SQL attento alle prestazioni:

EXISTS interrompe la scansione al primo risultato — smette di cercare non appena trova la prima corrispondenza, evitando i duplicati senza dover usare DISTINCT.
JOIN restituisce tutte le righe corrispondenti — lo utilizzi quando servono dati della tabella correlata, ma aggiunga DISTINCT o GROUP BY se le interessa solo la riga della tabella principale.
NOT EXISTS è un pattern chiaro per un anti-join; LEFT JOIN ... IS NULL è equivalente, ma più verboso.
Eviti IN con sottoquery di grandi dimensioni — materializza l'intero risultato interno; EXISTS usa la memoria in modo più efficiente.
Indicizzi le chiavi esterne — questo singolo passaggio spesso offre il maggiore miglioramento delle prestazioni, indipendentemente dalla sintassi scelta.
Utilizzi EXPLAIN / EXPLAIN ANALYZE per verificare il piano di esecuzione e confermare che gli indici vengano utilizzati.

Gratis per iniziare

Impara SQL con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 46
Lezioni: 183

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Prestazioni di EXISTS e JOIN» è gratuita?

Sì — il testo completo di «Prestazioni di EXISTS e JOIN» è 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 SQL Academy, passa a CoddyKit PRO. Il corso SQL Academy include 4 lezioni in totale.

Cosa imparerò in «Prestazioni di EXISTS e JOIN»?

Scelga il pattern più veloce Eserciti SQL 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 SQL Academy?

Non è richiesta alcuna esperienza precedente. SQL 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 di EXISTS e JOIN»?

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 SQL Academy?

Sì. Ogni lezione SQL 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 SQL Academy