Лист за преговор: Introduction à la modélisation relationnelle

📋 Plan du Cours

1. Modèle relationnel
2. Terminologie relationnelle
3. Contraintes d'intégrité
4. Algèbre relationnelle
5. Langage SQL DDL
6. Création de tables
7. Manipulation des données
8. Propriétés ACID
9. Requêtes SQL
10. Jointures SQL
11. Normalisation
12. Indexation

📖 1. Modèle relationnel

🔑 Notions clés & Définitions

• Relation : Ensemble de tuples (lignes) organisés en colonnes (attributs). Représentée par une table dans une base de données.
  Exemple : La table Eleve avec attributs id_eleve, nom, prenom, date_naissance.

• Attribut : Colonne d'une relation, définie par un nom et un domaine (type de données).
  Exemple : nom (VARCHAR), date_naissance (DATE).

• Tuple (ou Uplet) : Ligne d'une table, représentant un enregistrement unique.
  Exemple : (1, "Dupont", "Marie", "2000-05-15").

• Schéma de la relation : Définition de la structure d'une relation, incluant son nom et ses attributs avec leurs domaines.
  Exemple : Eleve(id_eleve INT, nom TEXT, prenom TEXT, date_naissance DATE).

• Clé Primaire (PK) : Attribut ou ensemble d'attributs garantissant l'unicité de chaque tuple.
  Exemple : id_eleve dans Eleve.

• Clé Étrangère (FK) : Attribut ou ensemble d'attributs référant à la clé primaire d'une autre relation, assurant l'intégrité référentielle.

📝 Points essentiels

• Le modèle relationnel repose sur une structure mathématique d'ensembles, permettant une organisation claire et cohérente des données.
• La relation est représentée par une table, chaque ligne par un tuple, chaque colonne par un attribut.
• La clé primaire doit être unique et non nulle pour garantir l'identification de chaque tuple.
• La clé étrangère assure la cohérence entre deux relations, évitant les données orphelines.
• La normalisation (1NF, 2NF, 3NF) vise à réduire la redondance et les anomalies de mise à jour.
• La manipulation des données s'appuie sur l'algèbre relationnelle : projection, sélection, jointure.

💡 À retenir

Le modèle relationnel structure l'information sous forme de tables liées par des clés, garantissant cohérence, intégrité et facilité d'accès aux données. La maîtrise des notions de relation, clé primaire et étrangère est essentielle pour concevoir une base de données efficace et fiable.

📖 2. Terminologie relationnelle

🔑 Notions clés & Définitions

• Relation : Ensemble de tuples (lignes) partageant une même structure, représenté par une table en base de données.
  Exemple : La table Eleves est une relation contenant des tuples d'élèves.

• Attribut : Colonne d'une relation, définie par un nom et un domaine (type de données).
  Exemple : nom, prenom, date_naissance.

• Tuple (ou Uplet) : Ligne d'une relation, représentant un enregistrement unique.
  Exemple : Un élève avec ses informations dans la table Eleves.

• Schéma de relation : Définition de la structure d'une relation, incluant son nom et la liste de ses attributs avec leurs domaines.
  Exemple : Eleve(id_eleve INT, nom TEXT, prenom TEXT, date_naissance DATE).

• Clé Primaire (PK) : Attribut ou ensemble d'attributs garantissant l'unicité de chaque tuple dans une relation.
  Exemple : id_eleve dans la relation Eleve.

• Clé Étrangère (FK) : Attribut dans une relation qui référence la clé primaire d'une autre relation, assurant l'intégrité référentielle.
  Exemple : id_classe dans Etudiants référant à Classes.

• Contraintes d'intégrité : Règles assurant la cohérence des données, incluant l'intégrité d'entité, référentielle et de domaine.
  Exemple : La clé primaire doit être unique, la clé étrangère doit correspondre à une valeur existante, le type de données doit respecter le domaine.

📝 Points essentiels

• La relation est une abstraction mathématique, concrétisée par une table en SGBDR.
• La clé primaire doit être unique et non nulle pour assurer l'identification de chaque tuple.
• La clé étrangère garantit la cohérence entre deux relations en empêchant la création de références invalides.
• Les contraintes de domaine vérifient que les données insérées respectent le type et les restrictions définies.
• L'algèbre relationnelle utilise des opérations comme la projection, la sélection et la jointure pour manipuler les ensembles de données.
• La normalisation (1NF, 2NF, 3NF) vise à réduire la redondance et à éviter les anomalies de mise à jour.

💡 À retenir

La terminologie relationnelle repose sur des concepts mathématiques fondamentaux qui structurent la gestion des données, assurant cohérence, intégrité et efficacité dans les bases relationnelles.

📖 3. Contraintes d'intégrité

🔑 Notions clés & Définitions

• Intégrité d'entité : Garantie que chaque relation possède une clé primaire unique et non nulle, assurant l'unicité de chaque enregistrement.
• Clé Primaire (PK) : Attribut ou ensemble d'attributs identifiant de manière unique chaque tuple dans une relation.
• Intégrité référentielle : Condition où une clé étrangère (FK) dans une relation doit correspondre à une clé primaire existante dans une autre relation, évitant les références orphelines.
• Clé Étrangère (FK) : Attribut ou ensemble d'attributs dans une relation référencée à une clé primaire d'une autre relation.
• Contraintes de domaine : Vérifications que les données insérées respectent le type, les restrictions ou les règles (ex : CHECK).
• Règle ON DELETE CASCADE : Option de gestion de l'intégrité référentielle qui supprime automatiquement les enregistrements dépendants lorsqu'une clé primaire est supprimée.

📝 Points essentiels

• La cohérence des données est assurée par trois piliers : intégrité d'entité, référentielle et de domaine.
• La clé primaire doit être unique et non nulle pour chaque relation.
• La clé étrangère doit faire référence à une clé primaire existante pour maintenir la cohérence.
• Les contraintes de domaine garantissent la validité des données insérées, évitant les erreurs de typage ou de valeurs invalides.
• La gestion des suppressions via ON DELETE CASCADE permet de maintenir l'intégrité en supprimant automatiquement les enregistrements dépendants.
• La création et l'ordre des tables dans le schéma doivent respecter les dépendances de clés étrangères pour éviter les erreurs.

💡 À retenir

Les contraintes d'intégrité assurent la cohérence, la fiabilité et la validité des données dans une base relationnelle, en empêchant toute incohérence ou corruption lors des opérations.

📖 4. Algèbre relationnelle

🔑 Notions clés & Définitions

• Relation : Ensemble de tuples (lignes) structurés selon un schéma, représenté par une table dans une base de données.
  Exemple : La relation Étudiants avec attributs (id, nom, prénom).

• Attribut : Colonne d'une relation, définie par un nom et un domaine (type de données).
  Exemple : nom, prénom, date_naissance.

• Tuple (ou Uplet) : Ligne d'une relation, représentant une instance spécifique.
  Exemple : (1, "Dupont", "Marie").

• Projection (π) : Opération qui extrait certains attributs d'une relation, créant une nouvelle relation avec ces colonnes.
  Exemple : π nom, prénom (Étudiants).

• Sélection (σ) : Filtrage des tuples selon une condition, conservant uniquement ceux qui satisfont le critère.
  Exemple : σ âge > 20 (Étudiants).

• Jointure (⋈) : Fusion de deux relations sur un attribut commun, permettant de combiner des informations liées.
  Exemple : Étudiants ⋈ Inscriptions sur id_etudiant.

📝 Points essentiels

• La relation est la structure fondamentale, équivalent à une table dans une base relationnelle.
• La projection permet de sélectionner des colonnes spécifiques, utile pour réduire la dimension des résultats.
• La sélection filtre les lignes selon une condition, essentielle pour extraire des sous-ensembles précis.
• La jointure est la clé pour combiner plusieurs relations, permettant de reconstituer des informations réparties.
• Ces opérations sont formalisées par des symboles mathématiques, facilitant leur compréhension et leur manipulation logique.
• La logique relationnelle repose sur la manipulation d'ensembles, garantissant la cohérence et la non-redondance.

💡 À retenir

L'algèbre relationnelle est la base logique du traitement des données dans une base relationnelle, utilisant des opérations mathématiques pour manipuler et interroger efficacement les relations.

📖 5. Langage SQL DDL

🔑 Notions clés & Définitions

• Relation : Ensemble de données représenté sous forme de table, définie par un schéma comprenant un nom et une liste d’attributs avec leurs domaines. Exemple : Eleve(id_eleve INT, nom TEXT, prenom TEXT, date_naissance DATE).

• Attribut : Colonne d'une relation, caractérisée par un nom et un domaine (type de données). Exemple : nom (TEXT).

