Selman Bouzlafa
Thème

Base de données à partir d’un besoin réel

Modélisation d’un besoin réel en base de données, du MCD au schéma relationnel puis à SQLite.

Année
BUT1, 2025
Type
SAÉ
Domaine
Données
Période
janvier – juin 2025
Stack
SQLite, SQL, MCD

En bref

Problème
Modéliser une partie du système d’information d’une organisation réelle à partir de son besoin.
Ce que j’ai réalisé
Un modèle conceptuel, son passage au schéma relationnel, puis une base SQLite et ses requêtes.
Résultat
La base répond aux requêtes de tri, de filtre et d’agrégat prévues au cahier des charges.
Rôle
Modélisation et requêtes, en binôme.
Équipe
2 personnes
Statut
Terminé
Sommaire6 sections

Contexte

Une organisation réelle avait exprimé un besoin. En binôme, nous devions modéliser une partie de son système d’information.

Démarche et décisions

Nous avons recueilli le besoin par un échange avec l’organisation, puis construit un modèle conceptuel de données et un dictionnaire des données. Les règles de gestion modélisables ont été traduites en contraintes lors du passage au schéma relationnel. La base a été implémentée en SQLite, avec les requêtes attendues.

La figure 1 reprend cette chaîne étape par étape.

passage modélisable dans le modèle non modélisable Besoinrecueil MCD+ dictionnaire Schémarelationnel SQLitela base RequêtesSQL règles de gestion contraintes conventionshors du modèle Les règles non modélisables sont restéesdes conventions, hors du modèle.
1 / 5

  1. Besoin. Le point de départ : le besoin de l’organisation, recueilli lors d’un échange avec elle.
  2. MCD. Un modèle conceptuel de données et son dictionnaire des données.
  3. Passage au schéma relationnel. Les règles de gestion modélisables deviennent des contraintes qui entrent dans le modèle ; les autres restent des conventions, hors du modèle.
  4. SQLite. Le schéma relationnel devient une base SQLite.
  5. Requêtes. Les requêtes de tri, de filtre et d’agrégat prévues au départ.
Fig. 1 — La chaîne de modélisation, du besoin recueilli aux requêtes SQL. Parcours pas à pas au clavier (← →).

La figure 2 détaille le passage au relationnel sur un modèle générique de trois entités.

MCD : trois entités, deux associations

cardinalité côté R : 0,n
cardinalité côté S : 1,1
cardinalité côté S : 0,n
cardinalité côté T : 0,n

SQLite : le schéma relationnel en commentaire, puis les tables

PRAGMA foreign_keys = ON; -- SQLite : les clés étrangères s’activent par connexion
-- R ( a, b, c ) CREATE TABLE R ( a INTEGER PRIMARY KEY, b TEXT NOT NULL, c INTEGER NOT NULL, CHECK (c > 0) -- RG 1 : dans le modèle );
-- S ( d, e, f → R.a ) CREATE TABLE S ( d INTEGER PRIMARY KEY, e TEXT NOT NULL, f INTEGER NOT NULL REFERENCES R (a) -- A1 : 1,1 côté S );
-- T ( g, h ) CREATE TABLE T ( g INTEGER PRIMARY KEY, h TEXT );
-- ST ( d → S.d, g → T.g, k ) CREATE TABLE ST ( d INTEGER NOT NULL REFERENCES S (d), g INTEGER NOT NULL REFERENCES T (g), k TEXT, PRIMARY KEY (d, g) -- A2 : 0,n des deux côtés, clé composée );
RG 1 (modélisable)
« La valeur de c est toujours strictement positive. » → dans le modèle : la contrainte CHECK (c > 0) de la table R, vérifiée par la base à chaque écriture.
RG 2 (non modélisable)
« Le rattachement d’un S à un R est validé par une personne avant la saisie. » → hors du modèle : la base ne peut pas vérifier une validation humaine ; la règle reste une convention, notée dans le dictionnaire des données.
Règle de gestion d’exemple :

Sélectionnez une entité ou une association du MCD, ou une table SQL : son équivalent s’allume en face.

Fig. 2 — Du MCD au SQL, sur un modèle générique : chaque entité devient une table, l’association A1 une clé étrangère, l’association A2 (plusieurs à plusieurs) une table ST à clé composée.

Résultat

La base a été remplie de données réelles ou simulées. Le livrable a été remis avec sa documentation de modélisation.

Ce que j’ai appris

Du recueil du besoin aux requêtes SQL, j’ai parcouru chaque étape de la conception d’une base : MCD, schéma relationnel, contraintes. Le passage au relationnel m’a obligé à trier les règles de gestion entre contraintes vérifiées par la base et conventions laissées hors du modèle.

Limites et suite

Nous nous sommes arrêtés aux requêtes de base. Des vues et des requêtes d’analyse permettraient d’en tirer des indicateurs.

Compétences BUT mobilisées

Compétences du référentiel BUT Informatique démontrées dans ce projet : niveau, ce que le projet montre et preuve.
CompétenceNiveauCe que le projet montre, et preuve
GérerGérer des données de l’informationNiveau 1Concevoir et mettre en place une base de données.Preuve : Passage du MCD au schéma relationnel avec contraintes, implémenté en SQLite.

Projets liés