Coding Interview Prep · Lezione

Ristrutturare query annidate in CTE

Un pattern da colloquio: trasformare una query annidata illeggibile in CTE organizzati per passaggi

Ristrutturare query annidate in CTE è una lezione Coding Interview Prep 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 Coding Interview Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Coding Interview Prep include 4 lezioni in totale.

Il refactoring durante il colloquio

Una richiesta tipica per un profilo mid-level è: ecco una query, la renda leggibile. L’intervistatore Le presenta un SELECT profondamente annidato e osserva come lo scompone. Trasformare l’annidamento in una sequenza di CTE con nome è la risposta più pulita.

Questa lezione illustra i passaggi esatti, così potrà eseguirli con calma alla lavagna.

Inizi dalla query più interna

Le sottoquery annidate vengono concettualmente eseguite dall’interno verso l’esterno. Perciò legga la query nello stesso modo: individui per prima il SELECT racchiuso tra parentesi più interne; quella sarà la prima fase della pipeline.

Gli assegni un nome descrittivo e lo trasformi in una CTE. Tutto ciò che faceva riferimento a quel blocco interno farà ora riferimento al nome della CTE.

SELECT *
FROM (
    SELECT customer_id, SUM(amount) AS total
    FROM orders
    GROUP BY customer_id
) t
WHERE t.total > 1000;

Porti un livello in una CTE

Prenda quella tabella derivata più interna e la trasformi in una CTE. La query esterna rimane invariata, salvo il fatto che ora esegue la selezione dalla CTE con nome.

Questo singolo passaggio elimina già un livello di annidamento mentale e assegna alla fase un nome significativo.

WITH spend AS (
    SELECT customer_id, SUM(amount) AS total
    FROM orders
    GROUP BY customer_id
)
SELECT *
FROM spend
WHERE total > 1000;

Un esempio davvero annidato

Ecco un caso più difficile da sottoporre a refactoring: due livelli di annidamento più un filtro di tipo correlato. L’obiettivo è calcolare il valore medio degli ordini tra i clienti appartenenti alla fascia di spesa più alta.

La query è corretta, ma difficile da leggere. La scomporremo fase per fase.

SELECT AVG(o.amount) AS avg_order
FROM orders o
WHERE o.customer_id IN (
    SELECT customer_id
    FROM (
        SELECT customer_id, SUM(amount) AS total
        FROM orders
        GROUP BY customer_id
    ) s
    WHERE s.total > 1000
);

Assegni un nome alla prima fase

Il blocco più interno calcola la spesa totale per cliente. Lo trasformi in una CTE chiamata spend. Ora il livello intermedio si limita a filtrare quella CTE.

Noti come ogni estrazione riduca di uno la profondità dell’annidamento e aggiunga un nome autoesplicativo.

WITH spend AS (
    SELECT customer_id, SUM(amount) AS total
    FROM orders
    GROUP BY customer_id
)
SELECT AVG(o.amount) AS avg_order
FROM orders o
WHERE o.customer_id IN (
    SELECT customer_id FROM spend WHERE total > 1000
);

Assegni un nome alla seconda fase

Estragga il filtro su spend nella CTE big_spenders. La query principale rimanente diventa un’unione piatta o un test di appartenenza rispetto a un insieme con un nome chiaro.

Ora ogni fase ha una sola responsabilità, caratteristica fondamentale di un SQL ben strutturato.

WITH spend AS (
    SELECT customer_id, SUM(amount) AS total
    FROM orders GROUP BY customer_id
),
big_spenders AS (
    SELECT customer_id FROM spend WHERE total > 1000
)
SELECT AVG(o.amount) AS avg_order
FROM orders o
JOIN big_spenders b ON b.customer_id = o.customer_id;

Preservare la semantica durante il refactoring

La regola d’oro è che un refactoring non deve modificare i risultati. Faccia attenzione alle insidie che alterano silenziosamente l’output:

