Bases de données relationnelles et SQL en Terminale
Cours complet, points clés à retenir et exercices d'entraînement de bases de données relationnelles et sql pour les élèves de Terminale. Conforme au programme officiel.
Réviser notion par notion
- Relation et attribut dans une base de données
- Domaine et types de données
- Clé primaire et identifiant unique
- Contraintes d'intégrité et validité des données
- WHERE : filtrer les résultats
- DISTINCT : supprimer les doublons
- ORDER BY : trier les résultats
- JOIN : combiner deux tables
- Fonctions d'agrégation : COUNT, SUM, AVG, MIN, MAX
- UPDATE : modifier des données
- DELETE : supprimer des données
Ce que tu vas réviser
- Modèle relationnel : relation, attribut, domaine, clé primaire
- Clés étrangères et contraintes d'intégrité
- Requêtes SQL : SELECT, FROM, WHERE, JOIN ; DISTINCT, ORDER BY, fonctions d'agrégation (sans GROUP BY ni HAVING)
- Mise à jour : INSERT, UPDATE, DELETE
Relation et attribut dans une base de données
Une relation est un tableau qui organise les données. Chaque colonne du tableau s'appelle un attribut et représente une propriété. Par exemple, une table des élèves a des attributs comme « nom », « prénom », « classe ».
Exemple
Ton carnet de contact sur ton téléphone est une relation : chaque personne est une ligne, et les attributs sont « nom », « numéro », « email ».
À retenir : Une relation = un tableau avec des colonnes (attributs) et des lignes (enregistrements).
Domaine et types de données
Le domaine d'un attribut définit le type et la plage de valeurs possibles. Par exemple, l'attribut « âge » a un domaine de nombres entiers positifs, tandis que « nom » a un domaine de texte.
Exemple
Si tu crées un profil Instagram, le domaine de « date de naissance » est une date, celui de « nombre d'abonnés » est un nombre entier.
À retenir : Le domaine spécifie quel type de données peut être stocké dans chaque colonne.
Clé primaire et identifiant unique
La clé primaire est un attribut (ou groupe d'attributs) qui identifie de manière unique chaque ligne d'une table. Deux lignes ne peuvent pas avoir la même clé primaire.
Exemple
Dans une table d'élèves, le numéro d'étudiant est la clé primaire : chaque élève en a un seul et différent des autres.
À retenir : La clé primaire garantit qu'on peut toujours identifier une ligne de façon unique.
Clé étrangère et lien entre tables
Une clé étrangère est un attribut d'une table qui fait référence à la clé primaire d'une autre table. Cela crée un lien entre deux tables.
Exemple
Dans une base de restaurant, la table « commande » contient « id_client » qui fait référence à la clé primaire « id » de la table « client ».
À retenir : Une clé étrangère relie deux tables et maintient la cohérence des données.
Contraintes d'intégrité et validité des données
Les contraintes d'intégrité sont des règles qui garantissent que les données restent valides et cohérentes. Par exemple : interdire les valeurs NULL, vérifier qu'une clé étrangère existe, ou que deux valeurs respectent une relation.
Exemple
Un magasin demande que le prix d'un article soit toujours positif et qu'un client commandant un article existe vraiment dans la table des clients.
À retenir : Les contraintes d'intégrité protègent la base de données contre les données incorrectes ou incohérentes.
SELECT : extraire des données
SELECT est la commande SQL pour récupérer des données d'une table. On peut choisir les colonnes à afficher et les lignes selon des critères.
Exemple
Pour voir tous les films de moins de 2 heures d'une base de cinéma, on utilise SELECT pour récupérer cette information.
À retenir : SELECT colonnes FROM table récupère les colonnes demandées ; on complète la requête avec WHERE (filtrer), DISTINCT (supprimer les doublons) et ORDER BY (trier).
WHERE : filtrer les résultats
WHERE permet de sélectionner seulement les lignes qui respectent une condition. On peut utiliser des opérateurs comme =, >, <, AND, OR pour construire la condition.
Exemple
Pour trouver tous les élèves de classe Terminale qui ont plus de 17 ans, on ajoute WHERE classe='Terminale' AND age > 17.
À retenir : WHERE filtre les lignes selon des conditions logiques.
DISTINCT : supprimer les doublons
SELECT DISTINCT supprime les lignes en double du résultat : chaque valeur (ou chaque combinaison de valeurs, si on demande plusieurs colonnes) n'apparaît qu'une seule fois. La table elle-même n'est pas modifiée.
Exemple
Dans une table eleves(id_eleve, nom, classe), SELECT classe FROM eleves; affiche la classe de chaque élève : « Terminale » apparaît autant de fois qu'il y a d'élèves de Terminale. SELECT DISTINCT classe FROM eleves; affiche la liste des classes, chacune une seule fois.
À retenir : SELECT DISTINCT colonne FROM table élimine les doublons du résultat.
ORDER BY : trier les résultats
ORDER BY trie les lignes du résultat selon une ou plusieurs colonnes, par ordre croissant (ASC, choisi par défaut) ou décroissant (DESC). Les nombres sont triés par valeur, les textes par ordre alphabétique. ORDER BY se place à la fin de la requête, après WHERE.
Exemple
Dans une table film(id_film, titre, duree) où la durée est en minutes : SELECT titre, duree FROM film WHERE duree < 120 ORDER BY duree DESC; affiche les films de moins de 2 heures, du plus long au plus court. SELECT nom, classe FROM eleves ORDER BY classe, nom; trie par classe puis, à classe égale, par nom.
À retenir : ORDER BY colonne ASC (croissant, par défaut) ou DESC (décroissant) trie le résultat sans modifier la table.
JOIN : combiner deux tables
JOIN … ON combine les données de deux tables en associant les lignes qui vérifient une condition, le plus souvent l'égalité entre une clé étrangère et la clé primaire qu'elle référence. Seules les lignes qui ont une correspondance dans les deux tables apparaissent dans le résultat.
Exemple
Pour afficher chaque commande avec le nom du client : SELECT commande.id_commande, client.nom FROM commande JOIN client ON commande.id_client = client.id; La condition après ON relie la clé étrangère id_client de la table commande à la clé primaire id de la table client.
À retenir : JOIN table2 ON table1.cle_etrangere = table2.cle_primaire relie deux tables pour afficher des données complètes.
Fonctions d'agrégation : COUNT, SUM, AVG, MIN, MAX
Une fonction d'agrégation calcule une seule valeur à partir de toutes les lignes sélectionnées par la requête : COUNT compte les lignes, SUM fait la somme d'une colonne, AVG en calcule la moyenne, MIN et MAX donnent la plus petite et la plus grande valeur.
Exemple
SELECT COUNT(*) FROM commande WHERE id_client = 3; compte les commandes du client 3. SELECT AVG(montant) FROM commande; donne le montant moyen de toutes les commandes. SELECT MAX(montant) FROM commande; donne le montant de la commande la plus élevée.
À retenir : COUNT, SUM, AVG, MIN et MAX renvoient une seule valeur calculée sur toutes les lignes sélectionnées (après le filtrage par WHERE).
INSERT : ajouter des données
INSERT ajoute une nouvelle ligne dans une table avec les valeurs pour chaque colonne. Tous les attributs obligatoires doivent avoir une valeur.
Exemple
Pour ajouter un nouveau film dans une base de cinéma : dans la table film(id_film, titre, duree) : INSERT INTO film (id_film, titre, duree) VALUES (7, 'Gladiator', 155);
À retenir : INSERT INTO nomTable (colonnes) VALUES (valeurs) ajoute une nouvelle ligne.
UPDATE : modifier des données
UPDATE change les valeurs d'attributs pour certaines lignes. Il faut utiliser WHERE pour spécifier quelles lignes modifier, sinon toutes les lignes sont modifiées.
Exemple
Si un client change d'adresse, on fait UPDATE client SET adresse = 'nouvelle adresse' WHERE id = 5; (id est la clé primaire de la table client).
À retenir : UPDATE modifie les données existantes, toujours avec WHERE pour cibler les bonnes lignes.
DELETE : supprimer des données
DELETE supprime une ou plusieurs lignes d'une table. Comme UPDATE, il faut toujours utiliser WHERE pour éviter de supprimer toute la table accidentellement.
Exemple
Pour supprimer un film archivé : DELETE FROM film WHERE id_film = 42;
À retenir : DELETE FROM nomTable WHERE condition supprime les lignes, attention à toujours ajouter WHERE.
Les points clés
- Une base de données relationnelle est composée de tables (relations) avec des colonnes (attributs) et des lignes (tuples)
- La clé primaire identifie de manière unique chaque ligne ; la clé étrangère crée des liens entre tables
- Les contraintes d'intégrité garantissent la cohérence et la validité des données
- SELECT récupère, WHERE filtre, JOIN … ON combine deux tables, DISTINCT supprime les doublons, ORDER BY trie (ASC ou DESC) ; COUNT, SUM, AVG, MIN, MAX calculent une valeur sur toutes les lignes sélectionnées
- INSERT ajoute, UPDATE modifie, DELETE supprime les données — toujours utiliser WHERE avec UPDATE et DELETE
L'essentiel
Une base de données relationnelle organise les données en tables liées par des clés, et SQL permet de les consulter, filtrer, combiner et modifier de manière sûre grâce aux contraintes d'intégrité.
Exercices d'entraînement
Entraîne-toi sur ces exercices, puis fais-toi corriger pas à pas par le tuteur.
Exercice 1
On dispose d'une base de restaurant avec deux tables : - Table « clients » : id_client (clé primaire), nom, email - Table « commandes » : id_commande (clé primaire), id_client (clé étrangère), date, montant 1. Écris la requête SQL qui affiche, sans doublon et par ordre alphabétique, le nom des clients qui ont passé au moins une commande de plus de 50 euros. 2. Écris l'instruction SQL pour ajouter un nouveau client d'identifiant 12 : « Dupont », « dupont@mail.com ».
Corrige cet exercice avec le tuteur →Exercice 2
Une base d'école contient : - Table « eleves » : id_eleve (clé primaire), nom, classe - Table « notes » : id_note (clé primaire), id_eleve (clé étrangère), matiere, note Écris une requête SQL qui : 1. Affiche le nombre de notes de l'élève dont id_eleve = 5. 2. Modifie la note « Maths » de l'élève avec id_eleve=5 pour mettre 18.
Corrige cet exercice avec le tuteur →