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

Salle d’analyse fictive vide avec deux tables de fiches vierges, lampes en laiton et dossier bordeaux Illustration éditoriale générée par IA

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

  1. 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.

  2. 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.

  3. 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.

  4. 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

  1. Définissez la granularité des commandes et des lignes.
  2. Joignez une commande possédant deux lignes, puis comparez les sommes.
  3. Conservez clés, nombres de lignes et totaux avant/après agrégation.

PostgreSQL — Table expressions and joins

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.

ChampInformation à consigner
GrainSignification de la ligne et clé attendue
CardinalitéOccurrences, valeurs nulles et relation attendue
RéconciliationEffectifs, 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écanismeUtilitéPoint de vigilance
INNER JOINConserver les correspondancesLes lignes sans correspondance disparaissent
LEFT JOINConserver les lignes de gaucheDes filtres ultérieurs peuvent modifier cet effet

Indicateurs de pilotage

IndicateurCe qu’il mesurePremière action
Écart de totalDifférence avec la somme indépendanteBloquer la publication d’un total inexpliqué
Taux non rapprochéClés sans correspondance dans le périmètreDocumenter 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

Quatre repères pour lire la jointure
RepèreEffet 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 WHEREON 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 NULLL’é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égatsCOUNT(*) 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.

Source gauche lab_left
l.idl.keyl.metric
L1A100
L2A200
L3B50
L4C0
L5NULL80
L6DNULL
Source droite lab_right
r.idr.keyr.state
R1Aactive
R2Ainactive
R3Bactive
R4NULLactive
R5Eactive
R6DNULL

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.

Ce que comptent réellement les six résultats

Ce que comptent réellement les six résultats
ExpressionLecture 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
LEFT avec clé A répétée
Jointure / filtre / clés / droiteLecture attendue
LEFT / none / equal / full8 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
INNER et lignes perdues
Jointure / filtre / clés / droiteLecture attendue
INNER / none / equal / full6 lignes, 4 identifiants gauches, 5 mesures ; somme 650. L4 et L5 disparaissent ; la duplication de A subsiste.
J03 · Filtre actif dans ON
Filtre actif dans ON
Jointure / filtre / clés / droiteLecture attendue
LEFT / on / equal / full6 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
Même filtre dans WHERE
Jointure / filtre / clés / droiteLecture attendue
LEFT / where / equal / full3 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
Deux clés NULL rapprochées
Jointure / filtre / clés / droiteLecture attendue
LEFT / none / safe / full8 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
Égalité de somme trompeuse
Jointure / filtre / clés / droiteLecture attendue
INNER / where / safe / full4 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
Résultat vide et somme NULL
Jointure / filtre / clés / droiteLecture attendue
INNER / none / equal / emptyAucune 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
Droite vide, gauche préservée
Jointure / filtre / clés / droiteLecture attendue
LEFT / none / equal / empty6 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
WHERE retire toute la complétion
Jointure / filtre / clés / droiteLecture attendue
LEFT / where / equal / emptyLEFT 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

Préparer la preuve d’un rapprochement fiable
Contrôle proposéTrace utile
Grain et clésDé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 étatFixer période, fuseau, version des sources et état à la date voulue avant de rapprocher.
CorrespondancesLister les lignes à zéro, une ou plusieurs correspondances ; garder les identifiants des deux côtés.
Valeurs absentesDistinguer clé NULL, mesure NULL, état NULL et absence de ligne droite. Ne pas remplacer ces quatre situations par zéro.
AgrégationComparer 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égressionGarder 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.