0Pricing
SQL Academy · Leçon

Les valeurs NULL dans les agrégations et les jointures

Découvrez le comportement de NULL dans COUNT, SUM et JOIN.

Les valeurs NULL dans les agrégations et les jointures est une leçon SQL Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Academy comprend 4 leçons au total.

Les NULL modifient les calculs

Les fonctions d'agrégation et les jointures traitent toutes deux NULL de manière particulière. Si vous ne connaissez pas les règles, vos totaux et vos décomptes peuvent être discrètement erronés.

Cette leçon montre comment COUNT, SUM, AVG, GROUP BY et les jointures externes interagissent avec les valeurs manquantes.

SELECT amount FROM payments;
-- amount
-- -------
--    100
--   NULL   <- missing
--    200

Les agrégats ignorent les NULL

La plupart des agrégats — SUM, AVG, MIN, MAX — ignorent simplement les valeurs NULL. Ils agrègent uniquement les lignes qui contiennent des données.

Ainsi, un montant NULL n'empêche pas SUM de fonctionner : il est simplement exclu du total.

-- Using amounts 100, NULL, 200
SELECT
  SUM(amount) AS total,  -- 300 (NULL skipped)
  MIN(amount) AS lo,     -- 100
  MAX(amount) AS hi      -- 200
FROM payments;

AVG ignore aussi les NULL

AVG divise la somme des valeurs non NULL par le nombre de valeurs non NULL. Les NULL sont exclus des deux calculs.

C'est important : la moyenne de {100, NULL, 200} est 150, et non 100 — le NULL n'est pas compté comme zéro.

-- (100 + 200) / 2 = 150, the NULL row is ignored
SELECT AVG(amount) AS avg_amount FROM payments;

-- If you WANT NULLs counted as 0, COALESCE first:
SELECT AVG(COALESCE(amount, 0)) AS avg_with_zeros FROM payments; -- 100

COUNT(*) ou COUNT(column)

Cette distinction déroute beaucoup de personnes :

  • COUNT(*) compte les lignes, y compris celles qui contiennent des NULL.
  • COUNT(column) compte uniquement les lignes dans lesquelles cette colonne n'est pas NULL.
-- 3 rows total, but only 2 have a non-NULL amount
SELECT
  COUNT(*)       AS row_count,    -- 3
  COUNT(amount)  AS has_amount    -- 2
FROM payments;

COUNT(DISTINCT) et NULL

COUNT(DISTINCT col) compte le nombre de valeurs distinctes non NULL. Les NULL sont entièrement exclus : ils n'augmentent jamais le décompte des valeurs distinctes.

Gardez cela à l'esprit lorsque vous mesurez « combien de X uniques » il y a.

-- statuses: 'paid', NULL, 'paid', 'void'
SELECT COUNT(DISTINCT status) AS distinct_statuses
FROM payments;
-- 2  (paid, void) -- NULL not counted

Agrégats sur un ensemble vide

Lorsqu'un agrégat porte sur zéro ligne, le résultat dépend de la fonction :

  • COUNT(...) renvoie 0.
  • SUM, AVG, MIN, MAX renvoient NULL.

Utilisez COALESCE pour transformer une somme NULL en 0 lorsque cela est approprié.

-- No rows match -> SUM is NULL, not 0
SELECT COALESCE(SUM(amount), 0) AS total
FROM payments
WHERE status = 'refunded';  -- no such rows

GROUP BY regroupe les NULL

Bien que NULL = NULL soit indéterminé ailleurs, GROUP BY place tous les NULL dans un seul groupe.

Ainsi, une catégorie NULL devient son propre groupe dans les résultats, ce qui vous permet de résumer ensemble les lignes dont les données sont manquantes.

SELECT category, COUNT(*) AS n
FROM products
GROUP BY category;

-- category | n
-- ---------+---
-- books    | 5
-- toys     | 3
-- NULL     | 2   <- all NULL categories in one group

NULL issus des jointures externes

