Ficha de revisão: Introduction aux bases de données relationnelles

📋 Plan du Cours

1. Bases de données relationnelles
2. Modèle relationnel et MCD
3. Contraintes et schéma relationnel
4. Systèmes de gestion de bases de données
5. Requêtes SQL et jointures
6. Fonctions d’agrégat et Python

📖 1. Bases de données relationnelles

🔑 Notions clés & Définitions

• Base de données : Une base de données est un ensemble structuré de données enregistrées sur des supports accessibles par ordinateur, représentant des informations du monde réel et modifiables puis consultables par des utilisateurs.
• Base de données relationnelles : Une base de données relationnelles est une base de données organisée en tables reliées entre elles pour structurer et exploiter des données en limitant la répétition.

📝 Points essentiels

• Une base de données sert à organiser, stocker, mettre à jour et interroger des données structurées utilisées par plusieurs programmes ou utilisateurs.
• Les bases de données hiérarchiques organisent les données en arborescence avec un possesseur unique par donnée.
• Dans une base de données relationnelles, les données sont les plus utilisées au monde parmi les grands types présentés.
• Le modèle relationnel sépare les informations en plusieurs tables afin d’éviter la redondance et de ne pas stocker ce qui peut être déduit ou calculé.

📖 2. Modèle relationnel et MCD

🔑 Notions clés & Définitions

• Modèle relationnel : Modèle mathématique qui organise des informations sous forme de relations entre plusieurs données et vise à limiter la redondance.
• MCD : Modèle conceptuel de données décrivant les entités distinctes et les associations qui les relient, avec leurs cardinalités.
• Cardinalités : Couples (min, max) placés sur les associations pour exprimer les règles de participation entre entités.

📝 Points essentiels

• Les bases relationnelles séparent les données en plusieurs tables pour éviter la répétition, sans stocker des valeurs calculables comme un total.
• Un MCD se représente avec des rectangles pour les entités et un rectangle à bord arrondi pour les associations libellées souvent par un verbe.
• Une cardinalité de type 1,n traduit qu’une entité de l’association correspond à plusieurs occurrences de l’autre, avec au moins 1 cas.

💡 Astuce mémo

MCD = Entités (rectangles) + Association (verbe) + (min,max) = règles de liaison.

📖 3. Contraintes et schéma relationnel

🔑 Notions clés & Définitions

• Intégrité référentielle : L’intégrité référentielle regroupe les contraintes qui garantissent la cohérence des données entre attributs et entre tables liées.
• Contrainte de domaine : La contrainte de domaine impose que chaque attribut prenne uniquement une valeur compatible avec le type (et éventuellement l’intervalle) défini pour lui.
• Clé étrangère : Une clé étrangère est un attribut d’une table qui pointe vers la clé primaire d’une autre table pour maintenir les liens entre enregistrements.

📝 Points essentiels

• Chaque attribut doit respecter son domaine, sinon on ne peut pas créer d’enregistrement incohérent (exemple : une salle doit être un entier).
• Une relation ne contient pas deux tuples identiques et doit avoir une clé primaire pour identifier chaque enregistrement de façon unique.
• Une clé étrangère doit correspondre à une clé primaire d’une autre table, et empêche l’effacement d’un enregistrement référencé ainsi que sa modification si des enregistrements liés existent.
• Quand une association a une cardinalité 0,1 ou 1,1, on implémente par une clé étrangère dans la table de l’entité du côté “0,1/1,1”, alors que pour 0,n ou 1,n on crée une table d’association contenant les deux clés primaires.

💡 Astuce mémo

Domaine = Types valides, Clé primaire = Unicité, Référence/FK = Cohérence entre tables (D-P-FK).

📖 4. Systèmes de gestion de bases de données

🔑 Notions clés & Définitions

• Système de gestion de bases de données : Un SGBD est un logiciel qui permet de sauvegarder, interroger, rechercher et afficher des données stockées dans une base de données.
• Gestion des autorisations d’accès : La gestion des autorisations permet de contrôler quels utilisateurs ont le droit de lire ou d’écrire dans une base de données.
• Accès concurrent : L’accès concurrent décrit la situation où plusieurs utilisateurs accèdent en même temps à la base, y compris pour modifier les mêmes données.

📝 Points essentiels

• Un SGBD assure la persistance des données et maintient la structure de la base malgré les modifications.
• Les SGBD gèrent l’accès concurrent afin d’éviter des conflits quand plusieurs personnes modifient simultanément les mêmes données.
• Pour la continuité en cas de panne, les bases sont répliquées sur plusieurs ordinateurs et le SGBD synchronise les copies.
• Il existe des SGBD relationnels et NoSQL, et dans ce cours on utilise SQLite avec DB Browser.

📖 5. Requêtes SQL et jointures

🔑 Notions clés & Définitions

• Clause SELECT : La clause SELECT sert à choisir les attributs (ou *) à renvoyer à partir d’une ou plusieurs tables selon un filtre éventuel.
• Jointure SQL : Une jointure combine des lignes de deux tables en ne gardant que les correspondances sur une clé commune.
• Notation pointée : La notation pointée du type table.colonne indique explicitement la table d’où vient chaque attribut quand plusieurs tables sont utilisées.

