Langage SQL

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Les jointures en SQL - JOIN

La clause JOIN est utilisée pour récupérer les données de deux ou plusieurs tables, qui sont jointes pour apparaître comme un seul ensemble de données. Elle est utilisée pour combiner des colonnes de deux tables ou plus en utilisant des valeurs communes aux deux tables.

Le mot-clé JOIN est utilisé dans les requêtes SQL pour joindre deux tables ou plus. Les conditions minimales requises pour joindre la table sont (n-1), n étant le nombre de tables. Une table peut également se joindre à elle-même, appelée SELF JOIN.

Voici les types de jointure que nous pouvons utiliser en SQL:

  •  CROSS
  •  INNER
  •  LEFT
  •  RIGHT
  •  SELF
Pendant ce cours, nous allons travailler sur ces deux tables
Table - Employes                                      
+----+---------+-----+---------+------------+------+
| Id | Nom     | Age | Salaire | Profession | Dep  |
+----+---------+-----+---------+------------+------+
|  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |
|  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |
+----+---------+-----+---------+------------+------+ 
Table - Departement
+--------+--------------+
| Id_dep | Nom_dep      |
+--------+--------------+
|      1 | Informatique |
|      2 | RH           |
|      3 | Vente        |
|      4 | Strategies   |
+--------+--------------+                           
                            

CROSS JOIN

Ce type de JOIN renvoie le produit cartésien des lignes des tables de la jointure. Elle renverra un jeu de résultats des enregistrements combinant chaque ligne de la première table avec chaque ligne de la deuxième table.

Syntaxe :
                                SELECT liste-colonnes
                                FROM 
                                table1 CROSS JOIN table2;
                            
Exemple 1 :
                                SELECT * FROM Departement CROSS JOIN Employes;
                            

Cette requête produira le jeu de résultats suivant :

+--------+--------------+----+---------+-----+---------+------------+------+
| Id_dep | Nom_dep      | Id | Nom     | Age | Salaire | Profession | Dep  |
+--------+--------------+----+---------+-----+---------+------------+------+
|      1 | Informatique |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|      2 | RH           |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|      3 | Vente        |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|      4 | Strategies   |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|      1 | Informatique |  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|      2 | RH           |  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|      3 | Vente        |  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|      4 | Strategies   |  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|      1 | Informatique |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|      2 | RH           |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|      3 | Vente        |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|      4 | Strategies   |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|      1 | Informatique |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|      2 | RH           |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|      3 | Vente        |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|      4 | Strategies   |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|      1 | Informatique |  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |
|      2 | RH           |  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |
|      3 | Vente        |  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |
|      4 | Strategies   |  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |
|      1 | Informatique |  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |
|      2 | RH           |  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |
|      3 | Vente        |  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |
|      4 | Strategies   |  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |
+--------+--------------+----+---------+-----+---------+------------+------+

Comme vous pouvez le constater, cette jointure renvoie le produit cartésien de tous les enregistrements présents dans les deux tables.

INNER JOIN

La jointure la plus importante et la plus utilisée est la jointure INNER. Elle est également appelée jointure d'égalité.

INNER JOIN crée un jeu de résultats en combinant les valeurs de colonne de deux tables (table1 et table2) en fonction du prédicat de jointure. La requête compare chaque ligne de table1(A) avec chaque ligne de table2(B) pour rechercher toutes les paires de lignes satisfaisant le prédicat de jointure. Lorsque le prédicat de jointure est satisfait, les valeurs de colonne de chaque paire de lignes correspondante de A et de B sont combinées dans une ligne de résultat.

Syntaxe 1 :
                                SELECT liste-colonnes
                                FROM 
                                table1 INNER JOIN table2
                                ON table1.champ_commun = table1.champ_commun;
                            
Syntaxe 2 :

La plupart des gens utilisent cette syntaxe à la place de la première syntaxe

                                SELECT liste-colonnes
                                FROM 
                                table1, table2
                                WHERE table1.champ_commun = table1.champ_commun;
                            
Exemple 2 :
                                SELECT * FROM Departement AS D INNER JOIN Employes AS E ON D.Id_dep=E.Dep;
                            

Cette requête produira le jeu de résultats suivant :

+--------+--------------+----+---------+-----+---------+------------+------+
| Id_dep | Nom_dep      | Id | Nom     | Age | Salaire | Profession | Dep  |
+--------+--------------+----+---------+-----+---------+------------+------+
|      2 | RH           |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|      1 | Informatique |  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|      3 | Vente        |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|      4 | Strategies   |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|      1 | Informatique |  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |
+--------+--------------+----+---------+-----+---------+------------+------+

LEFT JOIN

LEFT JOIN renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la table de droite. Cela signifie que si la clause ON correspond à 0 (zéro) enregistrements dans la table de droite; la jointure retournera toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de droite.

Cela signifie qu'une jointure gauche renvoie toutes les valeurs de la table de gauche, ainsi que les valeurs correspondantes de la table de droite ou NULL en cas d'absence de prédicat de jointure correspondant.

Syntaxe:
                                SELECT liste-colonnes
                                FROM 
                                table1 LEFT JOIN table2
                                ON table1.champ_commun = table1.champ_commun;
                            
Exemple 3 :
                                SELECT * FROM Employes AS E LEFT JOIN Departement as D ON D.Id_dep=E.Dep;
                            

Cette requête produira le jeu de résultats suivant :

+----+---------+-----+---------+------------+------+--------+--------------+
| Id | Nom     | Age | Salaire | Profession | Dep  | Id_dep | Nom_dep      |
+----+---------+-----+---------+------------+------+--------+--------------+
|  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |      1 | Informatique |
|  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |      1 | Informatique |
|  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |      2 | RH           |
|  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |      3 | Vente        |
|  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |      4 | Strategies   |
|  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |   NULL | NULL         |
+----+---------+-----+---------+------------+------+--------+--------------+

RIGHT JOIN

RIGHT JOIN renvoie toutes les lignes de la table de droite, même s'il n'y a pas de correspondance dans la table de gauche. Cela signifie que si la clause ON correspond à 0 (zéro) enregistrements dans la table de gauche; la jointure retournera toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de gauche.

Syntaxe:
                                SELECT liste-colonnes
                                FROM 
                                table1 RIGHT JOIN table2
                                ON table1.champ_commun = table1.champ_commun;
                            
Exemple 4 :
                                SELECT * FROM Employes AS E RIGHT JOIN Departement as D ON D.Id_dep=E.Dep;
                            

Cette requête produira le jeu de résultats suivant :

+------+---------+------+---------+------------+------+--------+--------------+
| Id   | Nom     | Age  | Salaire | Profession | Dep  | Id_dep | Nom_dep      |
+------+---------+------+---------+------------+------+--------+--------------+
|    1 | Ismail  |   25 | 6000.00 | Assistant  |    2 |      2 | RH           |
|    2 | Mohamed |   30 | 8000.40 | Directeur  |    1 |      1 | Informatique |
|    3 | Fatima  |   29 | 6000.00 | Directeur  |    3 |      3 | Vente        |
|    4 | Dounia  |   30 | 7000.00 | Assistant  |    4 |      4 | Strategies   |
|    5 | Omar    |   29 | 9000.00 | Ingenieur  |    1 |      1 | Informatique |
+------+---------+------+---------+------------+------+--------+--------------+   

SELF JOIN

SELF JOIN est utilisée pour joindre une table à elle-même comme si la table était deux tables; renommer temporairement au moins une table dans l'instruction SQL.

Syntaxe:
                                SELECT liste-colonnes
                                FROM 
                                table1 AS T1, table1 AS T2
                                WHERE T1.champ_commun = T2.champ_commun;
                            

Ici, la clause WHERE peut être toute expression donnée en fonction de vos besoins.

Exemple 5 :
                                SELECT * FROM Employes AS T1, Employes AS T2 WHERE T1.Salaire>T2.Salaire;
                            

Cette requête produira le jeu de résultats suivant :

+----+---------+-----+---------+------------+------+----+---------+-----+---------+------------+------+
| Id | Nom     | Age | Salaire | Profession | Dep  | Id | Nom     | Age | Salaire | Profession | Dep  |
+----+---------+-----+---------+------------+------+----+---------+-----+---------+------------+------+
|  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |  1 | Ismail  |  25 | 6000.00 | Assistant  |    2 |
|  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |
|  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |  3 | Fatima  |  29 | 6000.00 | Directeur  |    3 |
|  2 | Mohamed |  30 | 8000.40 | Directeur  |    1 |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|  5 | Omar    |  29 | 9000.00 | Ingenieur  |    1 |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
|  7 | Mostafa |  29 | 9000.00 | Ingenieur  | NULL |  4 | Dounia  |  30 | 7000.00 | Assistant  |    4 |
+----+---------+-----+---------+------------+------+----+---------+-----+---------+------------+------+

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :