0Pricing
SQL Interview Prep · Leçon

Enchaîner plusieurs CTE

Construire un pipeline d’étapes nommées qui se référencent les unes les autres

Enchaîner plusieurs CTE est une leçon SQL Interview Prep gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage SQL Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Interview Prep comprend 4 leçons au total.

Pourquoi enchaîner les CTE

Les problèmes d'entretien technique réels tiennent rarement en une seule étape. Enchaîner les CTE vous permet de construire une chaîne de traitement composée d'étapes nommées, où chaque étape transforme la sortie de la précédente. Cela correspond à la manière dont un ingénieur expérimenté décompose une requête complexe en éléments gérables.

Au lieu d'imbriquer des sous-requêtes sur trois niveaux, vous écrivez chaque étape une seule fois, lui donnez un nom, puis laissez les étapes suivantes la référencer.

La syntaxe séparée par des virgules

Pour définir plusieurs CTE, écrivez WITH une seule fois, puis séparez chaque bloc nommé par une virgule. Vous ne devez pas répéter le mot-clé WITH.

  • Un seul WITH au début.
  • Une virgule entre chaque définition de CTE.
  • Aucune virgule avant la requête principale finale.
WITH a AS (
    SELECT customer_id FROM orders
),
b AS (
    SELECT customer_id FROM a
)
SELECT *
FROM b;

Les CTE suivantes peuvent référencer les précédentes

C'est là toute la puissance de l'enchaînement : une CTE peut lire les données de n'importe quelle CTE définie avant elle. Cette visibilité uniquement vers l'avant vous permet de construire une chaîne de dépendances.

Une CTE précédente ne peut pas voir une CTE suivante ; l'ordre est donc important. Organisez vos étapes des données brutes vers la forme finale.

WITH filtered AS (
    SELECT *
    FROM events
    WHERE event_type = 'purchase'
),
per_user AS (
    SELECT user_id, COUNT(*) AS purchases
    FROM filtered
    GROUP BY user_id
)
SELECT *
FROM per_user;

Exemple détaillé : une chaîne de traitement en trois étapes

Question : parmi les clients ayant dépensé plus de 1 000 dollars, quelle est la dépense moyenne ? Décomposez le problème en trois étapes : calculer la dépense totale par client, filtrer les clients à forte dépense, puis calculer leur moyenne.

Chaque nom de CTE décrit son objectif, ce qui permet à un évaluateur de comprendre immédiatement le déroulement.

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

L'ordre des définitions est important

Comme la visibilité ne s'exerce que vers l'avant, une CTE qui dépend d'une autre doit être placée après sa dépendance. Si vous référencez un nom qui n'a pas encore été défini, la base de données génère une erreur « la relation n'existe pas ».

Une bonne habitude consiste à lire votre liste de CTE de haut en bas et à vérifier que chaque nom utilisé est déjà apparu plus haut.

Référencer une CTE depuis plusieurs autres

Une seule CTE peut alimenter plusieurs CTE en aval. C'est là que l'enchaînement est supérieur aux sous-requêtes imbriquées : vous calculez une base une seule fois, puis vous créez plusieurs branches à partir d'elle.

Ici, active et recent lisent toutes deux les données de base, ce qui évite de dupliquer la logique.

WITH base AS (
    SELECT * FROM users WHERE deleted = false
),
active AS (
    SELECT id FROM base WHERE last_login > NOW() - INTERVAL '7 days'
),
recent AS (
    SELECT id FROM base WHERE created_at > NOW() - INTERVAL '30 days'
)
SELECT (SELECT COUNT(*) FROM active) AS active_cnt,
       (SELECT COUNT(*) FROM recent) AS recent_cnt;

Joindre deux CTE

Les CTE enchaînées sont souvent jointes dans la requête principale. Calculez chaque côté séparément, puis combinez-les. Chaque calcul reste ainsi isolé et la jointure demeure simple.

Nous calculons ci-dessous séparément le nombre de commandes et le nombre de remboursements, puis nous les joignons pour chaque client.