• Tuple (ou Ligne) : Enregistrement individuel dans une table, correspondant à une ligne. Exemple : (1, "Dupont", "Jean", "2000-05-15").

• Clé Primaire (PK) : Attribut ou ensemble d’attributs garantissant l’unicité de chaque tuple dans une relation. Elle ne doit pas être nulle.

• Clé Étrangère (FK) : Attribut ou ensemble d’attributs dans une table qui référence la clé primaire d’une autre table, assurant l’intégrité référentielle.

• Contraintes d’intégrité : Règles assurant la cohérence des données, notamment l’unicité (PK), la référence (FK), et le respect des domaines (CHECK).

📝 Points essentiels

• La création de tables doit respecter l’ordre pour gérer les dépendances de clés étrangères : d’abord les tables "mères", puis les "filles".
• La syntaxe SQL de création inclut la définition des clés primaires et étrangères, avec des options comme ON DELETE CASCADE pour gérer la suppression en cascade.
• Les contraintes d’intégrité garantissent la cohérence des données et évitent les anomalies.
• La manipulation des données (INSERT, UPDATE, DELETE) doit respecter l’ordre et les contraintes pour préserver l’intégrité.
• La normalisation (1NF, 2NF, 3NF) permet d’éviter la redondance et les anomalies de mise à jour.

💡 À retenir

Le SQL DDL sert à définir la structure logique et physique d’une base de données, en assurant la cohérence et la normalisation des données via les contraintes d’intégrité et l’ordre de création des tables.

📖 6. Création de tables

🔑 Notions clés & Définitions

• Relation : Ensemble de tuples (lignes) partageant la même structure (attributs). En pratique, une table dans une base de données relationnelle.
• Attribut : Colonne d'une relation, définie par un nom et un domaine (type de données comme INTEGER, VARCHAR, DATE). Exemple : nom, prénom.
• Tuple (ou Uplet) : Ligne d'une table, représentant une instance ou un enregistrement.
• Schéma de la relation : Définition formelle de la structure d'une table, incluant son nom, ses attributs et leurs domaines.
• Clé Primaire (PK) : Attribut ou ensemble d'attributs garantissant l'unicité de chaque tuple dans une relation. Doit être non nulle.
• Clé Étrangère (FK) : Attribut ou ensemble d'attributs dans une relation qui référence la clé primaire d'une autre relation, assurant l'intégrité référentielle.
• Contraintes d'intégrité : Règles garantissant la cohérence des données (unicité, référence, domaine).

📝 Points essentiels

• La création de tables doit respecter l'ordre des dépendances, en créant d'abord les tables "mères" (avec PK) avant les "filles" (avec FK).
• La syntaxe SQL pour créer une table inclut la définition des attributs, des clés primaires, et des clés étrangères.
• La clause ON DELETE CASCADE permet de supprimer automatiquement les enregistrements liés lors de la suppression d'une table parent.
• La cohérence des données est assurée par les contraintes d'intégrité : PK, FK, et contraintes de domaine (CHECK).
• La normalisation (3NF) évite la redondance et les anomalies en structurant correctement les relations.

💡 À retenir

La création de tables doit respecter l'ordre des dépendances et intégrer des contraintes d'intégrité pour assurer la cohérence et la fiabilité des données dans une base relationnelle.

📖 7. Manipulation des données

🔑 Notions clés & Définitions

• Relation : Ensemble de tuples (lignes) organisés en colonnes (attributs), représenté par une table dans une base de données.
• Attribut : Colonne d'une relation, définie par un nom et un domaine (type de données).
• Tuple (ou Uplet) : Ligne d'une table, représentant un enregistrement ou un élément de la relation.
• Clé Primaire (PK) : Attribut ou ensemble d'attributs garantissant l'unicité de chaque tuple dans une relation.
• Clé Étrangère (FK) : Attribut dans une relation référant à la clé primaire d'une autre relation, assurant l'intégrité référentielle.
• Propriétés ACID : Garanties essentielles pour la fiabilité des transactions : Atomicité, Cohérence, Isolation, Durabilité.

📝 Points essentiels

