Discussion :

[fsmrel]

Bonjour,

Et enfin, j'essaye d'acquérir une frénésie pour un joueur qui n'a pas rencontré le monstre concerné, là, ça couine

 
On n’en attend pas moins.

Mais pour la nième fois j’en reviens à la contrainte initiale :
 

« Un utilisateur peut acquérir une frénésie, à condition qu'elle soit celle d'un monstre présent dans une formation déjà rencontrée. »

Maintenant, explique nous comment savoir quelle est cette formation déjà rencontrée par l’utilisateur. Le code SQL correspondant sera le bienvenu.

Accessoirement, dans le MCD initial proposé par deedolith, les cardinalités de l’association "possede" sont 0,1/1,1, ce qu’il confirme ainsi :

« Chaque monstre à, outre ses caractéristiques, une compétence particulière appelée Frénésie ».

Pourquoi changes-tu en 0,n/1,1 ?

[escartefigue]

Mais pour la nième fois j’en reviens à la contrainte initiale :
 

« Un utilisateur peut acquérir une frénésie, à condition qu'elle soit celle d'un monstre présent dans une formation déjà rencontrée. »

Maintenant, explique nous comment savoir quelle est cette formation déjà rencontrée par l’utilisateur. Le code SQL correspondant sera le bienvenu.

De ce que j'ai compris, peut-être à tort, c'est que c'est lors de la rencontre que le joueur apprend une frénésie grâce à l'un des monstres de la rencontre.
Ce faisant, on se fiche royalement de savoir de quelle rencontre il s'agit, il suffit de savoir que le joueur a rencontré le monstre possesseur de cette frénésie, c'est ce que fait ma contrainte.

Accessoirement, dans le MCD initial proposé par deedolith, les cardinalités de l’association "possede" sont 0,1/1,1, ce qu’il confirme ainsi :

« Chaque monstre à, outre ses caractéristiques, une compétence particulière appelée Frénésie ».

Pourquoi changes-tu en 0,n/1,1 ?

Ah oui, bien vu, c'est une coquille de ma part, mais qui ne change rien sur l'acquisition des frénésies

[fsmrel]

Ce faisant, on se fiche royalement de savoir de quelle rencontre il s'agit, il suffit de savoir que le joueur a rencontré le monstre possesseur de cette frénésie, c'est ce que fait ma contrainte.

Ce qui veut dire qu’il faut se ficher royalement de la formation rencontrée par le joueur, et la fameuse contrainte initiale doit être évacuée des règles de gestion…

Maintenant, si je soumets la requête suivante :

Code SQL :

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

1
2
3
4
5
6
7
8
select distinct f.FormationNom, m.MonstreNom, u.UtilisateurNom
from Formation as f join Agreger as g on f.FormationId = g.FormationId 
                    join Monstre as m on g.MonstreId = m.MonstreId
                    join Rencontrer as r on r.MonstreId = g.MonstreId 
                    join Utilisateur as u on u.UtilisateurId = r.MonstreId
                    join Acquerir as q on u.UtilisateurId = q.UtilisateurId
                    join Frenesie as s on s.MonstreId = m.MonstreId
where u.UtilisateurNom = 'dupont' ;

Manifestement le joueur 'dupont' a rencontré deux fois le monstre 'raie des sables' dans deux rencontres distinctes :

Code :

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

1
2
3
FormationNom	MonstreNom	UtilisateurNom
F01  		raie des sables	dupont
F02 	 	raie des sables	dupont

Je ne sais pas ce qu’en pense deedolith, encore une fois à lui de trancher.

[deedolith]

@escartefigue:
Je ne voit pas pourquoi tu insistes sur le fait que l'utilisateur rencontre directement des monstres, j'ai bien apporté la précision dès mon premier poste que ce n'est pas le cas ...

[escartefigue]

J'ai très bien compris que l'utilisateur rencontrait une formation et que cette formation était composée de monstres, mais j'ai le sentiment que ça ne change rien à l'affaire.

La frénésie FR1 est portée par le monstre MO1

Que ce monstre MO1 ait été rencontré dans une formation FO1 ou FO2 change en quoi le fait que le joueur peut acquérir cette frénésie ?
Si ça ne change rien, alors mon modèle est valide et il est bien plus simple.

La formation aurait une importance si sa composition avait une influence sur l'acquisition des frénésie, or, visiblement ce n'est pas le cas

Par exemple la formation FO1 est composée d'un monstre MO1 et de deux monstres MO2
La formation FO2 est composée de deux monstres MO1 et d'un monstre MO3

De ma compréhension

• le joueur qui a rencontré FO1 peut très bien acquérir la frénésie de MO1 ou de MO2
• le joueur qui a rencontré FO2 peut très bien acquérir la frénésie de MO1 ou de MO3

Ce faisant, la formation on s'en fiche pour ce qui concerne les acquisitions de frénésies.

Ce qui veut dire qu’il faut se ficher royalement de la formation rencontrée par le joueur, et la fameuse contrainte initiale doit être évacuée des règles de gestion…

Non, ça signifie que cette contrainte est maintenue, mais qu'il faut comprendre que c'est la rencontre avec le monstre qui compte et ce quelle que soit la formation dans laquelle il se trouve.
En tout cas si mes propos qui précèdent sont confirmés.

[deedolith]

De ma compréhension

• le joueur qui a rencontré FO1 peut très bien acquérir la frénésie de MO1 ou de MO2
• le joueur qui a rencontré FO2 peut très bien acquérir la frénésie de MO1 ou de MO3

Jusque la, on est d'accord, mais l'inverse n'est pas vrai.

Certes, la formation n'influe pas directement sur l'acquisition de frénésies,
Par contre, elle influe sur ce qui a été rencontré.

Avec ton modèle, après n'avoir rencontré que FO2, et par conséquent les monstres qui la composent (MO1 et MO3):
Je veux la liste des formations que j'ai rencontré, j'obtiendrai FO1 et FO2. Ce qui est faux, je n'ai jamais rencontré FO1.

[escartefigue]

Alors là je suis d'accord, si on veut savoir quelle(s) formation(s) le joueur a rencontré, mon modèle ne convient pas.
Je n'avais tout simplement pas identifié ce besoin, il me semble qu'il n'était pas clairement exprimé, ou alors j'ai lu trop vite

[fsmrel]

Bonjour,

Supposons que les utilisateurs puissent désormais donner un avis sur les formations, faire un compte-rendu de leurs rencontres. A cet effet, enrichissons l’association Rencontrer d’un attribut "CompteRendu".
Le MCD proposé initialement par deedolith va devenir celui-ci :


 

 
Au fil des jours et des besoins, enrichir un MCD est chose assez courante...

deedolith, qu’en pensez-vous ?
Capitaine, comment envisages-tu l’évolution de ta version du MCD ?

[escartefigue]

Puisqu'il faut savoir quel joueur a rencontré quelle formation, je pense qu'il faut abandonner mon asso joueur <-> monstre, cette simplification qui facilitait grandement la vie pour les acquisitions n'est pas valide pour ce besoin.

[deedolith]

@fsmrel:
Merci pour la suggestion, mais je n'ai pas ce besoin actuellement.

Merci à tous,
je peux maintenant passer ce sujet en résolu.

[f-leb]

Hop tout le monde,

Je tente l'incruste, car j'ai suivi un peu cette discussion et je m'interroge...

Je suis parti du MCD du message #12 qui sauf erreur donne ce schéma relationnel sous Access :



Et je m'interroge sur cette table supplémentaire UFM pour gérer la contrainte d'inclusion.

Code sql :

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

1
2
3
4
5
6
7
8
insert into Acquérir values
  (1,1)
, (1,3)
, (2,1)
, (2,4)
, (3,2)
, (1,5) – UFM ne sera pas d’accord
;

Code sql :

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

1
2
3
insert into UFM values
  (1,3,5) -- délinquant : l’utilisateur 1 n’a pas rencontré la formation 3
