Discussion :

[mrfof]

Salut à tous

Je vous reviens avec un problème sur lequel je sollicite vos avis

J’ai à faire avec une application de gestion scolaire.

D’abord je vous donne un aperçu de la situation :

1R = Chaque matière est liée à une classe ou plusieurs classes
2R = Chaque classe possède une ou plusieurs matières

-- (Une relation plusieurs plusieurs) —

1R = Chaque matière d’une classe est enseigné par un enseignant
2R = Chaque enseignant enseigne une ou plusieurs matière dans une ou plusieurs classes



C’est la première idée que j’ai eu.

Problème :

Avec cette relation de type n,n pour ajouter une matière je dois choisir obligatoirement : classe, et enseignant.
Dans la pratique, il peut arriver d’ajouter une matière qui ne possède ni classe, ni enseignant dans un premier temps, ou possède classe seulement ou enseignant
C’est ce dernier cas qui n’est pas possible à cause des FOREIGN KEYS

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
CREATE TABLE Classe(
   classe_id INT,
   nom VARCHAR(15) NOT NULL UNIQUE,
   PRIMARY KEY(classe_id)
);

CREATE TABLE Matiere(
   matiere_id INT,
   nom VARCHAR(20) NOT NULL UNIQUE,
   PRIMARY KEY(matiere_id)
);

CREATE TABLE Enseignant(
   enseignant_id INT,
   nom VARCHAR(50) NOT NULL UNIQUE,
   PRIMARY KEY(enseignant_id)
);

CREATE TABLE Enseigner(
   classe_id INT,
   matiere_id INT,
   enseignant_id INT,
   coeff BYTE NOT NULL,
   priorite BYTE NOT NULL,
   PRIMARY KEY(classe_id, matiere_id, enseignant_id),
   FOREIGN KEY(classe_id) REFERENCES Classe(classe_id),
   FOREIGN KEY(matiere_id) REFERENCES Matiere(matiere_id),
   FOREIGN KEY(enseignant_id) REFERENCES Enseignant(enseignant_id)
);

Je cherche des idées pour rendre possible : ajout d’une matière sans dans l’immédiat choisir obligatoirement la classe et enseignant.
Il se pourrait aussi que la matière à des classes mais sans enseignant
Il se pourrait aussi que la matière à des enseignants mais sans classe

C'est a dire la possibilité d'ajouter une matière sans classe et enseignant si je ne les ai pas.

Merci

[mrfof]

Salut

J'ai finalement accepté les NULL pour certains enregistrement de l'association 'Enseigner' qui se transforme en table

J'aime pas voir ça dans mes table. Pour l'instant c'est le cas

[escartefigue]

Bonjour,

N'ay -t-il pas d'autres acteurs pour ce sujet : les élèves, les cours, les notes, les salles de classe...
N'y a -t- il pas aussi d'autres règles de gestion à mettre en place ?

Par exemple, est-ce que tout enseignant peut enseigner n'importe quelle matière comme l'autorise votre MCD ou bien doit il être diplômé dans la matière enseignée ?
Faut il aussi prendre en compte des niveaux d'enseignement (un prof qui enseigne les maths en terminale a -t- il la même qualification que celui qui enseigne les maths en 6^e ?
Un même cours (vous avez oublié cette notion dans votre MCD) peut il concerner plusieurs matières (cours pluri-disciplinaire)

[fsmrel]

Bonsoir,


mrfof,

Je viens seulement de découvrir votre message, car il ne figure pas dans le forum SCHEMA...
Je réponds quand même, en demandant aux modérateurs que ce message soit transféré dans ce forum.


Capitaine,

Ce qui suit ne concerne que le MCD initial.

mrfof, vous écrivez :

J'ai finalement accepté les NULL pour certains enregistrements de l'association 'Enseigner' qui se transforme en table.
J'aime pas voir ça dans mes table. Pour l'instant c'est le cas.

Null est à chasser d’ici ! Dans un premier temps, vous pouvez produire le MCD suivant :

S’il existe la règle de gestion (RG1) suivante :

(1) Si l'enseignant E enseigne la matière M,
(2) si la matière M est enseignée à la classe C,
(3) si l'enseignant E enseigne dans la classe C,
(4) alors l'enseignants E enseigne la matière M dans la classe C.

Alors on reste là puisque (4) est la conclusion des prémisses (1), (2), (3).


Au stade SQL :

CREATE TABLE MATIERE
(
        matiereId            INTEGER            NOT NULL
      , matiereNom           VARCHAR(16)        NOT NULL
    , CONSTRAINT MATIERE_PK PRIMARY KEY (matiereId)
);

CREATE TABLE CLASSE
(
        classeId             INTEGER            NOT NULL
      , classeNom            VARCHAR(16)        NOT NULL 
    , CONSTRAINT CLASSE_PK PRIMARY KEY (classeId)
);

CREATE TABLE ENSEIGNANT
(
        enseignantId         INTEGER            NOT NULL
      , enseignantNom        VARCHAR(16)        NOT NULL
    , CONSTRAINT ENSEIGNANT_PK PRIMARY KEY (enseignantId)
);

