NSI (Spé) — Bases de données
Bases de données relationnelles et SQL
Modèle relationnel, tables, clés, requêtes SELECT, INSERT, UPDATE, DELETE
Résumé synthétiqueFiche en 4 sectionsQuiz de 10 questionsGratuit, sans pub
Résumé
Une base de données relationnelle range les données dans des tables (relations) faites de lignes (enregistrements) et de colonnes (attributs). Chaque table a une clé primaire qui identifie chaque ligne de façon unique (par exemple un numéro d'étudiant). Une clé étrangère référence la clé primaire d'une autre table et crée un lien entre elles. Le langage SQL interroge et modifie les données : SELECT * FROM eleves WHERE moyenne > 14 récupère les bons élèves. Les jointures (JOIN) combinent plusieurs tables. INSERT ajoute, UPDATE modifie et DELETE supprime des données. Les contraintes d'intégrité garantissent la cohérence de l'ensemble.
Une base relationnelle organise l'information en tables reliées entre elles. Chaque table décrit une catégorie d'objets ; la clé primaire identifie ses lignes sans ambiguïté, et la clé étrangère tisse des liens entre tables. Les contraintes veillent à la cohérence des données.
La clé étrangère classe_id de la table eleves pointe vers la clé primaire id de la table classes.
- Relation (table) : un ensemble de n-uplets (lignes) partageant les mêmes attributs (colonnes).
- Schéma : nom de la table et attributs typés, ex. Eleve(id INT, nom TEXT, moyenne REAL).
- Clé primaire (PRIMARY KEY) : attribut(s) identifiant de façon unique chaque ligne.
- Clé étrangère (FOREIGN KEY) : attribut référençant la clé primaire d'une autre table.
- Contraintes : unicité de la clé primaire, NOT NULL, domaine des valeurs autorisées.
Exemple
Eleve(id, nom, classe_id) et Classe(id, salle) : la colonne classe_id de Eleve est une clé étrangère qui pointe vers id de Classe, reliant chaque élève à sa salle.
Piège à éviter
Une clé primaire doit être unique et non nulle : deux lignes ne peuvent pas la partager. Une clé étrangère, elle, doit correspondre à une clé primaire existante, sinon le lien est incohérent.
SELECT est la requête reine : elle interroge la base sans la modifier. On choisit les colonnes, on filtre les lignes avec WHERE, on trie avec ORDER BY et on résume avec des fonctions d'agrégation. C'est l'équivalent SQL de la recherche dans une table.
- Base : SELECT colonnes FROM table extrait des données.
- Projection : SELECT nom, moyenne FROM eleves ne garde que certaines colonnes.
- Filtre : WHERE classe = '1A' AND moyenne > 12 sélectionne les lignes voulues.
- Tri et doublons : ORDER BY moyenne DESC trie ; SELECT DISTINCT supprime les répétitions.
- Agrégation : COUNT, SUM, AVG, MIN, MAX, souvent avec GROUP BY pour regrouper.
Exemple
SELECT classe, AVG(moyenne) FROM eleves GROUP BY classe calcule la moyenne de chaque classe : GROUP BY regroupe les lignes par classe, puis AVG les résume.
Piège à éviter
Une fonction d'agrégation (AVG, COUNT...) résume un groupe de lignes : sans GROUP BY, elle s'applique à toute la table. Mélanger une colonne brute et une agrégation sans GROUP BY donne un résultat incohérent.
Quand l'information est répartie dans plusieurs tables, JOIN les combine sur une condition de correspondance. C'est l'opération qui réunit, par exemple, le nom d'un élève (table eleves) et sa salle (table classes), en suivant la clé étrangère.
- Principe : JOIN combine les lignes de deux tables selon une condition.
- Syntaxe : SELECT * FROM eleves JOIN classes ON eleves.classe_id = classes.id.
- INNER JOIN : (par défaut) ne garde que les lignes ayant une correspondance dans les deux tables.
- Condition ON : désigne les colonnes de jointure (en général clé étrangère = clé primaire).
- Usage : afficher ensemble des infos venant de tables différentes.
Exemple
SELECT eleves.nom, classes.salle FROM eleves JOIN classes ON eleves.classe_id = classes.id affiche, pour chaque élève, le nom et la salle de sa classe.
Piège à éviter
Sans la condition ON, la jointure produit un produit cartésien : toutes les combinaisons de lignes des deux tables, souvent un résultat énorme et dénué de sens. La clause ON n'est pas optionnelle.
Au-delà de la lecture, SQL modifie la base avec trois commandes : INSERT ajoute des lignes, UPDATE en change le contenu, DELETE en supprime. Ces opérations sont puissantes et donc dangereuses : une clause WHERE oubliée touche toute la table.
- INSERT : INSERT INTO eleves (nom, classe, moyenne) VALUES ('Dupont', '1A', 14.5).
- UPDATE : UPDATE eleves SET moyenne = 15.0 WHERE nom = 'Dupont'.
- DELETE : DELETE FROM eleves WHERE id = 42.
- Le WHERE est vital : UPDATE ou DELETE sans WHERE affecte toutes les lignes.
- Intégrité : les contraintes empêchent les incohérences (supprimer une classe encore référencée).
Exemple
UPDATE eleves SET moyenne = 16 WHERE nom = 'Dupont' ne change que la ligne de Dupont. Sans le WHERE, c'est la moyenne de tous les élèves qui passerait à 16.
Piège à éviter
DELETE FROM eleves sans clause WHERE supprime toutes les lignes de la table ! Toujours vérifier (voire tester avec un SELECT) la clause WHERE avant un UPDATE ou un DELETE.
Quiz - Bases de données relationnelles et SQL
10 questions
S'entraîner
Articles utiles
Questions fréquentes
Les points clés à retenir sur Bases de données relationnelles et SQL, extraits du quiz de révision.
Qu'est-ce qu'une clé primaire ?
Réponse :
Un attribut identifiant de façon unique chaque enregistrement
La clé primaire a une valeur unique pour chaque ligne et l'identifie sans ambiguïté.
Quelle requête sélectionne les élèves de moyenne supérieure à 14 ?
Réponse :
SELECT * FROM eleves WHERE moyenne > 14
On filtre avec SELECT ... FROM ... WHERE ; la clause WHERE porte la condition.
Que fait SELECT DISTINCT classe FROM eleves ?
Réponse :
Liste les classes sans doublons
DISTINCT élimine les doublons du résultat : on obtient la liste des classes différentes (sans modifier la table).
Qu'est-ce qu'une clé étrangère ?
Réponse :
Un attribut qui référence la clé primaire d'une autre table
La clé étrangère relie deux tables en référençant la clé primaire de l'autre table.