;

Si je veux signifier que l'utilisateur 1 a fait l'acquisition de la frénésie 5, il faut rechercher dans quelles formations on retrouve le monstre, l'insérer dans UFM qui va tousser parce que l'utilisateur n'a pas rencontré cette formation, et donc on ne peut pas l'insérer dans Acquérir...

Je pense que je n'ai pas compris le traitement à effectuer pour assurer cette contrainte d'inclusion, ça me semble bien compliqué...

[fsmrel]

Ave Achille !

Reprenons la règle énoncée par deedolith :

"Un utilisateur ne peut acquérir une frénésie que si celle-ci appartient à un monstre d’une formation rencontrée par l’utilisateur."

Je fais abstraction de ce que j’ai déjà pondu le nez dans le guidon, et remets les compteurs à zéro.

Au fond, vu la règle, il suffit d’établir une association entre Rencontrer et Frenesie :

 

 

Exit l’association UFM...

En tout cas, un utilisateur ne pourra toujours pas acquérir de frénésie qui ne fasse pas référence (via Monstre et Agreger) à une des formations qu’il a rencontrées, le SGBD restera intraitable.

Tables SQL

Code SQL :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
create table Formation
(
   FormationId INT
,  FormationNom varchar(24) NOT NULL
,  CONSTRAINT Formation_PK PRIMARY KEY(FormationId)
,  CONSTRAINT Formation_UK UNIQUE(FormationNom)
);
create table Monstre
(
    MonstreId INT
,   MonstreNom VARCHAR(24) NOT NULL
,   CONSTRAINT Monstre_PK PRIMARY KEY(MonstreId)
,   CONSTRAINT Monstre_UK UNIQUE(MonstreNom)
);
 
create table Agreger
(
    FormationId INT
,   MonstreId INT
,   CONSTRAINT Agreger_PK PRIMARY KEY(FormationId, MonstreId)
,   CONSTRAINT Agreger_Formation_FK FOREIGN KEY(FormationId) REFERENCES Formation(FormationId)
,   CONSTRAINT Agreger_Monstre_FK FOREIGN KEY(MonstreId) REFERENCES Monstre(MonstreId)
);
create table Frenesie
(
    MonstreId INT
,   FrenesieNom VARCHAR(24) NOT NULL
,   CONSTRAINT Frenesie_PK PRIMARY KEY(MonstreId)
,   CONSTRAINT Frenesie_Monstre_FK FOREIGN KEY(MonstreId) REFERENCES Monstre(MonstreId)
);
 
create table Utilisateur
(
   UtilisateurId INT
,  UtilisateurNom VARCHAR(24) NOT NULL
,  CONSTRAINT Utilisateur_PK PRIMARY KEY(UtilisateurId)
);
create table Rencontrer
(
    UtilisateurId INT
,   FormationId INT
,   CONSTRAINT Rencontrer_PK PRIMARY KEY(UtilisateurId, FormationId)
,   CONSTRAINT Rencontrer_Formation_FK FOREIGN KEY(FormationId) REFERENCES Formation(FormationId)
 ,  CONSTRAINT Rencontrer_Utilisateur_FK FOREIGN KEY(UtilisateurId) REFERENCES Utilisateur(UtilisateurId)
);
 
create table Acquerir
(
   UtilisateurId INT
,  FormationId INT
,  MonstreId INT
,  CONSTRAINT Acquerir_PK PRIMARY KEY(UtilisateurId, FormationId, MonstreId)
,  CONSTRAINT Acquerir_Rencontrer_FK FOREIGN KEY(UtilisateurId, FormationId) REFERENCES Rencontrer(UtilisateurId, FormationId)
,  CONSTRAINT Acquerir_Frenesie_FK FOREIGN KEY(MonstreId) REFERENCES Frenesie(MonstreId) 
);

 
Jeu d’essai

Code SQL :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
insert into Formation values
  (1,'f1')
, (2,'f2')
, (3,'f3')
, (5,'f5')
;
select '' as Formation, * from Formation ;
 
