Une jointure interne peut être effectuée de 2 façons différentes :
- A l'aide du mot-clé WHERE : c'est l'ancienne syntaxe, toujours utilisée aujourd'hui, qu'il faut donc connaître mais que vous devriez éviter d'utiliser si vous avez le choix.
- A l'aide du mot-clé JOIN : c'est la nouvelle syntaxe qu'il est recommandé d'utiliser. Elle est plus efficace et plus lisible.
Ces deux techniques produisent exactement le même résultat, mais il faut les connaître toutes les deux.
Jointure interne avec WHERE (ancienne syntaxe)
Construction d'une jointure interne pas à pas
Pour réaliser ce type de jointure, on va sélectionner des champs des 2 tables et indiquer le nom de ces 2 tables dans la clause FROM :
Code : SQL | SELECT nom, prenom FROM proprietaires, jeux_video
|
Cependant ça ne fonctionnera pas car ce n'est pas suffisant. En effet, le champ
nom apparaît dans les 2 tables : une fois pour le nom du propriétaire, et une autre fois pour le nom du jeu vidéo. C'est ce qu'on appelle une
colonne ambigüe car MySQL ne sait pas s'il doit récupérer un nom de personne (comme Dugommier) ou un nom de jeu (comme Super Mario Bros). Bref, il est un peu perdu.
L'astuce consiste à marquer le nom de la table devant le nom du champ comme ceci :
Code : SQL | SELECT jeux_video.nom, proprietaires.prenom FROM proprietaires, jeux_video
|
Ainsi, on demande clairement de récupérer le nom du jeu et le prénom du propriétaire avec cette requête.
Le champ prenom n'est pas ambigu, car il n'apparaît que dans la table proprietaires. On pourrait donc se passer d'écrire le préfixe proprietaires devant, mais ça ne coûte rien de le faire et c'est plus clair : on voit immédiatement en lisant la requête de quelle table est issu ce champ.
Il reste encore à lier les 2 tables entre elles. En effet, les jeux et leurs propriétaires ont une correspondance via le champ
ID_proprietaire (de la table
jeux_video) et le champ
ID (de la table
proprietaires). On va indiquer cette liaison dans un
WHERE comme ceci :
Code : SQL | SELECT jeux_video.nom, proprietaires.prenom
FROM proprietaires, jeux_video
WHERE jeux_video.ID_proprietaire = proprietaires.ID
|
Comme la requête devient longue, je me permets de l'écrire sur plusieurs lignes. Cette écriture est tout à fait autorisée et a l'avantage d'être plus lisible.
On indique bien que le champ
ID_proprietaire de la table
jeux_video correspond au champ
ID de la table
proprietaires. Cela établit la correspondance entre les 2 tables telle qu'on l'avait définie dans le schéma au début du chapitre.
Notre requête est enfin complète, vous pouvez l'essayer.
Vous devriez récupérer les données suivantes :
| nom | prenom |
|---|
| Super Mario Bros |
Florent |
| Sonic |
Patrick |
| ... |
... |
Utilisez les alias !
Nous avons appris à utiliser les alias lorsque nous avons découvert les fonctions SQL. Cela nous permettait de créer ce que j'appelais des "champs virtuels" pour représenter le résultat des fonctions.
Il est fortement conseillé d'utiliser des alias lorsqu'on fait des jointures. On peut utiliser des alias sur les noms de champs (comme on l'avait fait) :
Code : SQL | SELECT jeux_video.nom AS nom_jeu, proprietaires.prenom AS prenom_proprietaire
FROM proprietaires, jeux_video
WHERE jeux_video.ID_proprietaire = proprietaires.ID
|
On récupèrera donc 2 champs :
nom_jeu et
prenom_proprietaire. Ces alias permettent de donner un nom plus clair aux champs que l'on récupère.
| nom_jeu | prenom_proprietaire |
|---|
| Super Mario Bros |
Florent |
| Sonic |
Patrick |
| ... |
... |
Il est possible aussi de donner un alias aux noms des tables, ce qui est fortement recommandé pour donner un nom plus court et plus facile à écrire. En général, on crée des alias de tables d'une lettre ou deux correspondant à leurs initiales, comme ceci :
Code : SQL | SELECT j.nom AS nom_jeu, p.prenom AS prenom_proprietaire
FROM proprietaires AS p, jeux_video AS j
WHERE j.ID_proprietaire = p.ID
|
Comme vous le voyez, la table
jeux_video a pour alias la lettre
j et
proprietaires la lettre
p. On réutilise ces alias dans toute la requête, ce qui la rend plus courte à écrire (et plus lisible aussi au final
).
Notez que le mot-clé
AS est en fait facultatif, les développeurs ont tendance à l'omettre. Vous pouvez donc tout simplement le retirer de la requête :
Code : SQL | SELECT j.nom nom_jeu, p.prenom prenom_proprietaire
FROM proprietaires p, jeux_video j
WHERE j.ID_proprietaire = p.ID
|
Jointure interne avec JOIN (nouvelle syntaxe)
Bien qu'il soit possible de faire une jointure interne avec un WHERE comme on vient de le voir, c'est une ancienne syntaxe et on recommande aujourd'hui d'utiliser plutôt JOIN. Il faut dire que nous étions habitués à utiliser le WHERE pour filtrer les données, alors que nous l'utilisons ici pour associer des tables et récupérer plus de données.
Pour éviter de confondre le WHERE "traditionnel" qui filtre les données et le WHERE de jointure que l'on vient de découvrir, on va utiliser la syntaxe JOIN.
Pour rappel, voici la requête qu'on utilisait avec un WHERE :
Code : SQL | SELECT j.nom nom_jeu, p.prenom prenom_proprietaire
FROM proprietaires p, jeux_video j
WHERE j.ID_proprietaire = p.ID
|
Avec un JOIN, on écrirait cette même requête de la façon suivante :
Code : SQL | SELECT j.nom nom_jeu, p.prenom prenom_proprietaire
FROM proprietaires p
INNER JOIN jeux_video j
ON j.ID_proprietaire = p.ID
|
Cette fois, on récupère les données depuis une table principale (ici
proprietaires) et on fait une jointure interne (
INNER JOIN) avec une autre table (
jeux_video). La liaison entre les champs est faite dans la clause
ON un peu plus loin.
Le fonctionnement reste le même, on récupère les mêmes données que tout à l'heure avec la syntaxe WHERE.
Si vous voulez filtrer (WHERE), ordonner (ORDER BY) ou limiter les résultats (LIMIT), vous devez le faire à la fin de la requête, après le "
ON j.ID_proprietaire = p.ID". Par exemple :
Code : SQL | SELECT j.nom nom_jeu, p.prenom prenom_proprietaire
FROM proprietaires p
INNER JOIN jeux_video j
ON j.ID_proprietaire = p.ID
WHERE j.console = 'PC'
ORDER BY prix DESC
LIMIT 0, 10
|
Traduction (inspirez un grand coup avant de lire) : "Récupère le nom du jeu et le prénom du propriétaire dans les tables
proprietaires et
jeux_video, la liaison entre les tables se fait entre les champs
ID_proprietaire et
ID, prends uniquement les jeux qui tournent sur PC, trie-les par prix décroissant et ne prends que les 10 premiers."
Faut s'accrocher avec des requêtes de cette taille-là.
Les jointures entre tables
marwakhodor
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+