WITH orders_cte AS (
    SELECT customer_id, COUNT(*) AS orders
    FROM orders GROUP BY customer_id
),
refunds_cte AS (
    SELECT customer_id, COUNT(*) AS refunds
    FROM refunds GROUP BY customer_id
)
SELECT o.customer_id, o.orders, COALESCE(r.refunds, 0) AS refunds
FROM orders_cte o
LEFT JOIN refunds_cte r ON r.customer_id = o.customer_id;

Privilégier la lisibilité à l'imbrication

Comparez une sous-requête imbriquée sur trois niveaux à une chaîne de traitement composée de trois CTE. La version imbriquée oblige le lecteur à la déplier mentalement de l'intérieur vers l'extérieur. La version avec des CTE se lit dans l'ordre d'exécution, de haut en bas.

Les évaluateurs apprécient l'approche avec des CTE, car c'est ce qu'ils voudraient maintenir en production. Nommer chaque étape constitue une documentation qui ne devient jamais obsolète.

Une erreur courante lors de l'enchaînement

Les débutants ajoutent souvent une virgule après la dernière CTE, juste avant le SELECT principal. Cette virgule finale provoque une erreur de syntaxe.

  • Les virgules se placent uniquement entre les définitions de CTE.
  • La dernière parenthèse fermante est suivie directement par la requête principale, sans virgule.

Autre piège : oublier que chaque CTE doit contenir son propre SELECT complet entre les parenthèses.

Chaque étape s'exécute-t-elle séparément ?

Voici un point subtil souvent abordé en entretien : logiquement, la chaîne de traitement se lit comme une succession d'étapes distinctes, mais l'optimiseur peut les intégrer directement et les fusionner en un seul plan d'exécution. Dans la plupart des moteurs, vous n'êtes donc pas nécessairement contraint de payer le coût d'une matérialisation intermédiaire.

L'enchaînement vous aide ainsi à raisonner sur la requête sans nécessairement nuire aux performances. Mentionnez-le pour montrer votre maîtrise du sujet.

Nommer les étapes comme une chaîne de traitement

De bons noms d'étapes transforment une requête en code explicite. Préférez des noms qui décrivent la sortie de chaque étape plutôt que l'opération effectuée.

  • spend et big_spenders sont préférables à step1 et step2.
  • Le lecteur devrait pouvoir déduire tout le déroulement à partir des seuls noms des CTE.
  • Des noms cohérents d'une étape à l'autre rendent la jointure de la requête principale évidente.

En entretien, nommer clairement les étapes montre que vous écrivez du SQL de production facile à maintenir.

Vérification rapide

Vérifiez votre compréhension de la manière dont les CTE enchaînées se référencent entre elles.

Récapitulatif : enchaîner les CTE

Vous avez appris à construire des chaînes de traitement : un seul WITH, des définitions de CTE séparées par des virgules et une visibilité uniquement vers l'avant, chaque étape pouvant lire les étapes précédentes.

  • Ordonnez les CTE des données brutes vers le résultat final.
  • Réutilisez une CTE de base dans plusieurs étapes en aval.
  • N'ajoutez pas de virgule finale avant la requête principale.
  • L'enchaînement améliore la lisibilité sans nécessairement nuire aux performances.

Ensuite : comparer les CTE aux sous-requêtes et aux tables temporaires.

Questions Fréquemment Posées

La leçon « Enchaîner plusieurs CTE » est-elle gratuite ?

Oui — le texte complet de « Enchaîner plusieurs CTE » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours SQL Interview Prep, passe à CoddyKit PRO. Le cours SQL Interview Prep comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Enchaîner plusieurs CTE » ?

Construire un pipeline d’étapes nommées qui se référencent les unes les autres Tu pratiques SQL Interview Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer SQL Interview Prep ?

Aucune expérience préalable n'est requise. SQL Interview Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Enchaîner plusieurs CTE » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon SQL Interview Prep ?

Oui. Chaque leçon SQL Interview Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Écrire votre premier CTE
  2. Enchaîner plusieurs CTE
  3. CTE, sous-requête ou table temporaire
  4. Transformer des requêtes imbriquées en CTE
← Retour à SQL Interview Prep