Sostituire IN con una JOIN può introdurre righe duplicate se il lato destro non è distinto.
NOT IN con valori NULL si comporta in modo diverso da NOT EXISTS.
La granularità dell’aggregazione deve rimanere invariata.

Esponga questi rischi ad alta voce per dimostrare attenzione.

Verificare il refactoring

Come si dimostra che il refactoring è fedele all'originale? Dica che eseguirebbe entrambe le versioni e confronterebbe il numero di righe e un checksum, oppure farebbe il diff dei set di risultati su un campione.

In un colloquio, anche dire verificherei confrontando i conteggi e alcune righe campione dimostra una disciplina ingegneristica che va oltre la semplice riscrittura della sintassi.

SELECT COUNT(*), SUM(amount)
FROM orders
WHERE customer_id IN (SELECT customer_id FROM big_spenders);

Quando NON fare refactoring

Il refactoring non è sempre un miglioramento. Una singola sottoquery semplice può essere più chiara se lasciata così com'è, e anche suddividere eccessivamente la query in molte CTE minuscole può comprometterne la leggibilità.

Valuti caso per caso: faccia refactoring quando la nidificazione nasconde l'intento o quando la logica viene riutilizzata. Dica all'intervistatore che si fermerebbe quando la query si legge dall'alto verso il basso come una sequenza di passaggi distinti e con nomi espliciti.

La checklist del refactoring

Un metodo ripetibile da esporre:

Legga dall'interno verso l'esterno per trovare la sottoquery più profonda.
La estragga in una CTE con un nome.
Ripeta il procedimento verso l'esterno, un livello alla volta.
Dia a ogni fase un nome basato su ciò che produce.
Verifichi che i risultati non siano cambiati, prestando attenzione alle insidie di IN/JOIN e NULL.

In questo modo una query annidata che sembra complessa diventa una riscrittura ordinata e graduale.

Comunicare il proprio refactoring

Parli mentre lavora: Il blocco più interno calcola la spesa per cliente, quindi lo chiamerò spend. Il livello successivo filtra i clienti con spesa elevata. Infine, la query esterna calcola la media degli importi degli ordini.

Gli intervistatori valutano la capacità di comunicare tanto quanto la correttezza. Un refactoring spiegato a voce, fase per fase, mostra esattamente il livello di maturità intermedia che cercano.

Verifica rapida

Individui il primo passaggio corretto per trasformare una query profondamente annidata in CTE.

Riepilogo: refactoring con le CTE

Ha imparato un metodo di refactoring ordinato e ripetibile: leggere dall'interno verso l'esterno, estrarre la sottoquery più profonda in una CTE con un nome e procedere verso l'esterno un livello alla volta.

Dia a ogni fase un nome basato su ciò che produce.
Preservi la semantica, prestando attenzione ai duplicati causati da IN rispetto a JOIN e alle insidie legate a NULL.
Convalidi i risultati confrontando i conteggi e alcune righe campione.
Non suddivida eccessivamente la query: si fermi quando si legge come una sequenza chiara di passaggi con nomi espliciti.

Con questo si conclude il corso sulle CTE; ora può eseguire il refactoring con sicurezza durante un colloquio reale.

Domande Frequenti

La lezione «Ristrutturare query annidate in CTE» è gratuita?

Sì — il testo completo di «Ristrutturare query annidate in CTE» è 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 Coding Interview Prep, passa a CoddyKit PRO. Il corso Coding Interview Prep include 4 lezioni in totale.

Cosa imparerò in «Ristrutturare query annidate in CTE»?

Un pattern da colloquio: trasformare una query annidata illeggibile in CTE organizzati per passaggi Eserciti Coding Interview Prep 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 Coding Interview Prep?

Non è richiesta alcuna esperienza precedente. Coding Interview Prep 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 «Ristrutturare query annidate in CTE»?

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 Coding Interview Prep?

Sì. Ogni lezione Coding Interview Prep 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 Coding Interview Prep