Initiation à la conception de bases de données relationnelles avec MERISE

Chaque entité est unique et est décrite par un ensemble de propriétés encore appelées attributs ou caractéristiques. Une des propriétés de l'entité est l'identifiant. Cette propriété doit posséder des occurrences uniques et doit être source des dépendances fonctionnelles avec toutes les autres propriétés de l'entité. Bien souvent, on utilise une donnée de type entier qui s'incrémente pour chaque occurrence, ou encore un code unique spécifique du contexte.

Le formalisme d'une entité est le suivant :

Ainsi, si on reprend notre dictionnaire de données précédent, on schématise par exemple une entité «Auteur» comme ceci :

À partir de cette entité, on peut retrouver la règle de gestion suivante : un auteur est identifié par un numéro unique (id_a) et est caractérisé par un nom, un prénom et une date de naissance.

Une entité peut n'avoir aucune, une ou plusieurs occurrences. Pour illustrer ce terme d'« occurrence » qui a déjà été utilisé plusieurs fois, voici un exemple de table d'occurrences de l'entité Auteur :

Cette table est composée de trois occurrences de l'entité Auteur.

Remarques

• Les occurrences sont parfois appelées tuples. Par ailleurs, la table d'occurrences peut être comparée à l'instance d'une relation (implantation relationnelle d'une entité ou association) à un moment donné. Nous reviendrons sur cette notion de relation dans la partie III.
• Au niveau conceptuel, on devrait plutôt parler d'entités-types, les entités étant en fait des instances d'entités-types. Par souci de simplicité, on gardera les termes d'entités et associations tout au long du cours.

Une association définit un lien sémantique entre une ou plusieurs entités. En effet, la définition de liens entre entités permet de traduire une partie des règles de gestion qui n'ont pas été satisfaites par la simple définition des entités.

Le formalisme d'une association est le suivant :

Généralement le nom de l'association est un verbe définissant le lien entre les entités qui sont reliées par cette dernière. Par exemple :

Ici l'association « être né » traduit les deux règles de gestion suivantes :

• un auteur est né dans un et un seul pays ;
• dans un pays, sont nés aucun, un ou plusieurs auteurs.

Vous remarquerez que cette association est caractérisée par ces annotations 1,1 et 0,N qui nous ont permis de définir les règles de gestions précédentes. Ces annotations sont appelées les cardinalités.

Une cardinalité est définie comme ceci :

minimum, maximum

Les cardinalités les plus répandues sont les suivantes : 0,N ; 1,N ; 0,1 ; 1,1. On peut toutefois tomber sur des règles de gestion imposant des cardinalités avec des valeurs particulières, mais cela reste assez exceptionnel et la présence de ces cardinalités imposera l'implantation de traitements supplémentaires.

L'identifiant d'une association ayant des cardinalités 0,N/1,N de part et d'autre, est obtenu par la concaténation des entités qui participent à l'association. Imaginons l'association suivante :

Ici un auteur rédige au moins un ou plusieurs livres et pour chaque livre, on connaît le nombre de chapitres rédigés par l'auteur (on connaît aussi le nombre total de chapitres pour chaque livre).

L'association « rédiger » peut donc être identifiée par la concaténation des propriétés id_a et id_l. Ainsi, le couple id_a, id_l doit être unique pour chaque occurrence de l'association. On peut également définir la dépendance fonctionnelle suivante :

id_a, id_l ? nb_chapitres

On dit que nb_chapitres (nombre de chapitres rédigés par un auteur, pour un livre) est une donnée portée par l'association « rédiger ». Cette association est donc une association porteuse de données.

Pour une association ayant au moins une cardinalité de type 0,1 ou 1,1 considérons dans un premier temps que cette dernière ne peut être porteuse de données et qu'elle est identifiée par l'identifiant de l'entité porteuse de la cardinalité 0,1 ou 1,1.

Nous reviendrons plus en détail sur la notion d'identification d'une association lors du passage au modèle logique.

Avec toutes ces connaissances, il nous est donc possible d'élaborer le MCD complet à partir des données présentes dans le dictionnaire des données :

Remarques