insert into Monstre values
  (1,'m1')
, (2,'m2')
, (3,'m3')
, (4,'m4')
, (5,'m5')
;
select '' as Monstre,* from Monstre ;
 
insert into Agreger values
  (1,1)  -- f1,m1
, (1,2)  -- f1,m2
, (1,3)  -- f1,m3
, (1,5)  -- f1,m5 chouffe !
, (2,1)  -- f2,m1
, (2,3)  -- f2,m3
, (2,4)  -- f2,m4
, (2,5)  -- f2,m5
, (3,2)  -- f3,m2
, (3,5)  -- f3,m5
;
select '' as Agreger,* from Agreger ;
 
insert into Frenesie values
  (1,'f1')  
, (2,'f2')
, (3,'f3')
, (4,'f4')
, (5,'f5')
;
select '' as Frenesie, * from Frenesie ;
 
insert into Utilisateur values
  (1,'u1')
, (2,'u2')
, (3,'u3')
;
select '' as Utilisateur, * from Utilisateur ;
 
insert into Rencontrer values
  (1,1) -- u1,f1 
, (1,2) -- u1,f2
, (2,1) -- u2,f1
, (2,2) -- u2,f2
, (2,3) -- u2,f3
, (2,5) -- u2,f5
;
select '' as Rencontrer, * from Rencontrer ;
 
insert into Acquerir values
  (1,1,1)  -- u1,f1,m1
, (1,1,3)  -- u1,f1,m3
, (1,2,4)  -- u1,f2,m4 
;
select '' as Acquerir, * from Acquerir ;
 
insert into Acquerir values
  (1,3,5) -- u1,f3,m5 délinquant : l’utilisateur 1 n’a pas rencontré la formation 3
;
select '' as Acquerir, * from Acquerir ;

Les frénésies acquises par l’utilisateur u1 à l’occasion de ses rencontres avec les formations :

Code SQL :

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

1
2
3
4
5
6
select distinct u.UtilisateurNom, f.FormationNom, s.FrenesieNom
from Utilisateur as u join Rencontrer as r on u.UtilisateurId = r.UtilisateurId
                      join Acquerir as q on q.UtilisateurId =r.UtilisateurId and q.FormationId = r.FormationId 
                      join Frenesie as s on s.MonstreId =q.MonstreId
                      join Formation as f on f.FormationId = r.FormationId
where u.UtilisateurNom = 'u1' ;

Au résultat :

Code :

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

1
2
3
4
5
 
UtilisateurNom	FormationNom	FrenesieNom
u1		f1		f1
u1		f1		f3
u1		f2		f4

 
Ton avis, Achille ?

[f-leb]

Hello !

"Un utilisateur ne peut acquérir une frénésie que si celle-ci appartient à un monstre d’une formation rencontrée par l’utilisateur."

Cette règle-là est bien respectée.

Mais le voisin Hilarion me fait remarquer que la saisie qui suit est maintenant possible :

Code :

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

1
2
3
UtilisateurNom	FormationNom	FrenesieNom
u1		f1		frenesie1
u1		f2		frenesie1

Vision Lefuneste... Un utilisateur donné peut acquérir deux fois la même frénésie, parce qu'il a rencontré le monstre dans deux formations différentes, ce qui n'était pas prévu initialement.
Une contrainte d'unicité sur (UtilisateurId, MonstreId) s'impose, non ?

[fsmrel]

Ouch !

J’espère qu’Hilarion n’en a pas trop des comme ça dans sa besace...

En l’occurrence la clé primaire de la table Acquérir est effectivement à réduire à la paire {UtilisateurId, MonstreId} :

Code SQL :

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

1
2
3
4
5
6
7
8
9
create table Acquerir
(
   UtilisateurId INT
,  FormationId INT
,  MonstreId INT
,  CONSTRAINT Acquerir_PK PRIMARY KEY(UtilisateurId, MonstreId)
,  CONSTRAINT Acquerir_Rencontrer_FK FOREIGN KEY(UtilisateurId, FormationId) REFERENCES Rencontrer(UtilisateurId, FormationId)
,  CONSTRAINT Acquerir_Frenesie_FK FOREIGN KEY(MonstreId) REFERENCES Frenesie(MonstreId) 
);

