Discussion :

[asetabularia258100]

Bonjour / Bonsoir,

après quelques jours de réflexion j'ai décidé de me lancer et publier mon MCD pour bénéficier de votre aide et de vos conseils,
Voila je dois réaliser une application en java pour la gestion d'un stock de marchandise pour un supermarché (cette application est dédiée au chef de rayon)

Explication :

Dans mon supermarché il y a plusieurs département ,chaque département contient 1 ou plusieurs rayon , chaque rayon contient 1 ou plusieurs article , ont trouve un article x dans un seul rayon . (ex: on ne trouvera jamais un yaourt dans le rayon fruit et légume)

chaque rayon a un chef "Chef de rayon" et un chef de rayon peut être chef que q'un seul rayon .

puisque le chef de rayon est le responsable de son rayon il doit dont effectuer des commandes de produits pour alimenter l’entrepôt de marchandises pour ensuite alimenter son rayon à partir de l’entrepôt ,donc:

Un chef de rayon à la possibilité d'effectuer 2 types de commandes:

Commande externe : elle se fait avec un fournisseur ("externe" parce qu"elle est externe au supermarché). elle à comme effet d’augmenter la quantité de marchandises dans l’entrepôt.

Commande interne : (vos avez compris ) elle à comme effet de diminuer la quantité de marchandises dans l’entrepôt et d’augmenter la quantité dans le rayon (d'un article quelconque )

Ont comprend par la que : chaque commande externe c'est une "Entrée" , et chaque commande interne est une "Sortie" vis-à-vis de l’entrepôt

Chaque commande (externe ou interne est composé d'une ou plusieurs ligne de commande).

je crois que j'ai des erreurs de boucle fermer dans mon MCD mais j'ai beau tourner le problème de tout les cotés je trouve pas la solution , ou bien mon mcd est bon et y a pas de souci a se faire

PS: les ligne de commande possède une date de péremption qui peux être null si le produits est impérissable et que si le produit est périssable cela signifie que toute la quantité contenue dans la ligne est périmer .

Voila j’espère que mon explication est bonne est que le sujet va vous intéressez .

en attendant une réponse je vous salut et je vous remercie d'avance !

Hicham

[fsmrel]

Bonsoir asetabularia,

Tout d’abord, je fais observer qu’une association est un lieu de rencontre : votre association EFFECTUE s’interprète ainsi : un utilisateur effectue des commandes internes ou externes, une commande externe est effectuée par un utilisateur : so far do good, mais là où le bât blesse c’est qu’à vous lire, cette commande externe est aussi effectuée par une commande interne (et réciproquement) ...
Il faut donc casser l’association (ternaire) et en faire deux (binaires).

Maintenant, vous pouvez envisager de factoriser les deux types de commande, en utilisant la généralisation comme ci-dessous (à noter les attributs CommandeIntNo et CommandeExtNo qui représentent les numéros de commande connus des utilisateurs, alors que l’attribut CommandeId leur est caché) :




Attention, il y a une bijection entre les entités-types RAYON et UTILISATEUR : conceptuellement, pas de problème. Par contre il y a un piège au niveau SQL, car l’utilisation des clés étrangères ne garantit pas vraiment l’intégrité comme attendu, elles ne peuvent pas empêcher la situation suivante :

Code :

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

1
2
3
4
5
6
7
8
RAYON                                     UTILISATEUR
+------------+---------------+             +---------------+------------+
|   RayonId  | UtilisateurId |             | UtilisateurId |   RayonId  |
|------------+---------------|             |---------------+------------|
|       123  |          314  |             |          314  |       456  |
|       456  |          271  |             |          271  |       123  |
+------------+---------------+             +---------------+------------+

L’intégrité est à assurer au moyen d’une contrainte, comme dans l’exemple traité ici :

Code D :

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

1
2
CONSTRAINT RAYON_UTILISATEUR_CHK01
    RAYON {RayonId, UtilisateurId} = UTILISATEUR {RayonId, UtilisateurId} ;

Balek, ceci n’est pas du SQL mais du D, du relationnel pur...

Il faut aussi observer que si au niveau SQL on utilisait l’intégrité référentielle, à moins de figer le système, la suppression d’un rayon entraînerait la suppression de l’utilisateur correspondant (clause CASCADE en SQL), le stimulus émis par le rayon parvenant jusqu’à l’utilisateur serait renvoyé vers RAYON tel un boomerang : that’s a nasty cycle!

je crois que j'ai des erreurs de boucle fermer dans mon MCD

Vous avez sans doute le sentiment d’avoir modélisé un cycle à l’image de celui qui serait censé exister dans le diagramme ci-dessus, entre RAYON, UTILISATEUR, COMMANDE, LIGNE_COMMANDE et ARTICLE : exception faite du cas causé par la bijection entre RAYON et UTILISATEUR, si tel est bien votre sentiment, je dis : illusion d’optique ! Par exemple, si on supprime un rayon, un stimulus S1 part à destination d’UTILISATEUR et un stimulus S2 à destination d’ARTICLE. S1 parvient jusqu’à UTILISATEUR lequel le répercute sur COMMANDE (à supposer qu’une clause CASCADE soit prévue), qui le répercute sur LIGNE_COMMANDE qui ne peut pas le répercuter sur ARTICLE, car il n’y a pas de clé étrangère qui le permette : un article est insensible à la destruction des lignes de commande. En conséquence, RAYON ne reçoit pas non plus S1. Quant à S2, il arrive jusqu’à ARTICLE, et si la clause CASCADE ad-hoc est effective, S2 parvient jusqu’à LIGNE_COMMANDE, mais sans remonter à COMMANDE, et quand bien même, de toute façon S2 serait sans effet sur UTILISATEUR venant de COMMANDE : la suppression d’une commande n’a aucun effet sur l’utilisateur qui l’a créée.

Si vous souhaitez qu'on creuse plus avant, pas de problème.

[asetabularia258100]

je vous remercie pour votre réponse ,

j'ai oublié de préciser d'un utilisateur peux être un chef de rayon , ou un administrateur qui gérer les compte des chef de rayon.

j'ai une question si vous le permettez ,

si je souhaite intégrer cette notion dans mon mcd , qu'un utilisateur "chef de rayon" contact 1 ou plusieurs fournisseur ,et qu'un fournisseur et contacter que par un seul chef de rayon (ce que je souhaite avoir comme résultat dans ma base de données c'est que quand un chef de rayon se connecte et qu'il souhaite faire une commande externe le système ne lui affiche que les fournisseurs qui livrent les produits de son rayon) .
autre chose je me demande si le MLD doit parfaitement correspondre au MCD créer , parce-que quand on dis qu'une entité devient une table etc .. je me vois pas créer une table commande puis créer 2 table "ligne_cmd_ex" et "ligne cmd_in" .

Merci à vous !

Hicham

PS: vous trouverez ci joint mon MCD

[Kropernic]

autre chose je me demande si le MLD doit parfaitement correspondre au MCD créer , parce-que quand on dis qu'une entité devient une table etc .. je me vois pas créer une table commande puis créer 2 table "ligne_cmd_ex" et "ligne cmd_in" .

A quoi bon faire un MCD dans ce cas ?

Par contre, si je m'en tiens au MCD que vous avez posté, il ne vous faut pas une table commande mais bien une table commande_interne ET une table commande_externe. Et de ce fait, vous aurez effectivement une table ligne_commande_interne ET ligne_commande_externe.

A contrario, si vous utilisez l'héritage comme le suggère fsmrel dans son message précédent, vous aurez alors les tables suivantes :

• commande
• commande_interne
• commande_externe
• ligne_commande

Ce qui, je pense, sera plus proche de la réalité et plus facile à gérer.

[asetabularia258100]

merci a vous ,

suivant vos réponse j'ai réaliser le MCD suivant ,

je souhaite avoir votre avis

es-que c'est possible de lié entre chef de rayon et fournisseur afin de savoir pour chaque chef de rayon quel son les fournisseurs qui livre les produits correspondant à son rayon ?? ou bien lié fournisseur a rayon ? , quesque vous en pensez ?

MERCI A VOUS !

[Kropernic]

merci a vous ,

suivant vos réponse j'ai réaliser le MCD suivant ,

je souhaite avoir votre avis

es-que c'est possible de lié entre chef de rayon et fournisseur afin de savoir pour chaque chef de rayon quel son les fournisseurs qui livre les produits correspondant à son rayon ?? ou bien lié fournisseur a rayon ? , quesque vous en pensez ?

MERCI A VOUS !

A votre question "A quoi faut-il lier les fournisseurs ?"

A : les rayons
B : les chefs de rayons

Je choisis la réponse C : les articles !

Une fournisseur fournit un article. Article qui lui-même appartient à un rayon et ce dernier est sous la responsabilité d'un chef de rayon.
Par transitivité, vous savez donc quels sont les fournisseurs qui sont susceptibles d'intéresser un chef de rayon en particulier.

[fsmrel]

Bonsoir Hicham et Kropernic,


Comme dit Kropernic, autant se simplifier la vie quand c’est possible...

Je vois que vous avez spécialisé les utilisateurs : c’est parfait. Même chose pour les articles périmés.

Vous avez supprimé l’association CONTACT avec le FOURNISSEUR : il fallait effectivement le faire, car outre le fait qu’il serait bizarre qu’un seul chef de rayon puisse contacter un fournisseur, la raison de son existence ne tenait pas debout :

si je souhaite intégrer cette notion dans mon mcd, qu'un utilisateur "chef de rayon" contact 1 ou plusieurs fournisseur ,et qu'un fournisseur et contacter que par un seul chef de rayon (ce que je souhaite avoir comme résultat dans ma base de données c'est que quand un chef de rayon se connecte et qu'il souhaite faire une commande externe le système ne lui affiche que les fournisseurs qui livrent les produits de son rayon).

Association RAYON - CHEF_RAYON

Je vous ai peut-être un peu affolé avec cette histoire de bijection entre RAYON et CHEF_RAYON, ainsi qu’avec le problème de l’impuissance des clés étrangères dans ce cas-là à garantir l’intégrité référentielle. Comme je l’ai écrit précédemment, ceci devra plutôt faire l’objet d’une contrainte, tout en sachant qu’avec les SGBD SQL du marché ça n’est pas aussi simple qu’en relationnel pur, où là c’est « fingers in the nose » grâce notamment à l’affectation multiple (« plurielle » comme diraient les massacreurs de la bonne langue), sujet que j’ai évoqué notamment ici, chez scarface71, confronté lui aussi aux problèmes posés par la bijection, ou encore chez jolla. J’en avais parlé en son temps à Kropernic, mais à l’époque je n’avais pas vu la faille des clés étrangères . Au stade SQL, on finit souvent par ne faire qu’une seule table de RAYON et CHEF_RAYON : je trouve qu’il s’agit d’une solution de facilité, plutôt expéditive, mais vous pouvez réfléchir et peser le pour et le contre. Pour ma part, je définirais une vue qui serait la jointure des deux tables, et ventilerais les mises à jour dans chacune d’elles au moyen d’un trigger, tout en interdisant les mises à jour directes des tables, mais il faut reconnaître que ça n’est pas léger léger (et tous les SGBD n'acceptent pas la mise à jour des vues...)

Concernant la représentation graphique, je conserve le lien entre les entités-types RAYON et CHEF_RAYON au stade MCD, et symbolise pour la forme leur relation sous forme de pointillés au stade MLD, puisque les clés étrangères sont inefficaces pour les bijections.



A propos des lignes de commande :

Vous noterez que de mon côté j’utilise l’identification relative de LIGNE_COMMANDE par rapport à COMMANDE (cardinalité 1,1 mise entre parenthèses). En effet, des lignes ne sont jamais qu’un attribut, multivalué certes, mais attribut néanmoins d’une commande.


A propos de votre question :

« es-que c'est possible de lié entre chef de rayon et fournisseur afin de savoir pour chaque chef de rayon quel son les fournisseurs qui livre les produits correspondant à son rayon ?? ou bien lié fournisseur a rayon ? »

Pour le moment, votre modèle permet au chef de rayon Raoul de savoir quels sont les articles qu’il a commandés pour son rayon et à quels fournisseurs. Voir plus bas la requête SQL correspondante.

A votre question "A quoi faut-il lier les fournisseurs ?"

A : les rayons
B : les chefs de rayons

Je choisis la réponse C : les articles !

Un fournisseur fournit un article. Article qui lui-même appartient à un rayon et ce dernier est sous la responsabilité d'un chef de rayon.
Par transitivité, vous savez donc quels sont les fournisseurs qui sont susceptibles d'intéresser un chef de rayon en particulier.

D’accord Kro, mais il y a un problème : le camarade Hicham n’a pas mis FOURNISSEUR et ARTICLE en relation... Cela dit, il pourrait être opportun de le faire au cas où effectivement un utilisateur aimerait mémoriser et donc savoir quels sont les fournisseurs ayant quels articles proposés dans leur catalogue.



Un MCD (j’ai ajouté la proposition de Kropernic, et il manque les départements et les articles périmés) :




MLD





Code SQL + un bout de jeu d’essai :

TABLE UTILISATEUR

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
CREATE TABLE UTILISATEUR 
(
        UtilisateurId        INT                  NOT NULL
      , UtilisateurNom       VARCHAR(48)          NOT NULL
    , CONSTRAINT UTILISATEUR_PK PRIMARY KEY (UtilisateurId)
) ;
 
INSERT INTO UTILISATEUR (UtilisateurId, UtilisateurNom) VALUES (1, 'Hicham') ;
INSERT INTO UTILISATEUR (UtilisateurId, UtilisateurNom) VALUES (2, 'Raoul') ;
INSERT INTO UTILISATEUR (UtilisateurId, UtilisateurNom) VALUES (3, 'Paul') ;
INSERT INTO UTILISATEUR (UtilisateurId, UtilisateurNom) VALUES (4, 'Jean') ;
INSERT INTO UTILISATEUR (UtilisateurId, UtilisateurNom) VALUES (5, 'Pacal') ;
INSERT INTO UTILISATEUR (UtilisateurId, UtilisateurNom) VALUES (6, 'Bastien') ;
 
SELECT '' AS 'UTILISATEUR', * FROM UTILISATEUR ;

TABLE ADMINISTRATEUR

Code SQL :

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

1
2
3
4
5
6
7
8
9
10
11
12
CREATE TABLE ADMINISTRATEUR 
(
        UtilisateurId        INT                  NOT NULL
    , CONSTRAINT ADMINISTRATEUR_PK PRIMARY KEY (UtilisateurId)
    , CONSTRAINT ADMINISTRATEUR_UTILISATEUR_FK FOREIGN KEY (UtilisateurId)
          REFERENCES UTILISATEUR ON DELETE CASCADE
) ;
 
INSERT INTO ADMINISTRATEUR (UtilisateurId) VALUES (1) ;
INSERT INTO ADMINISTRATEUR (UtilisateurId) VALUES (4) ;
 
SELECT '' AS 'ADMINISTRATEUR', * FROM ADMINISTRATEUR ;

TABLE CHEF_RAYON

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
CREATE TABLE CHEF_RAYON 
(
        UtilisateurId        INT                  NOT NULL
      , RayonId              INT                  NOT NULL
    , CONSTRAINT CHEF_RAYON_PK PRIMARY KEY (UtilisateurId)
    , CONSTRAINT CHEF_RAYON_AK UNIQUE (RayonId)
    , CONSTRAINT CHEF_RAYON_UTILISATEUR_1 FOREIGN KEY (UtilisateurId)
          REFERENCES UTILISATEUR ON DELETE CASCADE
) ;
INSERT INTO CHEF_RAYON (UtilisateurId, RayonId) VALUES (2, 1) ;
INSERT INTO CHEF_RAYON (UtilisateurId, RayonId) VALUES (3, 2) ;
INSERT INTO CHEF_RAYON (UtilisateurId, RayonId) VALUES (5, 3) ;
INSERT INTO CHEF_RAYON (UtilisateurId, RayonId) VALUES (6, 4) ;
 
SELECT '' AS 'CHEF_RAYON', * FROM CHEF_RAYON ;

TABLE RAYON

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
CREATE TABLE RAYON 
(
        RayonId              INT                  NOT NULL
      , RayonNom             VARCHAR(48)          NOT NULL
      , UtilisateurId        INT                  NOT NULL
    , CONSTRAINT RAYON_PK PRIMARY KEY (RayonId)
    , CONSTRAINT RAYON_AK UNIQUE (UtilisateurId)
) ;
INSERT INTO RAYON (RayonId, UtilisateurId, RayonNom) VALUES (1, 2, 'Informatique') ;
INSERT INTO RAYON (RayonId, UtilisateurId, RayonNom) VALUES (2, 3, 'Librairie') ;
INSERT INTO RAYON (RayonId, UtilisateurId, RayonNom) VALUES (3, 5, 'Musique') ;
INSERT INTO RAYON (RayonId, UtilisateurId, RayonNom) VALUES (4, 6, 'Alimentation') ;
 
SELECT '' AS 'RAYON', * FROM RAYON ;

TABLE FOURNISSEUR

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
CREATE TABLE FOURNISSEUR 
(
        FournisseurId        INT                  NOT NULL
      , FournisseurNom       VARCHAR(48)          NOT NULL
    , CONSTRAINT FOURNISSEUR_PK PRIMARY KEY (FournisseurId)
) ;
INSERT INTO FOURNISSEUR (FournisseurId, FournisseurNom) VALUES (1, 'MicroMiniMacroSoft') ;
INSERT INTO FOURNISSEUR (FournisseurId, FournisseurNom) VALUES (2, 'Kropernic & Cie') ;
INSERT INTO FOURNISSEUR (FournisseurId, FournisseurNom) VALUES (3, 'Vivaldi & Chopin SA') ;
INSERT INTO FOURNISSEUR (FournisseurId, FournisseurNom) VALUES (4, 'Dugoineau Informatique') ;
INSERT INTO FOURNISSEUR (FournisseurId, FournisseurNom) VALUES (5, 'Dubicobit') ;
INSERT INTO FOURNISSEUR (FournisseurId, FournisseurNom) VALUES (6, 'H.A.L.') ;
INSERT INTO FOURNISSEUR (FournisseurId, FournisseurNom) VALUES (7, 'Poèmes en gros SARL') ;
 
SELECT '' AS 'FOURNISSEUR', * FROM FOURNISSEUR ;

TABLE ARTICLE

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
CREATE TABLE ARTICLE 
(
        ArticleId            INT                  NOT NULL
      , ArticleNom           VARCHAR(48)          NOT NULL
      , RayonId              INT                  NOT NULL
    , CONSTRAINT ARTICLE_PK PRIMARY KEY (ArticleId)
    , CONSTRAINT ARTICLE_RAYON_FK FOREIGN KEY (RayonId)
          REFERENCES RAYON 
) ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (1, 1, 'Imprimante Laser IQ') ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (2, 1, 'Imprimante à aiguilles XYZ') ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (3, 1, 'Ecran 12"') ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (4, 4, 'Ecran 14"') ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (5, 1, 'Tablette') ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (6, 2, 'La méthode à Fernand') ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (7, 2, 'La vie d’une brique dans un mur') ;
INSERT INTO ARTICLE (ArticleId, RayonId, ArticleNom) VALUES (8, 3, 'Léonin, concerto en Do majeur') ;
 
SELECT '' AS 'ARTICLE', * FROM ARTICLE ;

TABLE CATALOGUE

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
CREATE TABLE CATALOGUE
(
        ArticleId            INT                  NOT NULL
      , FournisseurId        INT                  NOT NULL
    , CONSTRAINT CATALOGUE_PK PRIMARY KEY (ArticleId, FournisseurId)
    , CONSTRAINT CATALOGUE_ARTICLE_FK FOREIGN KEY (ArticleId) 
          REFERENCES ARTICLE
    , CONSTRAINT CATALOGUE_FOURNISSEUR_FK FOREIGN KEY (FournisseurId) 
          REFERENCES FOURNISSEUR
) ; 
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (1, 2) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (1, 4) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (1, 5) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (1, 6) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (2, 4) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (2, 5) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (2, 6) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (4, 3) ;
INSERT INTO CATALOGUE (ArticleId, FournisseurId) VALUES (4, 4) ;
 
SELECT '' AS 'CATALOGUE', * FROM CATALOGUE ;

TABLE COMMANDE

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
CREATE TABLE COMMANDE 
(
        CommandeId           INT                  NOT NULL
      , UtilisateurId        INT                  NOT NULL
      , CommandeDate         DATETIME             NOT NULL
    , CONSTRAINT COMMANDE_PK PRIMARY KEY (CommandeId)
    , CONSTRAINT COMMANDE_CHEF_RAYON_FK FOREIGN KEY (UtilisateurId)
          REFERENCES CHEF_RAYON 
) ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (1, 2, '2000-01-15') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (2, 3, '2000-01-27') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (3, 2, '2000-02-11') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (4, 2, '2000-02-12') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (5, 2, '2000-12-03') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (6, 2, '2001-07-14') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (7, 3, '2000-04-01') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (8, 2, '2002-01-01') ;
 
SELECT '' AS 'COMMANDE', * FROM COMMANDE ;

Table COMMANDE_INTERNE

Code SQL :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
CREATE TABLE COMMANDE_INTERNE 
(
        CommandeId           INT                  NOT NULL
      , CommandeIntNo        VARCHAR(16)          NOT NULL
    , CONSTRAINT COMMANDE_INTERNE_PK PRIMARY KEY (CommandeId)
    , CONSTRAINT COMMANDE_INTERNE_AK UNIQUE (CommandeIntNo)
    , CONSTRAINT COMMANDE_INTERNE_COMMANDE_FK FOREIGN KEY (CommandeId)
          REFERENCES COMMANDE ON DELETE CASCADE
) ;
INSERT INTO COMMANDE_INTERNE (CommandeId, CommandeIntNo) VALUES (1, 'I-2000-0012345') ;
INSERT INTO COMMANDE_INTERNE (CommandeId, CommandeIntNo) VALUES (5, 'I-2000-0045671') ;
 
SELECT '' AS 'COMMANDE_INTERNE', * FROM COMMANDE_INTERNE ;

TABLE COMMANDE_EXTERNE

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
CREATE TABLE COMMANDE_EXTERNE 
(
        CommandeId           INT                  NOT NULL
      , CommandeExtNo        VARCHAR(16)          NOT NULL
      , FournisseurId        INT                  NOT NULL
    , CONSTRAINT COMMANDE_EXTERNE_PK PRIMARY KEY (CommandeId)
    , CONSTRAINT COMMANDE_EXTERNE_AK UNIQUE (CommandeExtNo)
    , CONSTRAINT COMMANDE_EXTERNE_COMMANDE_FK FOREIGN KEY (CommandeId)
          REFERENCES COMMANDE ON DELETE CASCADE
    , CONSTRAINT COMMANDE_EXTERNE_FOURNISSEUR_FK FOREIGN KEY (FournisseurId)
          REFERENCES FOURNISSEUR
) ;
INSERT INTO COMMANDE_EXTERNE (CommandeId, CommandeExtNo, FournisseurId) VALUES (3, 'E-2000-000001', 1) ;
INSERT INTO COMMANDE_EXTERNE (CommandeId, CommandeExtNo, FournisseurId) VALUES (6, 'E-2001-000124', 4) ;
INSERT INTO COMMANDE_EXTERNE (CommandeId, CommandeExtNo, FournisseurId) VALUES (8, 'E-2002-000286', 2) ;
INSERT INTO COMMANDE_EXTERNE (CommandeId, CommandeExtNo, FournisseurId) VALUES (7, 'E-2000-000478', 2) ;
 
SELECT '' AS 'COMMANDE_EXTERNE', * FROM COMMANDE_EXTERNE ;

Table LIGNE_COMMANDE

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
CREATE TABLE LIGNE_COMMANDE 
(
        CommandeId           INT                  NOT NULL
      , LigneCdeId           INT                  NOT NULL
      , ArticleId            INT                  NOT NULL
      , Quantite             INT                  NOT NULL
    , CONSTRAINT LIGNE_COMMANDE_PK PRIMARY KEY (CommandeId, LigneCdeId)
    , CONSTRAINT LIGNE_COMMANDE_COMMANDE_FK FOREIGN KEY (CommandeId)
          REFERENCES COMMANDE ON DELETE CASCADE
    , CONSTRAINT LIGNE_COMMANDE_ARTICLE_FK FOREIGN KEY (ArticleId)
          REFERENCES ARTICLE
) ;
 
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, Quantite) VALUES (1, 1, 1, 10) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, Quantite) VALUES (3, 1, 1, 3) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, Quantite) VALUES (3, 2, 5, 4) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, Quantite) VALUES (6, 1, 3, 2) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, Quantite) VALUES (7, 1, 6, 10) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, Quantite) VALUES (8, 1, 6, 4) ; -- Le trigger doit réagir !
 
