IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Schéma Discussion :

Conception d'un MCD pour une assurance automobile


Sujet :

Schéma

  1. #41
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Suite.


    Citation Envoyé par Zidane7 Voir le message
    Effectivement une caissière peut allez dans une autre agence
    Donc en principe, l’entité-type CAISSIERE n’est pas à identifier relativement à AGENCE, mais personne ne pourra vous en vouloir si vous conservez l’identification relative.

    A propos de « A la vie à la mort », un contrat peut-il passer d’une agence à une autre ?


    Citation Envoyé par fsmrel Voir le message
    Quel est votre SGBD ?
    Je repose ma question. Vu la présence du paramètre COUNTER dans votre code SQL, il s’agit a priori de MS ACCESS : merci de confirmer, sinon précisez quel votre véritable SGBD. Pour mémoire, dans mon post précédent j’ai utilisé SQL Server.

    De façon systématique, par référence à votre dernier script SQL, utilisez un identifiant artificiel pour les entités-types suivantes (COUNTER si ACCESS, IDENTITY si SQL Server ou DB2, etc.) :

    SOUS_CATEGORIE (attribut sousCategorieId)

    APPORTEUR

    GARANTIE

    SOUS_GARANTIE

    CONTRAT (attribut contratId, en répercutant sur les tables faisant référence à CONTRAT).


    Prise en compte de NOT NULL

    Je rappelle que les attributs naturels doivent être NOT NULL. Dans votre dernier script SQL, il y a encore des tables ayant des attributs naturels pouvant être marqués NULL :

    APPORTEUR (attributs nomApporteur, prenomApporteur)

    PFC (attribut responsabiliteCivile)

    ENCAISSE_A (attributs montantEncaisse_a, dateEncaisse_a)

    ENCAISSE_C (attributs montantEncaisse_c, dateEncaisse_c)

    Table VEHICULE : l’en-tête de la table VEHICULE contient deux attributs (colonnes en SQL) avec COUNTER (vehiculeId et codevehicule) donc une fois de trop. A corriger. Voir si cela ne se produit pas pour d’autres tables (de toutes façons, le SGBD rouspétera...)

    Table SOUS_CATEGORIE : Du fait que l’attribut codeSousCategorie soit déclaré UNIQUE (clé alternative) conformément à votre tableau des catégories et sous-catégories présenté dans le post #14, dans l’attribut codeSousCategorie la sous-garantie 1 de la garantie 3 doit avoir pour valeur "3-1" et non pas "1". Il sera prudent qu’un trigger contrôle que la partie gauche ("3") soit égale à la valeur ("3") de la catégorie référencée (attribut codeGarantie de la table CATEGORIE). Dans cet exemple, l’alternative consiste à ce que codeSousCategorie prenne seulement la valeur "1", mais en contrepartie que la clause "UNIQUE (codeSousCategorie)" disparaisse.

    Table SOUS_GARANTIE : remarques analogues à celles faites pour la table SOUS_CATEGORIE.
    Dans le MCD, identifier SOUS_GARANTIE relativement à GARANTIE.
    Renommer l’attribut libelleSousGarantieId en libelleSousGarantie.

    Table APPORTEUR : l’attribut apporteurId doit être artificiel (COUNTER dans le cas de MS ACCESS, IDENTITY dans le cas de SQL Server, etc.).

    Table PUISSANCE : vous utilisez le type BIGINT pour l’attribut puissanceMax (numérique 64 bits avec Looping).
    La valeur max pour cet attribut est donc 2^63-1 (9 223 372 036 854 775 807), Soit environ 9 exaoctets... C’est plus qu’astronomique !
    Avec le type INT (numérique 32 bits avec Looping), la valeur max est 2^31-1 (2 147 483 647) ce qui est déjà énorme (un moteur de 2 milliards de chevaux-vapeurs .
    Avec le type SMALLINT (numérique 16 bits avec Looping), la valeur max est 2^15-1 (32 767) ce qui est encore beaucoup et correspond à la puissance d’un gros porte-avions...

    Avec le type DECIMAL(3,0), la puissance peut aller jusqu’à 999 CV, c’est déjà pas mal...

    En passant, utilisez le même type pour les attributs puissanceMin et puissanceMax.

    Le type BIGINT est présent dans d’autres tables : faire les modifications qui s’imposent...
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  2. #42
    Membre à l'essai
    Homme Profil pro
    Développeur Java
    Inscrit en
    Décembre 2019
    Messages
    83
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Guinée

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Décembre 2019
    Messages : 83
    Points : 23
    Points
    23
    Par défaut Conception d'un MCD pour une assurance automobile
    Bonjour Monsieur fsmrel,
    Concernant les encaissements, ça va mieux. Toutefois, dans la mesure où rien ne fait référence à ENCAISSE_C, vous pouvez conserver l’association ENCAISSE_C comme je l’ai fait, plutôt qu’en faire une entité-type, en tout cas fonctionnellement et sémantiquement ça reste une association.
    Je l'ai fit comme vous m'avez dit. Vous verrez dans le MCD.
    A cette occasion, je reviens sur l’entité-type PFC : fonctionnellement et sémantiquement PFC est une association. Si j’en ai fait une entité-type, c’est parce que l’entité-type VEHICULE est à associer à PFC, mais Merise interdit qu’une association X soit liée à une association Y. C’est une contrainte injustifiée, et on administre donc un remède technique : pour pouvoir associer VEHICULE et PFC, la solution fut de transformer PFC en entité-type. Notez que je n’ai pas défini d’attribut identifiant pfcId ni d’attribut codePFC. L’identifiant de PFC est en réalité la paire {puissanceId, catId}, héritée des entités-types PUISSANCE et CATEGORIE. En l’absence d’identifiant déclaré pfcId, l’identifiant alternatif codePFC n’a pas de raison d’être.
    Pour en revenir à ENCAISSE_C, si vous tenez vraiment à en faire une entité-type, soit, mais faites comme j’ai fait pour PFC, supprimez les attributs encaisse_cid et codeencaisse_c qui n’apportent rien et au contraire alourdissent inutilement le modèle.
    Fait comme vous m'avez indiqué.
    Passons à SQL.

    Pour simplifier, je n’utilise ci-dessous que les tables concernant les encaissements des contrats (j’ai donc débarrassé la table CONTRAT des références à CLIENT et VEHICULE).

    J’ai utilisé SQL Server, donc son mode d’auto-incrémentation, à savoir IDENTITY.

    Les tables :
    CREATE TABLE AGENCE
    (
    agenceId INT IDENTITY,
    codeAgence VARCHAR(3) NOT NULL,
    nomAgence VARCHAR(50) NOT NULL,
    dateCreation DATE NOT NULL,
    CONSTRAINT AGENCE_PK PRIMARY KEY(agenceId),
    CONSTRAINT AGENCE_UK UNIQUE(codeagence)
    );

    CREATE TABLE CAISSIERE
    (
    caissiereId INT IDENTITY,
    codeCaissiere VARCHAR(6) NOT NULL,
    prenomCaissiere VARCHAR(40) NOT NULL,
    nomCaissiere VARCHAR(40) NOT NULL,
    agenceId INT NOT NULL,
    CONSTRAINT CAISSIERE_PK PRIMARY KEY (caissiereId),
    CONSTRAINT CAISSIERE_UK UNIQUE(codeCaissiere),
    CONSTRAINT CAISSIERE_AGENCE_FK FOREIGN KEY(agenceId)
    REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE CONTRAT
    (
    contratId INT IDENTITY,
    codeContrat VARCHAR(10) NOT NULL,
    dateEffetContrat DATE NOT NULL,
    dateExpirationContrat DATE NOT NULL,
    agenceId INT NOT NULL,
    CONSTRAINT CONTRAT_PK PRIMARY KEY(contratId),
    CONSTRAINT CONTRAT_UK UNIQUE(codeContrat),
    CONSTRAINT CONTRAT_AGENCE_FK FOREIGN KEY(agenceId)
    REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE ENCAISSE_C
    (
    contratId INT,
    caissiereId INT,
    dateEncaisse DATE NOT NULL,
    montantEncaisse INT NOT NULL,
    PRIMARY KEY(contratId, caissiereId),
    FOREIGN KEY(caissiereId) REFERENCES CAISSIERE(caissiereId),
    FOREIGN KEY(contratId) REFERENCES CONTRAT(contratId)
    );
    Un début de jeu d’essai :
    INSERT INTO AGENCE (codeAgence, nomAgence, dateCreation)
    VALUES
    ('ag1', 'Agence 1', '1990-01-02')
    , ('ag2', 'Agence 2', '1990-01-02')
    , ('ag3', 'Agence 3', '1998-01-02')
    ;
    INSERT INTO CONTRAT (codeContrat, dateEffetContrat, dateExpirationContrat, agenceId)
    VALUES
    ('ctr01', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag2'))
    , ('ctr02', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag3'))
    , ('ctr03', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag3'))
    ;
    INSERT INTO CAISSIERE (codeCaissiere, prenomCaissiere, nomCaissiere, agenceId)
    VALUES
    ('cai01', 'Julie', 'Dupont', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag1'))
    , ('cai02', 'Rose', 'Bonbon', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag1'))
    , ('cai03', 'Maud', 'Durand', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag2'))
    ;
    INSERT INTO ENCAISSE_C (contratId, caissiereId, dateEncaisse, montantEncaisse)
    VALUES
    ((SELECT contratId FROM CONTRAT WHERE codeContrat = 'ctr01')
    Ce que vous avez donné est normal mais quand j'exécute le Script Sql dans looping voici le code que cela me donne:
    Code SQL
    CREATE TABLE CATEGORIE(
    categorieId COUNTER,
    codecategorie VARCHAR(4) NOT NULL,
    libelleCategorie VARCHAR(50) NOT NULL,
    nombreplacecategorie INT,
    PRIMARY KEY(categorieId),
    UNIQUE(codecategorie)
    );

    CREATE TABLE CLIENT(
    clientId COUNTER,
    codeclient VARCHAR(10) NOT NULL,
    nomClient VARCHAR(50) NOT NULL,
    prenomClient VARCHAR(50) NOT NULL,
    adresseClient VARCHAR(50) NOT NULL,
    telephoneClient VARCHAR(30) NOT NULL,
    PRIMARY KEY(clientId),
    UNIQUE(codeclient)
    );

    CREATE TABLE APPORTEUR(
    apporteurId CHAR(8),
    codeapporteur VARCHAR(5) NOT NULL,
    nomApporteur VARCHAR(50),
    prenomApporteur VARCHAR(50),
    PRIMARY KEY(apporteurId),
    UNIQUE(codeapporteur)
    );

    CREATE TABLE TYPECONTRAT(
    typeContratId COUNTER,
    codetypecontrat VARCHAR(2) NOT NULL,
    libelleTypeContrat VARCHAR(50) NOT NULL,
    PRIMARY KEY(typeContratId),
    UNIQUE(codetypecontrat)
    );

    CREATE TABLE GARANTIE(
    garantieId CHAR(3),
    codegarantie VARCHAR(2) NOT NULL,
    Libelle_Garantie VARCHAR(50) NOT NULL,
    PRIMARY KEY(garantieId),
    UNIQUE(codegarantie)
    );

    CREATE TABLE Sous_Garantie(
    sousGarantieId CHAR(5),
    codesousgarantie VARCHAR(2) NOT NULL,
    libelleSousGarantieId VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    garantieId CHAR(3) NOT NULL,
    PRIMARY KEY(sousGarantieId),
    UNIQUE(codesousgarantie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE PUISSANCE(
    puissanceId COUNTER,
    codepuissance VARCHAR(3) NOT NULL,
    puissanceMin INT NOT NULL,
    puissanceMax BIGINT NOT NULL,
    PRIMARY KEY(puissanceId),
    UNIQUE(codepuissance)
    );

    CREATE TABLE PFC(
    categorieId INT,
    puissanceId INT,
    responsabilitecivile VARCHAR(50),
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(puissanceId) REFERENCES PUISSANCE(puissanceId)
    );

    CREATE TABLE AGENCE(
    agenceId COUNTER,
    codeagence VARCHAR(3) NOT NULL,
    nomAgence VARCHAR(50) NOT NULL,
    dateCreation DATE NOT NULL,
    PRIMARY KEY(agenceId),
    UNIQUE(codeagence)
    );

    CREATE TABLE SOUS_CATEGORIE(
    categorieId INT,
    souscategorieId INT,
    codesouscategorie VARCHAR(4) NOT NULL,
    libelleSousCategorie VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, souscategorieId),
    UNIQUE(codesouscategorie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId)
    );

    CREATE TABLE PFC_SC(
    categorieId INT,
    puissanceId INT,
    categorieId_1 INT NOT NULL,
    souscategorieId INT NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId),
    FOREIGN KEY(categorieId_1, souscategorieId) REFERENCES SOUS_CATEGORIE(categorieId, souscategorieId)
    );

    CREATE TABLE CAISSIERE(
    agenceId INT,
    caissiereId COUNTER,
    codecaissiere VARCHAR(4) NOT NULL,
    prenomcaissiere VARCHAR(40) NOT NULL,
    nomcaissiere VARCHAR(40) NOT NULL,
    PRIMARY KEY(agenceId, caissiereId),
    UNIQUE(codecaissiere),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE VEHICULE(
    vehiculeId COUNTER,
    codevehicule COUNTER NOT NULL,
    marque VARCHAR(50) NOT NULL,
    type VARCHAR(50) NOT NULL,
    energie VARCHAR(15) NOT NULL,
    serie VARCHAR(40) NOT NULL,
    vpuissance INT NOT NULL,
    nombreDePlaceCarteGrise INT NOT NULL,
    nombreDePlaceCabine BIGINT NOT NULL,
    categorieId INT NOT NULL,
    puissanceId INT NOT NULL,
    PRIMARY KEY(vehiculeId),
    UNIQUE(codevehicule),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId)
    );

    CREATE TABLE PRODUCTEUR(
    agenceId INT,
    producteurId COUNTER,
    codeproducteur VARCHAR(5) NOT NULL,
    Nomproducteur VARCHAR(50) NOT NULL,
    Prenomprodcteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(agenceId, producteurId),
    UNIQUE(codeproducteur),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE CONTRAT(
    typeContratId INT,
    contratId CHAR(10),
    codecontrat VARCHAR(10) NOT NULL,
    dateEffetContrat DATE,
    dateExpirationContrat DATE,
    apporteurId CHAR(8),
    agenceId INT NOT NULL,
    agenceId_1 INT NOT NULL,
    producteurId INT NOT NULL,
    vehiculeId INT NOT NULL,
    clientId INT NOT NULL,
    PRIMARY KEY(typeContratId, contratId),
    UNIQUE(codecontrat),
    FOREIGN KEY(typeContratId) REFERENCES TYPECONTRAT(typeContratId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId),
    FOREIGN KEY(agenceId_1, producteurId) REFERENCES PRODUCTEUR(agenceId, producteurId),
    FOREIGN KEY(vehiculeId) REFERENCES VEHICULE(vehiculeId),
    FOREIGN KEY(clientId) REFERENCES CLIENT(clientId)
    );

    CREATE TABLE AVENANT(
    avenantId COUNTER,
    codeavenant VARCHAR(10) NOT NULL,
    libelleAvenant VARCHAR(50) NOT NULL,
    dateEffetAvenant DATE,
    dateExpirationAvenant DATE,
    apporteurId CHAR(8),
    typeContratId INT NOT NULL,
    contratId CHAR(10) NOT NULL,
    PRIMARY KEY(avenantId),
    UNIQUE(codeavenant),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId)
    );

    CREATE TABLE PROTEGER(
    categorieId INT,
    garantieId CHAR(3),
    PRIMARY KEY(categorieId, garantieId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ASSOCIER(
    typeContratId INT,
    contratId CHAR(10),
    garantieId CHAR(3),
    PRIMARY KEY(typeContratId, contratId, garantieId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ENCAISSE_C(
    typeContratId INT,
    contratId CHAR(10),
    agenceId INT,
    caissiereId INT,
    dateEncaisseC DATE NOT NULL,
    montantEncaisseC BIGINT NOT NULL,
    PRIMARY KEY(typeContratId, contratId, agenceId, caissiereId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );

    CREATE TABLE ENCAISSE_A(
    avenantId INT,
    agenceId INT,
    caissiereId INT,
    dateEncaisseA DATE NOT NULL,
    montantEncaisseA BIGINT NOT NULL,
    PRIMARY KEY(avenantId, agenceId, caissiereId),
    FOREIGN KEY(avenantId) REFERENCES AVENANT(avenantId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );
    Vous pouvez essayé vous obtiendrez le même code.
    Voici le Schéma MCD en question.
    Merci infiniment pour votre soutien.
    Images attachées Images attachées  

  3. #43
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonsoir Zidane7,

    Au sujet des avenants


    A ma question :

    Citation Envoyé par fsmrel Voir le message
    Un avenant peut-il ne pas dépendre à la vie à la mort d’un contrat ?

    Vous répondez :

    Citation Envoyé par Zidane7 Voir le message
    Un avenant concerne un et un seul contrat
    Ça on le sait depuis le post #1 (cf. le MCD dans ce post).


    Quand je dis « à la vie à la mort », je répète ce que j’ai écrit :

    Citation Envoyé par fsmrel Voir le message
    Autrement dit, un avenant donné peut-il concerner un contrat C1 puis un contrat C2 ?
    Si la réponse à cette question est négative, alors c’est bien « à la vie à la mort », et l’entité-type AVENANT est une propriété (facultative) multivaluée de CONTRAT. Techniquement, cela implique l’identification relative :

    [CONTRAT]---0,N---(A)---1,1(R)---[AVENANT]


    En SQL (SQL Server) :

    CREATE TABLE AVENANT
    (
    contratId               INT           NOT NULL,
    avenantId               INT  IDENTITY,         
    codeAvenant             VARCHAR(10)   NOT NULL,
    libelleAvenant          VARCHAR(50)   NOT NULL,
    dateEffetAvenant        DATE          NOT NULL,
    dateExpirationAvenant   DATE          NOT NULL,
    CONSTRAINT AVENANT_PK PRIMARY KEY(contratId, avenantId),
    CONSTRAINT AVENANT_UK UNIQUE(codeAvenant),
    CONSTRAINT AVENANT_CONTRAT_FK FOREIGN KEY(contratId) 
        REFERENCES CONTRAT(contratId)
    );
    Un bout de jeu d’essai :

    INSERT INTO AVENANT (contratId, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr01')
      , 'av001-a', 'avenant 001-a', '2019-01-01', '2019-07-31'
    )
    ,
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr01')
      , 'av001-b', 'avenant 001-b', '2019-02-01', '2019-08-31'
    ) ;
    
    INSERT INTO AVENANT (contratId, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr02')
      , 'av002', 'avenant 002', '2019-01-01', '2019-12-31'
    ) ;
    
    INSERT INTO AVENANT (contratId, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr03')
      , 'av003', 'avenant 003', '2019-01-01', '2019-12-31'
    ) ;
    Pour voir :

    SELECT codeContrat, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant 
    FROM   CONTRAT as x JOIN AVENANT as y ON x.contratId = y.contratId
    ;
    =>

    codeContrat   codeAvenant   libelleAvenant   dateEffetAvenant   dateExpirationAvenant
    ctr01         av001-a       avenant 001-a    2019-01-01         2019-07-31
    ctr01         av001-b       avenant 001-b    2019-01-01         2019-07-31
    ctr02         av002         avenant 002      2019-01-01         2019-12-31
    ctr03         av003         avenant 003      2019-01-01         2019-12-31
    
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  4. #44
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    J’ai posté ma réponse précédente (post #43) sans avoir vu que vous aviez répondu quelques minutes plus tôt au post #41.

    Je commenterai donc votre réponse (post #42).

    Tout d’abord, vous ne m’avez toujours pas précisé quel est votre SGBD.
    Merci de le faire !

    Après cela, on reprendra le cours des choses. Quant aux différences entre votre script SQL et le mien, merci de me signaler les différences.
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  5. #45
    Membre à l'essai
    Homme Profil pro
    Développeur Java
    Inscrit en
    Décembre 2019
    Messages
    83
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Guinée

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Décembre 2019
    Messages : 83
    Points : 23
    Points
    23
    Par défaut Conception d'un MCD pour une assurance automobile
    Bonjour Monsieur fsmrel ?
    Je viens de faire les modifications sur le schéma et le code SQL.
    Voir code SQL ci-dessous:
    CREATE TABLE CATEGORIE(
    categorieId INT,
    codecategorie CHAR(4) NOT NULL,
    libelleCategorie VARCHAR(50) NOT NULL,
    nombreplacecategorie INT NOT NULL,
    PRIMARY KEY(categorieId),
    UNIQUE(codecategorie)
    );

    CREATE TABLE CLIENT(
    clientId INT,
    codeclient VARCHAR(10) NOT NULL,
    nomClient VARCHAR(50) NOT NULL,
    prenomClient VARCHAR(50) NOT NULL,
    adresseClient VARCHAR(50) NOT NULL,
    telephoneClient VARCHAR(30) NOT NULL,
    PRIMARY KEY(clientId),
    UNIQUE(codeclient)
    );

    CREATE TABLE APPORTEUR(
    apporteurId INT,
    codeapporteur VARCHAR(5) NOT NULL,
    nomApporteur VARCHAR(50) NOT NULL,
    prenomApporteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(apporteurId),
    UNIQUE(codeapporteur)
    );

    CREATE TABLE TYPECONTRAT(
    typeContratId INT,
    codetypecontrat CHAR(2) NOT NULL,
    libelleTypeContrat VARCHAR(50) NOT NULL,
    PRIMARY KEY(typeContratId),
    UNIQUE(codetypecontrat)
    );

    CREATE TABLE GARANTIE(
    garantieId INT,
    codegarantie CHAR(2) NOT NULL,
    Libelle_Garantie VARCHAR(50) NOT NULL,
    PRIMARY KEY(garantieId),
    UNIQUE(codegarantie)
    );

    CREATE TABLE Sous_Garantie(
    sousGarantieId INT,
    codesousgarantie CHAR(2) NOT NULL,
    libelleSousGarantieId VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    garantieId INT NOT NULL,
    PRIMARY KEY(sousGarantieId),
    UNIQUE(codesousgarantie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE PUISSANCE(
    puissanceId INT,
    codepuissance VARCHAR(3) NOT NULL,
    puissanceMin INT NOT NULL,
    puissanceMax BIGINT NOT NULL,
    PRIMARY KEY(puissanceId),
    UNIQUE(codepuissance)
    );

    CREATE TABLE PFC(
    categorieId INT,
    puissanceId INT,
    responsabilitecivile VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(puissanceId) REFERENCES PUISSANCE(puissanceId)
    );

    CREATE TABLE AGENCE(
    agenceId INT,
    codeagence VARCHAR(3) NOT NULL,
    nomAgence VARCHAR(50) NOT NULL,
    dateCreation DATE NOT NULL,
    PRIMARY KEY(agenceId),
    UNIQUE(codeagence)
    );

    CREATE TABLE SOUS_CATEGORIE(
    categorieId INT,
    souscategorieId INT,
    codesouscategorie VARCHAR(4) NOT NULL,
    libelleSousCategorie VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, souscategorieId),
    UNIQUE(codesouscategorie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId)
    );

    CREATE TABLE PFC_SC(
    categorieId INT,
    puissanceId INT,
    categorieId_1 INT NOT NULL,
    souscategorieId INT NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId),
    FOREIGN KEY(categorieId_1, souscategorieId) REFERENCES SOUS_CATEGORIE(categorieId, souscategorieId)
    );

    CREATE TABLE CAISSIERE(
    agenceId INT,
    caissiereId INT,
    codecaissiere VARCHAR(4) NOT NULL,
    prenomcaissiere VARCHAR(40) NOT NULL,
    nomcaissiere VARCHAR(40) NOT NULL,
    PRIMARY KEY(agenceId, caissiereId),
    UNIQUE(codecaissiere),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE VEHICULE(
    vehiculeId INT,
    codevehicule CHAR(5) NOT NULL,
    marque VARCHAR(50) NOT NULL,
    type VARCHAR(50) NOT NULL,
    energie VARCHAR(15) NOT NULL,
    serie VARCHAR(40) NOT NULL,
    vehiculepuissance INT NOT NULL,
    nombreDePlaceCarteGrise INT NOT NULL,
    nombreDePlaceCabine BIGINT NOT NULL,
    categorieId INT NOT NULL,
    puissanceId INT NOT NULL,
    PRIMARY KEY(vehiculeId),
    UNIQUE(codevehicule),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId)
    );

    CREATE TABLE AVENANT(
    avenantId INT,
    codeavenant VARCHAR(10) NOT NULL,
    libelleAvenant VARCHAR(50) NOT NULL,
    dateEffetAvenant DATE NOT NULL,
    dateExpirationAvenant DATE NOT NULL,
    apporteurId INT,
    PRIMARY KEY(avenantId),
    UNIQUE(codeavenant),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId)
    );

    CREATE TABLE PRODUCTEUR(
    agenceId INT,
    producteurId INT,
    codeproducteur VARCHAR(5) NOT NULL,
    Nomproducteur VARCHAR(50) NOT NULL,
    Prenomprodcteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(agenceId, producteurId),
    UNIQUE(codeproducteur),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE CONTRAT(
    typeContratId INT,
    contratId INT,
    codecontrat VARCHAR(10) NOT NULL,
    dateEffetContrat DATE NOT NULL,
    dateExpirationContrat DATE NOT NULL,
    apporteurId INT,
    agenceId INT NOT NULL,
    agenceId_1 INT NOT NULL,
    producteurId INT NOT NULL,
    vehiculeId INT NOT NULL,
    clientId INT NOT NULL,
    PRIMARY KEY(typeContratId, contratId),
    UNIQUE(codecontrat),
    FOREIGN KEY(typeContratId) REFERENCES TYPECONTRAT(typeContratId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId),
    FOREIGN KEY(agenceId_1, producteurId) REFERENCES PRODUCTEUR(agenceId, producteurId),
    FOREIGN KEY(vehiculeId) REFERENCES VEHICULE(vehiculeId),
    FOREIGN KEY(clientId) REFERENCES CLIENT(clientId)
    );

    CREATE TABLE A(
    typeContratId INT,
    contratId INT,
    avenantId INT,
    PRIMARY KEY(typeContratId, contratId, avenantId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(avenantId) REFERENCES AVENANT(avenantId)
    );

    CREATE TABLE PROTEGER(
    categorieId INT,
    garantieId INT,
    PRIMARY KEY(categorieId, garantieId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ASSOCIER(
    typeContratId INT,
    contratId INT,
    garantieId INT,
    PRIMARY KEY(typeContratId, contratId, garantieId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ENCAISSE_C(
    typeContratId INT,
    contratId INT,
    agenceId INT,
    caissiereId INT,
    dateEncaisseC DATE NOT NULL,
    montantEncaisseC BIGINT NOT NULL,
    PRIMARY KEY(typeContratId, contratId, agenceId, caissiereId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );

    CREATE TABLE ENCAISSE_A(
    avenantId INT,
    agenceId INT,
    caissiereId INT,
    dateEncaisseA DATE NOT NULL,
    montantEncaisseA BIGINT NOT NULL,
    PRIMARY KEY(avenantId, agenceId, caissiereId),
    FOREIGN KEY(avenantId) REFERENCES AVENANT(avenantId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );
    Par rapport à votre question:
    Au sujet des avenants


    A ma question :
    Envoyé par fsmrel
    Un avenant peut-il ne pas dépendre à la vie à la mort d’un contrat ?

    Vous répondez :
    Envoyé par Zidane7
    Un avenant concerne un et un seul contrat
    Ça on le sait depuis le post #1 (cf. le MCD dans ce post).


    Quand je dis « à la vie à la mort », je répète ce que j’ai écrit :
    Envoyé par fsmrel
    Autrement dit, un avenant donné peut-il concerner un contrat C1 puis un contrat C2 ?
    Si la réponse à cette question est négative, alors c’est bien « à la vie à la mort », et l’entité-type AVENANT est une propriété (facultative) multivaluée de CONTRAT. Techniquement, cela implique l’identification relative :
    [CONTRAT]---0,N---(A)---1,1(R)---[AVENANT]
    Un avenant appartien à un et un seul contrat.
    Deux contrats peuvent avoir un même nom d'avenant mais de nuemero different.
    Je vous demande dans ces condtions que faire?
    C'est comme deux voitures Mercedes 190 qui appartiennent à deux personnes differentes mais si tu regardes les numeros de serie ne sont pas les mêmes.
    Je vous demande dans c'est conditions que faire?
    NB: Une autre personne peut acheter une voiture MERCEDES mais qui n'est pas de la même serie que les deux autres.
    Par rapport votre dernière question:
    J’ai posté ma réponse précédente (post #43) sans avoir vu que vous aviez répondu quelques minutes plus tôt au post #41.

    Je commenterai donc votre réponse (post #42).

    Tout d’abord, vous ne m’avez toujours pas précisé quel est votre SGBD.
    Merci de le faire !

    Après cela, on reprendra le cours des choses. Quant aux différences entre votre script SQL et le mien, merci de me signaler les différences.
    Le SGBD est le SQL SERVER.
    Merci une fois de plus pour votre secours.
    Voici le MCD modifier:
    Images attachées Images attachées  

  6. #46
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonsoir Zidane7,


    Je reprends à nouveau ma remarque :

    Vous ne m’avez toujours pas précisé quel est le SGBD que vous utilisez (ou compterez utiliser).
    Avant quoi que ce soit, merci de le faire !
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  7. #47
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Vous utilisez SQL Server, voilà qui est parfait.

    Je reviens vers vous dès que je peux.

    Courage !
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  8. #48
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Concernant Looping :

    Puisque vous utilisez SQL Server, dans la fenêtre « Propriétés », case « SGBD cible » choisissez « SQL Server ».

    Alors COUNTER (qui concerne MS ACCESS) sera remplacé par IDENTITY.


    Je note que dans votre MCD, un contrat peut avoir plus d’un avenant (cardinalité 0,N portée par la patte connectant l’entité-type CONTRAT et l’association A), mais aussi qu’un avenant donné appartient à au moins un et au plus plusieurs contrats (cardinalité 1,N portée par la patte connectant l’entité-type AVENANT et l’association A), ce qui est en contradiction avec ce que vous avez écrit :

    Citation Envoyé par Zidane7 Voir le message
    Un avenant appartient à un et un seul contrat.

    Poursuivons.

    Citation Envoyé par Zidane7 Voir le message
    Deux contrats peuvent avoir un même nom d'avenant mais de numéro different.

    Qu’appelez-vous un nom d’avenant ? Je vais supposer qu’il d’agit en fait d’un texte descriptif d’un avenant, ce qui revient à la colonne libelleAvenant dans la table AVENANT ci-dessous (revoyez aussi le post #43). Vous remarquerez qu’il n’y a pas de contrainte d’unicité concernant la colonne libelleAvenant, en conséquence de quoi deux avenants ou plus peuvent avoir la même valeur dans la colonne libelleAvenant.

    Code SQL (je ne m’occupe pas des apporteurs des caissières, etc.) :

    CREATE TABLE AGENCE
    (
    agenceId      INT  IDENTITY,
    codeAgence    VARCHAR(3)   NOT NULL,
    nomAgence     VARCHAR(50)  NOT NULL,
    dateCreation  DATE         NOT NULL,
    CONSTRAINT AGENCE_PK PRIMARY KEY(agenceId),
    CONSTRAINT AGENCE_UK UNIQUE(codeagence)
    );
    
    CREATE TABLE CONTRAT
    (
    contratId                INT IDENTITY,
    codeContrat              VARCHAR(10)   NOT NULL,
    dateEffetContrat         DATE          NOT NULL,
    dateExpirationContrat    DATE          NOT NULL,
    agenceId                 INT           NOT NULL,
    CONSTRAINT CONTRAT_PK PRIMARY KEY(contratId),
    CONSTRAINT CONTRAT_UK UNIQUE(codeContrat),
    CONSTRAINT CONTRAT_AGENCE_FK FOREIGN KEY(agenceId) 
        REFERENCES AGENCE(agenceId)
    );
    CREATE TABLE AVENANT
    (
    contratId               INT           NOT NULL,
    avenantId               INT  IDENTITY,         
    codeAvenant             VARCHAR(10)   NOT NULL,
    libelleAvenant          VARCHAR(50)   NOT NULL,
    dateEffetAvenant        DATE          NOT NULL,
    dateExpirationAvenant   DATE          NOT NULL,
    CONSTRAINT AVENANT_PK PRIMARY KEY(contratId, avenantId),
    CONSTRAINT AVENANT_UK UNIQUE(codeAvenant),
    CONSTRAINT AVENANT_CONTRAT_FK FOREIGN KEY(contratId) 
        REFERENCES CONTRAT(contratId)
    );

    Quelques agences :

    INSERT INTO AGENCE (codeAgence, nomAgence, dateCreation)
    VALUES
        ('ag1', 'Agence 1', '1990-01-02')
      , ('ag2', 'Agence 2', '1990-01-02')
      , ('ag3', 'Agence 3', '1998-01-02')
    ;
    SELECT codeAgence, nomAgence, dateCreation 
    FROM   AGENCE ; 
    =>

    agenceId    codeAgence    nomAgence    dateCreation
    1           ag1           Agence 1     1990-01-02
    2           ag2           Agence 2     1990-01-02
    3           ag3           Agence 3     1998-01-02
    

    Quelques contrats :

    INSERT INTO CONTRAT (codeContrat, dateEffetContrat, dateExpirationContrat, agenceId)
    VALUES
        ('ctr01', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag2'))
      , ('ctr02', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag3'))
      , ('ctr03', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag3'))
    ;
    SELECT codeContrat, dateEffetContrat, dateExpirationContrat, codeAgence
    FROM   CONTRAT as x JOIN AGENCE as y ON x.agenceId = y.agenceId   
    ; 
    =>

     
    codeContrat   dateEffetContrat   dateExpirationContrat   codeAgence
    ctr01         2018-01-01         2022-12-31              ag2
    ctr02         2018-01-01         2022-12-31              ag3
    ctr03         2018-01-01         2022-12-31              ag3
    

    Quelques avenants, dont 2 contrats différents, "ctr01" et "ctr02" ont le même libellé, en l’occurence "avenant lambda" :

    INSERT INTO AVENANT (contratId, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr01')
      , 'av001-a', 'avenant spécial', '2019-01-01', '2019-07-31'
    )
    ,
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr01')
      , 'av001-b', 'avenant lambda', '2019-02-01', '2019-08-31'
    )
    ;
    
    INSERT INTO AVENANT (contratId, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr02')
      , 'av002', 'avenant lambda', '2019-01-01', '2019-12-31'
    ) ;
    
    INSERT INTO AVENANT (contratId, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr03')
      , 'av003', 'avenant particulier', '2019-01-01', '2019-12-31'
    ) ;
    
    SELECT codeContrat, codeAvenant, libelleAvenant, dateEffetAvenant, dateExpirationAvenant 
    FROM   CONTRAT as x JOIN AVENANT as y ON x.contratId = y.contratId
    ;
    =>

    codeContrat  codeAvenant  libelleAvenant       dateEffetAvenant  dateExpirationAvenant
    ctr01        av001-a      avenant spécial      2019-01-01        2019-07-31
    ctr01        av001-b      avenant lambda       2019-02-01        2019-08-31
    ctr02        av002        avenant lambda       2019-01-01        2019-12-31
    ctr03        av003        avenant particulier  2019-01-01        2019-12-31
    
    Si vous avez une multitude de libellés d’avenants qui sont les mêmes, vous pouvez en faire une entité-type pour vous simplifier la vie.


    Avez-vous encore des problèmes avec les avenants ? Si oui, donnez des exemples concrets de ce que vous attendez.
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  9. #49
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonjour Zidane7,

    Pour en revenir aux avenants, je rappelle que dans votre MCD, l’association CONTRAT-AVENANT devrait être modélisée ainsi :

    [CONTRAT]---0,N---(A)---1,1(R)---[AVENANT] 
    En tout cas de mon côté c’est ce que j’ai fait, et mon CREATE TABLE AVENANT en est la conséquence (cf. post #48).

    En passant, si vous souhaitez gérer des libellés de types d’avenants souvent utilisés, vous pouvez définir une entité-type ad-hoc, à laquelle ferait référence AVENANT :

    [AVENANT]---1,1---(AVT_LIB)---0,N---[AVENANT_LIBELLE] 
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  10. #50
    Membre à l'essai
    Homme Profil pro
    Développeur Java
    Inscrit en
    Décembre 2019
    Messages
    83
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Guinée

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Décembre 2019
    Messages : 83
    Points : 23
    Points
    23
    Par défaut Conception d'un MCD pour une assurance automobile
    Bonsoir Monsieur fsmrel,
    Je vous montre le code SQL:
    CREATE TABLE CATEGORIE(
    categorieId INT IDENTITY,
    codecategorie CHAR(4) NOT NULL,
    libelleCategorie VARCHAR(50) NOT NULL,
    nombreplacecategorie INT NOT NULL,
    PRIMARY KEY(categorieId),
    UNIQUE(codecategorie)
    );

    CREATE TABLE CLIENT(
    clientId INT IDENTITY,
    codeclient VARCHAR(10) NOT NULL,
    nomClient VARCHAR(50) NOT NULL,
    prenomClient VARCHAR(50) NOT NULL,
    adresseClient VARCHAR(50) NOT NULL,
    telephoneClient VARCHAR(30) NOT NULL,
    PRIMARY KEY(clientId),
    UNIQUE(codeclient)
    );

    CREATE TABLE APPORTEUR(
    apporteurId INT IDENTITY,
    codeapporteur VARCHAR(5) NOT NULL,
    nomApporteur VARCHAR(50) NOT NULL,
    prenomApporteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(apporteurId),
    UNIQUE(codeapporteur)
    );

    CREATE TABLE TYPECONTRAT(
    typeContratId INT IDENTITY,
    codetypecontrat CHAR(2) NOT NULL,
    libelleTypeContrat VARCHAR(50) NOT NULL,
    PRIMARY KEY(typeContratId),
    UNIQUE(codetypecontrat)
    );

    CREATE TABLE GARANTIE(
    garantieId INT IDENTITY,
    codegarantie CHAR(2) NOT NULL,
    Libelle_Garantie VARCHAR(50) NOT NULL,
    PRIMARY KEY(garantieId),
    UNIQUE(codegarantie)
    );

    CREATE TABLE Sous_Garantie(
    sousGarantieId INT IDENTITY,
    codesousgarantie CHAR(2) NOT NULL,
    libelleSousGarantieId VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    garantieId INT NOT NULL,
    PRIMARY KEY(sousGarantieId),
    UNIQUE(codesousgarantie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE PUISSANCE(
    puissanceId INT IDENTITY,
    codepuissance VARCHAR(3) NOT NULL,
    puissanceMin INT NOT NULL,
    puissanceMax BIGINT NOT NULL,
    PRIMARY KEY(puissanceId),
    UNIQUE(codepuissance)
    );

    CREATE TABLE PFC(
    categorieId INT,
    puissanceId INT,
    responsabilitecivile VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(puissanceId) REFERENCES PUISSANCE(puissanceId)
    );

    CREATE TABLE AGENCE(
    agenceId INT IDENTITY,
    codeagence VARCHAR(3) NOT NULL,
    nomAgence VARCHAR(50) NOT NULL,
    dateCreation DATE NOT NULL,
    PRIMARY KEY(agenceId),
    UNIQUE(codeagence)
    );

    CREATE TABLE SOUS_CATEGORIE(
    categorieId INT,
    souscategorieId INT IDENTITY,
    codesouscategorie VARCHAR(4) NOT NULL,
    libelleSousCategorie VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, souscategorieId),
    UNIQUE(codesouscategorie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId)
    );

    CREATE TABLE PFC_SC(
    categorieId INT,
    puissanceId INT,
    categorieId_1 INT NOT NULL,
    souscategorieId INT NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId),
    FOREIGN KEY(categorieId_1, souscategorieId) REFERENCES SOUS_CATEGORIE(categorieId, souscategorieId)
    );

    CREATE TABLE CAISSIERE(
    agenceId INT,
    caissiereId INT IDENTITY,
    codecaissiere VARCHAR(4) NOT NULL,
    prenomcaissiere VARCHAR(40) NOT NULL,
    nomcaissiere VARCHAR(40) NOT NULL,
    PRIMARY KEY(agenceId, caissiereId),
    UNIQUE(codecaissiere),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE VEHICULE(
    vehiculeId INT IDENTITY,
    codevehicule CHAR(5) NOT NULL,
    marque VARCHAR(50) NOT NULL,
    type VARCHAR(50) NOT NULL,
    energie VARCHAR(15) NOT NULL,
    serie VARCHAR(40) NOT NULL,
    vehiculepuissance INT NOT NULL,
    nombreDePlaceCarteGrise INT NOT NULL,
    nombreDePlaceCabine BIGINT NOT NULL,
    categorieId INT NOT NULL,
    puissanceId INT NOT NULL,
    PRIMARY KEY(vehiculeId),
    UNIQUE(codevehicule),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId)
    );

    CREATE TABLE PRODUCTEUR(
    agenceId INT,
    producteurId INT IDENTITY,
    codeproducteur VARCHAR(5) NOT NULL,
    Nomproducteur VARCHAR(50) NOT NULL,
    Prenomprodcteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(agenceId, producteurId),
    UNIQUE(codeproducteur),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE CONTRAT(
    typeContratId INT,
    contratId INT IDENTITY,
    codecontrat VARCHAR(10) NOT NULL,
    dateEffetContrat DATE NOT NULL,
    dateExpirationContrat DATE NOT NULL,
    apporteurId INT,
    agenceId INT NOT NULL,
    agenceId_1 INT NOT NULL,
    producteurId INT NOT NULL,
    vehiculeId INT NOT NULL,
    clientId INT NOT NULL,
    PRIMARY KEY(typeContratId, contratId),
    UNIQUE(codecontrat),
    FOREIGN KEY(typeContratId) REFERENCES TYPECONTRAT(typeContratId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId),
    FOREIGN KEY(agenceId_1, producteurId) REFERENCES PRODUCTEUR(agenceId, producteurId),
    FOREIGN KEY(vehiculeId) REFERENCES VEHICULE(vehiculeId),
    FOREIGN KEY(clientId) REFERENCES CLIENT(clientId)
    );

    CREATE TABLE AVENANT(
    typeContratId INT,
    contratId INT,
    avenantId INT IDENTITY,
    codeavenant VARCHAR(10) NOT NULL,
    libelleAvenant VARCHAR(50) NOT NULL,
    dateEffetAvenant DATE NOT NULL,
    dateExpirationAvenant DATE NOT NULL,
    apporteurId INT,
    PRIMARY KEY(typeContratId, contratId, avenantId),
    UNIQUE(codeavenant),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId)
    );

    CREATE TABLE PROTEGER(
    categorieId INT,
    garantieId INT,
    PRIMARY KEY(categorieId, garantieId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ASSOCIER(
    typeContratId INT,
    contratId INT,
    garantieId INT,
    PRIMARY KEY(typeContratId, contratId, garantieId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ENCAISSE_C(
    typeContratId INT,
    contratId INT,
    agenceId INT,
    caissiereId INT,
    dateEncaisseC DATE NOT NULL,
    montantEncaisseC BIGINT NOT NULL,
    PRIMARY KEY(typeContratId, contratId, agenceId, caissiereId),
    FOREIGN KEY(typeContratId, contratId) REFERENCES CONTRAT(typeContratId, contratId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );

    CREATE TABLE ENCAISSE_A(
    typeContratId INT,
    contratId INT,
    avenantId INT,
    agenceId INT,
    caissiereId INT,
    dateEncaisseA DATE NOT NULL,
    montantEncaisseA BIGINT NOT NULL,
    PRIMARY KEY(typeContratId, contratId, avenantId, agenceId, caissiereId),
    FOREIGN KEY(typeContratId, contratId, avenantId) REFERENCES AVENANT(typeContratId, contratId, avenantId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );
    J'ai remis la cardinalité selon votre conseil.
    Pour en revenir aux avenants, je rappelle que dans votre MCD, l’association CONTRAT-AVENANT devrait être modélisée ainsi :
    [CONTRAT]---0,N---(A)---1,1(R)---[AVENANT]
    En tout cas de mon côté c’est ce que j’ai fait, et mon CREATE TABLE AVENANT en est la conséquence (cf. post #48).
    Par rapport à:
    En passant, si vous souhaitez gérer des libellés de types d’avenants souvent utilisés, vous pouvez définir une entité-type ad-hoc, à laquelle ferait référence AVENANT :
    [AVENANT]---1,1---(AVT_LIB)---0,N---[AVENANT_LIBELLE]
    J'aimerais que vous me donnez un exemple de schéma pour me permetre de mieux comprendre.
    Une fois de plus merci.
    Voici le MCD ci-dessous:
    Images attachées Images attachées  

  11. #51
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonsoir Zidane7,

    Concernant les avenants, ok pour l’identification relative.

    Concernant les libellés des types d’avenants, on verra ça un peu plus tard.

    Concernant les contrats, il y a une correction à apporter, à savoir qu’il ne faut pas identifier l’entité-type CONTRAT relativement à l’entité-type TYPE_CONTRAT. En effet, un contrat n’est pas une propriété multivaluée du type de contrat, lequel n’est qu’une référence pour des contrats. L’identification relative a pour conséquence au stade SQL que la colonne typeContratId fait partie de la clé primaire de la table CONTRAT, alors que la colonne contratId suffit pour composer cette clé.


    Un retour sur les catégories et sous-catégories.

    Entité-type SOUS_CATEGORIE  

    Cette fois-ci vous avez identifié l’entité-type SOUS_CATEGORIE relativement à l’entité-type CATEGORIE : très bien.

    Cela dit, je reprends ce que j’ai écrit dans le post #41 (en corrigeant une coquille, c’est-à-dire en y remplaçant évidemment sous-garantie par sous-catégorie) :

    Du fait que l’attribut codeSousCategorie soit déclaré UNIQUE (clé alternative) conformément à votre tableau des catégories et sous-catégories présenté dans le post #14, dans l’attribut codeSousCategorie la sous-catégorie 1 de la garantie 3 doit avoir pour valeur "3-1" et non pas "1". Il sera alors prudent qu’un trigger SQL contrôle que la partie gauche ("3") soit égale à la valeur ("3") de la catégorie référencée (attribut codeCategorie de la table CATEGORIE). Dans cet exemple, l’alternative consiste à ce que codeSousCategorie prenne seulement la valeur "1", mais en contrepartie que la clause "UNIQUE (codeSousCategorie)" disparaisse.

    C’est cette alternative que pour ma part je mettrais volontiers en oeuvre, mais c’est à vous de choisir.

    Pour illustrer l’alternative, au stade SQL :

    Les CREATE TABLE :

    CREATE TABLE CATEGORIE
    (
       catId        INT IDENTITY,
       catCode      VARCHAR(4) NOT NULL,
       catLibelle   VARCHAR(64) NOT NULL,
       CONSTRAINT CATEGORIE_PK PRIMARY KEY(catId),
       CONSTRAINT CATEGORIE_AK UNIQUE(catCode)
    );
    
    CREATE TABLE SOUS_CATEGORIE
    (
       catId INT,
       sousCatId        INT IDENTITY,
       sousCatCode      VARCHAR(4) NOT NULL,
       sousCatLibelle   VARCHAR(64) NOT NULL,
       CONSTRAINT SOUS_CATEGORIE_PK PRIMARY KEY(catId, sousCatId),
       CONSTRAINT SOUS_CATEGORIE_CATEGORIE_FK FOREIGN KEY(catId) 
           REFERENCES CATEGORIE(catId)
    ) ;
    Jeu d’essai : catégories

    SET IDENTITY_INSERT CATEGORIE OFF ;
    DBCC CHECKIDENT (CATEGORIE, RESEED, 1)
    
    INSERT INTO CATEGORIE (catCode, catLibelle)
    VALUES
        ('1', 'Catégorie 1 : affaires et promenades')
      , ('2', 'Catégorie 2 : transport pour le compte de l''assuré')
      , ('3', 'Catégorie 3 : xxx')
      , ('4', 'Catégorie 4 : taxis urbains et inter urbains')
    
    SELECT catCode, catLibelle 
    FROM   CATEGORIE ; 
    =>

    catCode   catLibelle
    1         Catégorie 1 : affaires et promenades
    2         Catégorie 2 : transport pour le compte de l'assuré
    3         Catégorie 3 : xxx
    4         Catégorie 4 : taxis urbains et inter urbains
    

    Jeu d’essai : sous-catégories

    SET IDENTITY_INSERT SOUS_CATEGORIE OFF ;
    DBCC CHECKIDENT (SOUS_CATEGORIE, RESEED, 1)
    
    INSERT INTO SOUS_CATEGORIE (catId, sousCatCode, sousCatLibelle)
    VALUES
        ((SELECT catId FROM CATEGORIE WHERE catCode = '3'), '1', 'Catégorie 3 - sous-categorie 3-1')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '3'), '2', 'Catégorie 3 - sous-categorie 3-2')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '1', 'Catégorie 4 - sous-categorie 4-1')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '2', 'Catégorie 4 - sous-categorie 4-2')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '3', 'Catégorie 4 - sous-categorie 4-3')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '4', 'Catégorie 4 - sous-categorie 4-4')
    ;
    SELECT catCode, sousCatCode, sousCatLibelle
    FROM   CATEGORIE as x JOIN SOUS_CATEGORIE as y ON x.catId = y.catId   
    ; 
    =>

    catCode   sousCatCode   sousCatLibelle
    3         1             Catégorie 3 - sous-catégorie 3-1
    3         2             Catégorie 3 - sous-catégorie 3-2
    4         1             Catégorie 4 - sous-catégorie 4-1
    4         2             Catégorie 4 - sous-catégorie 4-2
    4         3             Catégorie 4 - sous-catégorie 4-3
    4         4             Catégorie 4 - sous-catégorie 4-4
    
    Mais je me rends compte dans les exemples que vous avez fournis (post #14) que la catégorie 4 existe deux fois, une 1ere fois avec les taxis 4 places, une 2e fois avec les taxis 5 places, il y a manifestement redondance. Il faudra donc a priori avoir deux valeurs distinctes concernant la colonne catCode... De votre côté, comment comptez-vous traiter cette redondance ?


    Concernant les sous-garanties

    Entité-type SOUS_GARANTIE : A identifier relativement à GARANTIE. Plus globalement prenez l’entité-type SOUS_CATEGORIE comme modèle.  


    N.B. Vous ne levez pas souvent le pouce, serait-ce que je ne suis pas clair dans mes explications ?
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  12. #52
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonjour Zidane7,


    Citation Envoyé par Zidane7 Voir le message
    J'aimerais que vous me donniez un exemple de schéma pour me permettre de mieux comprendre.
    Côté MCD :

    Nom : zidane7_avenants_libelles_mcd.png
Affichages : 213
Taille : 7,5 Ko
    Au stade SQL :

    Les CREATE TABLE

    CREATE TABLE AGENCE
    (
    agenceId      INT  IDENTITY,
    codeAgence    VARCHAR(3)   NOT NULL,
    nomAgence     VARCHAR(50)  NOT NULL,
    dateCreation  DATE         NOT NULL,
    CONSTRAINT AGENCE_PK PRIMARY KEY(agenceId),
    CONSTRAINT AGENCE_UK UNIQUE(codeAgence)
    );
    
    CREATE TABLE CONTRAT
    (
    contratId                INT IDENTITY,
    codeContrat              VARCHAR(10)   NOT NULL,
    dateEffetContrat         DATE          NOT NULL,
    dateExpirationContrat    DATE          NOT NULL,
    agenceId                 INT           NOT NULL,
    CONSTRAINT CONTRAT_PK PRIMARY KEY(contratId),
    CONSTRAINT CONTRAT_UK UNIQUE(codeContrat),
    CONSTRAINT CONTRAT_AGENCE_FK FOREIGN KEY(agenceId) 
        REFERENCES AGENCE(agenceId)
    );
    
    CREATE TABLE AVENANT_LIBELLE
    (
       avenantLibelleId       INT IDENTITY,
       avenantLibelleCode     VARCHAR(8) NOT NULL,
       avenantLibelleValeur   VARCHAR(48) NOT NULL,
       CONSTRAINT AVENANT_LIBELLE_PK PRIMARY KEY (avenantLibelleId),
       CONSTRAINT AVENANT_LIBELLE_AK UNIQUE (avenantLibelleCode)
    );
    
    CREATE TABLE AVENANT
    (
    contratId               INT           NOT NULL,
    avenantId               INT  IDENTITY,         
    codeAvenant             VARCHAR(10)   NOT NULL,
     avenantLibelleId       INT           NOT NULL,
    dateEffetAvenant        DATE          NOT NULL,
    dateExpirationAvenant   DATE          NOT NULL,
    CONSTRAINT AVENANT_PK PRIMARY KEY (contratId, avenantId),
    CONSTRAINT AVENANT_UK UNIQUE (codeAvenant),
    CONSTRAINT AVENANT_CONTRAT_FK FOREIGN KEY(contratId) 
        REFERENCES CONTRAT(contratId),
    CONSTRAINT AVENANT_AVENANT_LIBELLE_FK FOREIGN KEY(avenantLibelleId) 
        REFERENCES AVENANT_LIBELLE(avenantLibelleId)
    ) ; 

    Un début de jeu d’essai

    Les agences

    INSERT INTO AGENCE (codeAgence, nomAgence, dateCreation)
    VALUES
        ('ag1', 'Agence 1', '1990-01-02')
      , ('ag2', 'Agence 2', '1990-01-02')
      , ('ag3', 'Agence 3', '1998-01-02')
    ;
    
    SELECT codeAgence, nomAgence, dateCreation 
    FROM   AGENCE ; 
    =>

    codeAgence   nomAgence   dateCreation
    ag1          Agence 1    1990-01-02
    ag2          Agence 2    1990-01-02
    ag3          Agence 3    1998-01-02
    

    Les contrats

     
    INSERT INTO CONTRAT (codeContrat, dateEffetContrat, dateExpirationContrat, agenceId)
    VALUES
        ('ctr01', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag2'))
      , ('ctr02', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag3'))
      , ('ctr03', '2018-01-01', '2022-12-31', (SELECT agenceId FROM AGENCE WHERE codeAgence = 'ag3'))
    ;
    
    SELECT codeContrat, dateEffetContrat, dateExpirationContrat, codeAgence
    FROM   CONTRAT as x JOIN AGENCE as y ON x.agenceId = y.agenceId   
    ;
    =>

    codeContrat   dateEffetContrat   dateExpirationContrat   codeAgence
    ctr01         2018-01-01         2022-12-31              ag2
    ctr02         2018-01-01         2022-12-31              ag3
    ctr03         2018-01-01         2022-12-31              ag3
    

    Les libellés des avenants

    INSERT INTO AVENANT_LIBELLE (avenantLibelleCode, avenantLibelleValeur)
    VALUES 
        ('spec', 'avenant spécial')
      , ('part', 'avenant particulier')
      , ('lamb', 'avenant lambda') 
    ;
    
    SELECT 'avenantLibelleCode, avenantLibelleValeur
    FROM   AVENANT_LIBELLE ;
    
    =>

    avenantLibelleCode   avenantLibelleValeur
    spec                 avenant spécial
    part                 avenant particulier
    lamb                 avenant lambda
    
    Les avenants

    INSERT INTO AVENANT (contratId, codeAvenant, avenantLibelleId
                       , dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (
         SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr01'
        )
      , 'av001-a'
      , (
         SELECT avenantLibelleId 
         FROM   AVENANT_LIBELLE 
         WHERE  avenantLibelleCode = 'spec'
        )
      , '2019-01-01', '2019-07-31'
    )
    ,
    ( 
        (
         SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr01'
        )
      , 'av001-b'
      , (
         SELECT avenantLibelleId 
         FROM   AVENANT_LIBELLE 
         WHERE  avenantLibelleCode = 'lamb'
        )
      , '2019-02-01', '2019-08-31'
    )
    ;
    
    INSERT INTO AVENANT (contratId, codeAvenant, avenantLibelleId
                       , dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (
         SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr02'
       )
      , 'av002'
      , (
         SELECT avenantLibelleId 
         FROM   AVENANT_LIBELLE 
         WHERE  avenantLibelleCode = 'lamb'
        )
      , '2019-01-01', '2019-12-31'
    ) ;
    
    INSERT INTO AVENANT (contratId, codeAvenant, avenantLibelleId
                       , dateEffetAvenant, dateExpirationAvenant)
    VALUES
    ( 
        (SELECT contratId 
         FROM   CONTRAT 
         WHERE  codeContrat = 'ctr03')
      , 'av003'
      , (
         SELECT avenantLibelleId 
         FROM   AVENANT_LIBELLE 
         WHERE  avenantLibelleCode = 'part'
        )
      , '2019-01-01', '2019-12-31'
    ) ;
    
    SELECT codeContrat, codeAvenant, avenantLibelleValeur as avenantLibelle
         , dateEffetAvenant, dateExpirationAvenant 
    FROM   CONTRAT as x JOIN AVENANT as y ON x.contratId = y.contratId
      JOIN AVENANT_LIBELLE as z ON y.avenantLibelleId = z.avenantLibelleId
    ;
    =>

    codeContrat   codeAvenant avenantLibelle        dateEffetAvenant   dateExpirationAvenant
    ctr01         av001-a     avenant spécial       2019-01-01         2019-07-31
    ctr01         av001-b     avenant lambda        2019-02-01         2019-08-31
    ctr02         av002       avenant lambda        2019-01-01         2019-12-31
    ctr03         av003       avenant particulier   2019-01-01         2019-12-31
    
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  13. #53
    Membre à l'essai
    Homme Profil pro
    Développeur Java
    Inscrit en
    Décembre 2019
    Messages
    83
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Guinée

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Décembre 2019
    Messages : 83
    Points : 23
    Points
    23
    Par défaut Conception d'un MCD pour une assurance automobile
    Bonsoir Monsieur fsmrel,
    Voici le code SQL ci-dessous:
    CREATE TABLE CATEGORIE(
    categorieId INT IDENTITY,
    codecategorie CHAR(4) NOT NULL,
    libelleCategorie VARCHAR(50) NOT NULL,
    nombreplacecategorie INT NOT NULL,
    PRIMARY KEY(categorieId),
    UNIQUE(codecategorie)
    );

    CREATE TABLE CLIENT(
    clientId INT IDENTITY,
    codeclient VARCHAR(10) NOT NULL,
    nomClient VARCHAR(50) NOT NULL,
    prenomClient VARCHAR(50) NOT NULL,
    adresseClient VARCHAR(50) NOT NULL,
    telephoneClient VARCHAR(30) NOT NULL,
    PRIMARY KEY(clientId),
    UNIQUE(codeclient)
    );

    CREATE TABLE APPORTEUR(
    apporteurId INT IDENTITY,
    codeapporteur VARCHAR(5) NOT NULL,
    nomApporteur VARCHAR(50) NOT NULL,
    prenomApporteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(apporteurId),
    UNIQUE(codeapporteur)
    );

    CREATE TABLE TYPECONTRAT(
    typeContratId INT IDENTITY,
    codetypecontrat CHAR(2) NOT NULL,
    libelleTypeContrat VARCHAR(50) NOT NULL,
    PRIMARY KEY(typeContratId),
    UNIQUE(codetypecontrat)
    );

    CREATE TABLE GARANTIE(
    garantieId INT IDENTITY,
    codegarantie CHAR(2) NOT NULL,
    Libelle_Garantie VARCHAR(50) NOT NULL,
    PRIMARY KEY(garantieId),
    UNIQUE(codegarantie)
    );

    CREATE TABLE Sous_Garantie(
    sousGarantieId INT IDENTITY,
    codesousgarantie CHAR(2) NOT NULL,
    libelleSousGarantieId VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    garantieId INT NOT NULL,
    PRIMARY KEY(sousGarantieId),
    UNIQUE(codesousgarantie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE PUISSANCE(
    puissanceId INT IDENTITY,
    codepuissance VARCHAR(3) NOT NULL,
    puissanceMin INT NOT NULL,
    puissanceMax BIGINT NOT NULL,
    PRIMARY KEY(puissanceId),
    UNIQUE(codepuissance)
    );

    CREATE TABLE PFC(
    categorieId INT,
    puissanceId INT,
    responsabilitecivile VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(puissanceId) REFERENCES PUISSANCE(puissanceId)
    );

    CREATE TABLE AGENCE(
    agenceId INT IDENTITY,
    codeagence VARCHAR(3) NOT NULL,
    nomAgence VARCHAR(50) NOT NULL,
    dateCreation DATE NOT NULL,
    PRIMARY KEY(agenceId),
    UNIQUE(codeagence)
    );

    CREATE TABLE SOUS_CATEGORIE(
    souscategorieId INT IDENTITY,
    codesouscategorie VARCHAR(4) NOT NULL,
    libelleSousCategorie VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    PRIMARY KEY(souscategorieId),
    UNIQUE(codesouscategorie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId)
    );

    CREATE TABLE PFC_SC(
    categorieId INT,
    puissanceId INT,
    souscategorieId INT NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId),
    FOREIGN KEY(souscategorieId) REFERENCES SOUS_CATEGORIE(souscategorieId)
    );

    CREATE TABLE CAISSIERE(
    agenceId INT,
    caissiereId INT IDENTITY,
    codecaissiere VARCHAR(4) NOT NULL,
    prenomcaissiere VARCHAR(40) NOT NULL,
    nomcaissiere VARCHAR(40) NOT NULL,
    PRIMARY KEY(agenceId, caissiereId),
    UNIQUE(codecaissiere),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE AVENANT_LIBELLE(
    avenantlibelleId INT IDENTITY,
    avenantlibellecode CHAR(3) NOT NULL,
    avenantlibellevaleur VARCHAR(50),
    PRIMARY KEY(avenantlibelleId),
    UNIQUE(avenantlibellecode)
    );

    CREATE TABLE VEHICULE(
    vehiculeId INT IDENTITY,
    codevehicule CHAR(5) NOT NULL,
    marque VARCHAR(50) NOT NULL,
    type VARCHAR(50) NOT NULL,
    energie VARCHAR(15) NOT NULL,
    serie VARCHAR(40) NOT NULL,
    vehiculepuissance INT NOT NULL,
    nombreDePlaceCarteGrise INT NOT NULL,
    nombreDePlaceCabine BIGINT NOT NULL,
    categorieId INT NOT NULL,
    puissanceId INT NOT NULL,
    PRIMARY KEY(vehiculeId),
    UNIQUE(codevehicule),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId)
    );

    CREATE TABLE PRODUCTEUR(
    agenceId INT,
    producteurId INT IDENTITY,
    codeproducteur VARCHAR(5) NOT NULL,
    Nomproducteur VARCHAR(50) NOT NULL,
    Prenomprodcteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(agenceId, producteurId),
    UNIQUE(codeproducteur),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE CONTRAT(
    contratId INT IDENTITY,
    codecontrat VARCHAR(10) NOT NULL,
    dateEffetContrat DATE NOT NULL,
    dateExpirationContrat DATE NOT NULL,
    apporteurId INT,
    agenceId INT NOT NULL,
    agenceId_1 INT NOT NULL,
    producteurId INT NOT NULL,
    typeContratId INT NOT NULL,
    vehiculeId INT NOT NULL,
    clientId INT NOT NULL,
    PRIMARY KEY(contratId),
    UNIQUE(codecontrat),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId),
    FOREIGN KEY(agenceId_1, producteurId) REFERENCES PRODUCTEUR(agenceId, producteurId),
    FOREIGN KEY(typeContratId) REFERENCES TYPECONTRAT(typeContratId),
    FOREIGN KEY(vehiculeId) REFERENCES VEHICULE(vehiculeId),
    FOREIGN KEY(clientId) REFERENCES CLIENT(clientId)
    );

    CREATE TABLE AVENANT(
    contratId INT,
    avenantId INT IDENTITY,
    codeavenant VARCHAR(10) NOT NULL,
    libelleAvenant VARCHAR(50) NOT NULL,
    dateEffetAvenant DATE NOT NULL,
    dateExpirationAvenant DATE NOT NULL,
    avenantlibelleId INT NOT NULL,
    apporteurId INT,
    PRIMARY KEY(contratId, avenantId),
    UNIQUE(codeavenant),
    FOREIGN KEY(contratId) REFERENCES CONTRAT(contratId),
    FOREIGN KEY(avenantlibelleId) REFERENCES AVENANT_LIBELLE(avenantlibelleId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId)
    );

    CREATE TABLE PROTEGER(
    categorieId INT,
    garantieId INT,
    PRIMARY KEY(categorieId, garantieId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ASSOCIER(
    contratId INT,
    garantieId INT,
    PRIMARY KEY(contratId, garantieId),
    FOREIGN KEY(contratId) REFERENCES CONTRAT(contratId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ENCAISSE_C(
    contratId INT,
    agenceId INT,
    caissiereId INT,
    dateEncaisseC DATE NOT NULL,
    montantEncaisseC BIGINT NOT NULL,
    PRIMARY KEY(contratId, agenceId, caissiereId),
    FOREIGN KEY(contratId) REFERENCES CONTRAT(contratId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );

    CREATE TABLE ENCAISSE_A(
    contratId INT,
    avenantId INT,
    agenceId INT,
    caissiereId INT,
    dateEncaisseA DATE NOT NULL,
    montantEncaisseA BIGINT NOT NULL,
    PRIMARY KEY(contratId, avenantId, agenceId, caissiereId),
    FOREIGN KEY(contratId, avenantId) REFERENCES AVENANT(contratId, avenantId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId)
    );
    Un retour sur les catégories et sous-catégories.

    Entité-type SOUS_CATEGORIE

    Cette fois-ci vous avez identifié l’entité-type SOUS_CATEGORIE relativement à l’entité-type CATEGORIE : très bien.

    Cela dit, je reprends ce que j’ai écrit dans le post #41 (en corrigeant une coquille, c’est-à-dire en y remplaçant évidemment sous-garantie par sous-catégorie) :
    Du fait que l’attribut codeSousCategorie soit déclaré UNIQUE (clé alternative) conformément à votre tableau des catégories et sous-catégories présenté dans le post #14, dans l’attribut codeSousCategorie la sous-catégorie 1 de la garantie 3 doit avoir pour valeur "3-1" et non pas "1". Il sera alors prudent qu’un trigger SQL contrôle que la partie gauche ("3") soit égale à la valeur ("3") de la catégorie référencée (attribut codeCategorie de la table CATEGORIE). Dans cet exemple, l’alternative consiste à ce que codeSousCategorie prenne seulement la valeur "1", mais en contrepartie que la clause "UNIQUE (codeSousCategorie)" disparaisse.

    C’est cette alternative que pour ma part je mettrais volontiers en oeuvre, mais c’est à vous de choisir.
    C'est ce passage que je n'ai pas compris.
    Veuillez m'éclaircire si possible le passage.
    Mais je me rends compte dans les exemples que vous avez fournis (post #14) que la catégorie 4 existe deux fois, une 1ere fois avec les taxis 4 places, une 2e fois avec les taxis 5 places, il y a manifestement redondance. Il faudra donc a priori avoir deux valeurs distinctes concernant la colonne catCode... De votre côté, comment comptez-vous traiter cette redondance ?

    Concernant les sous-garanties
    Entité-type SOUS_GARANTIE : A identifier relativement à GARANTIE. Plus globalement prenez l’entité-type SOUS_CATEGORIE comme modèle.
    A cet endroit, le tarif est déterminé en fonction du nombre de place de la ctegorie et de la puissance.
    Avez vous d'autres remarques à ce niveau?
    Voici le MCD cidessous:
    Une fois de plus merci.
    Images attachées Images attachées  

  14. #54
    Membre à l'essai
    Homme Profil pro
    Développeur Java
    Inscrit en
    Décembre 2019
    Messages
    83
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Guinée

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Décembre 2019
    Messages : 83
    Points : 23
    Points
    23
    Par défaut Conception d'un MCD pour une assurance automobile
    Bonsoir Monsieur,
    Je viens de mettre une entité modepaiement qui concerne le paiement du contrat et de l'avenant.
    Voici le MCD ci-dessous:
    Que pensez vous?
    Voici aussi le code SQL en question.
    CREATE TABLE CATEGORIE(
    categorieId INT IDENTITY,
    codecategorie CHAR(4) NOT NULL,
    libelleCategorie VARCHAR(50) NOT NULL,
    nombreplacecategorie INT NOT NULL,
    PRIMARY KEY(categorieId),
    UNIQUE(codecategorie)
    );

    CREATE TABLE CLIENT(
    clientId INT IDENTITY,
    codeclient VARCHAR(10) NOT NULL,
    nomClient VARCHAR(50) NOT NULL,
    prenomClient VARCHAR(50) NOT NULL,
    adresseClient VARCHAR(50) NOT NULL,
    telephoneClient VARCHAR(30) NOT NULL,
    PRIMARY KEY(clientId),
    UNIQUE(codeclient)
    );

    CREATE TABLE APPORTEUR(
    apporteurId INT IDENTITY,
    codeapporteur VARCHAR(5) NOT NULL,
    nomApporteur VARCHAR(50) NOT NULL,
    prenomApporteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(apporteurId),
    UNIQUE(codeapporteur)
    );

    CREATE TABLE TYPECONTRAT(
    typeContratId INT IDENTITY,
    codetypecontrat CHAR(2) NOT NULL,
    libelleTypeContrat VARCHAR(50) NOT NULL,
    PRIMARY KEY(typeContratId),
    UNIQUE(codetypecontrat)
    );

    CREATE TABLE GARANTIE(
    garantieId INT IDENTITY,
    codegarantie CHAR(2) NOT NULL,
    Libelle_Garantie VARCHAR(50) NOT NULL,
    PRIMARY KEY(garantieId),
    UNIQUE(codegarantie)
    );

    CREATE TABLE Sous_Garantie(
    sousGarantieId INT IDENTITY,
    codesousgarantie CHAR(2) NOT NULL,
    libelleSousGarantieId VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    garantieId INT NOT NULL,
    PRIMARY KEY(sousGarantieId),
    UNIQUE(codesousgarantie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE PUISSANCE(
    puissanceId INT IDENTITY,
    codepuissance VARCHAR(3) NOT NULL,
    puissanceMin INT NOT NULL,
    puissanceMax BIGINT NOT NULL,
    PRIMARY KEY(puissanceId),
    UNIQUE(codepuissance)
    );

    CREATE TABLE PFC(
    categorieId INT,
    puissanceId INT,
    responsabilitecivile VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(puissanceId) REFERENCES PUISSANCE(puissanceId)
    );

    CREATE TABLE AGENCE(
    agenceId INT IDENTITY,
    codeagence VARCHAR(3) NOT NULL,
    nomAgence VARCHAR(50) NOT NULL,
    dateCreation DATE NOT NULL,
    PRIMARY KEY(agenceId),
    UNIQUE(codeagence)
    );

    CREATE TABLE SOUS_CATEGORIE(
    souscategorieId INT IDENTITY,
    codesouscategorie VARCHAR(4) NOT NULL,
    libelleSousCategorie VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    PRIMARY KEY(souscategorieId),
    UNIQUE(codesouscategorie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId)
    );

    CREATE TABLE PFC_SC(
    categorieId INT,
    puissanceId INT,
    souscategorieId INT NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId),
    FOREIGN KEY(souscategorieId) REFERENCES SOUS_CATEGORIE(souscategorieId)
    );

    CREATE TABLE CAISSIERE(
    agenceId INT,
    caissiereId INT IDENTITY,
    codecaissiere VARCHAR(4) NOT NULL,
    prenomcaissiere VARCHAR(40) NOT NULL,
    nomcaissiere VARCHAR(40) NOT NULL,
    PRIMARY KEY(agenceId, caissiereId),
    UNIQUE(codecaissiere),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE AVENANT_LIBELLE(
    avenantlibelleId INT IDENTITY,
    avenantlibellecode CHAR(3) NOT NULL,
    avenantlibellevaleur VARCHAR(50),
    PRIMARY KEY(avenantlibelleId),
    UNIQUE(avenantlibellecode)
    );

    CREATE TABLE MODE_PAIEMENT(
    modepaiemenId INT IDENTITY,
    modepaiement_libelle VARCHAR(50),
    PRIMARY KEY(modepaiemenId)
    );

    CREATE TABLE VEHICULE(
    vehiculeId INT IDENTITY,
    codevehicule CHAR(5) NOT NULL,
    marque VARCHAR(50) NOT NULL,
    type VARCHAR(50) NOT NULL,
    energie VARCHAR(15) NOT NULL,
    serie VARCHAR(40) NOT NULL,
    vehiculepuissance INT NOT NULL,
    nombreDePlaceCarteGrise INT NOT NULL,
    nombreDePlaceCabine BIGINT NOT NULL,
    categorieId INT NOT NULL,
    puissanceId INT NOT NULL,
    PRIMARY KEY(vehiculeId),
    UNIQUE(codevehicule),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId)
    );

    CREATE TABLE PRODUCTEUR(
    agenceId INT,
    producteurId INT IDENTITY,
    codeproducteur VARCHAR(5) NOT NULL,
    Nomproducteur VARCHAR(50) NOT NULL,
    Prenomprodcteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(agenceId, producteurId),
    UNIQUE(codeproducteur),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE CONTRAT(
    contratId INT IDENTITY,
    codecontrat VARCHAR(10) NOT NULL,
    dateEffetContrat DATE NOT NULL,
    dateExpirationContrat DATE NOT NULL,
    apporteurId INT,
    agenceId INT NOT NULL,
    agenceId_1 INT NOT NULL,
    producteurId INT NOT NULL,
    typeContratId INT NOT NULL,
    vehiculeId INT NOT NULL,
    clientId INT NOT NULL,
    PRIMARY KEY(contratId),
    UNIQUE(codecontrat),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId),
    FOREIGN KEY(agenceId_1, producteurId) REFERENCES PRODUCTEUR(agenceId, producteurId),
    FOREIGN KEY(typeContratId) REFERENCES TYPECONTRAT(typeContratId),
    FOREIGN KEY(vehiculeId) REFERENCES VEHICULE(vehiculeId),
    FOREIGN KEY(clientId) REFERENCES CLIENT(clientId)
    );

    CREATE TABLE AVENANT(
    contratId INT,
    avenantId INT IDENTITY,
    codeavenant VARCHAR(10) NOT NULL,
    libelleAvenant VARCHAR(50) NOT NULL,
    dateEffetAvenant DATE NOT NULL,
    dateExpirationAvenant DATE NOT NULL,
    avenantlibelleId INT NOT NULL,
    apporteurId INT,
    PRIMARY KEY(contratId, avenantId),
    UNIQUE(codeavenant),
    FOREIGN KEY(contratId) REFERENCES CONTRAT(contratId),
    FOREIGN KEY(avenantlibelleId) REFERENCES AVENANT_LIBELLE(avenantlibelleId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId)
    );

    CREATE TABLE PROTEGER(
    categorieId INT,
    garantieId INT,
    PRIMARY KEY(categorieId, garantieId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ASSOCIER(
    contratId INT,
    garantieId INT,
    PRIMARY KEY(contratId, garantieId),
    FOREIGN KEY(contratId) REFERENCES CONTRAT(contratId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ENCAISSE_C(
    contratId INT,
    agenceId INT,
    caissiereId INT,
    modepaiemenId INT,
    dateEncaisseC DATE NOT NULL,
    montantEncaisseC BIGINT NOT NULL,
    PRIMARY KEY(contratId, agenceId, caissiereId, modepaiemenId),
    FOREIGN KEY(contratId) REFERENCES CONTRAT(contratId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId),
    FOREIGN KEY(modepaiemenId) REFERENCES MODE_PAIEMENT(modepaiemenId)
    );

    CREATE TABLE ENCAISSE_A(
    contratId INT,
    avenantId INT,
    agenceId INT,
    caissiereId INT,
    modepaiemenId INT,
    dateEncaisseA DATE NOT NULL,
    montantEncaisseA BIGINT NOT NULL,
    PRIMARY KEY(contratId, avenantId, agenceId, caissiereId, modepaiemenId),
    FOREIGN KEY(contratId, avenantId) REFERENCES AVENANT(contratId, avenantId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId),
    FOREIGN KEY(modepaiemenId) REFERENCES MODE_PAIEMENT(modepaiemenId)
    );
    Pour ce qui concerne la catégorie et sous catégorie voici les tarifs en question.
    Merci par avance.
    Images attachées Images attachées     

  15. #55
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonjour Zidane7,


    Vos tableaux des catégories et sous-catégories (post #54) sont éclairants.

    Comme précédemment, la responsabilité civile et la défense recours dépendent soit de la catégorie (cas des catégories 1 et 2), soit de la sous-catégorie (cas des catégories 3 et 4). A la réflexion, le plus simple du point de vue de la modélisation (puis de la mise en oeuvre SQL) est que chaque catégorie possède au moins une sous-catégorie (ce qui vaut donc automatiquement pour les catégories 1 et 2, même si fonctionnellement ça n’est pas le cas), ce qui permet aussi de n’avoir qu’un seul endroit où représenter la sécurité routière et la défense recours, c’est-à-dire dans l’entité-type SOUS_CATEGORIE.

    Entité-type SOUS_CATEGORIE : le code de la sous-catégorie (attribut sousCatCode) devient clé alternative (clause UNIQUE dans Looping, puis dans SQL). Dans ces conditions, les valeurs de l’attribut sousCatCode sont par exemple les suivantes : "1-1" (cas de la catégorie 1), "2-1" (cas de la catégorie 2), "3-1" et "3-2" (cas de la catégorie 3), "4-1", "4-2", "4-3", etc. (cas de la catégorie 4).

    Entité-type PUISSANCE : avec l’apparition du tonnage, le nom de cette entité-type n’est plus très approprié, mais peu importe on va le garder, vu qu’essentiellement se sont les CV qui restent majoritaires. Tout au plus peut-on renommer les attributs puissanceMin et puissanceMax respectivement en borneInf et borneSup, et on ajoute un attribut puissanceCode (identifiant naturel, dont la valorisation est à notre charge),ainsi qu’un attribut unite qui permet de savoir si on a affaire à des chevaux-vapeurs ou à des tonnes, etc. (dans votre tableau associé à la catégorie 3, l’attribut unite prend systématiquement la valeur "tonne", sauf dans le cas de la dernière ligne où, comme un cheveu sur la soupe, on trouve la valeur "remorque" : admettons ! Pour des raisons de cohérence évidentes, j’ai pris le parti de faire appartenir à la catégorie 3-1 tout ce qui est du type "tonne" et d’isoler dans une autre sous-catégorie (disons 3-2) ce qui est "remorque".  


    Concernant les catégories, le MCD devient le suivant (PFC_SC se réduit simplement une association entre PFC et SOUS_CATEGORIE) :

    Nom : Zidane7_assurance_auto (rev sous-cat).png
Affichages : 191
Taille : 17,6 Ko


    Maintenant, il est temps de secouer tout ça avec SQL : en effet, techniquement sait-on retrouver l’équivalent des tableaux du post #54 à partir des tables issus du MCD ?

    Il serait bien que vous soumettiez le code ci-dessous à SQL Server.
    Notez qu’on ne manipule pas directement les valeurs prises par les clés primaires, on laisse le SGBD se débrouiller en fonction de ce qu’on lui fournit, c’est-à-dire les valeurs des clés candidates naturelles.

    Par exemple, dans le cas de la table PFC, pour transmettre à SQL la valeur de l’attribut puissanceId, partant du principe qu’on ne sait pas quelle est cette valeur, on se sert de l’attribut puissanceCode qui est clé naturelle. Même principe pour les attributs catId et sousCatId.

    Exemple

    Pour les taxis 4 places (catégorie '4', sous-catégorie '4-1'), de puissance comprise entre 3 et 6 CV (puissanceCode = 'C2', cf. ci-dessous) :

    INSERT INTO PFC (puissanceId, catId, sousCatId, respCivile, defenseRecours)
    VALUES 
          ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C2')
        , (SELECT catId FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '4-1')
        , 690102, 34505) 
    

    Code SQL à vérifier :

    USE test ;
    
    BEGIN TRANSACTION ;
    
    DROP TABLE IF EXISTS PFC ;
    DROP TABLE IF EXISTS SOUS_CATEGORIE ;
    DROP TABLE IF EXISTS CATEGORIE ;
    DROP TABLE IF EXISTS PUISSANCE ;
    
    CREATE TABLE PUISSANCE
    (
       puissanceId     INT IDENTITY,
       puissanceCode   VARCHAR(8)  NOT NULL,
       borneInf        INT NOT NULL,
       borneSup        INT NOT NULL,
       unite           VARCHAR(12) NOT NULL,
       CONSTRAINT PUISSANCE_PK PRIMARY KEY(puissanceId),
       CONSTRAINT PUISSANCE_AK UNIQUE(puissanceCode),
       CONSTRAINT PUISSANCE_UK UNIQUE(borneInf, unite)
    );
    
    SET IDENTITY_INSERT PUISSANCE OFF ;
    DBCC CHECKIDENT (PUISSANCE, RESEED, 1)
    
    INSERT INTO PUISSANCE (puissanceCode, borneInf, borneSup, unite)
    VALUES
        ('C1', 0, 2, 'CV')
      , ('C2', 3, 6, 'CV') 
      , ('C3', 7, 10, 'CV') 
      , ('C4', 11, 14, 'CV') 
      , ('C5', 15, 23, 'CV') 
      , ('C6', 24, 9999, 'CV') 
      , ('T1', 0, 1, 'tonne') 
      , ('T2', 2, 5, 'tonne') 
      , ('T3', 6, 10, 'tonne') 
      , ('T4', 11, 15, 'tonne') 
      , ('T5', 16, 25, 'tonne') 
      , ('T6', 26, 9999, 'tonne') 
      , ('R1', 0, 0, 'remorque') 
    ;
    SELECT '' as PUISSANCE, * FROM PUISSANCE ;
    
    CREATE TABLE CATEGORIE
    (
       catId        INT IDENTITY,
       catCode      VARCHAR(4) NOT NULL,
       catLibelle   VARCHAR(64) NOT NULL,
       CONSTRAINT CATEGORIE_PK PRIMARY KEY(catId),
       CONSTRAINT CATEGORIE_AK UNIQUE(catCode)
    );
    
    SET IDENTITY_INSERT CATEGORIE OFF ;
    DBCC CHECKIDENT (CATEGORIE, RESEED, 1) ;
    
    INSERT INTO CATEGORIE (catCode, catLibelle)
    VALUES
        ('1', 'Catégorie 1 : affaires et promenades (AP)')
      , ('2', 'Catégorie 2 : transport pour le compte de l''assuré (TPC)')
      , ('3', 'Catégorie 3 : transport public de marchandises (TPM)')
      , ('4', 'Catégorie 4 : taxis / transport public)')
    ;
    SELECT '' as CATEGORIE, catCode, catLibelle 
    FROM   CATEGORIE ; 
    
    CREATE TABLE SOUS_CATEGORIE
    (
       catId INT,
       sousCatId          INT IDENTITY,
       sousCatCode        VARCHAR(4) NOT NULL,
       securiteRoutiere   INT NOT NULL,  
       coutPolice         INT NOT NULL,
       sousCatLibelle     VARCHAR(96) NOT NULL,
       CONSTRAINT SOUS_CATEGORIE_PK PRIMARY KEY(catId, sousCatId),
       CONSTRAINT SOUS_CATEGORIE_AK UNIQUE(sousCatCode),
       CONSTRAINT SOUS_CATEGORIE_CATEGORIE_FK FOREIGN KEY(catId) 
           REFERENCES CATEGORIE(catId)
    );
    
    SET IDENTITY_INSERT SOUS_CATEGORIE OFF ;
    DBCC CHECKIDENT (SOUS_CATEGORIE, RESEED, 1) ;
    
    INSERT INTO SOUS_CATEGORIE (catId, sousCatCode, securiteRoutiere, coutPolice, sousCatLibelle)
    VALUES
        ((SELECT catId FROM CATEGORIE WHERE catCode = '1'), '1-1', 17500, 10000, ' /')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '2'), '2-1', 10500, 10000, ' /')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '3'), '3-1', 10500, 10000, 'marchandises (tonnage)')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '3'), '3-2', 00000, 00000, 'remorque')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '4-1', 00000, 10000, 'taxis 4 places')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '4-2', 00000, 10000, 'taxis 5 places')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '4-3', 00000, 10000, 'taxis 6 places')
      , ((SELECT catId FROM CATEGORIE WHERE catCode = '4'), '4-5', 00000, 10000, 'TPV 18 places')
    ;
    SELECT '' as SOUS_CATEGORIE, catCode, securiteRoutiere, coutPolice, sousCatCode, sousCatLibelle
    FROM   CATEGORIE as x JOIN SOUS_CATEGORIE as y ON x.catId = y.catId   
    ;
    
    CREATE TABLE PFC
    (
       puissanceId     INT,
       catId           INT,
       sousCatId       INT,
       respCivile      INT NOT NULL,
       defenseRecours  INT NOT NULL,
       CONSTRAINT PFC_PK PRIMARY KEY(puissanceId, catId, sousCatId),
       CONSTRAINT PFC_SOUS_CATEGORIE_FK FOREIGN KEY(catId, sousCatId) 
           REFERENCES SOUS_CATEGORIE(catId, sousCatId)
    );
    
    -- inserts - cas de la catégorie 1 
    
    INSERT INTO PFC (puissanceId, catId, sousCatId, respCivile, defenseRecours)
    VALUES 
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C1')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '1')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '1-1')
        , 201657, 10183) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C2')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '1')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '1-1')
        , 244399, 12220) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C3')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '1')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '1-1')
        , 285114, 14756) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C4')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '1')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '1-1')
        , 346233, 17312) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C5')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '1')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '1-1')
        , 407332, 20367) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C6')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '1')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '1-1')
        , 427698, 21385) 
    ;
    
    -- cas de la catégorie 2 
    
    INSERT INTO PFC (puissanceId, catId, sousCatId, respCivile, defenseRecours)
    VALUES 
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C2')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '2')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '2-1')
        , 401383, 20069) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C3')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '2')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '2-1')
        , 563124, 28156) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C4')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '2')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '2-1')
        , 583830, 29192) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C5')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '2')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '2-1')
        , 693298, 34665) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C6')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '2')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode = '2-1')
        , 716102, 35905) 
    ;
    
    -- cas de la catégorie 3 
    
    INSERT INTO PFC (puissanceId, catId, sousCatId, respCivile, defenseRecours)
    VALUES 
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'T1')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '3')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '3-1')
        , 578610, 28931) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'T2')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '3')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '3-1')
        , 694332, 34717) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'T3')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '3')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '3-1')
        , 921888, 46094) 
    , 
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'T4')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '3')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '3-1')
        , 1383054, 69153) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'T5')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '3')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '3-1')
        , 1843776, 92189) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'T6')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '3')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '3-1')
        , 2764164, 138208) 
    ,
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'R1')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '3')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '3-2')
        , 1000000, 0) 
    ;
    -- cas de la catégorie 4 (partiel)
    
    INSERT INTO PFC (puissanceId, catId, sousCatId, respCivile, defenseRecours)
    VALUES 
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C2')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-1')
        , 690102, 34505) 
    ,
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C3')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-1')
        , 728486, 36424) 
    ,
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C4')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-1')
        , 806813, 40341) 
    ,
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C5')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-1')
        , 846877, 42344) 
    ,
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C2')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-2')
        , 784239, 42344) 
    ,
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C3')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-2')
        , 822563, 41128) 
    ,
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C4')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-2')
        , 900947, 45047) 
    ,
        ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C5')
        , (SELECT catid FROM CATEGORIE WHERE catCode = '4')
        , (SELECT sousCatid FROM SOUS_CATEGORIE WHERE sousCatCode  = '4-2')
        , 941015, 47051) 
    ;
    
    
    --------------------
    -- Au résultat
    ---------------------
    
    SELECT unite, borneInf, borneSup 
         , LEFT(catLibelle,12) as cat, RIGHT(sousCatLibelle,24) as sousCat
         , respCivile, defenseRecours, securiteRoutiere, coutPolice
    FROM   PFC AS x 
      JOIN PUISSANCE AS y ON x.puissanceId = y.puissanceId
      JOIN CATEGORIE AS z ON x.catId = z.catId
      JOIN SOUS_CATEGORIE AS t ON x.catId = t.catId and x.sousCatId = t.sousCatId
    ORDER BY cat, sousCat, unite, borneInf    
    ;
    
    ROLLBACK ; 
    =>

    unite   borneInf  borneSup  cat          sousCat                  respCivile  defenseRecours securiteRoutiere coutPolice
    
    CV      0         2         Catégorie 1   /                       201657      10183          17500            10000
    CV      3         6         Catégorie 1   /                       244399      12220          17500            10000
    CV      7         10        Catégorie 1   /                       285114      14756          17500            10000
    CV      11        14        Catégorie 1   /                       346233      17312          17500            10000
    CV      15        23        Catégorie 1   /                       407332      20367          17500            10000
    CV      24        9999      Catégorie 1   /                       427698      21385          17500            10000
    CV      3         6         Catégorie 2   /                       401383      20069          10500            10000
    CV      7         10        Catégorie 2   /                       563124      28156          10500            10000
    CV      11        14        Catégorie 2   /                       583830      29192          10500            10000
    CV      15        23        Catégorie 2   /                       693298      34665          10500            10000
    CV      24        9999      Catégorie 2   /                       716102      35905          10500            10000
    tonne   0         1         Catégorie 3  marchandises (tonnage)   578610      28931          10500            10000
    tonne   2         5         Catégorie 3  marchandises (tonnage)   694332      34717          10500            10000
    tonne    6        10        Catégorie 3  marchandises (tonnage)   921888      46094          10500            10000
    tonne   11        15        Catégorie 3  marchandises (tonnage)   1383054     69153          10500            10000
    tonne   16        25        Catégorie 3  marchandises (tonnage)   1843776     92189          10500            10000
    tonne   26        9999      Catégorie 3  marchandises (tonnage)   2764164     138208         10500            10000
    remorque 0        0         Catégorie 3  remorque                 1000000     0              0                0
    CV      3         6         Catégorie 4  taxis 4 places           690102      34505          0                10000
    CV      7         10        Catégorie 4  taxis 4 places           728486      36424          0                10000
    CV      11        14        Catégorie 4  taxis 4 places           806813      40341          0                10000
    CV      15        23        Catégorie 4  taxis 4 places           846877      42344          0                10000
    CV      3         6         Catégorie 4  taxis 5 places           784239      42344          0                10000
    CV      7         10        Catégorie 4  taxis 5 places           822563      41128          0                10000
    CV      11        14        Catégorie 4  taxis 5 places           900947      45047          0                10000
    CV      15        23        Catégorie 4  taxis 5 places           941015      47051          0                10000
    
    Les résultats sont-ils en contradiction avec tableaux du post #54 ?
    Avez-vous des observations à faire ?

    Les tableaux exhaustifs sont éclairants pour la modélisation. Il serait bien que vous fournissiez ceux des garanties et des sous-garanties, ça aiderait pour une meilleure compréhension du système...

    Bon courage.
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  16. #56
    Membre à l'essai
    Homme Profil pro
    Développeur Java
    Inscrit en
    Décembre 2019
    Messages
    83
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Guinée

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Décembre 2019
    Messages : 83
    Points : 23
    Points
    23
    Par défaut Conception d'un MCD pour une assurance automobile
    Bonjour Monsieur fsmrel,
    Vos tableaux des catégories et sous-catégories (post #54) sont éclairants.

    Comme précédemment, la responsabilité civile et la défense recours dépendent soit de la catégorie (cas des catégories 1 et 2), soit de la sous-catégorie (cas des catégories 3 et 4). A la réflexion, le plus simple du point de vue de la modélisation (puis de la mise en oeuvre SQL) est que chaque catégorie possède au moins une sous-catégorie (ce qui vaut donc automatiquement pour les catégories 1 et 2, même si fonctionnellement ça n’est pas le cas), ce qui permet aussi de n’avoir qu’un seul endroit où représenter la sécurité routière et la défense recours, c’est-à-dire dans l’entité-type SOUS_CATEGORIE.
    Pour ce qui concerne la sécurité routière et la défense recours, elles sont des champs calculés. La sécurité routière est par endroit contenue dans la responsabilité civile telle que les catégories 4 et 5 sinon dans les autres cas, elle est calculée comme suit: sécurité routière= nombre de place assise sur la carte grise multiplié par 3500 selon notre code d'assurance sauf pour les engins portuaires et de chantier(EPC). Pour celle de la défense recours c'est égale = responsabilité civile multiplié par 25%.
    Entité-type PUISSANCE : avec l’apparition du tonnage, le nom de cette entité-type n’est plus très approprié, mais peu importe on va le garder, vu qu’essentiellement se sont les CV qui restent majoritaires. Tout au plus peut-on renommer les attributs puissanceMin et puissanceMax respectivement en borneInf et borneSup, et on ajoute un attribut puissanceCode (identifiant naturel, dont la valorisation est à notre charge),ainsi qu’un attribut unite qui permet de savoir si on a affaire à des chevaux-vapeurs ou à des tonnes, etc. (dans votre tableau associé à la catégorie 3, l’attribut unite prend systématiquement la valeur "tonne", sauf dans le cas de la dernière ligne où, comme un cheveu sur la soupe, on trouve la valeur "remorque" : admettons ! Pour des raisons de cohérence évidentes, j’ai pris le parti de faire appartenir à la catégorie 3-1 tout ce qui est du type "tonne" et d’isoler dans une autre sous-catégorie (disons 3-2) ce qui est "remorque".
    A ce niveau, je suis entièrement d'accord avec vous car l'unité peut être en cheval ou en tonne et aussi borneInf et borneSup est satisfaisant.
    Mais pour celle de la catégorie et sous-catégorie, je pensais qu'on pouvait maintenir l'ancienne forme à savoir celle de la catégorie et sous-catégorie liée à l'entité PFC. Si vous avez autres suggestion à ce niveau, j'aimerais bien comprendre.
    En ce qui concerne les transformations entre Véhicule-Contrat, Véhicule-Client, Véhicule-Avenant, Client-Contrat, Client-Avenant, vous trouverez dans le code Sql ci-dessous:
    CREATE TABLE CATEGORIE(
    categorieId INT IDENTITY,
    codecategorie CHAR(4) NOT NULL,
    libelleCategorie VARCHAR(50) NOT NULL,
    nombreplacecategorie INT NOT NULL,
    PRIMARY KEY(categorieId),
    UNIQUE(codecategorie)
    );

    CREATE TABLE CLIENT(
    clientId INT IDENTITY,
    codeclient VARCHAR(10) NOT NULL,
    nomClient VARCHAR(50) NOT NULL,
    prenomClient VARCHAR(50) NOT NULL,
    adresseClient VARCHAR(50) NOT NULL,
    telephoneClient VARCHAR(30) NOT NULL,
    PRIMARY KEY(clientId),
    UNIQUE(codeclient)
    );

    CREATE TABLE APPORTEUR(
    apporteurId INT IDENTITY,
    codeapporteur VARCHAR(5) NOT NULL,
    nomApporteur VARCHAR(50) NOT NULL,
    prenomApporteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(apporteurId),
    UNIQUE(codeapporteur)
    );

    CREATE TABLE TYPECONTRAT(
    typeContratId INT IDENTITY,
    codetypecontrat CHAR(2) NOT NULL,
    libelleTypeContrat VARCHAR(50) NOT NULL,
    PRIMARY KEY(typeContratId),
    UNIQUE(codetypecontrat)
    );

    CREATE TABLE GARANTIE(
    garantieId INT IDENTITY,
    codegarantie CHAR(2) NOT NULL,
    Libelle_Garantie VARCHAR(50) NOT NULL,
    PRIMARY KEY(garantieId),
    UNIQUE(codegarantie)
    );

    CREATE TABLE Sous_Garantie(
    sousGarantieId INT IDENTITY,
    codesousgarantie CHAR(2) NOT NULL,
    libelleSousGarantieId VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    garantieId INT NOT NULL,
    PRIMARY KEY(sousGarantieId),
    UNIQUE(codesousgarantie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE PUISSANCE(
    puissanceId INT IDENTITY,
    codepuissance VARCHAR(3) NOT NULL,
    borneInf INT NOT NULL,
    borneSup INT NOT NULL,
    unite INT NOT NULL,
    PRIMARY KEY(puissanceId),
    UNIQUE(codepuissance)
    );

    CREATE TABLE PFC(
    categorieId INT,
    puissanceId INT,
    responsabilitecivile VARCHAR(50) NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(puissanceId) REFERENCES PUISSANCE(puissanceId)
    );

    CREATE TABLE AGENCE(
    agenceId INT IDENTITY,
    codeagence VARCHAR(3) NOT NULL,
    nomAgence VARCHAR(50) NOT NULL,
    dateCreation DATE NOT NULL,
    PRIMARY KEY(agenceId),
    UNIQUE(codeagence)
    );

    CREATE TABLE SOUS_CATEGORIE(
    souscategorieId INT IDENTITY,
    codesouscategorie VARCHAR(4) NOT NULL,
    libelleSousCategorie VARCHAR(50) NOT NULL,
    categorieId INT NOT NULL,
    PRIMARY KEY(souscategorieId),
    UNIQUE(codesouscategorie),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId)
    );

    CREATE TABLE PFC_SC(
    categorieId INT,
    puissanceId INT,
    souscategorieId INT NOT NULL,
    PRIMARY KEY(categorieId, puissanceId),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId),
    FOREIGN KEY(souscategorieId) REFERENCES SOUS_CATEGORIE(souscategorieId)
    );

    CREATE TABLE CAISSIERE(
    agenceId INT,
    caissiereId INT IDENTITY,
    codecaissiere VARCHAR(4) NOT NULL,
    prenomcaissiere VARCHAR(40) NOT NULL,
    nomcaissiere VARCHAR(40) NOT NULL,
    PRIMARY KEY(agenceId, caissiereId),
    UNIQUE(codecaissiere),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE AVENANT_LIBELLE(
    avenantlibelleId INT IDENTITY,
    avenantlibellecode CHAR(3) NOT NULL,
    avenantlibellevaleur VARCHAR(50),
    PRIMARY KEY(avenantlibelleId),
    UNIQUE(avenantlibellecode)
    );

    CREATE TABLE MODEPAIEMENT(
    modepaiemenId INT IDENTITY,
    modepaiement_libelle VARCHAR(50),
    PRIMARY KEY(modepaiemenId)
    );

    CREATE TABLE PRODUCTEUR(
    agenceId INT,
    producteurId INT IDENTITY,
    codeproducteur VARCHAR(5) NOT NULL,
    Nomproducteur VARCHAR(50) NOT NULL,
    Prenomprodcteur VARCHAR(50) NOT NULL,
    PRIMARY KEY(agenceId, producteurId),
    UNIQUE(codeproducteur),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId)
    );

    CREATE TABLE CONTRAT(
    clientId INT,
    contratId INT IDENTITY,
    codecontrat VARCHAR(10) NOT NULL,
    dateEffetContrat DATE NOT NULL,
    dateExpirationContrat DATE NOT NULL,
    apporteurId INT,
    agenceId INT NOT NULL,
    agenceId_1 INT NOT NULL,
    producteurId INT NOT NULL,
    typeContratId INT NOT NULL,
    PRIMARY KEY(clientId, contratId),
    UNIQUE(codecontrat),
    FOREIGN KEY(clientId) REFERENCES CLIENT(clientId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId),
    FOREIGN KEY(agenceId) REFERENCES AGENCE(agenceId),
    FOREIGN KEY(agenceId_1, producteurId) REFERENCES PRODUCTEUR(agenceId, producteurId),
    FOREIGN KEY(typeContratId) REFERENCES TYPECONTRAT(typeContratId)
    );

    CREATE TABLE AVENANT(
    clientId INT,
    contratId INT,
    avenantId INT IDENTITY,
    codeavenant VARCHAR(10) NOT NULL,
    libelleAvenant VARCHAR(50) NOT NULL,
    dateEffetAvenant DATE NOT NULL,
    dateExpirationAvenant DATE NOT NULL,
    avenantlibelleId INT NOT NULL,
    apporteurId INT,
    PRIMARY KEY(clientId, contratId, avenantId),
    UNIQUE(codeavenant),
    FOREIGN KEY(clientId, contratId) REFERENCES CONTRAT(clientId, contratId),
    FOREIGN KEY(avenantlibelleId) REFERENCES AVENANT_LIBELLE(avenantlibelleId),
    FOREIGN KEY(apporteurId) REFERENCES APPORTEUR(apporteurId)
    );

    CREATE TABLE VEHICULE(
    clientId INT,
    contratId INT,
    vehiculeId INT IDENTITY,
    codevehicule CHAR(5) NOT NULL,
    marque VARCHAR(50) NOT NULL,
    type VARCHAR(50) NOT NULL,
    energie VARCHAR(15) NOT NULL,
    serie VARCHAR(40) NOT NULL,
    vehiculepuissance INT NOT NULL,
    nombreDePlaceCarteGrise INT NOT NULL,
    nombreDePlaceCabine BIGINT NOT NULL,
    clientId_1 INT NOT NULL,
    categorieId INT NOT NULL,
    puissanceId INT NOT NULL,
    PRIMARY KEY(clientId, contratId, vehiculeId),
    UNIQUE(codevehicule),
    FOREIGN KEY(clientId, contratId) REFERENCES CONTRAT(clientId, contratId),
    FOREIGN KEY(clientId_1) REFERENCES CLIENT(clientId),
    FOREIGN KEY(categorieId, puissanceId) REFERENCES PFC(categorieId, puissanceId)
    );

    CREATE TABLE PROTEGER(
    categorieId INT,
    garantieId INT,
    PRIMARY KEY(categorieId, garantieId),
    FOREIGN KEY(categorieId) REFERENCES CATEGORIE(categorieId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ASSOCIER(
    clientId INT,
    contratId INT,
    garantieId INT,
    PRIMARY KEY(clientId, contratId, garantieId),
    FOREIGN KEY(clientId, contratId) REFERENCES CONTRAT(clientId, contratId),
    FOREIGN KEY(garantieId) REFERENCES GARANTIE(garantieId)
    );

    CREATE TABLE ENCAISSE_C(
    clientId INT,
    contratId INT,
    agenceId INT,
    caissiereId INT,
    modepaiemenId INT,
    dateEncaisseC DATE NOT NULL,
    montantEncaisseC BIGINT NOT NULL,
    PRIMARY KEY(clientId, contratId, agenceId, caissiereId, modepaiemenId),
    FOREIGN KEY(clientId, contratId) REFERENCES CONTRAT(clientId, contratId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId),
    FOREIGN KEY(modepaiemenId) REFERENCES MODEPAIEMENT(modepaiemenId)
    );

    CREATE TABLE ENCAISSE_A(
    clientId INT,
    contratId INT,
    avenantId INT,
    agenceId INT,
    caissiereId INT,
    modepaiemenId INT,
    dateEncaisseA DATE NOT NULL,
    montantEncaisseA BIGINT NOT NULL,
    PRIMARY KEY(clientId, contratId, avenantId, agenceId, caissiereId, modepaiemenId),
    FOREIGN KEY(clientId, contratId, avenantId) REFERENCES AVENANT(clientId, contratId, avenantId),
    FOREIGN KEY(agenceId, caissiereId) REFERENCES CAISSIERE(agenceId, caissiereId),
    FOREIGN KEY(modepaiemenId) REFERENCES MODEPAIEMENT(modepaiemenId)
    );

    CREATE TABLE CLI_AV(
    clientId INT,
    clientId_1 INT,
    contratId INT,
    avenantId INT,
    dateemissioncliav DATE NOT NULL,
    PRIMARY KEY(clientId, clientId_1, contratId, avenantId),
    FOREIGN KEY(clientId) REFERENCES CLIENT(clientId),
    FOREIGN KEY(clientId_1, contratId, avenantId) REFERENCES AVENANT(clientId, contratId, avenantId)
    );

    CREATE TABLE VEH_AV(
    clientId INT,
    contratId INT,
    vehiculeId INT,
    clientId_1 INT,
    contratId_1 INT,
    avenantId INT,
    dateemissionvehav DATE NOT NULL,
    PRIMARY KEY(clientId, contratId, vehiculeId, clientId_1, contratId_1, avenantId),
    FOREIGN KEY(clientId, contratId, vehiculeId) REFERENCES VEHICULE(clientId, contratId, vehiculeId),
    FOREIGN KEY(clientId_1, contratId_1, avenantId) REFERENCES AVENANT(clientId, contratId, avenantId)
    );
    Au niveau des encaissements des contrats et des avenants, j'ai ajouté une entité MODEPAIEMENT qui permet de déterminer quel type de paiement qui a été effectué sur l'encaissement.
    Quelles sont vos remarques et suggestions?
    Merci par avance.
    Voici le MCD ci-dessous:
    Images attachées Images attachées  

  17. #57
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonjour Zidane7,

    Concernant les catégories et sous-catégories :

    Citation Envoyé par Zidane7 Voir le message
    Pour ce qui concerne la sécurité routière et la défense recours, elles sont des champs calculés.
    D’accord. Dans le MCD je supprime donc les attributs correspondants.

    Par ailleurs vous aviez écrit (post #18) :

    Citation Envoyé par Zidane7 Voir le message
    les champs non calculés sont les suivants: La RC (Responsabilité Civile), Cout de police et la CEDEAO.
    Dans le post #55, j’ai fait figurer le coût de la police dans l’entité-type SOUS_CATEGORIE (attribut coutPolice). Ceci justifie en fait la mise en oeuvre de l’entité-type PFC_SC, dans le MCD fourni dans le post #24. Ce MCD légèrement retouché est le suivant et peut remplacer celui du post #55 :

    Nom : Zidane7_assurance_auto_chemin(v2)coutPolice.png
Affichages : 180
Taille : 31,1 Ko

    Maintenant, fonctionnellement parlant, à quel niveau se situe la CEDEAO ? Catégorie ? Sous-catégorie ? Autre ?  

    Par ailleurs, dans le cas général, le coût de la police est le même pour l’ensemble des sous-catégories que vous aviez présentées, mais pour les remorques on y voit que ce coût est différent. Existe-t-il d’autres cas où le coût de la police ne serait pas celui du cas général ?
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  18. #58
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    J’ai écrit :

    Citation Envoyé par fsmrel Voir le message
    Ce MCD légèrement retouché est le suivant et peut remplacer celui du post #55
    En fait, pour l’instant ce MCD retouché ne peut pas remplacer celui du post #55 car pour la catégorie 4 la responsabilité civile dépend du nombre de places, ce qui fait qu’en l’occurrence c’est la sous-catégorie qui permet de déterminer la RC (en relation bien sûr avec la puissance). Je vais creuser ça.
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

  19. #59
    Membre à l'essai
    Homme Profil pro
    Développeur Java
    Inscrit en
    Décembre 2019
    Messages
    83
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Guinée

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Décembre 2019
    Messages : 83
    Points : 23
    Points
    23
    Par défaut Conception d'un MCD pour une assurance automobile
    Bonjour Monsieur fsmrel.
    Maintenant, fonctionnellement parlant, à quel niveau se situe la CEDEAO ? Catégorie ? Sous-catégorie ? Autre ?
    En principe la CEDEAO se trouve non seulement dans la catégorie mais aussi dans la sous catégorie à des différence près à savoir de la catégorie 1 jusqu'à la catégorie 4 et ses sous-catégories elle est égale à 100 0000 et de la catégorie 5 et sous-catégories (MOTO), elle est égale à 70 000. Pour se fait ne serait-il pas possible d'en faire une table(sous forme de constante qui contient les valeurs suivantes: 100 000 pour toutes sortes de véhicules et 70 000 pour toutes sortes de motos) qui li non seulement la catégorie mais aussi les sous-catégories?
    Par ailleurs, dans le cas général, le coût de la police est le même pour l’ensemble des sous-catégories que vous aviez présentées, mais pour les remorques on y voit que ce coût est différent. Existe-t-il d’autres cas où le coût de la police ne serait pas celui du cas général ?
    Oui à part la remorque, il ya aussi le cas des flottes dont la police peut varier donc à ce niveau on laisse la main à l'utilisateur de saisir la police.
    Avez-vous d'autres remarques et suggestions?
    Merci infiniment.

  20. #60
    Expert éminent sénior
    Avatar de fsmrel
    Homme Profil pro
    Spécialiste en bases de données
    Inscrit en
    Septembre 2006
    Messages
    7 966
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Spécialiste en bases de données
    Secteur : Conseil

    Informations forums :
    Inscription : Septembre 2006
    Messages : 7 966
    Points : 30 778
    Points
    30 778
    Billets dans le blog
    16
    Par défaut
    Bonjour Zidane7,  

    Pendant que j’ai 5 minutes...

    A propos des données calculées : puisque vous utilisez SQL Server, on peut envisager l’utilisation des « colonnes calculées ». Dans le cas de la défense recours, c’est simple, puisqu’elle est égale à 25% de la responsabilité civile. Aménagement du code fourni dans le post #55 :

    CREATE TABLE PFC
    (
       puissanceId     INT,
       catId           INT,
       sousCatId       INT,
       respCivile      DECIMAL(9) NOT NULL,
       defenseRecours AS CEILING(respCivile / 25) PERSISTED,  
       CONSTRAINT PFC_PK PRIMARY KEY(puissanceId, catId, sousCatId),
       CONSTRAINT PFC_SOUS_CATEGORIE_FK FOREIGN KEY(catId, sousCatId) 
           REFERENCES SOUS_CATEGORIE(catId, sousCatId)
    ); 
    Pour arriver à faire les arrondis pour la colonne defenseRecours (fonction CEILING), le type de la colonne respCivile passe à DECIMAL.

    L’utilisation du paramètre PERSISTED permet de rendre la donnée persistante, donc par exemple indexable. Si vous n’en voyez pas l’utilité vous pouvez ne pas utiliser ce paramètre.

    Vous avez précisé que la défense recours est égale à 25% de la responsabilité civile, mais dans vos tableaux c’est plutôt 20% (ce qui n’est pas toujours respecté, par exemple pour la catégorie 1, puissance < 3 CV, responsabilité civile = 203657, votre tableau fournit la valeur 10183 pour la défense recours, alors que, sur la base de 20%, le calcul donne 10083).

    Par ailleurs, attention ! Si un jour le pourcentage change, alors par ALTER TABLE on pourra modifier la règle de calcul de la colonne defenseRecours, mais il faudra réfléchir aux conséquences sur l’existant.

    Exemple de création d’une ligne dans PFC (catégorie 1), en reprenant et modifiant le code fourni dans le post #55 (on ne fournit évidemment plus rien pour la colonne defenseRecours) :

    INSERT INTO PFC (puissanceId, catId, sousCatId, respCivile)
    VALUES 
         ((SELECT puissanceId FROM PUISSANCE WHERE puissanceCode = 'C1')
        , (SELECT catId FROM CATEGORIE WHERE catCode = '1')
        , (SELECT sousCatId FROM SOUS_CATEGORIE WHERE sousCatCode  = '1-1')
        , 201657) ; 
    =>

    unite        borneInf    borneSup    cat           sousCat   respCivile  defenseRecours  
    CV           0           2           Catégorie 1   /         201657      10083 
    CV           3           6           Catégorie 1   /         244399      12220 
    Votre sentiment à propos de la colonne calculée defenseRecours ?
    (a) Faites simple, mais pas plus simple ! (A. Einstein)
    (b) Certes, E=mc², mais si on discute un peu, on peut l’avoir pour beaucoup moins cher... (G. Lacroix, « Les Euphorismes de Grégoire »)
    => La relativité n'existerait donc que relativement aux relativistes (Jean Eisenstaedt, « Einstein et la relativité générale »)

    __________________________________
    Bases de données relationnelles et normalisation : de la première à la sixième forme normale
    Modéliser les données avec MySQL Workbench
    Je ne réponds pas aux questions techniques par MP. Les forums sont là pour ça.

Discussions similaires

  1. Réponses: 2
    Dernier message: 28/03/2008, 20h23
  2. Mcd pour une suivi de materiel simple SVP
    Par moumio dans le forum Forms
    Réponses: 1
    Dernier message: 25/11/2007, 15h47
  3. [MCD] Conception d'un MCD pour des étudiants d'une fac
    Par beegees dans le forum Schéma
    Réponses: 7
    Dernier message: 16/10/2006, 03h05
  4. Réponses: 3
    Dernier message: 12/01/2006, 19h47
  5. [Conception] - Organisation des pages pour une requete.
    Par ShinJava dans le forum PHP & Base de données
    Réponses: 14
    Dernier message: 24/10/2005, 16h33

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo