Les jointures sont un moyen en Transact-SQL pour récupérer des informations provenant de plusieurs objets distincts, qu’il s’agisse de tables, tables temporaires ou vues en utilisant si, possible, leurs clefs primaires et étrangères. SQL Server comprend deux types de syntaxe pour respecter une compatibilité ascendante : - Le standard ANSI SQL 89 utilisé sur les SGBD SQL Server 6.5 et 7 - Le standard ANSI SQL 92 exploité réellement à partir de la version 2000 de SQL Server Il existe différents types de jointures, chacune répondant à des besoins précis : - Les jointures internes, - Les jointures externes, - Les jointures multiples, - L’auto-jointure.

1. 1
SQL Server 2000
Les jointures
28 JANVIER 2008 CHAPITRE 1
Les jointures sont un moyen en Transact-SQL pour récupérer des informations
provenant de plusieurs objets distincts, qu’il s’agisse de tables, tables temporaires ou
vues en utilisant si, possible, leurs clefs primaires et étrangères.
SQL Server comprend deux types de syntaxe pour respecter une compatibilité
ascendante :
- Le standard ANSI SQL 89 utilisé sur les SGBD SQL Server 6.5 et 7
- Le standard ANSI SQL 92 exploité réellement à partir de la version 2000 de SQL
Server
Il existe différents types de jointures, chacune répondant à des besoins précis :
莽莽 诲睢 睦 睨 睨
- Les jointures internes,
- Les jointures externes,
- Les jointures multiples,
- L’auto-jointure.
Constitution des tables d’exemple
Si la base Northwind fournit un certain nombre d’objets intéressants, de nouvelles tables sont
nécessaires pour illustrer au mieux les différents cas de jointures.
Imaginons le cas d’une société possédant plusieurs départements dont un dédié aux ressources
humaines. Pour la gestion du personnel, les informations seront stockées dans les tables suivantes :
- Département,
- Emploi,
- Personnel,
- Client.
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

2. 2
Création des tables :
CREATE TABLE Departement
(
Id_departement INT NOT NULL CONSTRAINT pk_id_departement PRIMARY KEY,
Nom_departement VARCHAR (128) NOT NULL
)
CREATE TABLE Emploi
(
Id_emploi INT NOT NULL CONSTRAINT pk_id_emploi PRIMARY KEY,
Description_emploi VARCHAR (128) NOT NULL
)
CREATE TABLE Personnel
Id_personnel INT NOT NULL CONSTRAINT pk_id_personnel PRIMARY KEY,
Nom_personnel VARCHAR (64) NOT NULL,
Departement_fk INT NULL CONSTRAINT fk_departement_fk REFERENCES Departement
(Id_departement),
Emploi_fk INT NOT NULL CONSTRAINT fk_emploi_fk REFERENCES Emploi (Id_emploi),
Salaire DEC (7,2) NOT NULL
)
CREATE TABLE Client
(
Id_client INT NOT NULL CONSTRAINT pk_id_client PRIMARY KEY,
Nom_client VARCHAR (128) NOT NULL,
Client_ref CHAR (1) NOT NULL CONSTRAINT chk_client_ref CHECK (Client_Ref IN ('O','N'))
)
CREATE TABLE Hierarchie (
Id_Hierarchie INT NOT NULL CONSTRAINT pk_id_hierarchie PRIMARY KEY,
Nom VARCHAR (64) NOT NULL,
Prenom VARCHAR (64) NOT NULL,
Responsable_Fk INT NULL CONSTRAINT responsable_fk REFERENCES Hierarchie
(Id_Hierarchie),
)
Insertion des données :
INSERT INTO Departement VALUES (100, 'Ingénierie')
INSERT INTO Departement VALUES (200, 'Production')
INSERT INTO Departement VALUES (300, 'Comptabilité')
INSERT INTO Departement VALUES (400, 'Direction')
INSERT INTO Departement VALUES (500, 'Partenariat')
INSERT INTO Emploi VALUES (10, 'Informaticien')
INSERT INTO Emploi VALUES (20, 'Technicien')
INSERT INTO Emploi VALUES (30, 'Expert Comptable')
INSERT INTO Emploi VALUES (40, 'Directeur')
INSERT INTO Emploi VALUES (50, 'Manager')
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

