USTHB – Faculté d’Electronique et Informatique Année 2010/2011

Département Informatique

EMD : Module Bases de données avancées, Master IL

Durée 1h30

Exercice 1 : Schéma de fragmentation

L'administrateur du portail web d’une entreprise spécialisés en vente par internet (e-commerce) dispose d’une
table Utilisateur dont le schéma est le suivant :

Utilisateur (IDU, Nom, Prénom, email, mot_de_passe, Date_Enregistrement, Date_Dernier_Accès, Ville, Pays,
Code_Postal, Téléphone, Age).

Soient les requêtes R1 et R2 suivantes :

R1 : Select Nom, Prénom, email From Utilisateur where Date_Dernier_Accès < ‘01-03-2011’
R2 : Select Ville, Pays, Age From Utilisateur where Date_Enregistrement < ‘01-01-2011’
R3 : Select Nom, Prénom, Ville From Utilisateur where Age>18

Pour optimiser les requêtes R1 et R2, l’administrateur décide de la fragmenter verticalement la table
Utilisateur en trois fragments : User1, User2 et User3. Ces fragments sont définis pour que chaque requête
charge uniquement les colonnes nécessaires à son exécution (R1 charge USER1, R2 Charge USER2).

1. Donner les expressions algébriques permettant de représenter chaque fragment

User1 IDU,Nom,Prénom,Email,Date_Dernier_Accès(Utilisateur)

User2 IDU,Ville, Pays, Age, Date_Enregistrement(Utilisateur)

User3 IDU,Mot_de_passe,Code_Postal,Téléphone (Utilisateur)

2. Donner la réécriture des requêtes R1 et R2 sur la table Utilisateur fragmentée.

R1 Select Nom, Prénom, email From User1 where Date_Dernier_Accès < ‘01-03-2011’

R2 Select Ville, Pays, Age From User2 where Date_Enregistrement < ‘01-01-2011’

3. Donner une réécriture de la requête R3 sur la table Utilisateur fragmentée. Que concluez-vous ?

R3 Select Nom, Prénom, Ville From User1 U1,User2 U2 where U1.IDU=U2.IDU and U2.Age>18

Les deux requêtes R1 et R2 sont réécrites chacune sur un fragment car tous les attributs référencés par chacune des requêtes
appartiennent au même fragment. La requête R3 accède à deux fragments, alors une opération de jointure supplémentaire entre User1
et User2 est ajoutée à la requête pour récupérer tous les attributs référencés.

L’entreprise est répartie géographiquement en trois sites distants : Alger, Oran et Constantine. Une allocation
simple de ces fragments consiste à mettre chacun sur un site : User1 à Alger, User2 à Oran et User3 à
Constantine. Supposons que chaque attribut est codé sur 50 octets, que la table Utilisateur contient 1000 000
de tuples et que la taille d’une page système est de 6000 octets. Le nombre de clients enregistrés avant le 01-
01-2011 est de 50 000, le nombre de clients dont le dernier accès a été fait avant le 01-03-2011 est de 5000, le
nombre de clients âgés de plus de 18 ans est de 800 000.

4. Calculer le coût d’exécution de R1, R2 et R3 avant fragmentation. Ce coût est exprimé en nombre de
pages chargées de la mémoire secondaire pour exécuter chaque requête.

Coût d’exécution avant fragmentation = coût de chargement de la table Utilisateur

Coût = (12*50*1 000 000)/6000= 100 000 E/S

 Exprimez ce coût en secondes sachant que le temps de chargement d’une page est estimé à 1
milliseconde.

Coût=100 000/1000= 100 secondes

5. Sachant que R1 et R2 ont été lancées à Oran et R3 à Constantine.

o Donner les stratégies d’exécution possibles pour R1 et R2.

o Calculer le coût d’exécution de R1 et R2 dans chaque stratégie. Rappelons que ce coût

d’exécution regroupe le coût de chargement de données et le coût de communication. On
suppose que le taux de transmission est de 1000 octets par seconde et que le délai d’attente
avant de mettre les données sur le canal de transmission est de 1 seconde.

o Que concluez-vous ?

Requête Stratégie 1 Stratégie 2

R1 Exécuter R1 à Alger ensuite Envoyer USER1 à Oran ensuite exécuter R1 à Oran

envoyer le résultat à Oran
Envoyer 1 000 000 tuples de USER1
Coût
d’exécution=5*50*1 000 000/6000 Coût = 1+(1 000 000*5*50/10 000)=25001 Secondes

= 41667 E/S = 41,66 secondes Exécuter R1 à Oran

Coût d’envoi du résultat : coût Coût = (1 000 000*5*50/6000)=41667 E/S = 41,66

secondes
d’envoi de 5000 tuples de User1

Coût = 1+(5000*5*50/10 000)=126 Coût total=25 042,66 secondes = 6,95 heures

Secondes

Coût Total=167,66 secondes

R2 Puisque R2 est lancée à Oran et les Conclusion :

données nécessaires à son
exécution sont à Oran, elle sera Par rapport à la table non fragmentée, le coût de R1
exécutée à Oran et aucune donnée a augmenté car les données recherchées par R1
n’est transférée. sont dans un site distant.

Coût d’exécution de R1 = Le coût de R2 a diminué car aucune donnée n’est

5*50*1 000 000/6000 = 41,66 transférée entre sites.
 secondes Nous pouvons conclure que le coût de