CREATE TABLE CM
(
        matiereId            INTEGER            NOT NULL
      , classeId             INTEGER            NOT NULL
    , CONSTRAINT CM_PK PRIMARY KEY (matiereId, classeId)
    , CONSTRAINT CM_MATIERE_FK FOREIGN KEY(matiereId)
          REFERENCES MATIERE (matiereId)
    , CONSTRAINT CM_CLASSE_FK FOREIGN KEY (classeId)
          REFERENCES CLASSE (classeId)
);

CREATE TABLE EM
(
        matiereId            INTEGER            NOT NULL
      , enseignantId         INTEGER            NOT NULL
    , CONSTRAINT EM_PK PRIMARY KEY (matiereId, enseignantId)
    , CONSTRAINT EM_MATIERE_FK FOREIGN KEY (matiereId) 
          REFERENCES MATIERE (matiereId)
    , CONSTRAINT EM_ENSEIGNANT_FK FOREIGN KEY (enseignantId)
          REFERENCES ENSEIGNANT(enseignantId)
);

CREATE TABLE EC
(
        classeId             INTEGER            NOT NULL
      , enseignantId         INTEGER            NOT NULL
    , CONSTRAINT EC_PK PRIMARY KEY (classeId, enseignantId)
    , CONSTRAINT EC_CLASSE_FK FOREIGN KEY (classeId) 
          REFERENCES CLASSE (classeId)
    , CONSTRAINT EC_ENSEIGNANT_FK FOREIGN KEY (enseignantId) 
          REFERENCES ENSEIGNANT (enseignantId)
);

Maintenant, une observation :

En toute logique, un enseignant E ne peut enseigner à une classe C que si la matière M qu’il y enseigne fait partie des matières associées à cette classe.

Pour s’assurer de cela, on peut prévoir le trigger suivant (SQL server en l’occurrence), contrôlant les inserts dans la table EC (prévoir bien sûr le cas des updates) :

CREATE TRIGGER EC_INSERT_TR ON EC AFTER INSERT AS
BEGIN 
DECLARE @erreur as INT ; 
DECLARE @Engueulade AS VARCHAR(512) ;

SET @erreur = 
   (
    SELECT COUNT(*) FROM
       (
        SELECT x.classeId, y.matiereId
        FROM   INSERTED as x  
          JOIN EM as y on x.enseignantId = y.enseignantId
        EXCEPT
        SELECT classeId, matiereId
        FROM   CM
       ) as truc 
   )
;
IF @erreur > 0 
    BEGIN
        SET @Engueulade = 'Pour qu''un enseignant enseigne une matière à une classe, '
                        + 'il faut d''abord que cette matière concerne cette classe.' 
        SELECT @Engueulade as ' ', * from INSERTED ;
        RAISERROR (@Engueulade, 16,1)
        ROLLBACK
    END
END 

GO

Supposons maintenant que la règle (RG1) n’a pas lieu d’être, c’est-à-dire qu’on peut affecter un enseignant E à une classe C sans tenir compte de l’adéquation des matières qu’il sait enseigner et de celles qui concernent la classe C.

Dans ces conditions, il faut appeler un chat un chat et mettre en oeuvre une association ternaire, appelons-la CME, non pas entre les entités-types CLASSE, MATIERE, ENSEIGNANT, mais entre les associations CM, EM et EC. Etant donné qu’en Merise on n’a pas le droit d’établir d’association entre ces associations, on les déguise en entités-types, avec identification relative (Looping sait parfaitement le faire à notre place) :

Le code SQL précédent est toujours en vigueur, augmenté du CREATE TABLE concernant l’association CME. Les AGL (Looping ici) génèrent ceci :

CREATE TABLE CME
(
        classeId             INTEGER            NOT NULL
        matiereId            INTEGER            NOT NULL
      , enseignantId         INTEGER            NOT NULL
      , classeId_1           INTEGER            NOT NULL
      , matiereId_1          INTEGER            NOT NULL
      , enseignantId_1       INTEGER            NOT NULL
   PRIMARY KEY(classeId, matiereId, enseignantId, matiereId_1, classeId_1, enseignantId_1),
   FOREIGN KEY(classeId, matiereId) REFERENCES CM(classeId, matiereId),
   FOREIGN KEY(enseignantId, matiereId_1) REFERENCES EM(enseignantId, matiereId),
   FOREIGN KEY(classeId_1, enseignantId_1) REFERENCES EC(classeId, enseignantId)
);

Code qui doit être débarrassé des attributs redondants classeId_1, matiereId_1, enseignantId_1 :

CREATE TABLE CME
(
        classeId             INTEGER            NOT NULL
      , matiereId            INTEGER            NOT NULL
      , enseignantId         INTEGER            NOT NULL
    , CONSTRAINT CME_PK PRIMARY KEY(classeId, matiereId, enseignantId)
    , CONSTRAINT CME_CM_FK FOREIGN KEY (matiereId, classeId) 
          REFERENCES CM (matiereId, classeId)
    , CONSTRAINT CME_EM_FK FOREIGN KEY (matiereId, enseignantId) 
          REFERENCES EM (matiereId, enseignantId)
    , CONSTRAINT CME_EC_FK FOREIGN KEY (classeId, enseignantId) 
          REFERENCES EC (classeId, enseignantId)
);