• La manipulation des données repose sur l'algèbre relationnelle, utilisant des opérations comme projection (sélection de colonnes), sélection (filtrage de lignes), et jointure (fusion de relations).
• La création de tables en SQL doit respecter l'ordre pour gérer les clés étrangères, en créant d'abord les tables "mères".
• La gestion de l'intégrité des données est assurée par des contraintes : clé primaire, clé étrangère, et contraintes de domaine (ex : CHECK).
• La mise à jour et la suppression nécessitent une clause WHERE pour éviter des modifications accidentelles sur toutes les données.
• Les propriétés ACID garantissent la fiabilité et la cohérence lors des opérations transactionnelles.
• Les jointures (INNER, LEFT OUTER) permettent de combiner des données issues de différentes relations, notamment pour gérer des données manquantes.
• La normalisation (1NF, 2NF, 3NF) évite la redondance et les anomalies de mise à jour en structurant les données de façon optimale.
• L'indexation (B-Tree) optimise la vitesse des requêtes en réduisant le coût de recherche dans de grandes bases.

💡 À retenir

La manipulation efficace des données en base relationnelle repose sur une compréhension claire des opérations algébriques, des contraintes d'intégrité, et des principes de normalisation pour assurer la cohérence et la performance.

📖 8. Propriétés ACID

🔑 Notions clés & Définitions

• Atomicité : Garantie que chaque transaction est traitée comme une unité indivisible. Elle est entièrement exécutée ou totalement annulée en cas d’échec.
  Exemple : Lors d’un transfert d’argent, le débit et le crédit doivent tous deux se produire ou aucun.

• Cohérence : Assure que la base de données passe d’un état valide à un autre état valide, respectant toutes les contraintes d’intégrité.
  Exemple : Après une insertion, le total des soldes doit rester cohérent avec les règles établies.

• Isolation : Permet que plusieurs transactions s’exécutent simultanément sans interférer, garantissant la cohérence des résultats.
  Exemple : Deux opérations de mise à jour concurrentes ne doivent pas produire de résultats incohérents.

• Durabilité : Une fois une transaction validée, ses effets sont permanents, même en cas de panne ou de coupure.
  Exemple : Un paiement confirmé doit rester enregistré même après une panne du serveur.

• Propriété ACID : Ensemble des quatre propriétés (Atomicité, Cohérence, Isolation, Durabilité) assurant la fiabilité des transactions dans un SGBD.

📝 Points essentiels

• Les propriétés ACID sont fondamentales pour garantir la fiabilité et l’intégrité des données dans un SGBD relationnel.
• La gestion de ces propriétés repose souvent sur des mécanismes de verrouillage, journaux de transactions (logs), et contrôles de concurrence.
• La violation d’une propriété peut entraîner des incohérences, des pertes de données ou des états invalides.
• La durabilité est souvent assurée par des journaux de transactions et des sauvegardes régulières.
• L’isolation peut être configurée via différents niveaux (READ COMMITTED, SERIALIZABLE, etc.) pour équilibrer performance et cohérence.

💡 À retenir

Les propriétés ACID garantissent que chaque transaction dans un SGBD relationnel est fiable, cohérente, isolée et durable, assurant ainsi la stabilité et l’intégrité des données même en cas de défaillance ou de concurrence.

📖 9. Requêtes SQL

🔑 Notions clés & Définitions

• Relation : Ensemble de données organisé en lignes (tuples) et colonnes (attributs), représenté par une table dans une base de données relationnelle.

• Attribut : Colonne d'une relation, définie par un nom et un domaine (type de données comme INTEGER, VARCHAR, DATE). Exemple : nom, prénom, date_naissance.

• Tuple (ou Ligne) : Enregistrement individuel dans une table, correspondant à une instance de la relation.

• Clé Primaire (PK) : Attribut ou ensemble d'attributs garantissant l'unicité de chaque tuple dans une relation. Ex : id_etudiant.

• Clé Étrangère (FK) : Attribut ou ensemble d'attributs dans une relation qui référence la clé primaire d'une autre relation, assurant l'intégrité référentielle.

• Requête SQL (SELECT) : Instruction permettant d'extraire, filtrer, agréger et manipuler des données dans une base relationnelle.

📝 Points essentiels

• La création de tables doit respecter l'ordre, en créant d'abord les tables "mères" (avec PK) avant les "filles" (avec FK).

• La manipulation des données (INSERT, UPDATE, DELETE) doit respecter l'intégrité et utiliser des clauses WHERE pour éviter des modifications accidentelles massives.

• Les jointures (INNER JOIN, LEFT OUTER JOIN) permettent de combiner plusieurs tables selon des conditions précises, essentielles pour exploiter des relations complexes.

