Discussion :

[Bendott]

Bonjour à tous,

J'ai un projet de site e-commerce à réalisé, et je me trouve confronté à un problème de conception. (J'utilise Merise : MCD/MLD).
Voilà, j'ai une table produit, une table type_declinaison et une table declinaison.
un exemple pourrait être :
produit : T-Shirt
type_declinaison : Taille
declinaison : XL

Mon problème est le suivant, j'aimerais avoir un champ quantité, qui soit en fonction d'un produit, et de plusieurs déclinaisons. Par exemple :
T-Shirt Couleur jaune, Taille L : 12
Pantalon Couleur vert, Taille 50, coupe droit : 20

J'avais éventuellement pensé créer une nouvelle table avec comme clé primaire le produit, et l'id de chaque déclinaison, mais je ne sais pas non plus comment faire.

Je vous remercie par avance.

PS: Je pense que les explications sont assez claires, mais si vous ne comprenez pas, n'hésitez pas à me le signaler, je donnerais plus d'explications.

[delphine35]

moi je verrais cela comme ca :

Table Produit : ID_PRODUIT,LIBELLE_PRODUIT, ...

Table Declinaison : ID_DECLINAISON, TYPE_DECLINAISON, LIBELLE_DECLINAISON, LIBELLE_TYPE, ...

Table ProduitDecli : ID_PRODUIT, ID_DECLINAISON, QUANTITE

( en souligné : les clefs )

Avec :
Produit.ID_PRODUIT = ProduitDecli.ID_PRODUIT et Declinaison.ID_DECLINAISON = ProduitDecli.ID_DECLINAISON

Et :
Produit ------- 0,n --------ProduitDecli
Declinaison --- 0,n-------- ProduitDecli

[delphine35]

J'ai oublié le type:

Table ProduitDecli : ID_PRODUIT, ID_DECLINAISON, TYPE_DECLINAISON,QUANTITE

Avec :
Produit.ID_PRODUIT = ProduitDecli.ID_PRODUIT
et
Declinaison.ID_DECLINAISON = ProduitDecli.ID_DECLINAISON
et
Declinaison.TYPE_DECLINAISON = ProduitDecli.TYPE_DECLINAISON

[Bendott]

Merci beaucoup d'avoir répondu si vite,

Je ne pense pas que ça résolve mon problème,
Comme je l'ai montré dans l'exemple, la quantité dépend d'un article et de plusieurs déclinaisons.

Si je suis votre exemple, je pourrais faire une truc du genre :
TShirt001 Couleur Bleu => quantité 12
TShirt001 Couleur Rouge => quantité 12
TShirt001 Taille S => quantité 20
TShirt001 Taille M => quantité 4
On aura bien le même nombre de TShirt001 dans chaque type de déclinaison, mais on ne pourra pas savoir la quantité de TShirt001 en taille S qui ont une couleur Bleu.
Là je prend un exemple plus simple que celui donné précédemment, car en plus, il faut que je puisse gérer un nombre aléatoire de type de déclinaison,
Car pour certain produit, seul la taille changera, pour d'autres, il faudra rajouter le type de coupe, la matière...

[Bendott]

J'ai oublié,
Si le nombre de déclinaisons avait été fixe, par exemple 2, j'aurais pu faire :
Produit_Declinaison : id_produit, id_declinaison1, id_declinaison2, quantite

[delphine35]

si tu veux

TShirt001 en taille S qui ont une couleur Bleu

,

il faut la taille soit une colonne et la couleur une autre colonne

Ex :

Table QteProduit = ID_PRODUIT, ID_COULEUR, ID_TAILLE, QTE

Table Couleur = ID_COULEUR, LIBELLE_COULEUR
Table Taille = ID_TAILLE, LIBELLE_TAILLE

[delphine35]

J'ai oublié,
Si le nombre de déclinaisons avait été fixe, par exemple 2, j'aurais pu faire :
Produit_Declinaison : id_produit, id_declinaison1, id_declinaison2, quantite

Je ne vois pas comment mettre en ligne une colonne .....

[Bendott]

Sauf que si je fais comme ça, à chaque fois que je veux rajouter un nouveau type de déclinaison, il faudra que je rajoute une nouvelle table, ce qui en au niveau programmation ne me dérange pas trop, mais au niveau conceptuel je ne trouve pas ça très propre ; mais ce qui me dérange beaucoup plus, c'est que je vais devoir à chaque fois changer la table QteProduit en ajoutant un nouveau champ dans la clé primaire, ce que je trouve encore moins bien.

[delphine35]