Quant au MCD produit avec l’excellent Looping, il est à revoir, comment je ne sais pas trop 
Le Capitaine aura peut-être une idée...

[fsmrel]

Bonsoir,
 
Pour le moment j’en suis à modifier le MCD ainsi, ça n’est pas terrible, mais si quelqu’un, tel Christophe Colomb, sait améliorer, qu’il expose sa solution (cela vaut même pour Hilarion) :

• Transformation de l’association Acquerir en ternaire, à savoir entre Utilisateur, Frenesie et Formation ;
   
• Ajout d’une CIF impliquant ces trois entités-types, ayant pour cible Formation, tandis que la paire Utilisateur, Frenesie en est le pivot (merci Bernard). Looping prend en compte la CIF et réduit (au stade SQL) la clé primaire de la table Acquerir à la paire {UtilisateurId, MonstreId} ; 
   
• Ajout d’une règle (R1) pour produire les clés étrangères pertinentes :
   
  DROP FOREIGN KEY Acquerir_Utilisateur_FK ;
  DROP FOREIGN KEY Acquerir_Formation_FK;
  ADD CONSTRAINT FOREIGN KEY Acquerir_Rencontrer_FK (UtilisateurId, FormationId) REFERENCES Rencontrer(UtilisateurId, FormationId).

Code SQL produit par Looping :

Code SQL :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
CREATE TABLE Utilisateur
(
    UtilisateurId INT NOT NULL
,   UtilisateurNom VARCHAR(24) NOT NULL
,   CONSTRAINT Utilisateur_PK PRIMARY KEY(UtilisateurId)
);
 
CREATE TABLE Formation
(
    FormationId INT NOT NULL
,   FormationNom VARCHAR(24) NOT NULL
,   CONSTRAINT Formation_PK PRIMARY KEY(FormationId)
,   CONSTRAINT Formation_AK UNIQUE(FormationNom)
);
 
CREATE TABLE Rencontrer
(
    UtilisateurId INT
,   FormationId INT
,   CONSTRAINT Rencontrer_PK PRIMARY KEY(UtilisateurId, FormationId)
,   CONSTRAINT Rencontrer_Utilisateur_FK FOREIGN KEY(UtilisateurId) REFERENCES Utilisateur(UtilisateurId)
,   CONSTRAINT Rencontrer_Formation_FK FOREIGN KEY(FormationId) REFERENCES Formation(FormationId)
);
 
CREATE TABLE Monstre
(
    MonstreId INT
,   MonstreNom VARCHAR(24) NOT NULL
,   CONSTRAINT Monstre_PK PRIMARY KEY(MonstreId)
,   CONSTRAINT Monstre_AK UNIQUE(MonstreNom)
);
 
CREATE TABLE Agreger
(
    FormationId INT
,   MonstreId INT
,   CONSTRAINT Agreger_PK PRIMARY KEY(FormationId, MonstreId)
,   CONSTRAINT Agreger_Formation_FK FOREIGN KEY(FormationId) REFERENCES Formation(FormationId)
,   CONSTRAINT Agreger_Monstre_FK FOREIGN KEY(MonstreId) REFERENCES Monstre(MonstreId)
);
 
CREATE TABLE Frenesie
(
    MonstreId INT
,   FrenesieNom VARCHAR(24) NOT NULL
,   CONSTRAINT Frenesie_PK PRIMARY KEY(MonstreId)
,   CONSTRAINT Frenesie_Monstre_FK FOREIGN KEY(MonstreId) REFERENCES Monstre(MonstreId)
);
 