communication est un facteur très important dans
l’exécution des requêtes distribuées. Aussi,
l’allocation des fragments aux sites doit être faites
d’une manière intelligente en prenant en compte
l’origine des requêtes distribuées et le temps de
communication.

o Donnez toutes les stratégies d’exécution de la requête R3

La requête R3 est lancée à Constantine, elle contient une jointure entre USER 1 et USER 2 qui sont à
Alger et Oran respectivement.

Description

Stratégie 1 Envoyer USER 1 à Oran, faire la jointure avec USER 2, envoyer le résultat à Constantine

Stratégie 2 Envoyer USER 2 à Alger, faire la jointure avec USER 1, envoyer le résultat à Constantine

Stratégie 3 Envoyer USER 1 et USER 2 à Constantine et exécuter la requête à Constantine

Stratégie 4 Exécuter la restriction Age>18 à Oran, envoyer le résultat à Alger, faire la jointure à alger
ensuite envoyer le résultat à Constantine.

6. Supposons qu’une table T composée de n attributs est fragmentée en m partitions (m<n) où chaque
partition Ti contient ni attributs. Donner l’algorithme de réécriture d’une requête quelconque sur la
table T fragmentée.

Algorithme de Réécriture
Entrées : m partition T1, T2, …, Tm, Une requête R
Sortie : R Réécrite
Début
Soit A={A1, A2, …, Ak}, l’ensemble des attributs de T référencés par R (sauf la clé).
Soit Ai l’ensemble des attributs de chaque fragment Ti (sauf la clé)
Pour j=1 à m
Faire
Si A  Ai alors Le fragment Ti est valide
Remplacer T dans la clause FROM par Ti
Sortir de l’algorithme
Sinon Si A Ai ≠  Alors Ti contient quelques attributs référencés par R
Ajouter Ti dans la liste des fragments valides
Sinon Ti ne contient aucun attribut de R, Il n’est pas valide
Ne rien faire
Fin
Remplacer T dans la clause FROM par des jointures entre tous les fragments valides.
Fin
 7. La fragmentation verticale n’est pas supportée sous Oracle. Proposez une implémentation de la
fragmentation verticale en utilisant les vues.

La fragmentation verticale n’est pas supportée dans la plupart des SGBD. Nous pouvons utiliser les Vues pour
l’implémenter comme suit :

 Créer une vue pour chaque fragment vertical. Si un fragment Ti contient les attributs A1, A2, …, Al de
T alors la vue sera créée comme suit : Create View Ti AS Select A1, A2, …, Al FROM T

 Effectuer la réécriture des requêtes sur les vues : nous pouvons utiliser pour cela l’algorithme de
réécriture donné dans la question précédente.

Exercice 2
Soit le schéma relationnel suivant traitant de la gestion des réservations de chambres d’hôtel :

Hotel (numhotel, nomhotel, ville, NbEtoiles)

Chambre (numchambre, numhotel, type, prix)
Reservation (numchambre, numclient, Date)
Client (numclient, nomcli, adressecli)
Questions
1. Transformez ce schéma relationnel en schéma Objet en précisant les opérations qui peuvent
s’appliquer sur chaque classe.

Pour représenter la classe d’association en ODL, elle est éclatée comme suit :
2. Ecrivez en ODL le code permettant de générer le schéma Objet obtenu à la question précédente
Module reserve_hotel {
Classe Hotel {
(extent hotels key(numhotel))
Attribute int numhotel,
Attribute string nomhotel ,
Attribute string ville,
Attribute int Nbetoiles,
Relationship set <chambre> Chambre_Disp inverse Chambre :: Hotel_Prop,
}
Classe Chambre {
(extent Chambres key(numchambre))
Attribute int numchambre,
Attribute string type,
Attribute float prix ,
Relationship Hotel Hotel_Prop inverse Hotel:: Chambre_Disp ;
Relationship set <reservation> ReservChambre inverse Reservation:: chambreReserv;
}
Classe Reservation {
(extent Reservations key(Chambre::numchambre,Hotel::numhotel))
Attribute date dater,
Relationship Chambre ChambreReser inverse Chambre ::Reservchambre ,
Relationship Client ClientReserv inverse Client :: Reservclient
}
Classe Client {
(extent Clients key(numclient))
Attribute int numclient,
Attribute string nomcli,
Attribute string adressecli,
Relationship set <Reservation> ReservClient inverse Reservation:: ClientReserv
}
};
3. Ecrivez en OQL les requêtes suivantes :
a. Enumérez tous les hôtels 5 étoiles
Select * from Hotels h Where h.nbétoilse=5.
b. Enumérez tous les clients ayant réservé une chambre avant le 01/06/2011 dont le prix est
inférieur à 10 000DA
Select NomClient
From Clients C, C.Réservclient R
Where R.ChambreRéserv.Prix<10 000 and R.Date<01/06/2011
c. Enumérez les noms et les adresses de tous les clients ayant effectué une réservation d’une
chambre de l’hôtel « Mercure » avant le 01/06/2011
Select C.nom, C.adresse
From Clients C, C. Réservclient R
Where R.Date<01/06/2011 and R.ChambreRéserv.Hotel_Prop.Nomhotel=’Mercure’
d. Etablissez la liste des prix et des types de toutes les chambres de l’hôtel « HILTON »
Select ch.type, ch.Prix
From Chambres ch
Where ch.Hotel_Prop.nomhotel=’Hilton’.