J'ai peut etre une piste :


Table Produit : ID_PRODUIT,LIBELLE_PRODUIT, ...
Table Declinaison : ID_DECLINAISON, LIBELLE_DECLINAISON, ...
Table TypeDecli : ID_TYPEDECLI, LIBELLE_TYPEDECLI, ...
Table ProduitDecli : ID_PRODUIT_DECLI, ID_PRODUIT, ID_DECLINAISON, ID_TYPEDECLI, ID_PRODUIT_DECLI_SUIV, QUANTITE


Ex table ProduitDecli :
ID_PRODUIT_DECLI, ID_PRODUIT, ID_DECLINAISON, ID_TYPEDECLI, ID_PRODUIT_DECLI_SUIV, QUANTITE
1 ; TSHIRT ; TAILLE ; S ; 2 ; NULL
2 ; TSHIRT ; COULEUR ; VERTE ; NULL ; 3

Ce qui fait que tu as Tshirt Taille S Couleur Verte en qte 3

[delphine35]

les clef :

Table Produit : ID_PRODUIT,LIBELLE_PRODUIT, ...
Table Declinaison : ID_DECLINAISON, LIBELLE_DECLINAISON, ...
Table TypeDecli : ID_TYPEDECLI, LIBELLE_TYPEDECLI, ...
Table ProduitDecli : ID_PRODUIT_DECLI, ID_PRODUIT, ID_DECLINAISON, ID_TYPEDECLI, ID_PRODUIT_DECLI_SUIV, QUANTITE

[Bendott]

Merci beaucoup,

Juste deux petites questions :
- pourquoi mettre ID_TYPEDECLI dans ProduitDecli ?
- La cardinalité qui va de ProduitDecli à Declinaison est bien 0,1 ?

[delphine35]

- pourquoi mettre ID_TYPEDECLI dans ProduitDecli ?

Parce que tu peux pour le meme produit ayant la meme déclinaison, des types décli different

Exemple :


Ex table ProduitDecli :
ID_PRODUIT_DECLI | ID_PRODUIT | ID_DECLINAISON | ID_TYPEDECLI | ID_PRODUIT_DECLI_SUIV | QUANTITE
----------------------------------------------------------------------
1 ......... TSHIRT ........ TAILLE ..... S ........ 3 ...... NULL
2 ......... TSHIRT ........ TAILLE .... XL ....... NULL .... 3
3 ..........TSHIRT .........DECLI2 .....NOIR .... NULL .... 1

- La cardinalité qui va de ProduitDecli à Declinaison est bien 0,1 ?

oui

[Bendott]

Désolé, du coup la question n'est pas sur ID_TYPE_DECLI mais sur ID_DECLINAISON, pourquoi vouloir stocker TAILLE ou DECLI2 ?

En fait, (je réfléchis en même temps ) ça pourrait être utile pour vérifier que l'on ne met pas deux déclinaisons identiques (TAILLE S ET XL) pour le même ProduitDecli, mais est-ce possible de le modéliser, vue qu'il n'y a qu'une seule Declinaison par ProduitDecli, ou est-ce que ce n'est plus du ressort du MCD ?

[delphine35]

Tu peux avoir :

1 .......... TSHIRT .......... TAILLE ........ S ......... 3 ...........NULL
2 .......... TSHIRT .......... TAILLE ........ S ..........4 ...........NULL
3 ...........TSHIRT .......... COULEUR...... VERT .....NULL....... 4
4 ...........TSHIRT .......... COULEUR ...... ROUGE...NULL........5


4 Tshirt Taille S Couleur Vert
5 Tshirt Taille S Couleur Rouge

Donc tu peux effectivement avoir plusieurs fois le
TSHIRT ..... TAILLE ..... S

Tu peux ne pas mettre ID_DECLINAISON si et seulement si : 1 type est attribuer a 1 et 1 seule declinaison.
et dans ce cas la table Declinaison ne sert a rien car Id_Decli devient un attribut de la table Type decli.

