SQL - Fiche de Révision BDA 2025

FICHE DE RÉVISION SQL

Bases de Données Avancées - Focus Jointures
1. Fondamentaux ˆ NOT NULL : Obligatoire
ˆ UNIQUE : Unique
Terminologie ˆ DEFAULT : Valeur par défaut
ˆ AUTO_INCREMENT : Auto-incrémentation
ˆ Relation : Table
ˆ Tuple : Ligne/Enregistrement
ˆ Attribut : Colonne 4. Modication de Tables
ˆ Cardinalité : Nombre de lignes
ˆ Degré : Nombre de colonnes
-- Ajouter colonne
ˆ Clé primaire : Identiant unique ALTER TABLE Client
ˆ Clé étrangère : Référence vers autre table ADD telephone VARCHAR (15) ;

-- Modifier colonne
Clé Primaire ALTER TABLE Client
MODIFY email VARCHAR (150) NOT NULL ;
ˆ Identie uniquement chaque ligne
-- Supprimer colonne
ˆ Jamais NULL ALTER TABLE Client
ˆ Une seule par table DROP COLUMN telephone ;
ˆ Simple (1 attribut) ou composée (plusieurs)
-- Renommer table
ALTER TABLE Client RENAME TO Customer ;
Valeur NULL

ˆ ̸= 0 et ̸= vide
ˆ Donnée manquante/inconnue 5. Requêtes SELECT
ˆ Test : IS NULL / IS NOT NULL
ˆ Jamais dans clé primaire Syntaxe générale

SELECT [ DISTINCT ] colonnes

2. Types de Données FROM tables
[ WHERE condition ]
[ GROUP BY colonnes ]
INT Entier [ HAVING condition ]
DECIMAL(M,D) Décimal [ ORDER BY colonnes [ ASC | DESC ]]
VARCHAR(M) Chaîne variable [ LIMIT n ];
CHAR(M) Chaîne xe
TEXT Texte long
DATE Date (aaaa-mm-jj) Opérateurs WHERE
DATETIME Date + heure
BOOLEAN Vrai/Faux -- Comparaison : =, <>, <, >, <=, >=
WHERE salaire > 50000

3. Création de Tables -- BETWEEN ( inclus )

WHERE age BETWEEN 25 AND 40

