Les requêtes SQL

À quoi sert SQL ?

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

| Type SQL | Description | |----------------------|----------------------------------------------------------------------| | INT, BIGINT | Nombres entiers (positifs ou négatifs) | | SMALLINT, TINYINT| Entiers de plus petite taille (moins de mémoire utilisée) | | DECIMAL(p,s) | Nombres décimaux précis avec p chiffres au total et s après la virgule | | FLOAT, REAL | Nombres décimaux à virgule flottante (moins précis, plus légers) | | CHAR(n) | Texte fixe de longueur n (utile pour des codes, comme un INSEE) | | VARCHAR(n) | Texte variable jusqu’à n caractères | | TEXT | Texte long (commentaires, descriptions…) | | DATE | Date au format AAAA-MM-JJ | | TIME, DATETIME | Heure seule ou date avec heure | | BOOLEAN | Valeur logique : TRUE ou FALSE | | ENUM(...) | Valeur choisie parmi une liste définie (ex : 'Homme', 'Femme') | | BLOB | Données binaires (images, fichiers, sons…) |

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.

| Catégorie | Signification | Exemples | |-----------|--------------------------------------|----------------------------------| | DDL (Data Definition Language) | Sert à définir ou modifier la structure des objets de la base (tables, vues, clés...). | CREATE TABLE, ALTER, DROP | | DML (Data Manipulation Language) | Sert à ajouter, modifier ou supprimer des données dans les tables. | INSERT, UPDATE, DELETE | | DQL (Data Query Language) | Sert à interroger les données pour les lire ou les analyser. | SELECT | | DCL (Data Control Language) | Sert à gérer les permissions et la sécurité d’accès aux données. | GRANT, REVOKE |

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,
  nom VARCHAR(50),
  prenom VARCHAR(50),
  dateNaissance DATE
);

Ajout d’une contrainte sur une colonne

On peut ajouter d'autres contraintes, par exemple rendre une colonne obligatoire :

CREATE TABLE Cours (
  idCours INT PRIMARY KEY,
  intitule VARCHAR(100) NOT NULL,
  volumeHoraire INT CHECK (volumeHoraire > 0)
);

Manipuler les données avec SQL

Insertion de données : `INSERT`

INSERT INTO Etudiant (idEtudiant, nom, prenom, dateNaissance)
VALUES (1, 'Durand', 'Claire', '2001-03-25');

Insérer plusieurs lignes à la fois :

INSERT INTO Etudiant (idEtudiant, nom, prenom, dateNaissance)
VALUES 
  (2, 'Dupont', 'Pierre', '2000-05-12'),
  (3, 'Martin', 'Sophie', '2002-07-18');

Sans nommer les colonnes (déconseillé) :

INSERT INTO Etudiant
VALUES (4, 'Lefevre', 'Luc', '2001-11-30');

Lecture des données : `SELECT`

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

Afficher toutes les colonnes :

SELECT * FROM Etudiant;

Filtrer un nom précis :

SELECT prenom
FROM Etudiant
WHERE nom = 'Dupont';

Mise à jour : `UPDATE`

UPDATE Etudiant
SET nom = 'Dupond'
WHERE nom = 'Dupont';

Suppression : `DELETE`

DELETE FROM Etudiant
WHERE nom = 'Lefevre';

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

DELETE FROM Etudiant;

Requêtes avec jointures

Une jointure permet de combiner des données provenant de plusieurs tables. Cela est essentiel dans une base de données relationnelle, où les informations sont souvent réparties sur plusieurs tables. Il existe différents types de jointures, selon le résultat souhaité.

Jointure interne (`INNER JOIN` ou `JOIN`)

La jointure interne ne conserve que les lignes qui ont des correspondances dans toutes les tables jointées. C'est à dire, elle ne retourne que les enregistrements qui existent dans les deux tables. C'est le type de jointure le plus courant.

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

Jointure externe gauche (`LEFT JOIN`)

La jointure externe gauche conserve toutes les lignes de la première table (à gauche) et les lignes correspondantes de la seconde table (à droite). Si aucune correspondance n'est trouvée, les colonnes de la seconde table contiendront des valeurs nulles.

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

Jointure avec filtres

Il est possible d'ajouter des filtres dans la clause WHERE pour restreindre les résultats. Par exemple, pour ne garder que les cours de plus de 20 heures :

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

Résumé des types de jointures

| Type de jointure | Résultat attendu | |------------------|------------------| | INNER JOIN | Correspondances exactes dans toutes les tables | | LEFT JOIN | Toutes les lignes de gauche, même sans correspondance | | RIGHT JOIN | Toutes les lignes de droite (rarement utilisé) | | FULL JOIN | Toutes les lignes des deux tables (non supporté par MySQL) |

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.

Exemple simple

SELECT AVG(note) AS moyenne, COUNT(*) AS nb_inscrits
FROM Inscription
WHERE idCours = 1;

Cette requête retourne la moyenne des notes et le nombre d'inscrits pour le cours dont l'identifiant est 1.

Fonctions d’agrégation utiles

| Fonction | Rôle | |------------|---------------------------------| | AVG() | Calcule la moyenne | | SUM() | Fait la somme des valeurs | | COUNT() | Compte le nombre de lignes | | MAX() | Renvoie la valeur maximale | | MIN() | Renvoie la valeur minimale |

Renommer une colonne avec `AS`

SELECT COUNT(*) AS total_etudiants
FROM Etudiant;

AS total_etudiants donne un nom lisible à la colonne résultante.
C’est utile notamment pour les fonctions d’agrégation qui n’ont pas de nom par défaut.

Regrouper des résultats : `GROUP BY`

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

Ici, la moyenne est calculée pour chaque cours.

Filtrer les groupes : `HAVING`

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

Cette requête retourne les cours dont la moyenne des notes est strictement supérieure à 12.

Exemple complet

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.

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),
  FOREIGN KEY (idCours) REFERENCES Cours(idCours)
);