Looping , logiciel gratuit et libre d'utilisation de Modélisation Conceptuelle de Données version 4.1 disponible (avec Rétroconception)

Membre émérite

Le 20/03/2025 à 14:03

Envoyé par escartefigue

Avec le même nom ? D'un coté c'est l'identifiant d'annulation E1ident_annul et de l'autre l'identifiant de validation E1ident_valid.
Cette contrainte d'inclusion me semble tout à fait classique : seule la personne qui a validé peut annuler.
Par contre, là où il y a coquille, c'est au niveau cardinalité, il devrait y avoir 0,1 et non pas 0,n de E1 vers E3 : une annulation ne se fait au plus qu'une seule fois

Mais ça ne change pas la contrainte.

Pour la cardinalité 0,n il y avait bien coquille à cause de l'identifiant relatif

: c'est corrigé !
Concernant la contrainte d'inclusion, elle est effectivement classique mais, comme tu le sais, Looping ne traite pas ces contraintes au niveau du DDL : c'est la raison pour laquelle il faut décrire le code SQL qui va bien.
Et ce code est tellement variable en fonction des contraintes (inclusion, partition, exclusion mutuelle, totalité, ...) et du SGBD qui les met en œuvre, qu'il est illusoire de vouloir tout automatiser.
Certes, le cas que tu proposes est relativement simple, mais en général on doit faire appel à des procédures stockées et autres triggers qui doivent répondre aux caprices du langage associé au SGBD.

Bref, tout ça pour dire que, si Looping ne génère pas seul la contrainte au niveau du DDL, il ne peut bien évidemment pas déduire une contrainte en fonction d'un DDL dans le cadre d'une rétroconception

...
Donc, en résumé, tout ce qui est codé en SQL par le concepteur (contraintes, règles, ...) ne sera pas traité par Looping si cela ne peut pas être modélisé sans le code en question.

2

0

fsmrel

Expert éminent sénior

Le 20/03/2025 à 14:42

Ave,

Envoyé par Paprick

Par contre, Looping ne devrait pas trafiquer pour générer un truc bizarre, mais plutôt indiquer l'impossibilité de traiter l'instruction : c'est en ce sens que je vais faire évoluer la rétroconception pour un meilleur contrôle de ce type d'instruction.