• Souvent, pour un même ensemble de règles de gestion, plusieurs solutions sont possibles au niveau conceptuel. Par exemple, rien ne nous obligeait ici à créer une entité Type. Une simple donnée portée par l'entité Livre aurait pu convenir également.
• Pour que le MCD soit sémantiquement valide, toute entité doit être reliée à au moins une association.
• Les entités et les propriétés peuvent être historisées. Dans ce cas on met un (H) à la fin du nom de l'entité ou de la propriété que l'on souhaite historiser (cela permet de préciser que l'on archivera toutes les modifications sur une entité ou une propriété donnée). Cela doit également répondre à une règle de gestion.
• Il existe des outils de modélisation payants et d'autres gratuits pour MERISE (powerAMC, OpenModelSphere, AnalyseSI, JMerise, etc.).
• On aurait pu, dans ce cas précis, conserver également une date de rentrée des livres, calculée à partir de la date de location et de la durée de celle-ci. C'est un exemple de donnée calculée dont la conservation peut s'avérer pertinente (notamment pour faciliter l'envoi de rappels).

Le modèle logique de données (MLD) est composé uniquement de ce que l'on appelle des relations. Ces relations sont à la fois issues des entités du MCD, mais aussi d'associations, dans certains cas. Ces relations nous permettront par la suite de créer nos tables au niveau physique.

Une relation est composée d'attributs. Ces attributs sont des données élémentaires issues des propriétés des différentes entités, mais aussi des identifiants et des données portées par certaines associations.

Une relation possède un nom qui correspond en général à celui de l'entité ou de l'association qui lui correspond. Elle possède aussi une clef primaire qui permet d'identifier sans ambiguïté chaque occurrence de cette relation. La clef primaire peut être composée d'un ou plusieurs attributs, il s'agit d'une implantation de la notion d'identifiant des entités et associations qui se répercute au niveau relationnel.

Voici un premier exemple de relation (issue de l'entité « Edition » de notre précédent MCD) :

Edition (id_ed, nom_ed)

Légende :
x : relation
x : clef primaire

Remarques

• Ce premier MLD est représenté de manière textuelle. C'est notamment cette représentation que l'on retrouve dans beaucoup de formations d'études supérieures. Il existe toutefois une représentation graphique équivalente.
• Il est important d'accompagner un MLD textuel d'une légende (ce dernier n'ayant pas de formalisme normé). Ceci est d'ailleurs exigé dans certaines formations.

Il existe un autre type de clef appelé clef étrangère. La clef étrangère est un attribut d'une relation qui fait référence à la clef primaire d'une autre relation (ces deux clefs devront donc avoir le même type de données).

Complétons notre premier exemple avec une autre relation où apparaît une clef étrangère :

Edition (id_ed, nom_ed)
Exemplaire (ref_e, id_ed#)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

Remarques

• Au niveau relationnel, on devrait plutôt parler de clef candidate qui permet d'identifier sans ambiguïté une occurrence de la relation pour les clefs primaires. De même, on devrait désigner une clef étrangère par une contrainte d'inclusion vers une clef candidate. Par souci de simplicité, on gardera les termes de clefs primaires et étrangères.
• Par convention, on fait précéder ou suivre la clef étrangère du symbole #. Ceci n'est pas une obligation à partir du moment où les légendes sont suffisamment précises.
• Ici la clef étrangère présente dans la relation « Exemplaire » fait référence à la clef primaire de la relation « Edition ».
• Une relation peut posséder aucune, une ou plusieurs clefs étrangères, mais possède toujours une et une seule clef primaire.

Enfin, vous pouvez également rencontrer le terme de cardinalité de la relation qui signifie ici le nombre d'occurrences d'une relation (ou nombre d'entrées dans la table correspondante) et le terme de degré de la relation qui correspond au nombre d'attributs d'une relation.

Comme cela a déjà été dit précédemment, les relations du MLD sont issues des entités du MCD et de certaines associations. Nous allons maintenant aborder ces règles de conversion de façon plus précise.

III-A-2-a. Règle 1 - conversion d'une entité▲

III-A-2-b. Règle 2 - conversion d'associations n'ayant que des cardinalités de type 0/1,N▲

Une association ayant des cardinalités 0,N ou 1,N de part et d'autre devient une relation dont la clef est constituée des identifiants des entités reliées par cette association. Ces identifiants seront donc également des clefs étrangères respectives. On parle de relations associatives.

Les cardinalités plus restrictives (comme 2,3 ; 1,7 ; …) seront perçues comme des cardinalités de type 0/1,N également (il s'agit en effet de sous-ensembles). Cependant, les règles de gestion qui ne seront plus satisfaites par cette modélisation logique devront l'être par des traitements supplémentaires (via le code de l'application qui exploite la base de données ou encore par des triggers (déclencheurs) si le SGBDR est suffisamment robuste).

Voici un exemple de relation associative issu de l'association « rédiger » de notre MCD :

Rediger (id_a#, id_l#)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

Dans le cas d'associations porteuses de données, les données portées deviennent des attributs de la relation correspondante. Si l'on reprend cet exemple :

L'association « rédiger » devrait maintenant être traduite comme ceci :

Rediger (id_a#, id_l#, nb_chapitres)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

III-A-2-c. Règle 3 - conversion des associations ayant au moins une cardinalité de type 1,1▲

III-A-2-d. Règle 4 - conversion des associations ayant au moins une cardinalité de type 0,1 (et dont les autres cardinalités sont de type 0,1/N)▲

De même que pour les cardinalités 1,1, une association ayant une cardinalité 0,1 doit être binaire, et les deux mêmes possibilités s'offrent à nous :

• créer la clef étrangère dans la relation correspondant à l'entité du côté de la cardinalité 0,1. Rappelons que dans ce cas, l'association ne peut pas être porteuse de données ;
• créer une relation associative qui serait identifiée de la même façon que pour une cardinalité 1,1.

Cependant, dans le cadre d'une cardinalité 0,1, nous verrons qu'il n'est pas toujours préférable de privilégier la première méthode comme c'est le cas pour une cardinalité 1,1.

Imaginons par exemple qu'un livre puisse appartenir à 0 ou 1 catégorie, on obtient le MCD suivant :

Certains diront que toutes les associations binaires de type père-fils ayant des cardinalités 1,N/0,N - 1,1/0,1 sont caractérisées par l'existence d'une dépendance fonctionnelle entre l'identifiant de l'entité père (ici id_cat) et de l'entité fils (ici id_l). Cette dépendance fonctionnelle se schématiserait ainsi :

id_l ? id_cat

Dans ce cas, il apparaît logique de traduire le MCD de cette façon (première méthode) :

Categorie (id_cat, libelle_cat)
Livre (id_l, titre_l, annee_l, resume_l, id_cat#)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

Cependant même si les SGBD le permettent (avec la valeur NULL par défaut), il n'est normalement pas permis d'avoir une clef étrangère sans valeur pour laquelle on retrouverait l'occurrence dans la relation sur laquelle on fait référence.

C'est pourquoi d'autres pensent (avec raison) qu'il vaut mieux créer une relation associative de cette manière (seconde méthode) :

Categorie (id_cat, libelle_cat)
Livre (id_l, titre_l, annee_l, resume_l)
Appartenir (id_l#, id_cat#)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

La pertinence de l'une ou l'autre méthode varie en fonction du nombre d'occurrences caractérisées par la cardinalité 0 ou la cardinalité 1. En effet, lorsque les occurrences avec la cardinalité 1 sont plus nombreuses que les occurrences avec la cardinalité 0, la première méthode est préférable. Dans le cas contraire, c'est la seconde méthode qui est la plus adaptée.

Enfin, dans le cas où une association binaire possède à la fois une cardinalité 0,1 et une cardinalité 1,1 (ce qui est rarement le cas), il est préférable que la clef étrangère soit du côté de la relation correspondant à l'entité située du côté de la cardinalité 1,1.

Avec ces différentes règles de conversion, il nous est déjà possible de convertir notre MCD au complet :

Pays (id_p, nom_p)
Auteur (id_a, nom_a, prenom_a, date_naissance_a, id_p#)
TypeLivre (id_t, libelle_t)
Livre (id_l, titre_l, annee_l, resume_l, id_t#)
Rediger (id_a#, id_l#)
Edition (id_ed, nom_ed)
Exemplaire (ref_e, id_ed#, id_l#)
Inscrit (id_i, nom_i, prenom_i, date_naissance_i, rue_i, ville_i, cp_i, email_i, tel_i, tel_portable_i)
Emprunt (id_em, date_em, delais_em, id_i#, ref_e#)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

Comme vous pouvez le constater, le schéma de la base est déjà fait. Les règles de passage au SQL sont assez simples :

• chaque relation devient une table ;
• chaque attribut de la relation devient une colonne de la table correspondante ;
• chaque clef primaire devient une PRIMARY KEY ;
• chaque clef étrangère devient une FOREIGN KEY.

Voici ce que cela donnerait :

CREATE TABLE Pays ( 
    id_p INT NOT NULL,
    nom_p VARCHAR(50), 
    PRIMARY KEY (id_p) 
); 

CREATE TABLE Auteur ( 
    id_a INT NOT NULL, 
    nom_a VARCHAR (30), 
    prenom_a VARCHAR (30), 
    date_naissance_a DATE, 
    id_p INT NOT NULL, 
    FOREIGN KEY (id_p) REFERENCES Pays(id_p), 
    PRIMARY KEY (id_a) 
); 

CREATE TABLE TypeLivre ( 
    id_t INT NOT NULL, 
    libelle_t VARCHAR (30), 
    PRIMARY KEY (id_t) 
); 

CREATE TABLE Livre ( 
    id_l INT NOT NULL, 
    titre_l VARCHAR (254), 
    annee_l VARCHAR (4), 
    resume_l TEXT, 
    id_t INT NOT NULL, 
    FOREIGN KEY (id_t) REFERENCES TypeLivre(id_t), 
    PRIMARY KEY (id_l) 
); 

CREATE TABLE Rediger ( 
    id_a INT NOT NULL, 
    id_l INT NOT NULL, 
    FOREIGN KEY (id_a) REFERENCES Auteur(id_a), 
    FOREIGN KEY (id_l) REFERENCES Livre (id_l), 
    PRIMARY KEY (id_a, id_l) 
); 

CREATE TABLE Edition ( 
    id_ed INT NOT NULL, 
    nom_ed VARCHAR (254), 
    PRIMARY KEY (id_ed) 
); 

CREATE TABLE Exemplaire ( 
    ref_e VARCHAR(254) NOT NULL, 
    id_ed INT NOT NULL, 
    id_l INT NOT NULL, 
    FOREIGN KEY (id_ed) REFERENCES Edition (id_ed), 
    FOREIGN KEY (id_l) REFERENCES Livre(id_l), 
    PRIMARY KEY (ref_e) 
); 

CREATE TABLE Inscrit ( 
    id_i INT NOT NULL, 
    nom_i VARCHAR (30), 
    prenom_i VARCHAR (30), 
    date_naissance_i DATE, 
    rue_i VARCHAR(50), 
    ville_i VARCHAR(50), 
    cp_i VARCHAR (5), 
    tel_i VARCHAR(15), 
    tel_portable_i VARCHAR(15) ,
    email_i VARCHAR(100),
    PRIMARY KEY (id_i)
); 

CREATE TABLE Emprunt ( 
    id_em INT NOT NULL, 
    date_em DATE, 
    delais_em INT DEFAULT 0, 
    id_i INT NOT NULL, 
    ref_e VARCHAR (254) NOT NULL, 
    FOREIGN KEY (id_i) REFERENCES Inscrit(id_i), 
    FOREIGN KEY (ref_e) REFERENCES Exemplaire(ref_e), 
    PRIMARY KEY (id_em) 
);

Remarque : il est possible de ne pas avoir à gérer l'incrémentation des identifiants par soi-même lors des INSERT avec la plupart des SGBD.

Exemple d'auto-incrémentation sous MySQL :

CREATE TABLE TypeLivre ( 
    id_t INT AUTO_INCREMENT, 
    libelle_t VARCHAR (30), 
    PRIMARY KEY (id_t) 
);

Sous PostgreSQL :

CREATE TABLE TypeLivre ( 
    id_t SERIAL, 
    libelle_t VARCHAR (30), 
    PRIMARY KEY (id_t) 
);

SERIAL créera implicitement une séquence qui s'incrémente avec un pas de 1. Sous Oracle, il faudrait créer soi-même cette séquence.

Il est possible de relier une entité à elle-même par une association, on parle dans ce cas-là d'association réflexive. Imaginons que l'on veuille connaître les inscrits qui sont mariés entre eux tout en conservant leur date de mariage, voici ce que l'on obtiendrait au niveau conceptuel :

Dans ce cas, c'est la même. Il faudra cependant différencier les noms des clefs étrangères de la table associative correspondantes tout en référençant la même clef primaire :

Inscrit (id_i, nom_i, prenom_i, date_naissance_i, rue_i, ville_i, cp_i, email_i, tel_i, tel_portable_i)
EtreMarie (id_epoux#, id_epouse#, date_mariage_i)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

On aurait pu choisir des cardinalités 1,1 et mettre la date de mariage comme donnée de l'entité Inscrit. Ce modèle permet tout de même de mettre la date de mariage en commun avec deux inscrits (ce qui est plus juste au niveau des dépendances fonctionnelles). Si l'on souhaite limiter le nombre de mariages à 1 pour une personne, il suffira de mettre en place un traitement qui vérifiera le nombre d'occurrences pour un inscrit dans la relation EtreMarie.

Comme exemple de traitement de vérification, nous pouvons utiliser un trigger si le SGBDR le permet. Voici un exemple de trigger avec une procédure stockée vérifiant la présence d'une occurrence pour un identifiant donné dans la table EtreMarie :

/* Procédure stockée se chargeant de la vérification */
CREATE OR REPLACE FUNCTION verif_mariage () RETURNS TRIGGER AS $$ 
    DECLARE nb INT; 
    BEGIN 
        SELECT INTO nb COUNT(*) FROM EtreMarie WHERE id_epoux = NEW.epoux OR id_epouse = NEW.id_epouse; 
        IF (nb >= 1) THEN 
            /* Le RAISE EXCEPTION bloquera la suite des traitements dont L'INSERT */ 
            RAISE EXCEPTION 'Mariage impossible !'; 
        END IF; 
        RETURN NEW; 
    END; 
$$ LANGUAGE plpgsql; 

/* Trigger qui se déclenchera avant chaque INSERT dans la table EtreMarie */
CREATE TRIGGER t_verif_mariage BEFORE INSERT 
    ON auteur FOR EACH ROW 
    EXECUTE PROCEDURE verif_mariage();

Pour cet exemple, nous avons choisi le langage PL/PgSQL qui est propre au SGBDR PostgreSQL. Vous pourrez toutefois trouver des syntaxes ressemblantes ou équivalentes sur une grande partie des SGBDR connus. C'est ce type de traitements qui permet de répondre aux règles de gestion non satisfaites par le MCD.

Ne pas limiter le nombre d'occurrences de cette relation, permettrait en outre de conserver les différents mariages des inscrits en cas de divorce (l'intérêt est certes très limité dans le contexte de la gestion des emprunts pour une bibliothèque).

Dans certains cas, il n'est pas toujours pertinent de convertir une entité au niveau conceptuel, par une relation au niveau logique. C'est le cas pour certaines entités simplement composées d'un identifiant, à l'exemple des entités de type Date ou Heure qui sont souvent utilisées dans des associations ternaires.

Imaginons par exemple que des inscrits auraient le privilège de rencontrer un auteur à une date donnée (une rencontre organisée par la bibliothèque). La rencontre est organisée avec un nombre de places limité, il faut donc garder une trace de ceux qui ont déjà fait une rencontre afin de favoriser ceux qui n'ont pas encore eu cette chance. Voici comment nous pourrions représenter cela au niveau conceptuel :

La date de rencontre ne doit pas être une simple donnée portée par l'association, car cela limiterait le nombre de rencontres d'un inscrit avec un auteur à 1 (la relation correspondant à l'association aurait dans ce cas un couple identifiant unique qui imposerait cette restriction).

Le fait de créer une relation Date aurait pour incidence de créer de la redondance inutile, c'est pourquoi, il est recommandé dans ce cas de figure, de passer au niveau logique de cette façon :

Inscrit (id_i, nom_i, prenom_i, date_naissance_i, rue_i, ville_i, cp_i, email_i, tel_i, tel_portable_i)
Auteur (id_a, nom_a, prenom_a, date_naissance_a, nom_p#)
Rencontrer (id_a#, id_i#, date_rencontre)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

Toutes les occurrences du sur-type ne peuvent se trouver que dans aucun ou un seul sous-type. Dans notre exemple ci-dessus, un auteur ne peut pas être également un inscrit et un inscrit ne peut pas être également un auteur (une personne peut être un auteur, un inscrit ou quelqu'un d'autre).

Toutes les occurrences du sur-type se trouvent dans au moins un des sous-types existants. Dans notre exemple, une personne est forcément un auteur ou un inscrit (ou les deux).

Il s'agit d'une combinaison des deux héritages précédents : toutes les occurrences du sur-type se trouvent forcément dans un et un seul des sous-types. Une personne est soit un auteur, soit un inscrit. Cette contrainte est parfois notée « + ».

À son apparition avec Merise II, l'héritage n'était pas encore implanté sur l'ensemble des SGBDR répandus (ce n'est d'ailleurs toujours pas le cas aujourd'hui). Il a donc fallu le simuler au point de vue relationnel.

De façon générale, l'héritage peut être implanté au niveau relationnel en utilisant une clef étrangère vers la relation mère, comme clef primaire pour les relations filles. Reprenons notre exemple précédent :

Personne (id_p, nom_p, prenom_p, date_naissance_p)
Inscrit (id_p#, rue_i, ville_i, cp_i, email_i, tel_i, tel_portable_i)
Auteur (id_p#)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

Ainsi pour satisfaire les contraintes de totalité, d'exclusion ou de partition il faudra mettre en place des traitements supplémentaires au niveau de la base de préférence (triggers, procédures stockées).

Aujourd'hui, la plupart des SGBDR performants sont capables de gérer eux-mêmes l'héritage. C'est notamment le cas avec la clause INHERITS de PostgreSQL. Cette solution est en général préférable parce qu'elle évite les jointures coûteuses entre tables mères et filles. En effet les attributs du sur-type seront automatiquement accessibles depuis le sous-type. Par conséquent, une insertion, modification ou suppression dans le sous-type se répercutera également dans l'entité mère. Cependant, cette solution a pour inconvénient de pouvoir créer des tuples en double au niveau de la relation mère et de violer ainsi les contraintes d'intégrités référentielles en quelque sorte.

Par ailleurs, certains font parfois abstraction de la relation mère dans le cas d'un héritage par partition, et se contentent de créer les relations filles comme relations distinctes ne partageant pas de données communes. Exemple :

Auteur (id_a, nom_a, prenom_a, date_naissance_a)
Inscrit (id_i, nom_i, prenom_i, date_naissance_i, rue_i, ville_i, cp_i, email_i, tel_i, tel_portable_i)

Légende :
x : relation
x : clef primaire
x# : clef étrangère

Cette solution est également acceptable, mais peut nous amener à nous interroger sur la pertinence de l'héritage étant donné que ce dernier n'est pas implanté au niveau relationnel. Cependant, la contrainte de partition reste une règle de gestion à satisfaire d'où l'importance de la modélisation de celle-ci au niveau conceptuel.

Pour conclure, bien qu'appréciée par l'enseignement, la notion d'héritage est très souvent mise de côté par les développeurs dans le cadre d'une base de données relationnelle.

La présence d'occurrences d'une ou plusieurs associations doit obligatoirement se répercuter sur l'association cible de la contrainte d'inclusion.

Par exemple imaginons que l'on souhaite recenser les présentations des ouvrages par leurs auteurs à une date donnée. Voici comment cela pourrait être représenté (de manière simpliste) au niveau conceptuel :

Cela signifie que si un couple livre-auteur est présent dans l'association « presenter », alors il doit obligatoirement être présent dans l'association « rediger ». Cela traduit simplement la règle de gestion qui impose que pour qu'un auteur fasse la promotion d'un ouvrage, il doit en être l'un des écrivains.

Lorsqu'une occurrence est présente dans l'une des associations concernées par la contrainte d'exclusion, elle ne doit pas être présente dans une des autres associations concernées par cette contrainte.

Passons cette fois dans le cadre d'une librairie/imprimerie qui dispose de plusieurs services d'impressions qui lui sont propres. On souhaite déterminer quels sont les livres imprimés et les livres achetés tout en gardant une trace des fournisseurs et des services d'impression :

Dans cet exemple, un livre ne peut pas à la fois être acheté chez un fournisseur et être imprimé par un service d'impression interne.

Chacune des occurrences d'une entité doit être présente dans au moins une de ses associations qui font l'objet d'une contrainte de totalité.

Reprenons notre exemple précédent et adaptons-le à la contrainte de totalité :

Dans cet exemple, un livre est toujours imprimé dans un service interne ou acheté chez un fournisseur.

Une occurrence présente dans une des associations concernées par la contrainte d'égalité l'est également dans toutes les autres associations concernées par cette contrainte.

Prenons l'exemple d'un magasin qui vend des livres et qui souhaite archiver les dépôts et les imprimeries du livre :

Un livre acheté dans un dépôt sera donc également imprimé dans une imprimerie et vice et versa.

Comme dans le cadre d'un héritage, il est possible de combiner les contraintes (TI, T=, XT ou + pour la partition, etc.). Voici un exemple de contrainte de partition :

Pour cet exemple, le livre sera soit imprimé dans un service interne, soit acheté.