SELECT '' AS 'LIGNE_COMMANDE', * FROM LIGNE_COMMANDE ;

Un trigger (pour INSERT) chargé de contrôler qu’un utilisateur ne commande pas d’article déjà présent dans le rayon d’un collègue (prévoir un trigger pour les updates) :

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
CREATE TRIGGER LIGNE_COMMANDE_TRIGGER_INSERT ON LIGNE_COMMANDE INSTEAD OF INSERT AS
    DECLARE @N AS INT ; 
 
    SET @N = (SELECT COUNT(*)
              FROM   INSERTED AS a JOIN ARTICLE AS b ON a.ArticleId = b.ArticleId
                                   JOIN COMMANDE AS c ON a.CommandeId = c.CommandeId
                                   JOIN RAYON AS d ON b.RayonId = d.RayonId
              WHERE  d.UtilisateurId <> c.UtilisateurId 
             ) 
    IF @N > 0
        BEGIN
            RAISERROR ('un utilisateur n’a pas le droit de commander des articles qu’un autre utilisateur a en rayon !', 16, 1)
            RETURN
        END
    INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, Quantite)
        SELECT CommandeId, LigneCdeId, ArticleId, Quantite
        FROM INSERTED ;

Quelques requêtes :

Les articles du rayon de Raoul

Code SQL :

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

1
2
3
4
5
SELECT UtilisateurNom, RayonNom, ArticleNom 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId
                       JOIN RAYON AS c ON a.UtilisateurId = c.UtilisateurId  
                       JOIN ARTICLE AS d ON c.RayonId = d.RayonId
WHERE UtilisateurNom = 'Raoul' ;

Les commandes internes

Code SQL :

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

1
2
3
4
5
6
7
SELECT UtilisateurNom, RayonNom, CommandeIntNo, CommandeDate, ArticleNom, Quantite 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId 
                       JOIN RAYON AS c ON a.UtilisateurId = c.UtilisateurId  
                       JOIN COMMANDE AS d ON a.UtilisateurId = d.UtilisateurId 
                       JOIN COMMANDE_INTERNE AS e ON d.CommandeId = e.CommandeId
                       JOIN LIGNE_COMMANDE AS f ON d.CommandeId = f.CommandeId
                       JOIN ARTICLE AS g ON f.ArticleId = g.ArticleId ;

Les commandes externes

Code SQL :

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

1
2
3
4
5
6
7
8
SELECT UtilisateurNom, RayonNom, FournisseurNom, CommandeExtNo, CommandeDate, ArticleNom, Quantite 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId 
                       JOIN RAYON AS c ON a.UtilisateurId = c.UtilisateurId 
                       JOIN COMMANDE AS d ON a.UtilisateurId = d.UtilisateurId 
                       JOIN COMMANDE_EXTERNE AS e ON d.CommandeId = e.CommandeId
                       JOIN FOURNISSEUR AS f ON e.FournisseurId = f.FournisseurId  
                       JOIN LIGNE_COMMANDE AS g ON d.CommandeId = g.CommandeId
                       JOIN ARTICLE AS h ON g.ArticleId = h.ArticleId ;