On ne peut pas juger d’un DDL sur la base du nom des attributs ou des clés. Paprick, tu es un sage, mieux vaut prévenir que tenter de guérir, et un homme averti en vaut deux : à celui-ci de prendre ses responsabilités et décider en toute conscience de la modification du MCD obtenu par rétroconception (surrtout à partir d’un DDL SQL Ave,

2

0

fsmrel

Expert éminent sénior

Le 31/03/2025 à 18:57

Rétroconception, suite - cas des courses hippiques (cf. la discussion « Quel logiciel télécharger pour réaliser un MCD », le post #53).

Code SQL proposé ;

Code SQL :

Sélectionner tout

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
CREATE TABLE COURSE( 
   courseId INTEGER, 
   courseNom VARCHAR(48) NOT NULL, 
   courseDate DATE NOT NULL, 
   PRIMARY KEY(courseId) 
); 
  
CREATE TABLE CHEVAL( 
   chevalId INTEGER, 
   chevalNom VARCHAR(48) NOT NULL, 
   chevalDateNaissance DATE, 
   PRIMARY KEY(chevalId) 
); 
  
CREATE TABLE JOCKEY( 
   jockeyId INTEGER, 
   licence CHAR(50), 
   jockeyNom VARCHAR(48) NOT NULL, 
   jockeyPrenom VARCHAR(48) NOT NULL, 
   PRIMARY KEY(jockeyId), 
   UNIQUE(licence) 
); 
  
CREATE TABLE PARTICIPER( 
   courseId INTEGER, 
   chevalId INTEGER, 
   poids NUMERIC(4,2) NOT NULL, 
   numero SMALLINT NOT NULL, 
   jockeyId INTEGER NOT NULL, 
   PRIMARY KEY(courseId, chevalId), 
   UNIQUE(courseId, jockeyId), 
   UNIQUE(courseId, numero), 
   FOREIGN KEY(courseId) REFERENCES COURSE(courseId), 
   FOREIGN KEY(chevalId) REFERENCES CHEVAL(chevalId), 
   FOREIGN KEY(jockeyId) REFERENCES JOCKEY(jockeyId) 
);

MCD produit par Looping :

Code SQL produit par Looping à partir de ce MCD (table PARTICIPER) :

Code SQL :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
CREATE TABLE PARTICIPER( 
   courseId INT, 
   jockeyId INT, 
   numero SMALLINT NOT NULL, 
   poids DECIMAL(4,2) NOT NULL, 
   chevalId INT NOT NULL, 
   PRIMARY KEY(courseId, jockeyId), 
   UNIQUE(courseId, numero), 
   UNIQUE(courseId, chevalId), 
   FOREIGN KEY(courseId) REFERENCES COURSE(courseId), 
   FOREIGN KEY(jockeyId) REFERENCES JOCKEY(jockeyId), 
   FOREIGN KEY(chevalId) REFERENCES CHEVAL(chevalId) 
);

C’est tout bon ! (même si Miss PK a cédé sa place à une de ses dauphines...)

Rétroconception avec AMC :

MPD : Muy bien !

MLD : So far, so good !

MCD : Balek !

AMC a choisi la paire {courseId, chevalId} pour être l’ identifiant « primaire » de Participer. Ok.

Je demande la vérification du MCD : y a de l’eau dans le gaz car AMC répond que le MCD est invalide :

=>

Ainsi, l’identifiant alternatif Cle_2 est réduit à {}...

Pour sa part, l’identifiant alternatif Cle_3 est réduit à {numero} ; un seul dossard par participation à une course, c’est plutôt réducteur...

On est donc dans les choux. Histoire de voir comment réagit AMC avec un modèle plus simple, je lui propose le code SQL suivant :

Code SQL :

Sélectionner tout

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
CREATE TABLE COURSE( 
   courseId INTEGER, 
   courseNom VARCHAR(48) NOT NULL, 
   courseDate DATE NOT NULL, 
   PRIMARY KEY(courseId) 
); 
  
CREATE TABLE JOCKEY( 
   jockeyId INTEGER, 
   licence CHAR(50), 
   jockeyNom VARCHAR(48) NOT NULL, 
   jockeyPrenom VARCHAR(48) NOT NULL, 
   PRIMARY KEY(jockeyId), 
   UNIQUE(licence) 
); 
  
CREATE TABLE PARTICIPER( 
   courseId INTEGER, 
   poids NUMERIC(4,2) NOT NULL, 
   numero SMALLINT NOT NULL, 
   jockeyId INTEGER NOT NULL, 
   PRIMARY KEY(courseId, numero), 
   UNIQUE(courseId, jockeyId), 
   FOREIGN KEY(courseId) REFERENCES COURSE(courseId), 
   FOREIGN KEY(jockeyId) REFERENCES JOCKEY(jockeyId) 
);

AMC produit le MPD suivant :

Puis le MLD :

Jusque-là, tout va bien. Le MCD produit par AMC :

L’affaire se corse (chef-lieu Ajaccio). En effet, je demande la vérification du MCD et AMC répond qu’il y a de l’erreur :

De fait, l’identifiant alternatif Cle_1 ne contient aucun attribut, puisque les attributs courseId et jockeyId n’ont aucune raison d’être présents dans l’entité-type PARTICIPER.

Conclusion :

Pour faire de la rétroconception, je confirme, utilisons Looping !

2

0

CinePhil

Expert éminent sénior

Le 15/03/2025 à 16:55

Merci pour cette nouvelle version.

Je n'ai pas de tâche de conception de BDD pour le moment mais lors de ma prochaine utilisation de Looping, je téléchargerai la nouvelle version.

1

0

fsmrel

Expert éminent sénior

Le 16/03/2025 à 17:17

@Capitaine

A mon tour j’ai repris ton code SQL, et s’il pose des problèmes à PowerAMC, je confirme les propos de Paprick, avec Looping ça marche parfaitement.

Looping dit simplement qu’il a ignoré les points-virgules.

1

0

fsmrel

Expert éminent sénior

Le 17/03/2025 à 19:11

Rétroconception : compaison du comportement de 3 systèmes.

Soit le MCD suivant(créé avec PowerAMC), où Chauffeur « hérite » de Employe (spécialisation) :

Le code SQL source, produit par PowerAMC :

Code SQL :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
CREATE TABLE Employe  
( 
      EmployeId                INT                      NOT NULL, 
      Matricule                CHAR(8)                  NOT NULL, 
      EmployeNom               VARCHAR(24)              NOT NULL, 
      EmployePrenom            VARCHAR(24)              NOT NULL, 
   CONSTRAINT EMPLOYE_PK PRIMARY KEY (EmployeId), 
   CONSTRAINT EMPLOYE_AK UNIQUE (Matricule) 
) ; 
CREATE TABLE Chauffeur  
( 
      EmployeId                INT                      NOT NULL, 
      permis                   VARCHAR(24)              NOT NULL, 
   CONSTRAINT CHAUFFEUR_PK PRIMARY KEY (EmployeId) 
) ; 
alter table Chauffeur 
   add constraint CHAUFFEUR_EMPLOYE_FK foreign key (EmployeId) 
      references Employe (EmployeId)

Message d’erreur lors de la rétroconception avec Looping :

« point-virgule manquant à la fin de ALTER TABLE Chauffeur »

Une fois ajouté le point-virgule, c’est ok !

Rétroconception avec PowerAMC (même code SQL), ça n’est pas top (le coup du 0,n)...

Avec MySQL Workbench, ça n’est pas top non plus... :

Voilà, voilà... and the winner is...

1

0

escartefigue

Modérateur

Le 20/03/2025 à 15:01

Envoyé par Paprick

Bref, tout ça pour dire que, si Looping ne génère pas seul la contrainte au niveau du DDL, il ne peut bien évidemment pas déduire une contrainte en fonction d'un DDL dans le cadre d'une rétroconception

...
Donc, en résumé, tout ce qui est codé en SQL par le concepteur (contraintes, règles, ...) ne sera pas traité par Looping si cela ne peut pas être modélisé sans le code en question.

En même temps c'est tout à fait logique, et dans la mesure où Looping fait plutôt mieux - voire beaucoup mieux - que les autres logiciels de modélisation (et pas uniquement sur ce chapitre), je ne saurais lui en tenir rigueur

1

0

Paprick

Membre émérite

Le 20/03/2025 à 19:18

Salut François,

Envoyé par fsmrel

Je reviens sur la façon dont les outils font de la rétroconception (cf. https://www.developpez.net/forums/d2.../#post12075119). A mon sens, WinDesign devrait entrer dans le jeu. L’as-tu en ta possession ? Si oui, peux-tu voir ce qu’il produit avec le bout de code SQL que j’ai proposé ? A défaut, peux-tu demander à ton excellent préfacier de le faire (je serais fort étonné qu’il ne dispose pas de l’outil...)
Si je m’en trouve le courage, j’essaierai de voir ce qu’on peut faire avec DB-MAIN...

Je viens de tester ton cas dans WinDesign et... échec..

:

J'aurais pensé qu'il s'en sorte mieux...

1

0

fsmrel

Expert éminent sénior

Le 03/04/2025 à 23:13

Salve,

@Capitaine,

Dans le post #16 de la discussion « Looping version 4.1 disponible (avec Rétroconception) », tu proposes ce MCD :

Looping en dérive le DDL :

Code SQL :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
CREATE TABLE E1( 
   E1ident SMALLINT, 
   E1code CHAR(4) NOT NULL, 
   E1libelle VARCHAR(50) NOT NULL, 
   PRIMARY KEY(E1ident), 
   UNIQUE(E1code) 
); 
  
CREATE TABLE E3( 
   E1ident_1 SMALLINT, 
   E3seq SMALLINT, 
   E3nom VARCHAR(50) NOT NULL, 
   E1ident SMALLINT, 
   PRIMARY KEY(E1ident_1, E3seq), 
   FOREIGN KEYE1ident_1) REFERENCES E1(E1ident), 
   FOREIGN KEY(E1ident) REFERENCES E1(E1ident) 
);

Et tu complètes par

Code SQL :

Sélectionner tout

1
2
3
4
5
--la personne qui annule DOIT ETRE celle qui a validé 
alter table E3 
add constraint E3INC001 
foreign key (E1ident_annul, E3seq) 
references E3 (E1ident_valid, E3seq) ;

je suppose que E1ident_valid et E1ident_annul ont pris la place de E1ident et E1ident_1. Soit.

Les contraintes d’inclusion donnant, comme on le sait, quelques soucis lors de leur prise en compte avec SQL, afin de les éviter tant que faire se peut, que penses-tu en l’occurrence du MCD suivant ? (Ne te préoccupes pas des dates, elles sont là pour meubler).

Le LDD correspondant :

Code SQL :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
CREATE TABLE E1( 
   e1id SMALLINT, 
   e1code CHAR(4) NOT NULL, 
   e1libelle VARCHAR(50) NOT NULL, 
   PRIMARY KEY(e1id), 
   UNIQUE(e1code) 
); 
  
CREATE TABLE E3( 
   e1id SMALLINT, 
   e3seq SMALLINT, 
   e3nom VARCHAR(50) NOT NULL, 
   dateValidation DATE NOT NULL, 
   PRIMARY KEY(e1id, e3seq), 
   FOREIGN KEY(e1id) REFERENCES E1(e1id) 
); 
  
CREATE TABLE Annulation( 
   e1id SMALLINT, 
   e3seq SMALLINT, 
   dateAnnulation DATE NOT NULL, 
   PRIMARY KEY(e1id, e3seq), 
   FOREIGN KEY(e1id, e3seq) REFERENCES E3(e1id, e3seq) 
);

Qui donne par rétroconception le MCD :

Lequel ressemble comme deux gouttes d’eau à l’original, voilà qui arrange les affaires de Paprick...

1

0

Paprick

Membre émérite

Le 06/04/2025 à 22:41

Bonsoir,

Cet exemple repend le principe de ton post "Contraintes d'inclusion (du MCD au code SQL)".
Et ma réflexion est la même

!

1

0

Identifiez-vous

Créer un compte

Looping , logiciel gratuit et libre d'utilisation de Modélisation Conceptuelle de Données version 4.1 disponible (avec Rétroconception)

Identifiant
Mot de passe

Mot de passe oublié ?