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

CHAR vs VARCHAR - quand choisir lequel ?

Utilisez CHAR(n) quand la valeur a toujours exactement la même taille (code postal, numéro INSEE, identifiant fixe).
Utilisez VARCHAR(n) pour les textes de longueur variable (noms, adresses, titres).
CHAR est légèrement plus rapide ; VARCHAR économise de l'espace disque.

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
);

Ce que ça donne dans la table

Une fois la table créée, vous pourrez y stocker des données comme :

+------------+--------+--------+---------------+---------------------+-------+
| 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   |
+------------+--------+--------+---------------+---------------------+-------+

idEtudiant a été généré automatiquement grâce à AUTO_INCREMENT.

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

Insérer plusieurs lignes à la fois :

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

Opérateurs de filtre courants

Le caractère joker % dans LIKE

% remplace n'importe quelle suite de caractères (y compris vide).
_ remplace exactement un caractère.
Exemples : 'Du%' → commence par "Du" | '%on' → finit par "on" | 'D_pont' → "Dupont", "Damont", etc.

Afficher des valeurs distinctes : DISTINCT

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

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

Mise à jour : UPDATE

Suppression : DELETE

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;

DELETE vs TRUNCATE

DELETE sans WHERE supprime toutes les lignes mais conserve la structure et peut être annulé avec ROLLBACK.
TRUNCATE vide la table et remet l'AUTO_INCREMENT à 1 - opération non annulable. À réserver aux environnements de développement.

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)

Résultat :

Jointure interne

Une JOIN (ou INNER JOIN) ne conserve que les lignes ayant une correspondance dans les deux tables. Emma n'apparaît pas car elle n'a aucune inscription.

Jointure externe gauche (LEFT JOIN)

Résultat :

Jointure externe gauche

Une LEFT JOIN conserve toutes les lignes de la table de gauche (Etudiant), même si elles n'ont pas de correspondance à droite. Emma apparaît avec NULL dans idCours.

Jointure sur 3 tables

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

COUNT(*) vs COUNT(colonne)

COUNT(*) compte toutes les lignes, y compris celles avec des NULL.
COUNT(colonne) ne compte que les lignes où la colonne n'est pas NULL.

Renommer une colonne avec AS

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

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

Filtrer les groupes : HAVING

WHERE vs HAVING

WHERE filtre les lignes avant le regroupement - il s'applique aux données brutes.
HAVING filtre les groupes après le GROUP BY - il s'applique aux résultats agrégés.

On ne peut pas écrire WHERE AVG(note) > 12 : WHERE ne connaît pas encore la moyenne à ce stade.

Exemple complet avec jointure + agrégat

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.

Pourquoi cet ordre est important

Cela explique pourquoi on ne peut pas utiliser un alias défini dans SELECT dans une clause WHERE : WHERE est exécuté avant SELECT, donc l'alias n'existe pas encore.
En revanche, on peut utiliser cet alias dans ORDER BY (qui vient après).

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

Ce que garantit l'intégrité référentielle

Ressources complémentaires

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