■ Cours Complet SQL
Requêtes & Gestion de Bases de Données Relationnelles
Chapitre 0 — Sommaire
1. Introduction aux bases de données
2. Créer et gérer des tables (DDL)
3. Insérer, modifier, supprimer des données (DML)
4. Requêtes SELECT — Lire des données
5. Filtrer avec WHERE et opérateurs
6. Trier, grouper et agréger
7. Jointures (JOIN)
8. Sous-requêtes
9. Index et performances
10. Transactions et intégrité
Chapitre 1 — Introduction aux bases de données
Qu'est-ce qu'une base de données ?
Une base de données (BDD) est un système organisé de stockage et de gestion d'informations. Une
base de données relationnelle organise les données en tables (comme des feuilles Excel) reliées
entre elles par des clés.
Les principaux SGBD
SGBD Type Utilisation
MySQL Open-source Sites web, WordPress, PHP
PostgreSQL Open-source Applications avancées, données géo
SQLite Embarqué Applications mobiles, prototypes
SQL Server Microsoft Entreprises Windows
Oracle Commercial Grandes entreprises, banques
Vocabulaire clé
■ Table : structure de stockage organisée en lignes et colonnes.
■ Ligne (tuple/enregistrement) : une entrée dans la table.
■ Colonne (attribut/champ) : une propriété des données.
■ Clé primaire (PRIMARY KEY) : identifiant unique de chaque ligne.
■ Clé étrangère (FOREIGN KEY) : lien vers la clé primaire d'une autre table.
Chapitre 2 — Créer et gérer des tables (DDL)
Les commandes DDL
DDL (Data Definition Language) regroupe les commandes permettant de définir la structure de la
base de données : créer, modifier, supprimer tables.
-- Créer une base de données
CREATE DATABASE ecole;
USE ecole;
-- Créer une table
CREATE TABLE etudiants (
id INT PRIMARY KEY AUTO_INCREMENT,
nom VARCHAR(100) NOT NULL,
prenom VARCHAR(100) NOT NULL,
email VARCHAR(150) UNIQUE,
age INT CHECK (age >= 0 AND age <= 120),
date_inscr DATE DEFAULT CURRENT_DATE
);
-- Modifier une table (ajouter une colonne)
ALTER TABLE etudiants ADD COLUMN filiere VARCHAR(50);
-- Supprimer une table
DROP TABLE etudiants;
Types de données SQL
Type Description Exemple
INT / BIGINT Nombre entier 42, -100
DECIMAL(p,s) Nombre décimal précis 9.99, 3.14
VARCHAR(n) Texte variable 'Bonjour'
TEXT Texte long Description longue
DATE Date '2024-01-15'
DATETIME Date et heure '2024-01-15 14:30:00'
BOOLEAN Vrai/Faux TRUE, FALSE
Chapitre 3 — Insérer, modifier, supprimer (DML)
INSERT — Insérer des données
-- Insérer une ligne
INSERT INTO etudiants (nom, prenom, email, age, filiere)
VALUES ('Dupont', 'Alice', 'alice@[Link]', 20, 'Informatique');
-- Insérer plusieurs lignes d'un coup
INSERT INTO etudiants (nom, prenom, age, filiere) VALUES
('Martin', 'Bob', 22, 'Réseaux'),
('Leroy', 'Clara', 21, 'Cybersécurité'),
('Petit', 'David', 23, 'IA');
UPDATE — Modifier des données
-- Modifier UN étudiant (toujours utiliser WHERE !)
UPDATE etudiants
SET filiere = 'Cloud Computing', age = 21
WHERE id = 1;
-- DANGER : sans WHERE, toutes les lignes sont modifiées !
UPDATE etudiants SET filiere = 'Inconnu'; -- Modifie TOUT !
DELETE — Supprimer des données
-- Supprimer un étudiant précis
DELETE FROM etudiants WHERE id = 3;
-- Supprimer tous les étudiants d'une filière
DELETE FROM etudiants WHERE filiere = 'Test';
■ Toujours utiliser WHERE avec UPDATE et DELETE, sinon vous modifiez/supprimez TOUTES les lignes
de la table !
Chapitre 4 — Requêtes SELECT — Lire des données
Structure d'un SELECT
SELECT est la commande la plus utilisée en SQL. Elle permet d'interroger la base pour extraire des
données selon des critères précis.
-- Structure générale (les crochets = optionnel)
SELECT colonnes -- quelles colonnes afficher
FROM table -- depuis quelle table
[WHERE condition] -- filtrer les lignes
[GROUP BY colonne] -- regrouper
[HAVING condition] -- filtrer les groupes
[ORDER BY colonne] -- trier
[LIMIT n]; -- limiter les résultats
-- Exemples concrets
SELECT * FROM etudiants;
SELECT nom, prenom, age FROM etudiants;
SELECT DISTINCT filiere FROM etudiants; -- Sans doublons
Chapitre 5 — Filtrer avec WHERE et opérateurs
Opérateurs de comparaison
-- Égalité, comparaisons
SELECT * FROM etudiants WHERE age = 20;
SELECT * FROM etudiants WHERE age > 18;
SELECT * FROM etudiants WHERE age BETWEEN 18 AND 25;
-- Listes de valeurs
SELECT * FROM etudiants WHERE filiere IN ('Informatique', 'Réseaux');
-- Recherche de texte (LIKE)
SELECT * FROM etudiants WHERE nom LIKE 'D%'; -- Commence par D
SELECT * FROM etudiants WHERE email LIKE '%@gmail%'; -- Contient @gmail
-- Valeurs nulles
SELECT * FROM etudiants WHERE filiere IS NULL;
SELECT * FROM etudiants WHERE filiere IS NOT NULL;
-- Combinaisons logiques
SELECT * FROM etudiants WHERE age > 20 AND filiere = 'Réseaux';
SELECT * FROM etudiants WHERE age < 18 OR age > 25;
Chapitre 6 — Trier, grouper et agréger
ORDER BY — Trier les résultats
SELECT nom, prenom, age FROM etudiants
ORDER BY age ASC; -- Ordre croissant (défaut)
SELECT nom, note FROM etudiants
ORDER BY note DESC -- Ordre décroissant
LIMIT 3; -- Top 3
Fonctions d'agrégation
Fonction Description Exemple
COUNT(*) Compter les lignes COUNT(*) → 42
SUM(col) Somme d'une colonne SUM(note) → 340
AVG(col) Moyenne AVG(age) → 21.5
MAX(col) Valeur maximale MAX(note) → 20
MIN(col) Valeur minimale MIN(age) → 17
-- Nombre d'étudiants par filière
SELECT filiere, COUNT(*) AS nb_etudiants
FROM etudiants
GROUP BY filiere
HAVING COUNT(*) > 2 -- Seulement les filières avec +2 étudiants
ORDER BY nb_etudiants DESC;
Chapitre 7 — Jointures (JOIN)
Pourquoi les jointures ?
Les jointures permettent d'interroger plusieurs tables en même temps, en les reliant via leurs clés.
C'est l'essence même des bases de données relationnelles : éviter la redondance en répartissant les
données.
-- Deux tables liées
CREATE TABLE cours (
id INT PRIMARY KEY AUTO_INCREMENT,
titre VARCHAR(100),
enseignant VARCHAR(100)
);
CREATE TABLE inscriptions (
id_etudiant INT,
id_cours INT,
note DECIMAL(4,2),
FOREIGN KEY (id_etudiant) REFERENCES etudiants(id),
FOREIGN KEY (id_cours) REFERENCES cours(id)
);
-- INNER JOIN : lignes correspondantes dans les deux tables
SELECT [Link], [Link], [Link], [Link]
FROM etudiants e
INNER JOIN inscriptions i ON [Link] = i.id_etudiant
INNER JOIN cours c ON [Link] = i.id_cours
ORDER BY [Link];
-- LEFT JOIN : tous les étudiants, même sans cours inscrit
SELECT [Link], [Link]
FROM etudiants e
LEFT JOIN inscriptions i ON [Link] = i.id_etudiant
LEFT JOIN cours c ON [Link] = i.id_cours;
Chapitre 8 — Sous-requêtes
Requêtes imbriquées
Une sous-requête est une requête SELECT placée à l'intérieur d'une autre requête. Elle est exécutée
en premier, et son résultat est utilisé par la requête principale.
-- Étudiants ayant une note supérieure à la moyenne
SELECT nom, prenom, note
FROM inscriptions i
JOIN etudiants e ON [Link] = i.id_etudiant
WHERE note > (SELECT AVG(note) FROM inscriptions);
-- Étudiants inscrits au cours 'Réseaux'
SELECT nom, prenom FROM etudiants
WHERE id IN (
SELECT id_etudiant FROM inscriptions
WHERE id_cours = (SELECT id FROM cours WHERE titre = 'Réseaux')
);
Chapitre 9 — Index et Performances
Qu'est-ce qu'un index ?
Un index est une structure de données qui accélère la recherche dans une table. Sans index, SQL
doit parcourir toutes les lignes (full scan). Avec un index, il va directement à la bonne ligne, comme
un index d'un livre.
-- Créer un index sur la colonne email
CREATE INDEX idx_email ON etudiants (email);
-- Index composé (plusieurs colonnes)
CREATE INDEX idx_nom_prenom ON etudiants (nom, prenom);
-- Voir les index d'une table
SHOW INDEX FROM etudiants;
-- Analyser les performances d'une requête
EXPLAIN SELECT * FROM etudiants WHERE email = 'alice@[Link]';
■ Trop d'index ralentissent les INSERT/UPDATE. Indexez uniquement les colonnes fréquemment utilisées
dans WHERE et JOIN.
Chapitre 10 — Transactions et intégrité
Les transactions ACID
Une transaction est un ensemble d'opérations SQL qui s'exécutent comme une seule unité. Soit tout
réussit, soit tout est annulé. Les transactions respectent les propriétés ACID.
Propriété Signification
Atomicité Tout ou rien : toutes les opérations réussissent ou aucune
Cohérence La base passe d'un état valide à un autre état valide
Isolation Les transactions simultanées ne se perturbent pas
Durabilité Les données validées sont persistées même en cas de panne
-- Exemple : virement bancaire
START TRANSACTION;
UPDATE comptes SET solde = solde - 500 WHERE id = 1; -- Débit
UPDATE comptes SET solde = solde + 500 WHERE id = 2; -- Crédit
-- Si tout s'est bien passé :
COMMIT;
-- En cas d'erreur, annuler TOUT :
ROLLBACK;