• Les fonctions d'agrégation (SUM, AVG, COUNT, MAX, MIN) combinées avec GROUP BY permettent de réaliser des synthèses sur des groupes de données.

• Les sous-requêtes corrélées permettent d'effectuer des requêtes imbriquées dépendantes du contexte de la requête principale.

• La normalisation (3NF) évite la redondance et les anomalies, en structurant la base pour que chaque donnée soit stockée à un seul endroit.

• L'indexation (B-Tree) optimise la vitesse d'accès aux données, mais peut ralentir les opérations d'insertion et de mise à jour.

💡 À retenir

Les requêtes SQL permettent d'extraire et de manipuler efficacement des données structurées, en garantissant leur cohérence grâce aux contraintes d'intégrité et à une structuration normalisée. La maîtrise des jointures, agrégations et index est essentielle pour optimiser les performances et la fiabilité d'une base relationnelle.

📖 10. Jointures SQL

🔑 Notions clés & Définitions

• Jointure (JOIN) : Opération permettant de combiner des lignes de deux ou plusieurs tables en fonction d'une condition de correspondance (prédicat commun). Elle permet d'extraire des données liées réparties dans plusieurs tables.

• INNER JOIN : Jointure qui retourne uniquement les lignes où la condition de correspondance est satisfaite dans les deux tables. Résultat intersection.

• LEFT OUTER JOIN (ou LEFT JOIN) : Retourne toutes les lignes de la table de gauche, même si aucune correspondance n’est trouvée dans la table de droite. Les valeurs non correspondantes de la table de droite sont NULL.

• Clé étrangère (FK) : Attribut ou ensemble d’attributs dans une table qui référence la clé primaire d’une autre table, assurant la cohérence référentielle.

• Prédicat de jointure : Condition utilisée pour faire correspondre les lignes entre les tables (ex : table1.id = table2.id).

• Relation : Ensemble de données structurées sous forme de tables, en relation via des jointures pour modéliser des liens logiques.

📝 Points essentiels

• Les jointures permettent de relier des tables pour obtenir des résultats combinés, essentiels dans la modélisation relationnelle.

• La syntaxe de base :

  SELECT colonnes
  FROM table1
  [JOIN type_de_jointure table2 ON condition]
  

• INNER JOIN est le type de jointure le plus courant, utilisé pour obtenir l’intersection des données.

• LEFT OUTER JOIN conserve toutes les lignes de la table de gauche, en complétant par NULL pour les données manquantes de la table de droite.

• La performance des jointures peut être optimisée par des index sur les clés de jointure.

• La compréhension des jointures est essentielle pour réaliser des requêtes complexes et modéliser efficacement la relation entre différentes entités.

💡 À retenir

Les jointures SQL sont la clé pour exploiter pleinement la puissance du modèle relationnel, permettant de combiner et d’analyser des données réparties dans plusieurs tables. La maîtrise de leur syntaxe et de leur logique est indispensable pour toute requête avancée.

📖 11. Normalisation

🔑 Notions clés & Définitions

• Normalisation : Processus visant à organiser les données dans une base pour réduire la redondance et éviter les anomalies de mise à jour, en appliquant des formes normales successives.

• 1NF (Première Forme Normale) : Condition où tous les attributs sont atomiques (indivisibles) et la relation possède une clé primaire. Elle garantit que chaque cellule contient une seule valeur.

• 2NF (Deuxième Forme Normale) : 1NF + tous les attributs non clés dépendent entièrement de la clé primaire (pas de dépendance partielle dans les clés composées).

• 3NF (Troisième Forme Normale) : 2NF + pas de dépendance transitive ; un attribut non clé ne doit pas dépendre d’un autre attribut non clé.

• Dépendance fonctionnelle : Relation entre deux ensembles d’attributs où la valeur d’un ensemble détermine la valeur d’un autre.

📝 Points essentiels

• La normalisation permet d’éviter la redondance, les anomalies d’insertion, de mise à jour et de suppression.

• La progression dans les formes normales (1NF → 3NF) consiste à éliminer successivement les dépendances non souhaitées.

• La 1NF impose l’atomicité des données, la 2NF élimine les dépendances partielles, la 3NF élimine les dépendances transitives.

• La normalisation est essentielle pour assurer l’intégrité et la cohérence des données dans un SGBDR.

