Construire un MCD à partir d’un énoncé en français

Objectifs Pédagogiques

Identifier les entités et leurs attributs dans un énoncé.
Déterminer les relations entre entités et poser les bonnes cardinalités.
Structurer le MCD en respectant les formes normales (1FN, 2FN, 3FN).
Préparer un modèle exploitable pour une base de données relationnelle.

Étapes pour construire un MCD

Lire attentivement le texte

Chercher :

Les choses à retenir (souvent des noms) → potentielles entités.

Ce sont généralement des personnes, objets, lieux ou événements que le système doit mémoriser. Exemples : élève, classe, enseignant, commande, produit.
Les liens entre ces choses (souvent des verbes) → potentielles relations.

Ces relations peuvent être explicites ("un élève est inscrit dans une classe") ou implicites ("chaque produit fait partie d’une commande").
Les contraintes exprimées (ex. "un élève est dans une seule classe").
Ces phrases permettent de poser les cardinalités :
- "chaque X a un seul Y" → cardinalité (1,1)
- "un Y peut avoir plusieurs X" → cardinalité (0,N) ou (1,N)
- "peut être" = relation facultative (0,...)
- "est toujours" = relation obligatoire (1,...)

Astuce : Surligner ou noter les noms, verbes et quantificateurs du texte permet d’identifier visuellement les futurs composants du MCD. Lire une deuxième fois en se posant les questions "Qui ? Quoi ? Comment ? Combien de fois ?" aide à repérer ce qui sera utile dans le modèle.

Exemple : "Chaque élève est inscrit dans une classe" → "élève" et "classe" sont des entités, "inscrit" est une relation, et la phrase indique que chaque élève a une seule classe (1,1) et qu'une classe peut avoir plusieurs élèves (0,N).

Identifier les entités

Une entité représente un objet ou un acteur que l'on doit mémoriser dans la base de données.

Astuce : Si c’est quelque chose qu’on peut “gérer”, “lister” ou “rechercher”, c’est probablement une entité.

Exemple d’entités	Pourquoi ?
Élève	On veut stocker ses infos
Classe	Un élève est dans une classe
Enseignant	Un professeur peut être responsable

Identifier les relations

Une relation lie deux (ou plusieurs) entités. Elle décrit un lien fonctionnel.

Astuce : les verbes dans l’énoncé donnent souvent la nature de la relation.

On doit aussi préciser les cardinalités :

(0,1) → peut-être un seul
(1,1) → obligatoirement un seul
(0,N) → zéro ou plusieurs
(1,N) → au moins un

Exemple de relation	Cardinalité	Interprétation
Élève → Classe	(1,1) → (1,N)	Un élève est dans une seule classe, une classe peut avoir plusieurs élèves
Classe → Enseignant	(1,1) → (0,N)	Une classe a un seul responsable, un enseignant peut gérer plusieurs classes

Définir les attributs

Chaque entité (et parfois relation) possède des attributs. Ce sont les informations à stocker dans la base, associées à chaque occurrence d’entité.

Tous les attributs doivent être atomiques : une seule valeur par cellule. On évite donc les champs contenant plusieurs valeurs séparées par des virgules ou des tirets.

Attribut	Type de données	Exemple
nom	`VARCHAR(50)`	`"Durand"`
date_naissance	`DATE`	`"2007-05-21"`
id_élève	`INT AUTO_INCREMENT`	`1024`
email	`VARCHAR(100)`	`"alice@mail.fr"`
actif	`BOOLEAN`	`true` ou `false`

Bonnes pratiques

Toujours nommer les attributs de manière claire et cohérente (nom, pas n, ni nom_eleve si on est déjà dans la table Élève).
Les identifiants (id_...) doivent être uniques, numériques et sans signification métier.
Un attribut peut exister dans une relation (ex : date_inscription dans une relation entre Élève et Classe).
Si un champ est obligatoire, il doit être déclaré NOT NULL dans le modèle logique.
On évite les doublons d’information entre entités : un même attribut ne doit pas apparaître inutilement dans plusieurs tables.

Exemple à éviter : stocker nom_classe dans la table Élève, alors qu’une relation vers la table Classe suffit.

À retenir

Un attribut est une caractéristique simple d’une entité. Il doit être bien typé, non redondant et directement lié à ce qu’il décrit. En cas de doute, mieux vaut créer une entité ou une relation supplémentaire que de complexifier un champ.

Respecter les formes normales

Un bon MCD doit respecter les trois premières formes normales pour éviter les erreurs, les incohérences et les redondances dans la base de données.

Forme normale	Règle à respecter
1FN	Pas de liste ou de valeurs multiples dans un champ. Tous les attributs doivent être atomiques.
2FN	Tous les attributs doivent dépendre entièrement de la clé primaire (et pas d’une partie seulement).
3FN	Aucun attribut ne doit dépendre d’un autre attribut non-clé. Tous doivent dépendre directement de la clé.

Exemple : ne jamais stocker "Maths, Français" dans un seul champ matières. On crée une relation N:N entre les entités Élève et Matière.

Exemple de 2FN non respectée : une table Inscription(id_élève, id_classe, nom_classe) viole la 2FN, car nom_classe dépend uniquement de id_classe, pas de la clé composite entière. Il faut sortir nom_classe dans la table Classe.

Exemple de 3FN non respectée : une table Élève(id, nom, code_postal, ville) viole la 3FN si ville dépend de code_postal. Il faut modéliser code_postal comme une entité distincte si nécessaire.

À retenir

