Fusion complète des données avec FULL OUTER JOIN

Aujourd'hui, on va plonger dans la forme la plus inclusive de la fusion de données — FULL OUTER JOIN. C'est la jointure où tout le monde est invité dans le résultat, même s'il n'a pas de pair.

FULL OUTER JOIN — c'est un type de jointure où toutes les lignes des deux tables sont retournées. Si une ligne d'une table n'a pas de correspondance dans l'autre, les valeurs manquantes dans le résultat seront remplacées par NULL. C'est comme faire la liste de toutes les personnes venues à deux soirées différentes : même si quelqu'un n'est venu qu'à l'une d'elles, il sera quand même compté.

Visuellement, ça donne ça :

Tableau A                     Tableau B
+----+----------+             +----+----------+
| id | nom      |             | id | cours    |
+----+----------+             +----+----------+
| 1  | Alice    |             | 2  | Math     |
| 2  | Bob      |             | 3  | Physique |
| 4  | Charlie  |             | 5  | Histoire |
+----+----------+             +----+----------+

FULL OUTER JOIN RÉSULTAT :
+----+----------+----------+
| id | nom      | cours    |
+----+----------+----------+
| 1  | Alice    | NULL     |
| 2  | Bob      | Math     |
| 3  | NULL     | Physique |
| 4  | Charlie  | NULL     |
| 5  | NULL     | Histoire |
+----+----------+----------+

Les lignes sans correspondance sont gardées, mais les colonnes manquantes sont remplies avec NULL.

Syntaxe de FULL OUTER JOIN

La syntaxe est simple, mais super puissante :

SELECT
    colonnes
FROM 
    table1
FULL OUTER JOIN 
    table2
ON table1.colonne_commune = table2.colonne_commune;

Le truc important ici — c'est FULL OUTER JOIN, qui dit à PostgreSQL de prendre toutes les lignes des deux tables. Si une ligne ne trouve pas de pair selon la condition ON, les valeurs sont remplacées par NULL.

Exemples d'utilisation

Regardons des exemples concrets avec la base de données university et les tables students et enrollments.

Exemple 1 : liste de tous les étudiants et cours

Imaginons qu'on a deux tables :

Table students :

Table enrollments :

Notre but — faire une liste complète des étudiants et des cours, y compris ceux qui ne sont inscrits à aucun cours, et les cours sans étudiants.

Voilà la requête :

SELECT
    s.student_id, 
    s.nom, 
    e.cours
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Résultat :

Comme tu vois, tous les étudiants et tous les cours sont là. L'étudiant Charlie n'est inscrit à aucun cours, donc pour lui la colonne cours est NULL. Et le cours Histoire n'a pas d'étudiant, donc ses student_id et nom sont NULL.

Exemple 2 : Analyse des ventes et des produits

Maintenant, pensons à un magasin. On a deux tables :

Table products :

Table sales :

On veut obtenir la liste complète de tous les produits et ventes, y compris les produits jamais vendus et les ventes avec des product_id incorrects.

Requête :

SELECT
    p.product_id,
    p.nom AS nom_produit,
    s.quantité
FROM 
    products p
FULL OUTER JOIN 
    sales s
ON 
    p.product_id = s.product_id;

Résultat :

Ici, on voit que Smartphone n'a pas été vendu (quantité = NULL), et la vente avec product_id = 4 ne correspond à aucun produit.

Exercice pratique

Essaie d'écrire une requête pour les tables departments et employees :

Table departments :

Table employees :

Écris un FULL OUTER JOIN pour obtenir la liste complète des départements et des employés. Remplis les données manquantes avec NULL.

Comment gérer les valeurs NULL

Le souci des valeurs NULL — c'est un effet inévitable du FULL OUTER JOIN. Par exemple, dans la vraie vie, tu pourrais vouloir remplacer les NULL par des valeurs plus parlantes. Dans PostgreSQL, tu peux faire ça avec la fonction COALESCE().

Exemple :

SELECT
    COALESCE(s.nom, 'Aucun étudiant') AS nom_étudiant,
    COALESCE(e.cours, 'Aucun cours') AS nom_cours
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Résultat :

Maintenant, au lieu de NULL, on voit des valeurs claires qui rendent les rapports plus lisibles.

Quand utiliser FULL OUTER JOIN

FULL OUTER JOIN est super utile quand tu veux voir toutes les données des deux tables, même si elles ne sont pas complètement liées. Exemples :

• Rapports sur les ventes et les produits — pour voir à la fois les produits vendus et non vendus.
• Analyse des étudiants et des cours — pour vérifier s'il y a des données manquantes.
• Comparaison de listes — par exemple, pour trouver des différences entre deux ensembles de données.

J'espère que cette leçon t'a donné une bonne idée de ce que fait FULL OUTER JOIN. Maintenant, à toi de jouer dans le monde passionnant des jointures plus complexes et du traitement de données !