• Cependant, une normalisation excessive peut nuire aux performances (requêtes complexes, jointures nombreuses).

💡 À retenir

La normalisation est un processus structurant qui optimise la cohérence et la maintenance des données, en appliquant successivement les formes normales pour réduire la redondance et les anomalies.

📖 12. Indexation

🔑 Notions clés & Définitions

• Index : Structure de données (souvent B-Tree) créée sur une ou plusieurs colonnes d'une table pour accélérer la recherche et l'accès aux données.
  Exemple : Un index sur la colonne nom permet de retrouver rapidement un étudiant par son nom.

• Clé d'index : Colonne ou ensemble de colonnes sur lesquelles l'index est construit. Elle doit être choisie pour optimiser les requêtes fréquentes.
  Exemple : Index sur id_classe pour des recherches par classe.

• Index unique : Index qui garantit l'unicité des valeurs dans la colonne indexée, équivalent à une contrainte d'unicité.
  Exemple : Index sur email pour éviter les doublons.

• Coût d'indexation : Ressources nécessaires pour créer, maintenir et mettre à jour un index, impactant notamment les opérations d'insertion, de mise à jour et de suppression.

• Indexation sélective : Utilisation d'index sur des colonnes très filtrées ou souvent utilisées dans les clauses WHERE pour optimiser les performances.

📝 Points essentiels

• L'index permet de réduire significativement le temps de réponse des requêtes SELECT, surtout sur de grandes tables.
• La création d'index doit être stratégique : trop d'index peut ralentir les opérations d'écriture (INSERT, UPDATE, DELETE) car chaque index doit être mis à jour.
• La structure la plus courante est l'index B-Tree, adaptée aux recherches par égalité ou plage.
• L'utilisation d'index doit respecter la fréquence d'utilisation des colonnes dans les requêtes pour un gain optimal.
• La maintenance des index (reconstruction, défragmentation) est essentielle pour conserver leur efficacité.

💡 À retenir

L'indexation est un levier clé pour optimiser les performances d'une base de données, mais elle doit être utilisée judicieusement pour équilibrer rapidité d'accès et coût de maintenance.

📊 Tableaux de Synthèse

⚠️ Pièges & Confusions Fréquentes

1. Confondre relation et table : une relation est une abstraction mathématique, une table est sa représentation physique.
2. Oublier que la clé primaire doit être non nulle et unique pour chaque tuple.
3. Utiliser une clé étrangère sans vérifier qu’elle référence une clé existante (problème d’intégrité référentielle).
4. Confondre la projection (π) et la sélection (σ) : la première sélectionne des colonnes, la seconde des lignes.
5. Négliger la normalisation : ne pas respecter 1NF, 2NF, 3NF peut entraîner redondance et anomalies.
6. Oublier que la jointure nécessite un attribut commun, souvent une clé étrangère.
7. Confondre la syntaxe SQL avec la logique relationnelle : ne pas maîtriser la traduction entre les deux.
8. Se tromper dans l’ordre de création des tables avec clés étrangères (dépendances).
9. Ignorer les contraintes d’intégrité lors des opérations de modification ou suppression.
10. Confondre relation et domaine : un attribut doit respecter son domaine, sinon erreur de type.
11. Utiliser une clé primaire non candidate ou non unique, ce qui compromet l’unicité.

✅ Checklist Examen

1. Vérifier la définition précise d’une relation et ses composants (tuples, attributs).
2. Savoir différencier relation, attribut, tuple, clé primaire, clé étrangère.
3. Connaître les contraintes d’intégrité (entité, référentielle, domaine) et leur rôle.
4. Maîtriser la syntaxe et la sémantique des opérations en algèbre relationnelle : projection, sélection, jointure.
5. Savoir créer une table en SQL avec clés primaires et étrangères.
6. Savoir insérer, mettre à jour, supprimer des données en respectant les contraintes.
7. Comprendre le fonctionnement des propriétés ACID (Atomicité, Cohérence, Isolation, Durabilité).
8. Rédiger une requête SQL simple (SELECT, WHERE, JOIN).
9. Réaliser des jointures SQL (INNER JOIN, LEFT JOIN, etc.) pour combiner plusieurs tables.
10. Appliquer les principes de normalisation pour éviter redondance et anomalies.
11. Utiliser des index pour optimiser les performances des requêtes.
12. Vérifier la cohérence des données après opérations de manipulation.