Les articles commandés en externe par Raoul

Code SQL :

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

1
2
3
4
5
6
7
SELECT FournisseurNom, ArticleNom
FROM   FOURNISSEUR AS a JOIN COMMANDE_EXTERNE AS b ON a.FournisseurId = b.FournisseurId
                        JOIN COMMANDE AS c ON b.CommandeId = c.CommandeId  
                        JOIN LIGNE_COMMANDE AS d ON c.CommandeId = d.CommandeId
                        JOIN ARTICLE AS e ON d.ArticleId = e.ArticleId
                        JOIN UTILISATEUR AS f ON c.UtilisateurId = f.UtilisateurId
WHERE  f.UtilisateurNom = 'Raoul' ;

Je constate que vous testez divers outils de modélisation : MySQL Workbench (gratuit) sera-t-il le prochain ?

Votre SGBD ?

[Kropernic]

D’accord Kro, mais il y a un problème : le camarade Hicham n’a pas mis FOURNISSEUR et ARTICLE en relation... Cela dit, il pourrait être opportun de le faire au cas où effectivement un utilisateur aimerait mémoriser et donc savoir quels sont les fournisseurs ayant quels articles proposés dans leur catalogue.

Ca tombe bien vu que c'est ce qu'il demandait comment faire

[asetabularia258100]