CREATE TABLE Acquerir
(
    UtilisateurId INT
,   MonstreId INT
,   FormationId INT NOT NULL
,   CONSTRAINT Acquerir_PK PRIMARY KEY(UtilisateurId, MonstreId)
,   CONSTRAINT Acquerir_Utilisateur_FK FOREIGN KEY(UtilisateurId) REFERENCES Utilisateur(UtilisateurId)
,   CONSTRAINT Acquerir_Frenesie_FK FOREIGN KEY(MonstreId) REFERENCES Frenesie(MonstreId)
,   CONSTRAINT Acquerir_Formation_FK FOREIGN KEY(FormationId) REFERENCES Formation(FormationId)
);
 
ALTER TABLE Acquerir DROP CONSTRAINT Acquerir_Utilisateur_FK ;
ALTER TABLE Acquerir DROP CONSTRAINT Acquerir_Formation_FK;
ALTER TABLE Acquerir ADD CONSTRAINT Acquerir_Rencontrer_FK  
            FOREIGN KEY (UtilisateurId, FormationId) 
                REFERENCES Rencontrer(UtilisateurId, FormationId) ;

Jeu d’essai :

Code sql :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
insert into Formation values
  (1,'f1')
, (2,'f2')
, (3,'f3')
, (5,'f5')
;
select '' as Formation, * from Formation ;
 
insert into Monstre values
  (1,'m1')
, (2,'m2')
, (3,'m3')
, (4,'m4')
, (5,'m5')
;
select '' as Monstre,* from Monstre ;
 
insert into Agreger values
  (1,1)  -- f1,m1
, (1,2)  -- f1,m2
, (1,3)  -- f1,m3
, (1,5)  -- f1,m5 chouffe !
, (2,1)  -- f2,m1
, (2,3)  -- f2,m3
, (2,4)  -- f2,m4
, (2,5)  -- f2,m5
, (3,2)  -- f3,m2
, (3,5)  -- f3,m5
;
select '' as Agreger,* from Agreger ;
 
insert into Frenesie values
  (1,'f1')  
, (2,'f2')
, (3,'f3')
, (4,'f4')
, (5,'f5')
;
select '' as Frenesie, * from Frenesie ;
 
insert into Utilisateur values
  (1,'u1')
, (2,'u2')
, (3,'u3')
;
select '' as Utilisateur, * from Utilisateur ;
 
insert into Rencontrer values
  (1,1) -- u1,f1 
, (1,2) -- u1,f2
, (2,1) -- u2,f1
, (2,2) -- u2,f2
, (2,3) -- u2,f3
, (2,5) -- u2,f5
;
select '' as Rencontrer, * from Rencontrer ;
 
insert into Acquerir values
  (1,1,1)  -- u1,m1,f1
, (1,3,1)  -- u1,m3,f1
, (1,4,2)  -- u1,m4,f2
--, (1,1,2)  -- u1,m1,f2 -- clé en double !
--, (1,4,1)  -- u1,m4,f1 -- clé en double !
,  (2,1,1)  -- u1,m1,f1
,  (2,3,3)  -- u1,m1,f1
;
select '' as Acquerir, * from Acquerir ;
 
select distinct u.UtilisateurNom, f.FormationNom, s.FrenesieNom
from Utilisateur as u join Rencontrer as r on u.UtilisateurId = r.UtilisateurId
                      join Acquerir as q on q.UtilisateurId =r.UtilisateurId and q.FormationId = r.FormationId 
                      join Frenesie as s on s.MonstreId =q.MonstreId
                      join Formation as f on f.FormationId = r.FormationId ;

Vos avis ?

[f-leb]

Bonsoir,

Je ne vois pas de lien avec 'Agréger' dans 'Acquérir', il est donc encore possible de saisir un délinquant, comme cet utilisateur u1 qui a rencontré la formation f1, acquérir un monstre m4 qui ne fait pas partie de la formation f1. Non ?

[fsmrel]

Bien vu, Achille !

Il est fort probable que demain je reviendrai sur UFM qui joue quelque part le rôle de ceinture, bretelles et épingle à nourrice...

Bonne nuit !

[f-leb]

