Logiciels pour faire un MCD et rétro-conception

Un logiciel de modélisation dessine le MCD, vérifie sa cohérence et génère le MLD et le script SQL. La rétro-conception fait le chemin inverse : elle part d'une base existante pour retrouver son MLD, puis son MCD. Ce chapitre présente les outils que tu croiseras au BTS SIO (Looping, Mocodo, MySQL Workbench), la notation « pattes de corbeau » qu'utilisent beaucoup d'entre eux, et la méthode pour retrouver le MCD d'une base que tu n'as pas conçue.

Pourquoi un logiciel

Sur papier, un MCD de dix entités se redessine trois fois avant d'être lisible. Un logiciel apporte :

• un schéma propre, qu'on réorganise sans tout effacer, à joindre au dossier d'E6 ou à la documentation d'un projet ;
• des contrôles : une entité sans identifiant, une association sans cardinalité, une propriété en double ;
• la génération du MLD et du script SQL, qui applique les règles de passage sans oubli ;
• la mise à jour : quand le besoin évolue, on modifie le MCD et on régénère.

Il ne pense pas à ta place : il traduit fidèlement un MCD faux en base fausse.

Looping

Looping est un logiciel gratuit de modélisation conceptuelle des données, diffusé par l'Université de Toulouse, très utilisé dans les sections de BTS SIO. La version 4.1 est sortie en mars 2025. Il s'installe sous Windows (sur macOS ou Linux, il faut passer par une couche de compatibilité comme Wine, ou par une machine virtuelle).

Ce qu'il sait faire, et qui correspond à ce cours :

• dessiner un MCD avec la notation de Merise : entités, associations, cardinalités, associations porteuses, réflexives et ternaires, identifiants relatifs, héritage, contraintes entre associations ;
• afficher le MLD correspondant, sous forme graphique ou textuelle ;
• générer le script SQL de création des tables pour plusieurs SGBD ;
• dessiner aussi des diagrammes de classes UML.

Une méthode de travail efficace : saisis d'abord toutes les entités avec leurs propriétés et leurs identifiants, puis les associations et leurs cardinalités ; place les entités pour que les pattes ne se croisent pas ; affiche le MLD et compare-le avec celui que tu attendais ; génère le script, puis complète-le à la main (types précis, CHECK, UNIQUE, ON DELETE) comme au chapitre 9.

Mocodo

Mocodo est un outil libre et gratuit, développé par Aristide Grange à l'Université de Lorraine (version 4.3, sortie en mars 2025). On ne dessine pas : on écrit le MCD dans un petit langage texte, et Mocodo dessine le schéma, le place automatiquement et produit sur demande le MLD, le script SQL ou le diagramme de classes UML. Il s'utilise en ligne sur mocodo.net, sans installation, ou s'installe en local avec Python (pip install mocodo) pour les données confidentielles.

Une entité s'écrit NOM: identifiant, propriété, … (la première propriété est l'identifiant) ; une association NOM, cardinalité ENTITE, cardinalité ENTITE, avec ses propriétés après deux points. Les cardinalités s'écrivent sans virgule : 0N, 11, 1N, 01. Voici le cœur du MCD de Rivelire :

GENRE: code_genre, libelle_genre
APPARTENIR, 11 DOCUMENT, 0N GENRE
DOCUMENT: num_document, titre, annee_parution, resume
CORRESPONDRE, 11 EXEMPLAIRE, 0N DOCUMENT
EXEMPLAIRE: code_barre, date_acquisition, etat
RATTACHER, 11 EXEMPLAIRE, 0N SITE
SITE: code_site, nom_site, adresse_site, ville_site
RESERVER, 0N ADHERENT, 0N DOCUMENT: date_reservation
ADHERENT: num_adherent, nom_adherent, prenom_adherent, date_naissance

Le texte se versionne avec Git, se corrige en deux secondes et se recopie dans un compte rendu. C'est un excellent outil pour s'entraîner : écris le MCD d'un exercice, puis compare le MLD que Mocodo génère avec le tien.

MySQL Workbench

MySQL Workbench est l'outil graphique d'Oracle pour MySQL. Il ne fait pas de MCD au sens de Merise : il dessine des modèles physiques (des tables avec leurs colonnes typées), qu'il appelle diagrammes EER, avec la notation des pattes de corbeau. Trois fonctions sont précieuses :

• Forward Engineer (menu Database) : crée la base à partir du modèle dessiné ;
• Reverse Engineer (menu Database) : dessine le modèle d'une base existante, avec toutes ses clés étrangères ;
• Synchronize Model : compare le modèle et la base, et génère les ALTER TABLE qui les mettent d'accord.

C'est l'outil de la rétro-conception et de la documentation d'une base MySQL réelle. DBeaver, un client SQL gratuit, affiche aussi le diagramme des tables d'une base existante, dans l'onglet ER Diagram d'un schéma.

Les autres outils

La notation des pattes de corbeau

Workbench, DBeaver et la plupart des outils anglo-saxons dessinent les liens avec la notation des pattes de corbeau (crow's foot). Chaque extrémité d'un lien porte deux symboles : le cercle pour zéro, le trait pour un, la patte de corbeau (trois branches) pour plusieurs. Le symbole le plus proche de l'entité donne le maximum, l'autre le minimum.

Attention au côté. Comme en UML, le symbole placé près d'une table dit combien de lignes de cette table sont liées à une ligne de l'autre. C'est l'inverse de Merise. Le lien entre site et exemplaire porte « un et un seul » du côté de site et « zéro ou plusieurs » du côté d'exemplaire, alors que le MCD écrit 0,n près de SITE et 1,1 près d'EXEMPLAIRE.

La rétro-conception : de la base au MCD

La rétro-conception (reverse engineering) consiste à reconstituer le modèle d'une base existante à partir de sa structure. Tu en as besoin quand tu reprends une application sans documentation (en stage, très souvent), quand tu dois faire évoluer une base que tu n'as pas conçue, ou quand un sujet d'examen te donne des tables et te demande de raisonner sur les règles de gestion qu'elles traduisent. Reprendre une application entière, code compris, suit la même logique : le chapitre Reprendre un code existant du cours Maintenance applicative en donne la méthode.

1. Récupère la structure. SHOW TABLES puis SHOW CREATE TABLE pour chaque table donnent les colonnes, les clés primaires, les clés étrangères, les NOT NULL et les UNIQUE. Pour la liste de toutes les clés étrangères d'une base, interroge le dictionnaire du serveur :

SELECT TABLE_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
FROM information_schema.KEY_COLUMN_USAGE
WHERE TABLE_SCHEMA = 'parc'
  AND REFERENCED_TABLE_NAME IS NOT NULL
ORDER BY TABLE_NAME;

Le Reverse Engineer de Workbench fait la même chose et dessine le résultat.

2. Classe les tables.

3. Traduis chaque clé étrangère restante en association. Une clé étrangère x dans la table A vers la table B donne une association entre A et B, avec le maximum 1 du côté de A. Le minimum de ce côté se lit dans la structure : NOT NULL donne 1,1, une colonne qui accepte NULL donne 0,1. Si la clé étrangère est aussi UNIQUE, l'association est un à un.

4. Pose les cardinalités du côté n. La structure ne dit rien du minimum côté B : un service peut-il exister sans employé ? Seules les règles de gestion le disent. Interroge les utilisateurs, regarde les données (un service sans employé existe-t-il ?) et écris ton hypothèse. Par défaut, 0,n est le choix prudent.

5. Nomme les associations par un verbe, en t'aidant du nom de la clé étrangère (id_demandeur : DEMANDER ; id_technicien : REALISER), et vérifie que le MCD obtenu se relit en français.

Exemple : le MCD de la base parc

La base parc du cours SQL (schéma et script) compte sept tables. Appliquons la méthode.

Les entités. service, employe, poste, logiciel, ticket et intervention ont une clé primaire simple, qui n'est pas une clé étrangère : ce sont six entités. La table installation, de clé primaire (id_poste, id_logiciel), est une association plusieurs à plusieurs qui porte date_installation.

Les associations, une par clé étrangère restante :

Et la table d'association : POSTE 0,n ── INSTALLER (date_installation) ── 0,n LOGICIEL.

Les minimums côté n sont des hypothèses, à confirmer avec les utilisateurs : un service qui vient d'être créé n'a encore aucun employé, un poste peut n'avoir jamais fait l'objet d'un ticket, un logiciel peut être au catalogue sans être installé. L'entité EMPLOYE est la plus reliée : quatre associations la relient à d'autres entités, avec quatre rôles différents (membre d'un service, utilisateur d'un poste, demandeur, technicien), plus la réflexive. C'est typique d'une entité « personne » dans un système de gestion.

Exercices

CREATE TABLE categorie (
  code_cat VARCHAR(5)  PRIMARY KEY,
  libelle  VARCHAR(30) NOT NULL
);
CREATE TABLE equipe (
  num_equipe INT         PRIMARY KEY,
  nom_equipe VARCHAR(50) NOT NULL,
  code_cat   VARCHAR(5)  NOT NULL,
  FOREIGN KEY (code_cat) REFERENCES categorie (code_cat)
);
CREATE TABLE joueur (
  num_licence CHAR(8)     PRIMARY KEY,
  nom         VARCHAR(50) NOT NULL,
  num_equipe  INT,
  num_parrain CHAR(8),
  FOREIGN KEY (num_equipe) REFERENCES equipe (num_equipe),
  FOREIGN KEY (num_parrain) REFERENCES joueur (num_licence)
);
CREATE TABLE entraineur (
  num_entraineur INT         PRIMARY KEY,
  nom            VARCHAR(50) NOT NULL
);
CREATE TABLE encadrer (
  num_entraineur INT     NOT NULL,
  num_equipe     INT     NOT NULL,
  saison         CHAR(9) NOT NULL,
  PRIMARY KEY (num_entraineur, num_equipe),
  FOREIGN KEY (num_entraineur) REFERENCES entraineur (num_entraineur),
  FOREIGN KEY (num_equipe) REFERENCES equipe (num_equipe)
);

CLIENT: num_client, nom_client, ville_client
PASSER, 0N CLIENT, 11 COMMANDE
COMMANDE: num_cde, date_cde
CONTENIR, 1N COMMANDE, 0N PRODUIT: quantite
PRODUIT: ref_produit, libelle, prix_unitaire