CREATE TABLE Client ( -- IN

id INT AUTO_INCREMENT PRIMARY KEY , WHERE ville IN ( ' Dakar ', ' Thies ')
nom VARCHAR (50) NOT NULL ,
email VARCHAR (100) UNIQUE , -- LIKE (% = n ' importe quoi )
ville VARCHAR (50) DEFAULT ' Dakar ', WHERE nom LIKE 'D% ' -- Commence par D
actif BOOLEAN DEFAULT TRUE WHERE email LIKE '% @gmail . com '
);
-- NULL
CREATE TABLE Commande ( WHERE date_livraison IS NULL
num INT AUTO_INCREMENT PRIMARY KEY ,
id_client INT NOT NULL , -- Logique : AND , OR , NOT
montant DECIMAL (10 ,2) , WHERE salaire > 50000 AND ville = ' Dakar '
FOREIGN KEY ( id_client )
REFERENCES Client ( id )
);
ORDER BY et LIMIT

-- Tri croissant ( defaut )

Contraintes ORDER BY salaire ASC
ˆ PRIMARY KEY : Clé primaire -- Tri decroissant
ˆ FOREIGN KEY : Clé étrangère ORDER BY salaire DESC

1
SQL - Fiche de Révision BDA 2025

-- Limitation
-- Multi - colonnes LIMIT 10 -- 10 premiers
ORDER BY ville ASC , salaire DESC LIMIT 10 OFFSET 20 -- Lignes 21 -30

2
SQL - Fiche de Révision BDA 2025

6. JOINTURES (Détaillé) +--------+--------+-------------+

| nom | dept | ville |
Tables d'exemple
+--------+--------+-------------+
| Diop | IT | Dakar |
Employe :
| Fall | RH | Thies |
| Ndiaye | IT | Dakar |
+----+--------+--------+ | Sow | VENTES | NULL |
| id | nom | dept | | Kane | NULL | NULL |
+----+--------+--------+ +--------+--------+-------------+
| 1 | Diop | IT |
| 2 | Fall | RH | Tous les employés présents !
| 3 | Ndiaye | IT | Quand l'utiliser ?
| 4 | Sow | VENTES |
ˆ Garder toutes les lignes de la table principale
| 5 | Kane | NULL |
ˆ Trouver les "orphelins" (sans correspondance)
+----+--------+--------+
Trouver les orphelins :

Departement :
SELECT e . nom
FROM Employe e
+---------+-------------+ LEFT JOIN Departement d
ON e. dept = d. libelle
| libelle | ville | WHERE d. libelle IS NULL ;
+---------+-------------+ -- Resultat : Sow , Kane
| IT | Dakar |
| RH | Thies |
| FINANCE | Saint-Louis |
+---------+-------------+ RIGHT JOIN

Principe : TOUTES les lignes de la table de droite +

INNER JOIN correspondances de gauche (NULL sinon).
Seulement les lignes avec correspondance dans
Principe : SELECT e . nom , d. libelle , d. ville
LES DEUX tables. FROM Employe e
RIGHT JOIN Departement d
SELECT e. nom , d. ville ON e. dept = d. libelle ;
FROM Employe e
INNER JOIN Departement d
Résultat :
ON e. dept = d. libelle ;

Résultat :
+--------+---------+-------------+
| nom | libelle | ville |
+--------+-------+ +--------+---------+-------------+
| nom | ville | | Diop | IT | Dakar |
+--------+-------+ | Ndiaye | IT | Dakar |
| Diop | Dakar | | Fall | RH | Thies |
| Fall | Thies | | NULL | FINANCE | Saint-Louis |
| Ndiaye | Dakar | +--------+---------+-------------+
+--------+-------+
FINANCE apparaît même sans employé !
Kane (dept=NULL) et Sow (VENTES non dans Équivalence :
Departement) sont exclus !
-- Ces deux requetes sont identiques :
Quand l'utiliser ? A RIGHT JOIN B = B LEFT JOIN A
ˆ Données complètes uniquement
ˆ Relation obligatoire entre tables
NATURAL JOIN
LEFT JOIN
Principe : Jointure automatique sur colonnes de même
Principe : TOUTES les lignes de la table de gauche + nom.
correspondances de droite (NULL sinon). SELECT nom , ville
SELECT e. nom , e. dept , d. ville FROM Employe
FROM Employe e NATURAL JOIN Departement ;
LEFT JOIN Departement d -- Joint sur TOUS les attributs communs
ON e. dept = d. libelle ;
Attention : Peut être dangereux si plusieurs colonnes
Résultat : communes inattendues !

3
SQL - Fiche de Révision BDA 2025

CROSS JOIN Auto-Jointure

Principe : Produit cartésien (toutes les combinaisons). Table jointe avec elle-même (ex: hiérarchie).
-- Employe avec champ id_manager
SELECT e. nom , d. ville SELECT e . nom AS employe ,
FROM Employe e m. nom AS manager
CROSS JOIN Departement d ; FROM Employe e
-- 5 employes x 3 depts = 15 lignes LEFT JOIN Employe m
ON e. id_manager = m. id ;
Rarement utilisé seul.

Récapitulatif Jointures
Jointures Multiples
Type Caractéristique

SELECT c. nom , cmd . montant , v. nom_ville INNER Correspondance

FROM Commande cmd obligatoire
INNER JOIN Client c
ON cmd . id_client = c. id
LEFT Toutes lignes de gauche
INNER JOIN Ville v RIGHT Toutes lignes de droite
ON c. id_ville = v. id NATURAL Auto sur colonnes
WHERE cmd . montant > 10000; communes
CROSS Produit cartésien

4
SQL - Fiche de Révision BDA 2025

7. Fonctions d'Agrégation 8. Opérations Ensemblistes

Fonctions de base UNION

ˆ COUNT(*) : Nombre de lignes Combine résultats en éliminant doublons.

ˆ COUNT(col) : Valeurs non NULL -- Tous les developpeurs
ˆ SUM(col) : Somme SELECT nom FROM Dev_Python
ˆ AVG(col) : Moyenne UNION
ˆ MIN(col) : Minimum SELECT nom FROM Dev_Javascript ;
ˆ MAX(col) : Maximum -- Avec doublons ( UNION ALL )
SELECT nom FROM Dev_Python
-- Nombre d ' employes UNION ALL
SELECT COUNT (*) FROM Employe ; SELECT nom FROM Dev_Javascript ;

-- Salaire moyen , min , max

SELECT AVG ( salaire ) , MIN ( salaire ) , MAX ( salaire ) Condition : Même nombre de colonnes, types
FROM Employe ; compatibles.
-- Nombre d ' employes avec dept ( NULL exclus )
SELECT COUNT ( dept ) FROM Employe ; INTERSECT

Lignes présentes dans les deux résultats.

-- Dev Python ET Javascript
GROUP BY SELECT nom FROM Dev_Python
INTERSECT
SELECT nom FROM Dev_Javascript ;
Principe : Regrouper puis agréger.
Règle : Toute colonne dans SELECT (hors agrégation)
doit être dans GROUP BY. EXCEPT

-- Nombre d ' employes par dept

SELECT dept , COUNT (*) AS nb
Diérence (dans le 1er, pas dans le 2e).
FROM Employe -- Dev Python mais PAS Javascript
GROUP BY dept ; SELECT nom FROM Dev_Python
EXCEPT
-- Salaire moyen par dept et ville SELECT nom FROM Dev_Javascript ;
SELECT dept , ville , AVG ( salaire )
FROM Employe e
JOIN Departement d ON e. dept = d. libelle
GROUP BY dept , ville ;
9. Mise à Jour
-- Total ventes par client
SELECT id_client , SUM ( montant ) AS total
FROM Commande INSERT
GROUP BY id_client
ORDER BY total DESC ;
-- Insertion complete
INSERT INTO Employe (id , nom , salaire )
VALUES (10 , ' Kane ', 350000) ;

-- Insertion partielle
HAVING
INSERT INTO Employe ( nom , prenom )
VALUES ( ' Fall ', ' Doudou ');

Principe : Filtrer les groupes APRÈS regroupement. -- Insertion multiple

INSERT INTO Employe ( nom , salaire ) VALUES
WHERE vs HAVING : ( ' Diallo ', 45000) ,
ˆ WHERE : ltre AVANT regroupement ( ' Sarr ', 52000) ;
ˆ HAVING : ltre APRÈS regroupement -- Depuis SELECT
INSERT INTO Archive
-- Depts avec plus de 1 employe SELECT * FROM Employe WHERE actif = 0;
SELECT dept , COUNT (*) AS nb
FROM Employe
GROUP BY dept
HAVING COUNT (*) > 1; UPDATE
-- Clients ayant depense > 50000 en 2024
SELECT id_client , SUM ( montant ) AS total -- Augmentation 10% pour tous
FROM Commande UPDATE Employe SET salaire = salaire * 1.10;
WHERE YEAR ( date_cmd ) = 2024
GROUP BY id_client -- Modification conditionnelle
HAVING SUM ( montant ) > 50000; UPDATE Employe
SET salaire = salaire * 1.15
WHERE dept = 'IT ';

5
SQL - Fiche de Révision BDA 2025

10. Algèbre Relationnelle

-- Modification multiple
UPDATE Employe
SET salaire = 60000 , dept = ' DIRECTION ' Correspondance
WHERE id = 5;
Algèbre SQL

ATTENTION : UPDATE sans WHERE modie TOUT σcondition (R) WHERE

! πA,B (R) SELECT A, B
R ▷◁ S JOIN
R∪S UNION
R∩S INTERSECT
R−S EXCEPT
DELETE
R×S CROSS JOIN

-- Suppression conditionnelle Exemple

DELETE FROM Employe WHERE age > 65;
Algèbre :
-- Suppression totale
DELETE FROM Table_Temp ;
πnom,ville (σsalaire>50000 (Employe ▷◁ Departement))
-- TRUNCATE ( plus rapide )
TRUNCATE TABLE Table_Temp ;
SQL :

SELECT e . nom , d. ville

DELETE vs TRUNCATE : FROM Employe e
JOIN Departement d ON e. dept = d. libelle
ˆ DELETE : ligne par ligne, avec WHERE WHERE e. salaire > 50000;
ˆ TRUNCATE : réinitialise tout, pas de WHERE

6
SQL - Fiche de Révision BDA 2025

11. Sous-Requêtes WHERE vs HAVING

Sous-requête scalaire -- Filtrer AVANT regroupement : WHERE

-- Filtrer APRES regroupement : HAVING
Retourne une seule valeur. SELECT dept , COUNT (*)
FROM Employe
-- Employes au - dessus du salaire moyen WHERE salaire > 30000 -- AVANT groupe
SELECT nom , salaire GROUP BY dept
FROM Employe HAVING COUNT (*) > 1; -- APRES groupe
WHERE salaire > ( SELECT AVG ( salaire ) FROM Employe
);

Sous-requête avec IN
13. Optimisations
-- Employes dans depts de Dakar Bonnes pratiques
SELECT nom FROM Employe
WHERE dept IN ( ˆ Éviter SELECT *, spécier colonnes
SELECT libelle FROM Departement ˆ Utiliser INNER JOIN plutôt que WHERE pour
WHERE ville = ' Dakar ' jointures
); ˆ Créer index sur colonnes fréquentes (WHERE, JOIN)
ˆ Préférer EXISTS à IN pour grandes tables
ˆ UNION ALL si doublons OK (plus rapide)
Sous-requête avec EXISTS ˆ Utiliser LIMIT pour tests

-- Clients ayant au moins une commande

SELECT nom FROM Client c EXISTS vs IN
WHERE EXISTS (
SELECT 1 FROM Commande -- IN : charge toute la liste
WHERE id_client = c . id WHERE id IN ( SELECT ...)
);
-- EXISTS : s ' arrete des qu ' il trouve
WHERE EXISTS ( SELECT 1 ...)
-- Plus rapide pour grandes tables
Sous-requête dans FROM

-- Depts avec salaire moyen > 50000

SELECT dept , avg_sal
FROM ( 14. Ordre d'Exécution
SELECT dept , AVG ( salaire ) AS avg_sal
FROM Employe Ordre logique SQL :
GROUP BY dept
) AS t 1. FROM (identication tables)
WHERE avg_sal > 50000; 2. WHERE (ltrage lignes)
3. GROUP BY (regroupement)
4. HAVING (ltrage groupes)
5. SELECT (projection)
12. Pièges Courants 6. ORDER BY (tri)
7. LIMIT (limitation)
NULL dans comparaisons

-- INCORRECT
WHERE dept = NULL
15. Points Clés
-- CORRECT Jointures
WHERE dept IS NULL
ˆ INNER : correspondance obligatoire
ˆ LEFT : toutes lignes de gauche
ˆ RIGHT : toutes lignes de droite
Colonnes manquantes dans GROUP BY
ˆ Orphelins : LEFT JOIN + WHERE table_droite IS
NULL
-- INCORRECT
SELECT dept , ville , COUNT (*)
FROM Employe GROUP BY dept ;
Agrégation
-- CORRECT
SELECT dept , ville , COUNT (*) ˆ WHERE avant GROUP BY
FROM Employe GROUP BY dept , ville ; ˆ HAVING après GROUP BY
ˆ Colonnes SELECT doivent être dans GROUP BY

7
SQL - Fiche de Révision BDA 2025

NULL Clés

ˆ Toujours IS NULL / IS NOT NULL ˆ Primaire : unique + NOT NULL

ˆ Jamais = NULL ˆ Étrangère : référence autre table
ˆ Interdit dans clé primaire ˆ Intégrité référentielle importante

8
SQL - Fiche de Révision BDA 2025

Exercices d'Entraînement
Schéma :

ˆ Etudiant(matricule, nom, prenom, ville)

ˆ Cours(code, titre, credits)
ˆ Inscription(matricule, code_cours, note)

Questions

1. Lister tous les étudiants de Dakar

2. Cours de plus de 3 crédits
3. Moyenne générale par étudiant
4. Cours sans inscription
5. Étudiants avec note > 15 en BDA
6. Nombre d'inscriptions par cours
7. Cours ayant plus de 10 inscrits
8. Étudiants inscrits à tous les cours
9. Meilleure note par cours
10. Étudiants sans aucune inscription

Solutions

-- 1. Etudiants de Dakar
SELECT * FROM Etudiant WHERE ville = ' Dakar ';

-- 2. Cours > 3 credits

SELECT * FROM Cours WHERE credits > 3;

-- 3. Moyenne par etudiant

SELECT e. matricule , e. nom , AVG (i. note ) AS moy
FROM Etudiant e
LEFT JOIN Inscription i ON e. matricule = i. matricule
GROUP BY e. matricule , e. nom ;

-- 4. Cours sans inscription

SELECT c .*
FROM Cours c
LEFT JOIN Inscription i ON c. code = i. code_cours
WHERE i. code_cours IS NULL ;

-- 5. Etudiants note > 15 en BDA

SELECT e. nom , i. note
FROM Etudiant e
JOIN Inscription i ON e. matricule = i. matricule
JOIN Cours c ON i. code_cours = c. code
WHERE c. titre = ' BDA ' AND i. note > 15;

-- 6. Nombre inscriptions par cours

SELECT c. titre , COUNT (i . matricule ) AS nb_inscrits
FROM Cours c
LEFT JOIN Inscription i ON c. code = i. code_cours
GROUP BY c. code , c. titre ;

-- 7. Cours > 10 inscrits

SELECT c. titre , COUNT (*) AS nb
FROM Cours c
JOIN Inscription i ON c. code = i. code_cours
GROUP BY c. code , c. titre
HAVING COUNT (*) > 10;

-- 8. Etudiants inscrits a tous les cours

SELECT e. nom
FROM Etudiant e
WHERE NOT EXISTS (
SELECT c. code FROM Cours c
WHERE NOT EXISTS (
SELECT * FROM Inscription i
WHERE i. matricule = e. matricule
AND i. code_cours = c . code
)
);

9
SQL - Fiche de Révision BDA 2025

-- 9. Meilleure note par cours

SELECT c. titre , MAX (i. note ) AS meilleure_note
FROM Cours c
JOIN Inscription i ON c. code = i. code_cours
GROUP BY c. code , c. titre ;

-- 10. Etudiants sans inscription

SELECT e .*
FROM Etudiant e
LEFT JOIN Inscription i ON e. matricule = i. matricule
WHERE i. matricule IS NULL ;

Bon courage pour l'examen !

La pratique est la clé de la maîtrise.

10