Dans la même idée, il faudrait obtenir ceci je pense (je suis resté sous Access) :



mais j'approfondirai demain aussi, c'est une torture ce MCD

Bonne nuit.

[fsmrel]

Merci Achille,

Je suis resté sous Access

Ce qui n’est pas un problème pour le lecteur, au cardinalités minimales près, mais on ne va pas chipoter pour ça, c'est très bien

En gros, tu as fait en sorte que Acquerir absorbe UFM, va bene...

Traduction en Looping :

 

Côté SQL, Looping produit ceci :

Code SQL :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
CREATE TABLE Utilisateur
(
    UtilisateurId INT
,   UtilisateurNom VARCHAR(24) NOT NULL
,   CONSTRAINT Utilisateur_PK PRIMARY KEY(UtilisateurId)
);
 
CREATE TABLE Formation
(
    FormationId INT
,   FormationNom VARCHAR(24) NOT NULL
,   CONSTRAINT Formation_PK PRIMARY KEY(FormationId)
,   CONSTRAINT Formation_AK UNIQUE(FormationNom)
);
CREATE TABLE Rencontrer
(
    UtilisateurId INT
,   FormationId INT
,   CONSTRAINT Rencontrer_PK PRIMARY KEY(UtilisateurId, FormationId)
,   CONSTRAINT Rencontrer_Utilisateur_FK FOREIGN KEY(UtilisateurId) REFERENCES Utilisateur(UtilisateurId)
,   CONSTRAINT Rencontrer_Formation_FK FOREIGN KEY(FormationId) REFERENCES Formation(FormationId)
);
 
CREATE TABLE Monstre
(
    MonstreId INT
,   MonstreNom VARCHAR(24) NOT NULL
,   CONSTRAINT Monstre_PK PRIMARY KEY(MonstreId)
,   CONSTRAINT Monstre_AK UNIQUE(MonstreNom)
);
 
CREATE TABLE Agreger
(
    FormationId INT
,   MonstreId INT
,   CONSTRAINT Agreger_PK PRIMARY KEY(FormationId, MonstreId)
,   CONSTRAINT Agreger_Formation_FK FOREIGN KEY(FormationId) REFERENCES Formation(FormationId)
,   CONSTRAINT Agreger_Monstre_FK FOREIGN KEY(MonstreId) REFERENCES Monstre(MonstreId)
);
 
CREATE TABLE Frenesie
(
    MonstreId INT
,   FrenesieNom VARCHAR(24) NOT NULL
,   CONSTRAINT Frenesie_PK PRIMARY KEY(MonstreId)
,   CONSTRAINT Frenesie_Monstre_FK FOREIGN KEY(MonstreId) REFERENCES Monstre(MonstreId)
);
 
CREATE TABLE Acquerir
(
    UtilisateurId INT
,   MonstreId INT
,   FormationId INT
,   FormationId_1 INT
,   MonstreId_1 INT
,   CONSTRAINT Acquerir_PK PRIMARY KEY(UtilisateurId, MonstreId, FormationId, FormationId_1, MonstreId_1)
,   CONSTRAINT Acquerir_Rencontrer_FK FOREIGN KEY(UtilisateurId, FormationId) REFERENCES Rencontrer(UtilisateurId, FormationId)
,   CONSTRAINT Acquerir_Agreger_1_FK FOREIGN KEY(FormationId_1, MonstreId) REFERENCES Agreger(FormationId, MonstreId)
,   CONSTRAINT Acquerir_Frenesie_1_FK FOREIGN KEY(MonstreId_1) REFERENCES Frenesie(MonstreId)
);

Comme je lui ai précisé (règle Modif accrochée à Acquerir) comment bricoler la structure et les contraintes de la table Acquerir, il a donc appliqué la modif :
...

Code SQL :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
ALTER TABLE Acquerir DROP CONSTRAINT Acquerir_Frenesie_1_FK ;
ALTER TABLE Acquerir DROP CONSTRAINT Acquerir_Agreger_1_FK ;
ALTER TABLE Acquerir DROP CONSTRAINT Acquerir_PK ;
ALTER TABLE Acquerir DROP COLUMN MonstreId_1 ;
ALTER TABLE Acquerir DROP COLUMN FormationId_1 ;
 
