Les requêtes SQL

À quoi sert SQL ?

Dans les chapitres précédents, vous avez appris à modéliser une base de données (MCD, MLD) et à raisonner sur les données avec l'algèbre relationnelle. SQL est la traduction concrète de tout cela : c'est le langage que vous tapez pour interroger une vraie base de données.

SQL est omniprésent dans les systèmes informatiques modernes. Il permet à la fois :

• De créer et structurer une base de données (CREATE, ALTER, DROP) ;
• D'ajouter, modifier ou supprimer des données (INSERT, UPDATE, DELETE) ;
• D'interroger et exploiter les données (SELECT, JOIN, GROUP BY, etc.) ;
• De contrôler les accès et la sécurité (GRANT, REVOKE) ;
• De générer des statistiques simples (moyennes, totaux, comptages).

Pourquoi le SQL est-il toujours utilisé aujourd'hui ?

• Standardisé : SQL est un langage reconnu par tous les grands systèmes de gestion de bases de données (MySQL, PostgreSQL, Oracle, SQL Server…).
• Lisible : sa syntaxe proche du langage naturel le rend facilement compréhensible.
• Puissant : il permet de traiter efficacement de très grandes quantités de données.
• Transverse : il est utilisé dans presque tous les métiers liés à la donnée.

Types de données courants

Familles de commandes SQL

Le langage SQL est divisé en plusieurs familles de commandes, selon leur rôle dans la gestion d'une base de données relationnelle.

Structure d'une base de données

Création d'une base de données

CREATE DATABASE Ecole;
USE Ecole;

Création d'une table

CREATE TABLE Etudiant (
  idEtudiant INT PRIMARY KEY AUTO_INCREMENT,
  nom        VARCHAR(50) NOT NULL,
  prenom     VARCHAR(50) NOT NULL,
  dateNaissance DATE,
  email      VARCHAR(100) UNIQUE,
  actif      BOOLEAN DEFAULT TRUE
);

+------------+--------+--------+---------------+---------------------+-------+
| idEtudiant | nom    | prenom | dateNaissance | email               | actif |
+------------+--------+--------+---------------+---------------------+-------+
|     1      | Martin | Alice  | 2001-05-12    | alice@ecole.fr      |   1   |
|     2      | Durand | Lucas  | 2000-11-03    | lucas@ecole.fr      |   1   |
+------------+--------+--------+---------------+---------------------+-------+

Autres contraintes utiles

CREATE TABLE Cours (
  idCours      INT PRIMARY KEY AUTO_INCREMENT,
  intitule     VARCHAR(100) NOT NULL,
  volumeHoraire INT CHECK (volumeHoraire > 0),
  coefficient  DECIMAL(3,1) DEFAULT 1.0
);

Modifier la structure d'une table : ALTER TABLE

Après la création, il est possible de modifier la structure d'une table sans la supprimer.

-- Ajouter une colonne
ALTER TABLE Etudiant ADD COLUMN telephone VARCHAR(15);

-- Modifier le type d'une colonne
ALTER TABLE Etudiant MODIFY COLUMN telephone VARCHAR(20);

-- Supprimer une colonne
ALTER TABLE Etudiant DROP COLUMN telephone;

-- Renommer une colonne (MySQL 8+)
ALTER TABLE Etudiant RENAME COLUMN actif TO estActif;

Manipuler les données avec SQL

Insertion de données : INSERT

INSERT INTO Etudiant (nom, prenom, dateNaissance, email)
VALUES ('Durand', 'Claire', '2001-03-25', 'claire@ecole.fr');

Insérer plusieurs lignes à la fois :

INSERT INTO Etudiant (nom, prenom, dateNaissance, email)
VALUES
  ('Dupont', 'Pierre', '2000-05-12', 'pierre@ecole.fr'),
  ('Martin', 'Sophie', '2002-07-18', 'sophie@ecole.fr');

Sans nommer les colonnes (déconseillé) :

-- ⚠️ Déconseillé : fragile si la structure de la table change
INSERT INTO Etudiant
VALUES (NULL, 'Lefevre', 'Luc', '2001-11-30', NULL, TRUE);

Lecture des données : SELECT

SELECT nom, prenom
FROM Etudiant
WHERE dateNaissance > '2001-01-01'
ORDER BY nom ASC;

Opérateurs de filtre courants

-- Étudiants dont le nom commence par "Du"
SELECT * FROM Etudiant WHERE nom LIKE 'Du%';

-- Étudiants sans email renseigné
SELECT nom, prenom FROM Etudiant WHERE email IS NULL;

-- Notes entre 10 et 15 inclus
SELECT * FROM Inscription WHERE note BETWEEN 10 AND 15;

Afficher des valeurs distinctes : DISTINCT

SELECT DISTINCT ville FROM Client;