effectivement j'ai tester pas mal d'outils de modélisation ,mon SGBD est mysql 5.2 .

encore une dernière question si vous le permettez , es-que c'est possible d'avoir une clé étrangère qui peut être NULL dans certain cas ?, et aussi j'aimerai savoir pour la table ligne_commande , elle sera remplie par tout les type de ligne c'est à dire les entrantes et les ligne sortantes de l'entrepôt , donc donc un attribut type_ligne sera créer je pense ! , après je me demander comment je vais savoir ou ce trouve cette ligne de commande à un moment donné , Je m'explique :
imaginons que j'ai fait une commande qui est externe , dans cette commande j'ai 2 ligne de commande (produit A avec quantité 100,entrée || produit B avec quantité 150,entrée), après un bout de temps j'ai décider d’alimenter mon rayon par la première ligne , donc j'effectue une commande interne qui crée une ligne_commande sortie (produit A avec quantité 100,sortie),mais le problème ici c'est que la quantité sortie reste toujours parmi les entrées se qui est bien puisque je dois aussi connaitre mes entrées et mes sorties même après leurs disparitions du stock , ne croyez vous pas je dois ajouter un attribut "emplacement" pour les lignes entrées pour savoir si cette ligne qui est entrée est toujours dans mon entrepôt ou bien quelle ne les plus (donc elle est passé au rayon) ???