ALTER TABLE Acquerir ADD CONSTRAINT Acquerir_PK PRIMARY KEY(UtilisateurId, MonstreId) ;
ALTER TABLE Acquerir ADD CONSTRAINT Acquerir_Agreger_FK  
            FOREIGN KEY (FormationId, MonstreId) 
                REFERENCES Agreger(FormationId, MonstreId) ;
ALTER TABLE Acquerir ADD CONSTRAINT Acquerir_Frenesie_FK  
            FOREIGN KEY (MonstreId) 
                REFERENCES Frenesie(MonstreId) ;

Jeu d’essai :

Code SQL :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
insert into Formation values
  (1,'f1')
, (2,'f2')
, (3,'f3')
, (5,'f5')
;
select '' as Formation, * from Formation ;
 
insert into Monstre values
  (1,'m1')
, (2,'m2')
, (3,'m3')
, (4,'m4')
, (5,'m5')
;
select '' as Monstre,* from Monstre ;
 
insert into Agreger values
  (1,1)  -- f1,m1
, (1,2)  -- f1,m2
, (1,3)  -- f1,m3
, (1,5)  -- f1,m5 chouffe !
, (2,1)  -- f2,m1
, (2,3)  -- f2,m3
, (2,4)  -- f2,m4
, (2,5)  -- f2,m5
, (3,2)  -- f3,m2
, (3,5)  -- f3,m5
;
select '' as Agreger,* from Agreger ;
 
insert into Frenesie values
  (1,'f1')  
, (2,'f2')
, (3,'f3')
, (4,'f4')
, (5,'f5')
;
select '' as Frenesie, * from Frenesie ;
 
insert into Utilisateur values
  (1,'u1')
, (2,'u2')
, (3,'u3')
;
select '' as Utilisateur, * from Utilisateur ;
 
insert into Rencontrer values
  (1,1) -- u1,f1 
, (1,2) -- u1,f2
, (2,1) -- u2,f1
, (2,2) -- u2,f2
, (2,3) -- u2,f3
, (2,5) -- u2,f5
;
select '' as Rencontrer, * from Rencontrer ;
 
insert into Acquerir values
  (1,1,1)  -- u1,m1,f1 -- ok
, (1,3,1)  -- u1,m3,f1 -- ok
--, (1,3,2)  -- u1,m3,f2 -- pk en double {u1,m3}, 
, (1,4,2)  -- u1,m4,f2 -- ok
--, (1,1,2)  -- u1,m1,f2 -- clé en double !
--, (1,4,1)  -- u1,m4,f1 -- clé en double !
,  (2,1,1)  -- u2,m1,f1 -- ok
--,  (2,3,3)  -- u2,m3,f3 -- m3 n'appartient pas à f3
;
select '' as Acquerir, * from Acquerir ;
 
select distinct u.UtilisateurNom, f.FormationNom, s.FrenesieNom
from Utilisateur as u join Rencontrer as r on u.UtilisateurId = r.UtilisateurId
                      join Acquerir as q on q.UtilisateurId =r.UtilisateurId 
                                        and q.FormationId = r.FormationId 
                      join Frenesie as s on s.MonstreId =q.MonstreId
                      join Formation as f on f.FormationId = r.FormationId

Merci de vérifier que je ne me suis pas planté...

[f-leb]

Le dernier ALTER TABLE :

Code sql :

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

1
2
3
ALTER TABLE Acquérir ADD CONSTRAINT Acquerir_Frenesie_FK  
            FOREIGN KEY (MonstreId) 
                REFERENCES Monstre(MonstreId) ;

Ne faudrait-il pas plutôt relier à 'Frenesie' ? Sachant qu'un utilisateur acquiert la frénésie d'un monstre, et qu'il peut y avoir des monstres sans frénésie.