DISTINCT supprime les doublons dans le résultat : si 50 clients habitent Lyon, "Lyon" n'apparaît qu'une fois.

Limiter le nombre de résultats : LIMIT

SELECT nom, prenom FROM Etudiant ORDER BY nom ASC LIMIT 10;

Retourne uniquement les 10 premiers résultats - utile pour la pagination ou pour tester une requête.

Mise à jour : UPDATE

UPDATE Etudiant
SET nom = 'Dupond', email = 'dupond@ecole.fr'
WHERE idEtudiant = 2;

Suppression : DELETE

DELETE FROM Etudiant
WHERE idEtudiant = 4;

Supprimer toutes les données de la table (dangereux) :

-- Supprime toutes les lignes une par une (lent, journalisé)
DELETE FROM Etudiant;

-- Vide la table d'un coup et réinitialise l'AUTO_INCREMENT (plus rapide, non journalisé)
TRUNCATE TABLE Etudiant;

Requêtes avec jointures

Une jointure permet de combiner des données provenant de plusieurs tables. C'est l'opération clé dans une base relationnelle, où les informations sont réparties sur plusieurs tables reliées par des clés.

Données d'exemple

Pour illustrer les jointures, imaginons ces deux tables :

Table Etudiant :

Inscription (idCours = 10 = "Maths", 20 = "SQL")

Emma (id=3) n'a aucune inscription.

Jointure interne (INNER JOIN)

SELECT e.nom, e.prenom, i.idCours
FROM Etudiant e
JOIN Inscription i ON e.idEtudiant = i.idEtudiant;

Résultat :

Jointure externe gauche (LEFT JOIN)

SELECT e.nom, e.prenom, i.idCours
FROM Etudiant e
LEFT JOIN Inscription i ON e.idEtudiant = i.idEtudiant;

Résultat :

Jointure sur 3 tables

SELECT e.nom, c.intitule
FROM Etudiant e
JOIN Inscription i ON e.idEtudiant = i.idEtudiant
JOIN Cours c       ON i.idCours    = c.idCours;

On chaîne les jointures pour remonter les données à travers la table de liaison Inscription.

Résumé des types de jointures

Requêtes avec agrégats

Les fonctions d'agrégation permettent de faire des calculs sur plusieurs lignes d'une table. Elles sont très utiles pour obtenir des statistiques ou des résumés de données.

Fonctions d'agrégation disponibles

Renommer une colonne avec AS

SELECT COUNT(*) AS total_etudiants, AVG(note) AS moyenne_generale
FROM Inscription;

AS donne un alias lisible à la colonne résultante. C'est particulièrement utile avec les agrégats, qui n'ont pas de nom par défaut.

Regrouper des résultats : GROUP BY

SELECT idCours, COUNT(*) AS nb_inscrits, AVG(note) AS moyenne
FROM Inscription
GROUP BY idCours;

Calcule le nombre d'inscrits et la moyenne pour chaque cours.

Filtrer les groupes : HAVING

SELECT idCours, AVG(note) AS moyenne
FROM Inscription
GROUP BY idCours
HAVING AVG(note) > 12;

Exemple complet avec jointure + agrégat

SELECT c.intitule, COUNT(*) AS nb_etudiants, AVG(i.note) AS moyenne
FROM Cours c
JOIN Inscription i ON c.idCours = i.idCours
GROUP BY c.intitule
HAVING AVG(i.note) >= 10
ORDER BY moyenne DESC;

Cette requête :

• Affiche chaque cours avec le nombre d'étudiants inscrits et la moyenne des notes,
• Ne garde que les cours avec une moyenne ≥ 10,
• Trie les résultats par moyenne décroissante.

Ordre d'exécution d'une requête SQL

Il est important de comprendre que SQL n'exécute pas les clauses dans l'ordre où on les écrit.

Créer une table avec une clé étrangère

CREATE TABLE Inscription (
  idEtudiant INT,
  idCours    INT,
  note       DECIMAL(4,2),
  PRIMARY KEY (idEtudiant, idCours),
  FOREIGN KEY (idEtudiant) REFERENCES Etudiant(idEtudiant) ON DELETE CASCADE,
  FOREIGN KEY (idCours)    REFERENCES Cours(idCours)       ON DELETE RESTRICT
);

-- ✅ Fonctionne si idEtudiant=1 et idCours=10 existent
INSERT INTO Inscription VALUES (1, 10, 14.5);

-- ❌ Erreur : l'étudiant 99 n'existe pas dans la table Etudiant
INSERT INTO Inscription VALUES (99, 10, 12.0);
-- Error: Cannot add or update a child row: a foreign key constraint fails

Ressources complémentaires

• SQLZOO (exercices interactifs)
• w3schools – SQL Tutorial
• OpenClassrooms – Apprenez à créer votre base de données
• Codecademy – Learn SQL