MERCI infiniment !

[Kropernic]

encore une dernière question si vous le permettez , es-que c'est possible d'avoir une clé étrangère qui peut être NULL dans certain cas ?,

Techniquement, c'est possible. Mais en général, c'est qu'il y a un souci au niveau de la modélisation et fsmrel va sortir sa sulfateuse anti NULL.

et aussi j'aimerai savoir pour la table ligne_commande , elle sera remplie par tout les type de ligne c'est à dire les entrantes et les ligne sortantes de l'entrepôt , donc donc un attribut type_ligne sera créer je pense !

Pas besoin d'attribut type_ligne. Chaque ligne de commande fait référence à une commande via la clef primaire de la-dite commande. Et cette commande, on peut savoir facilement de quel genre en particulier il s'agit. On sait donc de quel type est la ligne.

, après je me demander comment je vais savoir ou ce trouve cette ligne de commande à un moment donné , Je m'explique :
imaginons que j'ai fait une commande qui est externe , dans cette commande j'ai 2 ligne de commande (produit A avec quantité 100,entrée || produit B avec quantité 150,entrée), après un bout de temps j'ai décider d’alimenter mon rayon par la première ligne , donc j'effectue une commande interne qui crée une ligne_commande sortie (produit A avec quantité 100,sortie),mais le problème ici c'est que la quantité sortie reste toujours parmi les entrées se qui est bien puisque je dois aussi connaitre mes entrées et mes sorties même après leurs disparitions du stock , ne croyez vous pas je dois ajouter un attribut "emplacement" pour les lignes entrées pour savoir si cette ligne qui est entrée est toujours dans mon entrepôt ou bien quelle ne les plus (donc elle est passé au rayon) ???

Là c'est un sujet plus délicat.