📝 Points essentiels

• Une requête de sélection suit la forme SELECT attributs FROM table WHERE condition, avec WHERE optionnel.
• Les jointures se font via les clés reliées (clé étrangère → clé primaire) pour obtenir une fusion virtuelle des lignes correspondantes.
• Avec JOIN, les lignes sans correspondance dans l’autre table ne sont pas affichées dans l’exemple utilisateur/commande.
• La clause WHERE peut s’ajouter après une jointure pour filtrer les résultats (par exemple note = 10).

📖 6. Fonctions d’agrégat et Python

🔑 Notions clés & Définitions

• COUNT(*) : Fonction d’agrégation qui renvoie le nombre total de lignes d’une table ou d’un ensemble filtré dans une requête.
• AVG(A) : Fonction d’agrégation qui calcule la moyenne des valeurs numériques de l’attribut A sur les lignes sélectionnées.
• PRAGMA foreign_keys = ON : Instruction SQLite qui active la prise en compte des clés étrangères pour les requêtes exécutées dans la session Python.

📝 Points essentiels

• Les agrégats courants sont COUNT(*), COUNT(DISTINCT A), SUM(A), MAX(A), MIN(A) et AVG(A) utilisés sous la forme SELECT fonction(colonne) FROM table.
• Pour la plus ancienne publication, on combine MIN sur l’année avec SELECT titre, MIN(annee_publi) FROM livre.
• En Python avec sqlite3, après une exécution modifiant les données, il faut appeler connexion.commit() pour que les changements soient réellement enregistrés.
• Pour activer les clés étrangères en sqlite3, il faut exécuter curseur.execute("PRAGMA foreign_keys = ON") juste après la création du curseur.

📅 Repères chronologiques

📊 Tableaux de synthèse

Types de SGBD (relationnel vs NoSQL)

⚠️ Pièges & confusions fréquents

1. Confondre MCD et schéma relationnel : le MCD décrit entités/associations et cardinalités, tandis que le schéma relationnel liste tables, attributs, PK/FK.
2. Croire qu’une association 0,n ou 1,n se traduit par une simple clé étrangère : ici, le cours impose une table d’association avec les deux clés primaires.
3. Penser qu’on peut stocker des données calculables (exemple « total ») : le modèle relationnel recommande de ne pas stocker ce qui peut être déduit ou calculé.
4. Oublier que SQLite n’active pas les clés étrangères par défaut : il faut exécuter PRAGMA foreign_keys = ON juste après la création du curseur.
5. Confondre jointure et sélection sans jointure : avec JOIN, les lignes sans correspondance dans l’autre table ne sont pas affichées dans l’exemple du cours.
6. Se tromper de forme SQL : SELECT suit SELECT attributs FROM table avec WHERE optionnel, et il faut terminer chaque ordre par un ;.
7. Faire des modifications en Python sans connexion.commit() : sans commit, les changements ne sont pas enregistrés et donc pas visibles.

✅ Checklist Examen

1. Définir une base de données et une base de données relationnelle, et expliquer le rôle de la séparation en plusieurs tables pour éviter la redondance.
2. Rappeler la représentation d’un MCD : rectangles (entités), rectangle à bord arrondi (association), association libellée par un verbe, et cardinalités (min,max).
3. Interpréter une cardinalité 1,n et relier cardinalités et règles de participation dans le MCD.
4. Expliquer l’intégrité de domaine, la contrainte de relation via clé primaire (unicité) et la contrainte de référence via clé étrangère.
5. Dire comment implémenter les associations : cardinalité 0,1 ou 1,1 avec une FK dans la table du côté indiqué, et cardinalités 0,n ou 1,n avec une nouvelle table d’association.
6. Associer FK et schéma relationnel : une clé étrangère pointe vers une clé primaire d’une autre table, avec règles d’empêchement d’effacement/modification si des enregistrements liés existent.
7. Citer les fonctions d’un SGBD (persistance, autorisations, gestion de l’accès concurrent, sauvegardes/répliques) et distinguer SGBD relationnel vs NoSQL d’après le cours.
8. Maîtriser les requêtes SQL : CREATE TABLE, INSERT INTO, DELETE FROM (avec/ sans WHERE), UPDATE ... SET ... WHERE, SELECT ... WHERE (WHERE optionnel) et DISTINCT/ORDER BY/tri ASC-DESC.
9. Expliquer et produire une jointure SQL avec JOIN ON et la notation pointée table.colonne, puis ajouter une clause WHERE après la jointure.
10. Savoir utiliser les fonctions d’agrégation COUNT/DISTINCT, SUM, MIN, MAX, AVG dans une requête SELECT.
11. Expliquer l’usage de sqlite3 en Python : connect, cursor, activation des clés étrangères avec PRAGMA foreign_keys = ON, exécution (execute/executemany), et validation avec commit.
12. Donner la structure des traitements côté Python pour exécuter des requêtes et récupérer des résultats (fetchone / fetchmany / fetchall).