15 minutes de SQL
Croiser deux tables avec INNER JOIN
Pourquoi une jointure ?
Dans une base relationnelle, les informations sont réparties dans plusieurs tables. Une jointure permet de relier ces tables en utilisant les identifiants (clé primaire ↔ clé étrangère).
L’idée est simple : on associe chaque ligne d’une table avec la ligne correspondante d’une autre table lorsque les identifiants coïncident.
Syntaxe
SELECT ...
FROM table1 AS t1
INNER JOIN table2 AS t2 ON t2.cle_etrangere = t1.cle_primaire;-
INNER JOINne conserve que les lignes pour lesquelles la condition de jointure est vraie. Si aucune correspondance n’existe, la ligne n’apparaît pas dans le résultat. -
La condition
ONest une conjonction d’égalités reliant une clé étrangère à une clé primaire. -
On peut donner un alias à une table avec
AS(par exempleETUDIANTS AS E). Cela permet d’écrireE.nomau lieu deETUDIANTS.nom, ce qui rend la requête plus lisible. -
L’écriture
FROM ETUDIANTS AS Eest équivalente àFROM ETUDIANTS E, mais la présence deASrend l’alias plus explicite.
Exemples commentés
SELECT C.nom, Co.date_commande
FROM clients AS C
INNER JOIN commandes AS Co
ON Co.id_client = C.id_client;
Dans la base Personnel, on veut afficher le nom de chaque employé
ainsi que le nom du service auquel il appartient.
employes(id_emp, nom, id_service, salaire)
services(id_service, nom_service)
La colonne employes.id_service référence
services.id_service.
On relie donc chaque employé à son service grâce à cette égalité.
SELECT E.nom, S.nom_service
FROM employes AS E
INNER JOIN services AS S
ON E.id_service = S.id_service;
Dans la base Communication, on veut afficher le nom des abonnés
ainsi que le nom du forfait souscrit.
abonnes(id_abonne, nom, id_forfait)
forfaits(id_forfait, nom_forfait, prix)
La clé étrangère abonnes.id_forfait référence
forfaits.id_forfait.
La jointure permet donc d’associer à chaque abonné son forfait.
SELECT A.nom, F.nom_forfait, F.prix
FROM abonnes AS A
INNER JOIN forfaits AS F
ON A.id_forfait = F.id_forfait;
Dans la base LocationVoitures, on veut afficher la marque
des voitures louées ainsi que la date de début de location.
voitures(id_voiture, marque, modele, prix_jour)
locations(id_location, id_voiture, date_debut, date_fin)
La colonne locations.id_voiture référence
voitures.id_voiture.
La jointure associe donc chaque location au véhicule correspondant.
SELECT V.marque, L.date_debut
FROM voitures AS V
INNER JOIN locations AS L
ON L.id_voiture = V.id_voiture;
Dans la base Biblio, on veut afficher,
pour chaque vente, le nom du client et le titre du livre acheté.
clients(id_client, nom, ville)
ventes(id_vente, id_client, isbn, date_vente, quantite)
livres(isbn, titre, auteur, annee, prix)
La table ventes contient deux clés étrangères :
ventes.id_clientréférenceclients.id_clientventes.isbnréférencelivres.isbn
On doit donc effectuer deux jointures :
d’abord entre ventes et clients,
puis entre ventes et livres.
SELECT C.nom, L.titre, V.date_vente, V.quantite
FROM ventes AS V
INNER JOIN clients AS C
ON V.id_client = C.id_client
INNER JOIN livres AS L
ON V.isbn = L.isbn;
Et pour quelques minutes de plus…
Prendre en main la programmation, pas à pas.
Ces exercices sont conçus pour t’aider à maîtriser progressivement les requêtes SQL, en partant de la lecture et de la compréhension du code, jusqu’à l’écriture autonome de requêtes complètes.
L’objectif n’est pas d’aller vite, mais de construire des automatismes solides, en comprenant ce que fait chaque commande, puis en apprenant à les utiliser par toi-même.
L’ordre des exercices est volontaire : on lit, on comprend, on complète, puis on écrit seul. Prends le temps de chaque étape : c’est la clé pour progresser durablement.
Niveau 1 Lire et interpréter
Comprendre avant d’écrire.
Dans cette première série, tu observes et analyses des requêtes SQL déjà écrites.
L’objectif est de comprendre la logique et d’être capable d'expliquer ce que renvoie la requête.
Niveau 2 Compléter une requête
Écrire, mais avec un cadre.
Ici, tu passes à l’écriture sans partir de zéro.
Le squelette de la requête est fourni : il te reste à compléter certaines parties
pour que le code fonctionne correctement.
Ce format permet de se concentrer sur l’essentiel, sans se perdre dans la structure générale.
Niveau 3 Écrire une requête
Passer à l’autonomie.
Dans cette dernière série, tu écris les requêtes complètes à partir d’une consigne.
Tu dois organiser ton code, choisir les bonnes instructions et construire la logique globale.
C’est ici que tu mets en pratique tout ce que tu as appris dans les niveaux précédents.
Contenu réservé aux membres
Les exercices interactifs et le feedback IA sont réservés aux membres.
Dans la base
Boutique, on veut afficher le nom des clients ainsi que la date de leurs commandes.La colonne
commandes.id_clientest une clé étrangère qui référenceclients.id_client. Pour relier une commande à son client, on impose donc :commandes.id_client = clients.id_client.On utilise des alias (
AS CetAS Co) pour rendre l’écriture plus lisible.