3. 3
INSERT INTO Personnel VALUES (1, 'Paul Kaiser', 100, 10, 2700.00)
INSERT INTO Personnel VALUES (2, 'Angela Mitchell', 300, 30, 4200.00)
INSERT INTO Personnel VALUES (3, 'Alain Maurison', 200, 20, 1480.00)
INSERT INTO Personnel VALUES (4, 'Isabelle Tcheky', 400, 40, 5700.00)
INSERT INTO Personnel VALUES (5, 'Gilbert Menon', 400, 50, 5300.00)
INSERT INTO Personnel VALUES (6, 'Jean Picard', NULL, 20, 1510.00)
INSERT INTO Client VALUES (1, 'SOMATRA', 'O')
INSERT INTO Client VALUES (2, 'USINOR', 'N')
INSERT INTO Client VALUES (3, 'PLASTEX', 'O')
INSERT INTO Client VALUES (4, 'GONDRAND & FILS', 'O')
INSERT INTO Client VALUES (5, 'CASPER ET FRERES', 'N')
INSERT INTO Hierarchie VALUES (1, ‘Thenan’, ' Gérard', NULL)
INSERT INTO Hierarchie VALUES (2, ‘Michel’, 'Louise',1)
INSERT INTO Hierarchie VALUES (3, ‘Keil’, ‘Paul’, 2)
INSERT INTO Hierarchie VALUES (4, ‘Pelon’, ‘Géraldine’, 2)
INSERT INTO Hierarchie VALUES (5, ‘Matserki’, ‘Luc’, 4)
Relations entre les tables :
La table ‘Personnel’ est liée aux tables ‘Emploi’ et ‘Departement’ par deux clés étrangères.
Rappel : Ecriture d’une clause ‘SELECT’
Une clause ‘SELECT’ s’écrit de la manière suivante :
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

4. 4
SELECT ‘Liste des colonnes’
FROM Table
WHERE “Condition”
GROUP BY “Liste des colonnes”
HAVING “Condition”
ORDER BY “Liste des colonnes” (« DESC »| « ASC »)
Jointure Interne
Une jointure interne lie deux tables par une condition d’égalité et ne retournent que les informations
conformes à cette condition. Cette égalité porte de préférence sur les liens établis entre les deux
tables, soit la clé primaire de la première table et la clé étrangère de la seconde table.
Syntaxe SQL-89 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1,
Table2 AS T2
WHERE T1. ‘Clé primaire’ = T2. ‘Clé étrangère’
Syntaxe SQL-92 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1 INNER JOIN Table2 AS T2 ON T1. ‘Clé primaire’ = T2. ‘Clé étrangère’
WHERE ‘Condition’
Exemple :
On souhaite afficher la liste des salariés ainsi que leur département respectifs. Pour cela, les tables
‘Personnel’ et ‘Departement’ vont être utilisées.
Résultat :
Nom_personnel Nom_departement
Paul Kaiser Ingénieurie
Angela Mitchell Comptabilité
Alain Maurison Production
Isabelle Tcheky Direction
Gilbert Menon Direction
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

5. 5
Syntaxe SQL-89 :
SELECT P.Nom_personnel,
D.Nom_departement
FROM Departement AS D,
Personnel AS P
WHERE D.Id_departement = P.Departement_fk
Syntaxe SQL-92:
SELECT P.Nom_personnel,
D.Nom_departement
FROM Departement AS D
INNER JOIN Personnel AS P ON D.Id_departement = P.departement_fk
Remarque :
- La clause ‘INNER JOIN’ ne prend en compte que les informations répondant à la condition de
jointure. Aussi, les informations qui n’ont pas de liens n’apparaissent dans le résultat final :
o Jean Picard n’a pas de département attitré.
o Le département ‘Partenariat’ ne compte aucun employé.
- Il est possible de simplifier l’écriture de la requête en supprimant la clause ‘INNER’ car la
jointure interne est le fonctionnement par défaut du moteur SQL.
Jointure Externe
Une jointure externe permet de retourner les lignes répondant à la condition de jointure mais aussi
toutes celles de la première table, de la seconde table ou des deux qui ne vérifient pas la jointure.
Pour cela, trois expressions sont possibles :
- L’expression LEFT OUTER JOIN retourne toutes les lignes répondant à la condition de
jointure et celles de la table appelée par la clause FROM qui n’y répondent pas.
Syntaxe SQL-89 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1,
Table2 AS T2
WHERE T1. ‘clé primaire’ *= T2. ‘clé étrangère’
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

6. 6
Syntaxe SQL-92 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1 LEFT OUTER JOIN Table2 AS T2 ON T1. ‘clé primaire’ = T2. ‘clé étrangère’
- L’expression RIGHT OUTER JOIN retourne toutes les lignes vérifiant la condition de jointure
et toutes celles de la table appelée par la clause JOIN qui n’y répondent pas.
Syntaxe SQL-89 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1,
Table2 AS T2
WHERE T1. ‘clé primaire’ =* T2. ‘clé étrangère’
Syntaxe SQL-92 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1 RIGHT OUTER JOIN Table2 AS T2 ON T1. ‘clé primaire’ = T2. ‘clé étrangère’
- L’expression FULL OUTER JOIN retourne toutes les lignes correspondant à la condition de
jointure mais affiche également toutes les lignes des deux tables utilisées dans la requête.
Syntaxe SQL-89 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1,
Table2 AS T2
WHERE T1. ‘clé primaire’ *=* T2. ‘clé étrangère’
Syntaxe SQL-92 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1 FULL OUTER JOIN Table2 AS T2 ON T1. ‘clé primaire’ = T2. ‘clé étrangère’
Cette dernière jointure est généralement à éviter vu le nombre de lignes qu’elle peut retourner.
Pour illustrer les différents cas de jointure externes, nous allons nous inspirer de l’exemple précédent.
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

7. 7
Exemple : jointure externe gauche
Syntaxe SQL-92 :
SELECT P.Nom_personnel,
D.Nom_departement
FROM Departement AS D
LEFT OUTER JOIN Personnel AS P ON D.Id_departement = P.departement_fk
Résultat :
Nom_personnel Nom_departement
Paul Kaiser Ingénieurie
Alain Maurison Production
Angela Mitchell Comptabilité
Isabelle Tcheky Direction
Gilbert Menon Direction
NULL Partenariat
Cette requête va afficher tout d’abord toutes les lignes répondant à la condition de jointure puis celles
de la table ‘Departement’ qui n’ont pas de correspondance avec la table ‘Personnel’.
Exemple : jointure externe droite
Syntaxe SQL-92 :
SELECT P.Nom_personnel,
D.Nom_departement
FROM Departement AS D
RIGHT OUTER JOIN Personnel AS P ON D.Id_departement = P.departement_fk
Résultat :
Nom_personnel Nom_departement
Paul Kaiser Ingénieurie
Angela Mitchell Comptabilité
Alain Maurison Production
Isabelle Tcheky Direction
Gilbert Menon Direction
Jean Picard NULL
Cette requête affiche en premier lieu les lignes correspondant à la condition de jointure puis ajoute les
lignes de la table ‘Personnel’ qui n’ont pas de correspondance avec la table ‘Departement’.
Comme on peut le remarquer, ‘Personnel’ est bien à droite dans l’écriture de la jointure.
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

8. 8
Exemple : jointure externe complète
Syntaxe SQL-92 :
SELECT P.Nom_personnel,
D.Nom_departement
FROM Departement AS D
FULL OUTER JOIN Personnel AS P ON D.Id_departement = P.departement_fk
Résultat :
Nom_personnel Nom_departement
Paul Kaiser Ingénieurie
Alain Maurison Production
Angela Mitchell Comptabilité
Isabelle Tcheky Direction
Gilbert Menon Direction
NULL Partenariat
Jean Picard NULL
Cette requête va agir en trois étapes :
- Tout d’abord, elle retourne les lignes correspondant à une jointure de type « INNER JOIN ».
- Ensuite, elle affiche le résultat répondant à une jointure de type « LEFT OUTER JOIN ».
- Enfin, elle affiche les lignes cohérentes avec une jointure de type « RIGHT OUTER JOIN ».
Jointures multiples
Les exemples cités jusqu’à maintenant offraient des combinaisons de jointures entre deux tables. Il
est cependant possible de construire une requête basée sur une jointure sur trois tables ou plus
encore.
Les conditions de jointures s’écriront simplement les unes à la suite des autres.
La syntaxe ci-dessous montre une requête de jointure simple entre une table T1 qui est liée à une
table T2 mais aussi à une table T3 par l’intermédiaire de deux clés étrangères distinctes.
Syntaxe SQL-89 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1,
Table2 AS T2,
Table3 AS T3
WHERE T2. ‘clé primaire’ = T1. ‘clé étrangère’
AND T3. ‘clé primaire’ = T1. ‘clé étrangère’
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

9. 9
Syntaxe SQL-92 :
SELECT ‘Liste des colonnes’
FROM Table1 AS T1
INNER JOIN Table2 AS T2 ON T2. ‘clé primaire’ = T1. ‘clé étrangère’
INNER JOIN Table3 AS T3 ON T3. ‘clé primaire’ = T1. ‘Clé étrangère’
Exemple :
SELECT P.Nom_personnel,
D.Nom_departement,
E.Description_emploi,
P.Salaire
FROM Personnel AS P
INNER JOIN Departement AS D ON D.Id_departement = P.Departement_fk
INNER JOIN Emploi AS E ON E.Id_emploi = P.Emploi_fk
Résultat :
Nom_personnel Nom_departement Description_emploi Salaire
Paul Kaiser Ingénieurie Informaticien 2700.00
Angela Mitchell Comptabilité Expert Comptable 4200.00
Alain Maurison Production Technicien 1480.00
Isabelle Tcheky Direction Directeur 5700.00
Gilbert Menon Direction Manager 5300.00
Auto-jointure
Parfois, certaines tables contiennent une colonne de clé étrangère qui appelle la clé primaire de cette
même table. Pour visualiser les données, il est donc nécessaire de créer une liaison entre ces deux
clés. La distinction se fera grâce aux alias.
Syntaxe SQL-92 :
SELECT T1. ‘Liste des colonnes de la table T1’,
T2. ‘Liste des colonnes de la table T2’
FROM Table1 AS T1
INNER JOIN Table1 AS T2 ON T1. ‘clé primaire’ = T2. ‘clé étrangère’
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

10. 1
Exemple : Affichage du personnel et de ses supérieurs.
Prenons le cas de la table ‘Hierarchie’. Elle dresse une liste de personnes et la colonne
‘Responsable_Fk’ permet d’identifier à quel supérieur chacune d’elle est liée.
Le patron, lui, n’a aucun supérieur, d’où la valeur NULL à cette colonne.
Organigramme :
Gérard
Thenan
Louise
Michel
Paul Géraldine
Keil Pelon
Luc
Matserki
Syntaxe SQL-92 :
Select H1.Id_Hierarchie,
H1.Nom,
H1.Prenom,
H1.Responsable_Fk,
H2.Nom,
H2.Prenom
FROM Hierarchie AS H1
INNER JOIN Hierarchie AS H2 ON H1.Id_Hierarchie = H2.Responsable_Fk
Résultat :
Id_Hierarchie Nom Prenom Responsable_FK Nom Prenom
1 Thenan Gérard NULL Michel Louise
2 Michel Louise 1 Keil Paul
2 Michel Louise 1 Pelon Géraldine
4 Pelon Géraldine 2 Matserki Luc
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1

11. 1
Daniel Muller 1 – SQL Server 2000 : les jointures Version 1.1