Les jointures externes sont une source importante de NULL. Un LEFT JOIN conserve chaque ligne de gauche ; lorsqu'aucune correspondance n'existe à droite, les colonnes du côté droit deviennent NULL.

Ces NULL signifient « aucune ligne correspondante », et non « une valeur NULL enregistrée ».

SELECT c.name, o.id AS order_id
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id;

-- name  | order_id
-- ------+---------
-- Alice | 10
-- Bob   | NULL     <- Bob has no orders

Compter les correspondances après un LEFT JOIN

Pour compter uniquement les correspondances réelles après un LEFT JOIN, comptez une colonne non NULL de la table de droite, et non COUNT(*).

COUNT(o.id) ignore les lignes NULL produites par les lignes de gauche sans correspondance, ce qui donne le véritable nombre de commandes.

SELECT c.name, COUNT(o.id) AS order_count
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;

-- Bob shows 0, not 1×NULL

Exclure les lignes sans correspondance

Attention à un piège subtil : placer une condition sur la table de droite dans WHERE après un LEFT JOIN le transforme en jointure interne, car NULL = value est indéterminé et la ligne est filtrée.

Si vous voulez conserver les lignes sans correspondance, placez la condition dans la clause ON ou testez explicitement la présence d'un NULL.

-- Accidentally drops Bob (his o.status is NULL)
SELECT c.name FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.status = 'open';

-- Keep unmatched rows: move the test into ON
SELECT c.name FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id AND o.status = 'open';

Règles générales

Appliquez ces règles à toutes vos requêtes combinant agrégats et jointures :

  • Les agrégats ignorent les NULL, à l'exception de COUNT(*).
  • COUNT(col) < COUNT(*) lorsque col contient des NULL.
  • Pour un ensemble vide, SUM/AVG renvoie NULL — entourez-le de COALESCE.
  • LEFT JOIN produit des NULL pour les lignes sans correspondance : comptez une clé du côté droit.
  • Les filtres sur la table de droite doivent se trouver dans ON, et non dans WHERE.
SELECT c.name,
  COALESCE(SUM(o.amount), 0) AS spent,
  COUNT(o.id)                AS orders
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name;

Vérification rapide

Une colonne amount contient les valeurs 100, NULL et 200 sur trois lignes. Que renvoient COUNT(*) et COUNT(amount) ?

Récapitulatif

Vous avez appris comment les NULL se propagent dans les agrégations et les jointures : les agrégats ignorent les NULL, COUNT(*) compte les lignes tandis que COUNT(col) compte les valeurs non NULL, les sommes sur un ensemble vide sont NULL et GROUP BY regroupe tous les NULL dans un seul groupe.

Vous avez également vu que les jointures externes génèrent des NULL pour les lignes sans correspondance, et pourquoi les filtres sur la table de droite doivent se trouver dans ON. Le cours Utiliser les NULL est maintenant terminé : vous savez gérer les données manquantes avec assurance.

-- A NULL-safe summary query
SELECT c.name,
  COUNT(o.id)                AS orders,
  COALESCE(SUM(o.amount), 0) AS total_spent
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
GROUP BY c.name
ORDER BY total_spent DESC;

Questions Fréquemment Posées

La leçon « Les valeurs NULL dans les agrégations et les jointures » est-elle gratuite ?

Oui — le texte complet de « Les valeurs NULL dans les agrégations et les jointures » 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 Academy, passe à CoddyKit PRO. Le cours SQL Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Les valeurs NULL dans les agrégations et les jointures » ?

Découvrez le comportement de NULL dans COUNT, SUM et JOIN. Tu pratiques SQL Academy 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 Academy ?

Aucune expérience préalable n'est requise. SQL Academy 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 4 sur 4.

Combien de temps prend la leçon « Les valeurs NULL dans les agrégations et les jointures » ?

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

Oui. Chaque leçon SQL Academy 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. Ce que signifie vraiment NULL
  2. IS NULL et IS NOT NULL
  3. COALESCE et NULLIF
  4. Les valeurs NULL dans les agrégations et les jointures
← Retour à SQL Academy