Ce qui te donnerais (je sais c'est pas du code, mais c plus joli )

Code :

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

1
2
3
4
5
6
7
Table Produit : ID_PRODUIT,LIBELLE_PRODUIT, ...
Table TypeDecli : ID_TYPEDECLI, LIBELLE_TYPEDECLI, LIBELLE_DECLINAISON ...
Table ProduitDecli : ID_PRODUIT_DECLI, ID_PRODUIT, ID_TYPEDECLI, ID_PRODUIT_DECLI_SUIV, QUANTITE 

avec : 
Produit.ID_PRODUIT  .......... 0,n ........ ProduitDecli.ID_PRODUIT
TypeDecli.ID_TYPEDECLI........ 0,n ........ ProduitDecli.ID_TYPEDECLI

Effectivement je t'ai dit une betise tout a l'heure

- La cardinalité qui va de ProduitDecli à Declinaison est bien 0,1 ?

C'est non ! => 0,n

[Bendott]

En fait ce que je voulais dire c'est que je pouvais avoir :
1 .......... TSHIRT .......... TAILLE ........ S ......... 2 ...........NULL
2 .......... TSHIRT .......... TAILLE ........ M ..........NULL ......NULL
voir même :
1 .......... TSHIRT .......... TAILLE ........ S ......... 2 ...........NULL
2 .......... TSHIRT .......... TAILLE ........ S ..........NULL ......NULL

Tu peux ne pas mettre ID_DECLINAISON si et seulement si : 1 type est attribuer a 1 et 1 seule declinaison.
et dans ce cas la table Declinaison ne sert a rien car Id_Decli devient un attribut de la table Type decli.

Je ne vois pas ce qui dérange d'avoir :
1 .......... TSHIRT ........ S ......... 2 ...........NULL
2 .......... TSHIRT ........ VERT......NULL ......NULL

C'est non ! => 0,n

Si c'est 0,n comment peut-tu mettre une clé étrangère dans ProduitDecli ?

[fsmrel]

Bonjour,


Dans le cas général, lorsqu’on veut présenter une liste variable d’éléments sur une seule ligne, on peut utiliser une requête récursive.

Le SGBD utilisé pour l’exemple qui suit est SQL Server 2005.

Partons de l’ensemble suivant, dans lequel les éléments d’une ligne qui sont à concaténer (taille L, couleur jaune, etc.) font l’objet d’une table ad-hoc CHAINE, permettant de chaîner les déclinaisons. Les quantités relatives à une chaîne sont inscrites dans une table à cet effet, QUANTITE, ayant pour clé celle du 1er élément de la chaîne correspondante.

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
CREATE TABLE PRODUIT 
(       Pid      CHAR(8)       NOT NULL
      , Pnom     VARCHAR(32)   NOT NULL
    , CONSTRAINT PRODUIT_PK PRIMARY KEY (Pid) 
) ;
CREATE TABLE TYPE_DECLINAISON 
(       TDid     CHAR(8)       NOT NULL
      , TDnom    VARCHAR(32)   NOT NULL
    , CONSTRAINT TYPE_DECLINAISON_PK PRIMARY KEY (TDid) 
) ;
CREATE TABLE DECLINAISON 
(       TDid     CHAR(8)       NOT NULL
      , Did      CHAR(8)       NOT NULL
      , Dnom     VARCHAR(32)   NOT NULL
    , CONSTRAINT DECLINAISON_PK PRIMARY KEY (TDid, Did) 
    , CONSTRAINT DECLINAISON_FK FOREIGN KEY (TDid) REFERENCES TYPE_DECLINAISON
) ;
CREATE TABLE P 
(       Xid      CHAR(8)       NOT NULL      
      , Pid      CHAR(8)       NOT NULL
      , TDid     CHAR(8)       NOT NULL
      , Did      CHAR(8)       NOT NULL
    , CONSTRAINT P_PK PRIMARY KEY (Xid) 
    , CONSTRAINT P_AK UNIQUE (Pid, TDid, Did) 
    , CONSTRAINT P_FK1 FOREIGN KEY (Pid) REFERENCES PRODUIT
    , CONSTRAINT P_FK2 FOREIGN KEY (TDid, Did) REFERENCES DECLINAISON
) ;
CREATE TABLE QUANTITE 
(       Xid         CHAR(8)       NOT NULL
      , Quantite     INT          NOT NULL
    , CONSTRAINT QUANTITE_PK PRIMARY KEY (Xid) 
    , CONSTRAINT QUANTITE_FK FOREIGN KEY (Xid) REFERENCES P
) ;
CREATE TABLE CHAINE 
(       Successeur        CHAR(8)       NOT NULL      
      , Predecesseur      CHAR(8)       NOT NULL
    , CONSTRAINT CHAINE_PK PRIMARY KEY (Successeur) 
    , CONSTRAINT CHAINE_AK UNIQUE (Predecesseur) 
    , CONSTRAINT CHAINE_FK1 FOREIGN KEY (Successeur) REFERENCES P
    , CONSTRAINT CHAINE_FK2 FOREIGN KEY (Predecesseur) REFERENCES P
    , CONSTRAINT CHAINE_CK1 CHECK (Successeur > Predecesseur)
) ;

Un 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
INSERT INTO PRODUIT VALUES ('p01', 't-shirt') ;
INSERT INTO PRODUIT VALUES ('p02', 'pantalon') ;
 
INSERT INTO TYPE_DECLINAISON VALUES ('td01', 'taille') ;
INSERT INTO TYPE_DECLINAISON VALUES ('td02', 'coupe') ;
INSERT INTO TYPE_DECLINAISON VALUES ('td03', 'couleur') ;
INSERT INTO TYPE_DECLINAISON VALUES ('td04', 'poids') ;
 
INSERT INTO DECLINAISON VALUES ('td01', 'd01', 'XL') ;    -- taille XL  
INSERT INTO DECLINAISON VALUES ('td01', 'd02', 'L') ;     -- taille L
INSERT INTO DECLINAISON VALUES ('td02', 'd03', 'droit') ; -- coupe droit
INSERT INTO DECLINAISON VALUES ('td03', 'd04', 'jaune') ; -- couleur jaune
INSERT INTO DECLINAISON VALUES ('td01', 'd05', '50') ;    -- taille 50 
INSERT INTO DECLINAISON VALUES ('td03', 'd06', 'vert') ;  -- couleur vert
INSERT INTO DECLINAISON VALUES ('td04', 'd07', 'lourd') ; -- poids lourd
 
INSERT INTO P VALUES ('x01', 'p01', 'td01', 'd02') ;
INSERT INTO P VALUES ('x02', 'p01', 'td03', 'd04') ;
INSERT INTO P VALUES ('x03', 'p02', 'td03', 'd06') ;
INSERT INTO P VALUES ('x04', 'p02', 'td01', 'd05') ;
INSERT INTO P VALUES ('x05', 'p02', 'td02', 'd03') ;
INSERT INTO P VALUES ('x06', 'p02', 'td04', 'd07') ;
 
INSERT INTO QUANTITE VALUES ('x01', 20) ;
INSERT INTO QUANTITE VALUES ('x03', 12) ;
 
INSERT INTO CHAINE VALUES ('x02', 'X01') ;
INSERT INTO CHAINE VALUES ('x05', 'X04') ;
INSERT INTO CHAINE VALUES ('x04', 'X03') ;
INSERT INTO CHAINE VALUES ('x06', 'X05') ;

On définit une vue qui permet de rassembler les types de déclinaison et leurs déclinaisons :

Code SQL :

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

1
2
3
4
5
6
7
CREATE VIEW V_DECLINAISON (TDid, TDnom, Did,Dnom) AS
    SELECT x.TDid, y.TDnom, x.Did, x.Dnom
    FROM   P JOIN DECLINAISON AS x
                  ON  P.TDid = x.TDid
                  AND P.Did = x.Did
             JOIN TYPE_DECLINAISON AS y
                  ON  x.TDid = y.TDid ;

On définit maintenant une vue récursive :

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
CREATE VIEW VUE_RECURSIVE (Racine, Successeur, Predecesseur, PNom, ListeDeclinaisons) AS 
 WITH V (Racine, Successeur, Predecesseur, PNom, ListeDeclinaisons) AS
 (
        SELECT   x.Predecesseur, x.Successeur, x.Predecesseur, y.Pnom
               , CAST(z.TDnom  + ' ' + z.Dnom AS VARCHAR(512))
        FROM     CHAINE AS x 
                    JOIN P ON x.Predecesseur = P.Xid
                    JOIN Produit AS y ON P.Pid = y.Pid 
                    JOIN V_DECLINAISON AS z ON  P.TDid = z.TDid
                                            AND P.Did = z.Did    
        WHERE  NOT EXISTS 
               (SELECT ''
                FROM   CHAINE AS z
                WHERE  z.Successeur = x.Predecesseur)     
    UNION ALL
        SELECT Racine, x.Successeur, x.Predecesseur, y.PNom
               , CAST(ListeDeclinaisons + ', ' + z.TDnom  + ' ' + z.Dnom AS VARCHAR(512))
        FROM   V JOIN CHAINE AS x ON x.Predecesseur = v.Successeur
                 JOIN P ON x.Predecesseur = P.Xid
                 JOIN Produit AS y ON P.Pid = y.Pid 
                 JOIN V_DECLINAISON AS z ON  P.TDid = z.TDid
                                         AND P.Did = z.Did    
)
SELECT *
FROM   V ;

Pour afficher le résultat :

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
SELECT x.Pnom + ', ' + x.ListeDeclinaisons + ', ' 
       + y.TDnom + ' ' + y.Dnom AS Liste, z.Quantite
FROM   VUE_RECURSIVE AS x  
           JOIN P 
                ON x.Successeur = P.Xid 
           JOIN V_DECLINAISON AS y
                ON  P.TDid = y.TDid
                AND P.Did = y.Did
           JOIN QUANTITE AS z
                ON x.Racine = z.Xid 
WHERE NOT EXISTS             -- ne conserver que le niveau feuille
     (SELECT  ''
      FROM    CHAINE as c
      WHERE   c.Predecesseur = x.Successeur) ;

Au résultat :

Code :

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

1
2
3
4
5
Liste                                                            Quantite

t-shirt, taille L, couleur jaune                                    20
pantalon, couleur vert, taille 50, coupe droit, poids lourd         12

Si vous avez besoin de plus d’explications, je vous les fournirai.

[delphine35]

oui,

J'ai juste fait une table où tu en fait 3 (P + Quantité + Chaine)

Mais c'est ça ....

[Bendott]

Bonjour, merci pour ta réponse
Je suis désolé, je travail principalement avec MySQL, et suis loin d'être un expert en la matière. Je comprend ta solution et la trouve très bien. Mais je me demande si la table CHAINE est indispensable ? et j'avoue avoir du mal avec ta vue récursive, je ne suis pas sûre de comprendre la syntaxe, et de pouvoir la mettre en place sur une base MySQL derrière.

Je ne connais pas très bien les vues (seulement les cas très basiques), est-il préférable de faire comme delphine35, c'est à dire une table récursive, ou comme fsmrel, faire trois tables, avec une vue récursive ?

[delphine35]

une vue est une "hoto" de la base. Cela te permet d'utiliser plus simplement tes données. Mais tu ne peux pas faire d'upadet ou d'insert dans la vue, cela se fait dans les tables.

L'une et l'autre des solutions sont bonnes

je me demande si la table CHAINE est indispensable ?

Oui elle l'ait, sinon tu ne peux pas chainer tes declinaison/type de decli. Ou tu met tout dans la meme ...

L'avantage en mettant dans 3 tables : Gain de volume
L'avantage en mettant dans 1 table : Gain de temps de traitement ... (et encore ) - Cette solution peut semblé plus simple pour un débutant mais a terme pour l'utilisation

Je te conseil la version de fsmrel et en plus tu as juste a copier/coller ....

[fsmrel]

il faut que je puisse gérer un nombre aléatoire de type de déclinaison

Une requête récursive permet de traiter ce problème.

Je ne vois pas comment mettre en ligne une colonne

Là aussi une requête récursive permet de traiter ce problème.

oui,
J'ai juste fait une table où tu en fait 3 (P + Quantité + Chaine)

Table Produit : ID_PRODUIT,LIBELLE_PRODUIT, ...
Table Declinaison : ID_DECLINAISON, LIBELLE_DECLINAISON, ...
Table TypeDecli : ID_TYPEDECLI, LIBELLE_TYPEDECLI, ...
Table ProduitDecli : ID_PRODUIT_DECLI, ID_PRODUIT, ID_DECLINAISON, ID_TYPEDECLI, ID_PRODUIT_DECLI_SUIV, QUANTITE

Mais c'est ça

De fait, par un LEFT JOIN des tables P, CHAINE et QUANTITE, on retrouve votre table ProduitDecli, mais celle-ci est infectée par le bonhomme NULL et le défi est de l'éradiquer.

Quoi qu’il en soit, quelle requête proposez-vous pour fournir le résultat attendu ?

je me demande si la table CHAINE est indispensable ?

La table CHAINE peut être absorbée par la table P (ce que fait Delphine avec la table ProduitDecli), mais sa mise en oeuvre permet de bannir le bonhomme NULL.

est-il préférable de faire comme delphine35, c'est à dire une table récursive, ou comme fsmrel, faire trois tables, avec une vue récursive ?

Comme je l’ai dit, par un LEFT JOIN des tables P, CHAINE et QUANTITE, on retrouve la table ProduitDecli de Delphine, mais celle-ci est envahie par le bonhomme NULL. La vue récursive n’est pas de même niveau, elle n’est que la requête qui permet de produire le résultat attendu et, en l’aménageant, elle peut être utilisée pour manipuler la table ProduitDecli.

je travail principalement avec MySQL

Je n’utilise pas MySQL, aussi devriez-vous poser la question sur le forum correspondant comment traiter des requêtes récursives avec ce SGBD.