Les formes normales visent à >éviter les doublons, prévenir les anomalies lors des insertions, suppressions ou modifications, et garantir la cohérence des données. Un bon MCD prépare une base de données stable et maintenable.

Voici un nouvel énoncé d’exemple dans le même style narratif et structuré que celui que tu as partagé, conçu pour être utilisé dans un exercice de modélisation MCD. Il est suivi d’une analyse complète (extraction des entités, attributs, relations et cardinalités).

Exemple complet

Énoncé

Un établissement scolaire souhaite mettre en place une base de données pour mieux organiser les informations concernant ses élèves, ses classes et ses enseignants. Chaque élève est inscrit dans une seule classe, et on souhaite enregistrer pour lui son nom, son prénom et sa date de naissance. Chaque classe est identifiée par un nom unique (par exemple "5A", "6B") et est encadrée par un enseignant responsable. Un enseignant peut être responsable de plusieurs classes, ou d’aucune. On souhaite également conserver le nom, le prénom et la date d’embauche de chaque enseignant.

Par ailleurs, l’école organise un système de tutorat : certains enseignants accompagnent individuellement certains élèves, dans un rôle défini (ex. “référent”, “soutien”). Enfin, pour mieux comprendre les parcours des élèves, l’établissement souhaite enregistrer les redoublements éventuels : il est possible qu’un élève ait été inscrit plusieurs années de suite dans la même classe.

Étapes d’analyse

Entités identifiées

Entité	Pourquoi ?
Élève	Élément central à gérer, possède des informations personnelles
Classe	Structure d’accueil des élèves, identifiée par un nom
Enseignant	Personne encadrante, avec rôle dans la structure scolaire

Attributs par entité

Entité	Attributs
Élève	`id_élève`, `nom`, `prénom`, `date_naissance`
Classe	`id_classe`, `nom_classe`
Enseignant	`id_enseignant`, `nom`, `prénom`, `date_embauche`

Relations et cardinalités

Relation	Entités concernées	Cardinalité	Détails
Inscription	Élève → Classe	(1,N) → (1,1)	Un élève peut avoir été inscrit plusieurs années
ResponsableDe	Classe → Enseignant	(1,1) → (0,N)	Une classe a un seul enseignant responsable
Tutorat	Enseignant ↔ Élève	(0,N) ↔ (0,N)	Un enseignant peut accompagner plusieurs élèves (et inversement), avec un rôle attribué

La relation Inscription inclura un attribut année pour distinguer les années scolaires. La relation Tutorat inclura un attribut rôle (texte).

MCD synthétique

Entités

Élève (id_élève, nom, prénom, date_naissance)
Classe (id_classe, nom_classe)
Enseignant (id_enseignant, nom, prénom, date_embauche)

Relations

Inscription (id_élève, id_classe, année)
ResponsableDe (id_classe, id_enseignant)
Tutorat (id_enseignant, id_élève, rôle)

Typage des attributs

Attribut	Type recommandé
`id_élève`	`INT PRIMARY KEY`
`nom` / `prénom`	`VARCHAR(50)`
`date_naissance`	`DATE`
`id_classe`	`INT PRIMARY KEY`
`nom_classe`	`VARCHAR(10)`
`id_enseignant`	`INT PRIMARY KEY`
`date_embauche`	`DATE`
`année`	`YEAR`
`rôle`	`VARCHAR(50)`

Représentation du MCD en ASCII

                             +------------------+
                             |    Enseignant     |
                             +------------------+
                             | id_enseignant     |
                             | nom               |
                             | prénom            |
                             | date_embauche     |
                             +------------------+
                                    |(0,N)
                                    |
                         +-----------------------+
                         |    ResponsableDe      |
                         +-----------------------+
                         | id_classe             |
                         | id_enseignant         |
                         +-----------------------+
                                    |
                                 (1,1)
                             +----------------+
                             |    Classe      |
                             +----------------+
                             | id_classe      |
                             | nom_classe     |
                             +----------------+
                                    |
                                  (1,1)
                                    |
                          +--------------------+
                          |    Inscription     |
                          +--------------------+
                          | id_élève           |
                          | id_classe          |
                          | année              |
                          +--------------------+
                                    |
                                 (1,N)
                             +----------------+
                             |    Élève       |
                             +----------------+
                             | id_élève       |
                             | nom            |
                             | prénom         |
                             | date_naissance |
                             +----------------+
                                    |
                                 (0,N)
                                    |
                          +--------------------+
                          |      Tutorat       |
                          +--------------------+
                          | id_enseignant      |
                          | id_élève           |
                          | rôle               |
                          +--------------------+
                                    |
                                 (0,N)
                             +------------------+
                             |    Enseignant     |
                             +------------------+
                             | ...              |
                             +------------------+

Légende rapide

Chaque entité est dans un rectangle avec ses principaux attributs.
Les relations sont représentées entre les entités avec les cardinalités notées entre parenthèses.
La relation ResponsableDe est de type 1:1 → 0:N entre Classe et Enseignant.
La relation Inscription permet d’enregistrer un élève dans une classe chaque année.
La relation Tutorat relie plusieurs enseignants à plusieurs élèves, avec un attribut rôle.

À retenir

Un MCD se construit à partir du sens du texte. Ne pas chercher à deviner ce qui n’est pas dit.
Une relation N:N implique une table de liaison avec une clé composite.
Un attribut = une seule valeur, pas de listes ou de tableaux dans une cellule.
On ne pense pas encore “SQL” : on reste au niveau conceptuel (relations, cardinalités, dépendances).