Ressources · 68
Jointures de données : éviter de multiplier les indicateurs
Vérifier le grain, les clés et les cardinalités avant de totaliser ventes, coûts ou conversions.
· 8 min
Ce que ce guide permet
- Décrire le grain
- Tester la cardinalité
- Réconcilier les totaux
- Examiner les exclusions
Contrôle express
- Que représente une ligne dans chaque table ?
- Les clés ont-elles la cardinalité attendue ?
- La somme indépendante reste-t-elle identique ?
Méthode pas à pas
- 01
Décrire le grain
Écrivez ce que représente une ligne de chaque table : commande, ligne de commande, paiement ou événement. Identifiez la clé attendue et les versions temporelles. Une clé client peut apparaître plusieurs fois sans être un doublon fautif.
Livrable : dictionnaire du grain.
- 02
Tester la cardinalité
Comptez les occurrences des clés de chaque côté et recherchez les valeurs nulles. Comparez le nombre de lignes avant et après rapprochement. Définissez si la relation attendue est un-à-un, un-à-plusieurs ou plusieurs-à-plusieurs.
Livrable : profil des clés et exceptions.
- 03
Réconcilier les totaux
Gardez une somme indépendante calculée au grain métier. Si une commande est rapprochée de plusieurs lignes, son montant peut être répété. Agrégez au bon grain avant la jointure ou choisissez une répartition explicite, puis vérifiez le total.
Livrable : bilan avant et après jointure.
- 04
Examiner les exclusions
Un filtre sur la table droite après une jointure externe peut éliminer les lignes sans correspondance. Mesurez les enregistrements non rapprochés, la période et le fuseau. Conservez des cas de test pour les nouvelles sources.
Livrable : rapport de couverture et tests de régression.
Cas de recette à reproduire
Exemple fictif : ces données ne décrivent aucun client ni résultat réel.
Voir les données du cas
{
"orders": [
{
"id": 1,
"total": 100
},
{
"id": 2,
"total": 200
}
],
"line_order_ids": [
1,
1,
2
],
"sum_before": 300,
"sum_after_raw_join": 400
}Décision attendue
Le total 400 double une commande. Agréger les lignes par commande avant de retrouver le total 300. Contrôler aussi deux commandes fictives de 100 chacune : leur total vaut 200. SUM(DISTINCT total) donnerait 100 et supprimerait une valeur légitime. Vérifier les identifiants et la cardinalité de la jointure, plutôt que dédupliquer les montants.
Reproduire le diagnostic en SQL
Exemple fictif : deux commandes de 100 et 200, avec trois lignes rattachées à 1, 1 et 2. Les requêtes utilisent uniquement VALUES ; exécutez-les dans un environnement de test.
WITH orders(id, total) AS (VALUES (1, 100), (2, 200)),
lines(order_id) AS (VALUES (1), (1), (2))
SELECT COUNT(*) AS rows, SUM(o.total) AS total
FROM orders o JOIN lines l ON l.order_id = o.id;WITH orders(id, total) AS (VALUES (1, 100), (2, 200)),
lines(order_id) AS (VALUES (1), (1), (2)),
per_order AS (
SELECT order_id, COUNT(*) AS line_count
FROM lines GROUP BY order_id
)
SELECT COUNT(*) AS orders, SUM(o.total) AS total
FROM orders o LEFT JOIN per_order l ON l.order_id = o.id;La jointure directe donne trois lignes et 400. L’agrégation préalable retrouve deux commandes et 300.
WITH orders(id, total) AS (VALUES (1, 100), (2, 100))
SELECT SUM(total) AS correct_total,
SUM(DISTINCT total) AS distinct_total
FROM orders;Avec deux montants de 100, le total correct est 200 ; SUM(DISTINCT total) donne 100.
Procédure de vérification
- Définissez la granularité des commandes et des lignes.
- Joignez une commande possédant deux lignes, puis comparez les sommes.
- Conservez clés, nombres de lignes et totaux avant/après agrégation.
Fiche de travail à réutiliser
À compléter avec vos observations autorisées. Ces champs constituent une trame de travail, pas des résultats observés.
| Champ | Information à consigner |
|---|---|
| Grain | Signification de la ligne et clé attendue |
| Cardinalité | Occurrences, valeurs nulles et relation attendue |
| Réconciliation | Effectifs, somme de référence et écarts |
Exemple d’application
Situation illustrative
Exemple fictif : une commande de 100 est liée à deux lignes de produit.
Décision et preuve attendue
L’addition du montant de commande après jointure donne 200. L’équipe agrège les lignes avant rapprochement et vérifie le total indépendant de 100.
Distinguer les mécanismes
| Mécanisme | Utilité | Point de vigilance |
|---|---|---|
| INNER JOIN | Conserver les correspondances | Les lignes sans correspondance disparaissent |
| LEFT JOIN | Conserver les lignes de gauche | Des filtres ultérieurs peuvent modifier cet effet |
Indicateurs de pilotage
| Indicateur | Ce qu’il mesure | Première action |
|---|---|---|
| Écart de total | Différence avec la somme indépendante | Bloquer la publication d’un total inexpliqué |
| Taux non rapproché | Clés sans correspondance dans le périmètre | Documenter les exclusions et la période |
Erreurs fréquentes
- Additionner une valeur répétée à un autre grain
- Cacher une erreur de cardinalité avec DISTINCT
Questions fréquentes
DISTINCT corrige-t-il une jointure incorrecte ?
Il peut masquer certaines répétitions sans réparer le grain ni la répartition. Vérifiez la relation avant de dédupliquer.
Des clés répétées sont-elles toujours erronées ?
Non : une table de lignes de commande répète normalement l’identifiant de commande. Le contrôle dépend du grain attendu.
Quel petit test retenir ?
Une commande fictive de 100 avec deux lignes doit garder un total de commande de 100, et non de 200 après rapprochement.
Cardinalité des jointures, NULL et agrégats
Une jointure transforme un ensemble de lignes avant de calculer les indicateurs. Pour comprendre un écart, inspectez les paires produites et les lignes écartées : comparer deux sommes ne suffit pas. Cet atelier montre le chemin entre deux sources fictives et six agrégats, sans se connecter à une base de données.
Référence documentaire : PostgreSQL 18, chapitres 7.2, 9.2 et 9.21, consultés le 23 octobre 2026. Les jeux de données, scénarios et recommandations de recette sont créés par CIE. Ils ne décrivent aucune entreprise, personne ou performance observée.
PostgreSQL 18 · Table expressions · PostgreSQL 18 · documentation reviewed 2026-10-23
Quatre repères pour lire la jointure
| Repère | Effet SQL documenté | Question de recette |
|---|---|---|
| Paires et cardinalité | Chaque correspondance vraie produit une paire ; LEFT complète les lignes gauches sans correspondance avec des valeurs droites NULL. | Combien de lignes droites correspondent à chaque identifiant gauche ? |
| ON et WHERE | ON décide les correspondances avant la complétion LEFT ; WHERE ne conserve ensuite que les lignes où son prédicat est vrai. | Le filtre concerne-t-il la relation ou la population finale ? |
| Clés NULL | L’égalité ordinaire avec NULL donne inconnu. IS NOT DISTINCT FROM considère deux NULL comme non distincts. | Rapprocher deux valeurs absentes a-t-il un sens métier ? |
| Agrégats | COUNT(*) compte les lignes ; COUNT(expression) compte les valeurs non nulles ; SUM ignore les valeurs nulles. | Quel est le grain des contributions et que signifie une valeur absente ? |
PostgreSQL 18 · Comparison functions · PostgreSQL 18 · documentation reviewed 2026-10-23
Deux sources fictives de six lignes
Une ligne gauche représente un relevé technique indépendant, identifié par l.id ; metric est une quantité entière sans unité métier. Une ligne droite représente un état associé à une clé. La clé A est répétée des deux côtés ; les identifiants de ligne sont uniques et non nuls. NULL désigne une valeur absente, jamais le texte « NULL ». La valeur 0 de L4 est une mesure présente. Référence gauche : 6 lignes, 5 mesures non nulles et SUM(metric) = 430 ; une des six mesures étant inconnue, cette somme de valeurs connues ne constitue pas un total complet de toutes les quantités.
| l.id | l.key | l.metric |
|---|---|---|
| L1 | A | 100 |
| L2 | A | 200 |
| L3 | B | 50 |
| L4 | C | 0 |
| L5 | NULL | 80 |
| L6 | D | NULL |
| r.id | r.key | r.state |
|---|---|---|
| R1 | A | active |
| R2 | A | inactive |
| R3 | B | active |
| R4 | NULL | active |
| R5 | E | active |
| R6 | D | NULL |
Atelier de rapprochement des lignes
Choisissez INNER ou LEFT, la position du prédicat r.state = 'active', la comparaison des clés et une source droite complète ou vide. Les 24 configurations sont bornées à ces données. La table de résultat montre chaque paire, ainsi que les lignes complétées par NULL. Les six agrégats portent sur ce résultat après le filtre WHERE éventuel.
Ce lecteur local ne lance aucune requête SQL, ne collecte aucune donnée et ne propose ni import ni export. Il ne traite ni collations, conversions de types, clés composites, jointures temporelles, autorisations, performances ou autres dialectes SQL. L’ordre affiché par identifiant est ajouté pour la lecture ; une jointure seule ne garantit pas cet ordre.
Pour comparer, gardez la référence gauche de 430 sur cinq mesures connues. Un total identique après jointure ne démontre pas la qualité du rapprochement : une duplication et une exclusion peuvent se compenser.
Résultat sur les lignes finales
| l.id | l.key | l.metric | r.id | r.key | r.state | Statut de la paire |
|---|
Requête de lignes correspondant aux choix
Les noms lab_left, lab_right et lab_right_empty sont illustratifs ; lab_right_empty a le même schéma que lab_right et zéro ligne. Le code affiché explique les choix : il n’est pas exécuté. Les agrégats ci-dessous sont calculés sur ces lignes, sans GROUP BY.
Ce que comptent réellement les six résultats
| Expression | Lecture dans cet exercice |
|---|---|
| COUNT(*) | Toutes les lignes finales, y compris les lignes LEFT complétées par NULL. |
| COUNT(DISTINCT l.id) | Identifiants gauches distincts retenus. Ce comptage ne répare pas une somme répétée. |
| COUNT(r.id) | Lignes avec un enregistrement droit réel : r.id est toujours non nul dans la source. |
| COUNT(r.key) | Clés droites non nulles. Peut être inférieur à COUNT(r.id) si une ligne à clé NULL a été rapprochée. |
| COUNT(l.metric) | Occurrences de mesures gauches non nulles, répétitions comprises ; zéro compte comme présent. |
| SUM(l.metric) | Addition des valeurs non nulles après jointure. Résultat NULL si aucune valeur non nulle ne contribue, notamment pour un résultat vide. |
PostgreSQL 18 · Aggregate functions · PostgreSQL 18 · documentation reviewed 2026-10-23
Neuf scénarios expliqués, lisibles sans JavaScript
J01 · LEFT avec clé A répétée
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| LEFT / none / equal / full | 8 lignes, 6 identifiants gauches, 6 r.id présents, 6 r.key présents, 7 mesures présentes ; somme 730. A produit quatre paires. |
J02 · INNER et lignes perdues
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| INNER / none / equal / full | 6 lignes, 4 identifiants gauches, 5 mesures ; somme 650. L4 et L5 disparaissent ; la duplication de A subsiste. |
J03 · Filtre actif dans ON
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| LEFT / on / equal / full | 6 lignes et 6 identifiants gauches ; 3 r.id présents, 5 mesures ; somme 430. L4, L5 et L6 restent avec une partie droite complétée par NULL. |
J04 · Même filtre dans WHERE
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| LEFT / where / equal / full | 3 lignes et 3 identifiants gauches ; somme 350. Le filtre retire les lignes sans état actif, y compris les lignes complétées par NULL. |
J05 · Deux clés NULL rapprochées
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| LEFT / none / safe / full | 8 lignes, 7 r.id présents mais 6 r.key présents ; somme 730. L5 rejoint réellement R4 ; un r.key NULL ne prouve donc pas l’absence de correspondance. |
J06 · Égalité de somme trompeuse
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| INNER / where / safe / full | 4 lignes, 4 identifiants gauches et somme 430 : même somme que la référence, alors que L4 et L6 sont absents. Égalité des totaux ne signifie pas égalité des populations. |
J07 · Résultat vide et somme NULL
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| INNER / none / equal / empty | Aucune ligne. Les cinq COUNT valent 0 ; SUM(l.metric) vaut NULL. Le lecteur ne remplace pas cette absence par zéro. |
J08 · Droite vide, gauche préservée
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| LEFT / none / equal / empty | 6 lignes, 6 identifiants gauches, aucun r.id ni r.key présent ; 5 mesures et somme 430. Les valeurs de gauche restent présentes. |
J09 · WHERE retire toute la complétion
| Jointure / filtre / clés / droite | Lecture attendue |
|---|---|
| LEFT / where / equal / empty | LEFT produit d’abord six lignes complétées ; le filtre actif dans WHERE les retire toutes. Cinq COUNT à 0, somme NULL. |
Préparer la preuve d’un rapprochement fiable
| Contrôle proposé | Trace utile |
|---|---|
| Grain et clés | Décrire une ligne de chaque source, ses identifiants et la cardinalité métier attendue. Une répétition de clé peut être légitime. |
| Périmètre et état | Fixer période, fuseau, version des sources et état à la date voulue avant de rapprocher. |
| Correspondances | Lister les lignes à zéro, une ou plusieurs correspondances ; garder les identifiants des deux côtés. |
| Valeurs absentes | Distinguer clé NULL, mesure NULL, état NULL et absence de ligne droite. Ne pas remplacer ces quatre situations par zéro. |
| Agrégation | Comparer au grain métier avant et après jointure. Si une répartition est nécessaire, documenter la règle et la réconciliation. |
| Régression | Garder des cas avec clés répétées, clés nulles, zéro, mesure inconnue et source vide ; vérifier les lignes, pas seulement le total. |
Dans cet exercice, deux lignes A à gauche et deux lignes A à droite donnent quatre paires avec le filtre absent. Retirer une des lignes droites ou appliquer DISTINCT sans comprendre leur rôle peut supprimer une information valide. Choisissez une agrégation préalable, une clé plus précise ou une règle de répartition seulement après avoir décrit le besoin métier.
Sources, édition et crédits
Documentation officielle PostgreSQL Global Development Group, édition 18. Synthèse, données fictives et lecteur pédagogique originaux CIE ; aucun moteur ni code PostgreSQL n’est embarqué. Les références ci-dessous décrivent la sémantique retenue, pas une certification de ce lecteur.
PostgreSQL 18 · Table expressions · PostgreSQL 18 · documentation reviewed 2026-10-23
SHA-256 : 252f02babbaec8ac702ff2966db75d0b38886cb576a90bbfc458bc4abd0dc688
PostgreSQL 18 · Aggregate functions · PostgreSQL 18 · documentation reviewed 2026-10-23
SHA-256 : c466d05fe796e77f1362dae39c8b212c7bf381065904eb555fa91537e363e5d0
PostgreSQL 18 · Comparison functions · PostgreSQL 18 · documentation reviewed 2026-10-23
SHA-256 : f08404f5624f8b87a91f117be7d59feca075508b124552b66b61940b5b6ef28c
Références officielles
Date de consultation des références : . La méthode et la fiche de travail proposent des contrôles à adapter à votre contexte ; elles ne constituent pas une certification.