Je préfère laisser fsmrel se prononcer là dessus. Je visualise comment je ferais mais arriver à l'expliquer, c'est autre chose. Et comme disait Einstein (enfin je crois que c'est lui), si je n'arrive pas à l'expliquer, c'est que je n'ai pas bien compris.

MERCI infiniment !

Avec plaisir

[fsmrel]

Bonsoir Hicham et Kropernic,

effectivement j'ai tester pas mal d'outils de modélisation

SI MySQL Workbench vous inspire, on pourra vous aider. J’avais même fourni un exemple à Krop, à propos des sorties du stock...

, mon SGBD est mysql 5.2.

Mauvaise pioche... Pas de possibilité de mise en œuvre de triggers sur des vues, pas de clés alternatives (obligation d’en passer par la quincaillerie des index qui devrait rester sous le capot, le mot « index » n’a pas à figurer dans l’instruction CREATE TABLE qui est du niveau logique, qui rejoint la théorie des ensembles quand on grimpe au niveau du Modèle Relationnel de Données aka théorie relationnelle), etc. Hélas ! Au niveau SQL vous en serez probablement réduit à fondre en une seule table RAYON et CHEF_RAYON.

es-que c'est possible d'avoir une clé étrangère qui peut être NULL dans certain cas ?

Comme dit Krop, c’est un truc à ce que je sorte ma sulfateuse à Null. Je vis en Relationland et le bonhomme Null y est hors-la-loi, car il fiche la zoubia dans la logique : avec lui, une tautologie du genre « Je chante si et seulement si je chante » n’en est plus une, il arrive à mettre en échec le théorème de Heath, il cherche à faire dérailler les systèmes experts des moteurs relationnels, etc. : voyez ici. Soit vous voulez bâtir façon Naf-Naf et l’on vous y aidera, ou bien Nif-Nif et Nouf-Nouf et là...

j’aimerai savoir pour la table ligne_commande, elle sera remplie par tout les type de ligne c'est à dire les entrantes et les lignes sortantes de l’entrepôt, donc un attribut type_ligne sera créer je pense !

Comme dit Krop, certes non. Avez-vous examiné les requêtes SQL que je vous ai proposées ? N’avez-vous pas vu comment on fait le distinguo entre les lignes des commandes internes et externes ? En définissant un attribut Type_ligne, vous créeriez une redondance funeste, et la redondance est un ennemi redoutable, allié inconditionnel du bonhomme Null...

Un rappel :

Sélectionner les commandes internes

Code SQL :

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

1
2
3
4
5
6
7
SELECT UtilisateurNom, RayonNom, CommandeIntNo, CommandeDate, ArticleNom, Quantite 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId 
                       JOIN RAYON AS c ON a.UtilisateurId = c.UtilisateurId  
                       JOIN COMMANDE AS d ON a.UtilisateurId = d.UtilisateurId 
                       JOIN COMMANDE_INTERNE AS e ON d.CommandeId = e.CommandeId
                       JOIN LIGNE_COMMANDE AS f ON d.CommandeId = f.CommandeId
                       JOIN ARTICLE AS g ON f.ArticleId = g.ArticleId ;

Sélectionner les commandes externes

Code SQL :

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

1
2
3
4
5
6
7
8
SELECT UtilisateurNom, RayonNom, FournisseurNom, CommandeExtNo, CommandeDate, ArticleNom, Quantite 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId 
                       JOIN RAYON AS c ON a.UtilisateurId = c.UtilisateurId 
                       JOIN COMMANDE AS d ON a.UtilisateurId = d.UtilisateurId 
                       JOIN COMMANDE_EXTERNE AS e ON d.CommandeId = e.CommandeId
                       JOIN FOURNISSEUR AS f ON e.FournisseurId = f.FournisseurId  
                       JOIN LIGNE_COMMANDE AS g ON d.CommandeId = g.CommandeId
                       JOIN ARTICLE AS h ON g.ArticleId = h.ArticleId ;

Sélectionner les articles commandés en externe par Raoul

Code SQL :

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

1
2
3
4
5
6
7
SELECT FournisseurNom, ArticleNom
FROM   FOURNISSEUR AS a JOIN COMMANDE_EXTERNE AS b ON a.FournisseurId = b.FournisseurId
                        JOIN COMMANDE AS c ON b.CommandeId = c.CommandeId  
                        JOIN LIGNE_COMMANDE AS d ON c.CommandeId = d.CommandeId
                        JOIN ARTICLE AS e ON d.ArticleId = e.ArticleId
                        JOIN UTILISATEUR AS f ON c.UtilisateurId = f.UtilisateurId
WHERE  f.UtilisateurNom = 'Raoul' ;

ne croyez vous pas je dois ajouter un attribut "emplacement pour les lignes entrées pour savoir si cette ligne qui est entrée est toujours dans mon entrepôt ou bien quelle ne les plus (donc elle est passé au rayon) ???"

Je préfère laisser fsmrel se prononcer là dessus.

Krop me refile la patate chaude (chouette, on va faire des frites ! ) mais normalement il devrait être désormais le roi de la modélisation des stocks.

Quoi qu’il en soit, pour savoir si les articles d’une ligne sont arrivés dans un rayon, il faut en faire un suivi.

On peut détailler la réception des articles, lesquels peuvent du reste arriver en plusieurs fois, selon une quantité qui n’est pas forcément celle de la ligne de commande (externe ou interne). A cette fin on peut définir une entité-type RECEPTION :



Tout comme LIGNE_COMMANDE est une propriété multivaluée de COMMANDE, RECEPTION est une propriété multivaluée de LIGNE_COMMANDE.


Structure SQL de la table RECEPTION (avec DB2 ou MS SQL Server) :

Code SQL :

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

1
2
3
4
5
6
7
8
9
10
11
CREATE TABLE RECEPTION 
(
        CommandeId           INT                  NOT NULL
      , LigneCdeId           INT                  NOT NULL
      , ReceptionId          INT                  NOT NULL
      , ReceptionDate        DATETIME             NOT NULL
      , ReceptionQuantite    INT                  NOT NULL
    , CONSTRAINT RECEPTION_PK PRIMARY KEY (CommandeId, LigneCdeId, ReceptionId)
    , CONSTRAINT RECEPTION_LIGNE_COMMANDE_FK FOREIGN KEY (CommandeId, LigneCdeId)
          REFERENCES LIGNE_COMMANDE ON DELETE CASCADE
) ;

La mise en œuvre de cette entité-type permet de dérouler des scénarios dans le genre de celui-ci :

Le 10/02/2000, Raoul qui a été nommé chef du rayon Informatique n’a rien en magasin. Le 11/02/2000, Raoul commande chez MicroMiniMacroSoft 9 imprimantes laser IQ et 4 tablettes. Le 12/02/2000, il commande 5 tablettes chez Dugoineau.

=>

Code SQL :

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

1
2
3
4
5
6
7
8
9
10
 
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (3, 2, '2000-02-11') ;
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (4, 2, '2000-02-12') ;
 
INSERT INTO COMMANDE_EXTERNE (CommandeId, CommandeExtNo, FournisseurId) VALUES (3, 'E-2000-000001', 1) ;
INSERT INTO COMMANDE_EXTERNE (CommandeId, CommandeExtNo, FournisseurId) VALUES (4, 'E-2000-000012', 4) ;
 
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, LigneCdeQuantite) VALUES (3, 1, 1, 9) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, LigneCdeQuantite) VALUES (3, 2, 5, 4) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, LigneCdeQuantite) VALUES (4, 1, 5, 5) ;

Commandes externes, situation concernant Raoul :

Code SQL :

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

1
2
3
4
5
6
7
SELECT FournisseurNom, CommandeExtNo, CommandeDate, ArticleNom, LigneCdeQuantite 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId 
                       JOIN COMMANDE AS d ON a.UtilisateurId = d.UtilisateurId 
                       JOIN COMMANDE_EXTERNE AS e ON d.CommandeId = e.CommandeId
                       JOIN FOURNISSEUR AS f ON e.FournisseurId = f.FournisseurId  
                       JOIN LIGNE_COMMANDE AS g ON d.CommandeId = g.CommandeId
                       JOIN ARTICLE AS h ON g.ArticleId = h.ArticleId

=>

FournisseurNom            CommandeExtNo    CommandeDate    ArticleNom             LigneCdeQuantite
----------------------    -------------    -----------     -------------------    ----------------
MicroMiniMacroSoft        E-2000-000001    2000-02-11      Imprimante Laser IQ                   9
MicroMiniMacroSoft        E-2000-000001    2000-02-11      Tablette                              4
Dugoineau Informatique    E-2000-000012    2000-02-12      Tablette                              5 

Le 15/02/2000, réception par le magasin de 4 imprimantes et 3 tablettes de chez MicroMiniMacroSoft, ainsi que 2 tablettes de chez Dugoineau.

=>

Code SQL :

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

1
2
3
4
 
INSERT INTO RECEPTION (CommandeId, LigneCdeId, ReceptionId, ReceptionDate, ReceptionQuantite) VALUES (3, 1, 1, '2000-02-15', 4) ;
INSERT INTO RECEPTION (CommandeId, LigneCdeId, ReceptionId, ReceptionDate, ReceptionQuantite) VALUES (3, 2, 1, '2000-02-15', 3) ;
INSERT INTO RECEPTION (CommandeId, LigneCdeId, ReceptionId, ReceptionDate, ReceptionQuantite) VALUES (4, 1, 1, '2000-02-15', 2) ;

Réceptions externes, situation concernant Raoul :

Code SQL :

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

1
2
3
4
5
6
7
8
SELECT FournisseurNom, CommandeExtNo, CommandeDate, ArticleNom, LigneCdeQuantite, ReceptionDate, ReceptionQuantite 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId 
                       JOIN COMMANDE AS d ON a.UtilisateurId = d.UtilisateurId 
                       JOIN COMMANDE_EXTERNE AS e ON d.CommandeId = e.CommandeId
                       JOIN FOURNISSEUR AS f ON e.FournisseurId = f.FournisseurId  
                       JOIN LIGNE_COMMANDE AS g ON d.CommandeId = g.CommandeId
                       JOIN ARTICLE AS h ON g.ArticleId = h.ArticleId
                       JOIN RECEPTION AS i ON g.CommandeId = i.CommandeId AND g.LigneCdeId = i.LigneCdeId

=>

 
FournisseurNom           CommandeExtNo   CommandeDate  ArticleNom            LigneCdeQuantite   ReceptionDate   ReceptionQuantite
----------------------   -------------   ------------  ------------------    ----------------   -------------   -----------------
MicroMiniMacroSoft       E-2000-000001   2000-02-11    Imprimante Laser IQ                  9   2000-02-15                      4
MicroMiniMacroSoft       E-2000-000001   2000-02-11    Tablette                             4   2000-02-15                      3
Dugoineau Informatique   E-2000-000012   2000-02-12    Tablette                             5   2000-02-15                      2 

Tenu au courant, Raoul passe le même jour une commande interne pour tous ces articles.

Code SQL :

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

1
2
3
4
5
 
INSERT INTO COMMANDE (CommandeId, UtilisateurId, CommandeDate) VALUES (5, 2, '2000-02-15') ;
INSERT INTO COMMANDE_INTERNE (CommandeId, CommandeIntNo) VALUES (5, 'I-2000-0000040') ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, LigneCdeQuantite) VALUES (5, 1, 1, 4) ;
INSERT INTO LIGNE_COMMANDE (CommandeId, LigneCdeId, ArticleId, LigneCdeQuantite) VALUES (5, 2, 5, 5) ;

Commandes internes, situation concernant Raoul :

Code SQL :

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

1
2
3
4
5
6
SELECT CommandeIntNo, CommandeDate, ArticleNom, LigneCdeQuantite 
FROM   CHEF_RAYON AS a JOIN UTILISATEUR AS b ON a.UtilisateurId = b.UtilisateurId  
                       JOIN COMMANDE AS d ON a.UtilisateurId = d.UtilisateurId 
                       JOIN COMMANDE_INTERNE AS e ON d.CommandeId = e.CommandeId
                       JOIN LIGNE_COMMANDE AS f ON d.CommandeId = f.CommandeId
                       JOIN ARTICLE AS g ON f.ArticleId = g.ArticleId

=>

 
CommandeIntNo     CommandeDate    ArticleNom             LigneCdeQuantite
--------------    ------------    -------------------    ----------------
I-2000-0000040    2000-02-15      Imprimante Laser IQ                   4
I-2000-0000040    2000-02-15      Tablette                              5 

Le 16/02/2000, Raoul reçoit les 4 imprimantes et les 3 tablettes de chez MicroMiniMacroSoft, mais une seule des 2 tablettes de chez Dugoineau, car entre temps un geste maladroit de la part de Gaston a fait que l’autre a pris un choc.

=>

Code SQL :

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

1
2
INSERT INTO RECEPTION (CommandeId, LigneCdeId, ReceptionId, ReceptionDate, ReceptionQuantite) VALUES (5, 1, 1, '2000-02-16', 4) ;
INSERT INTO RECEPTION (CommandeId, LigneCdeId, ReceptionId, ReceptionDate, ReceptionQuantite) VALUES (5, 2, 1, '2000-02-16', 4) ;

En rayon, on a au 16/02/2000 exactement 4 imprimantes et 4 tablettes.


Réceptions internes, situation concernant Raoul :

CommandeIntNo     CommandeDate    ArticleNom             LigneCdeQuantite    ReceptionDate    ReceptionQuantite
--------------    ------------    -------------------    ----------------    -------------    -----------------
I-2000-0000040    2000-02-15      Imprimante Laser IQ                   4    2000-02-16                       4
I-2000-0000040    2000-02-15      Tablette                              5    2000-02-16                       4

Etc., etc.

Maintenant, libre à l’imagination de chacun de s’exprimer sur ce sujet...

[Kropernic]

Krop me refile la patate chaude (chouette, on va faire des frites ! ) mais normalement il devrait être désormais le roi de la modélisation des stocks.

J'avais préféré ne pas m'avancer car dans mon cas, il y a une ligne par article. Du coup, je craignais que quelques nuances m'échappent.

[asetabularia258100]

merci à vous tous pour votre aide et votre patience !

Hicham

[larry_ngako]

puisqu’un chef de rayon est aussi un utilisateur je ne trouve pas la nécessite de créer une table chef de rayon tu dois faire plutôt une récursivité sur la table utilisilisateur. dans ton LMD tu aurra identifiant de utilisateur dans ta table utilisateur, maintenant tu prendra un comme le chef de rayon et l'autre comme un simple utilisateur de ce fait tu pourra facilement avoir la liste des utilisateur d'un chef de rayon :