Solutions(Word)

Solutions du chapitre 10

1. a) BPrêt = NPrêt/ FBPrêt  = 525 000/ 80  = 6 563 blocs

b) TempsES (BALPrêt) = BPrêt* TempsTrans + NombrePos * TempsPosDébut = 6 563 * 1 ms + 1 * 10 ms =

6 573 ms

c) TempsES (BALPrêt) = BPrêt* TempsTrans + NombrePos * TempsPosDébut = 6 563 * 6 563 / 20  ms + 1 * 10 ms =9 853 ms

d) 33 ms

TempsES(S=IPPrêt pour l'index sur idMembre de la table Prêt) = (HauteurI -1) * TempsESBloc +SelPrêt (idMembre = Valeur )/ FBPrêt)* TempsESBloc

= 2 * 11ms + 52,5 / 53 * 11ms = 33 ms OrdreMoyenI = 2/3 OrdreI = 66

FBPrêt= 2/3 FBMPrêt = 53 N.B. C’est le facteur de blocage dans l’index primaire.

HauteurI = 1 + log OrdreMoyenI (CardPrêt(idMembre) / FBPrêt) = 1+ log 66

(10 000 / 53) = 3

FacteurSélectivitéPrêt (idMembre) = 1/ CardPrêt (idMembre) = 1/10 000 SelPrêt (idMembre = Valeur ) = FacteurSélectivitéPrêt (idMembre)* NPrêt = 525 000/10 000 = 52,5

e) 10 058 blocs

FBPrêt= 2/3*FBMPrêt  = 53

BPrêt = NPrêt/ FBPrêt  = 525 000/ 53  = 9 906 blocs

TailleIndexInterne  CardPrêt (idMembre)/ OrdreMoyenI  = 152 blocs TailleMS(IP) = TailleIndexInterne + BPrêt  10 058 blocs

f) 621,5 ms

HauteurI = log66(525 000) = 4

SelPrêt (idMembre = Valeur )= NPrêt / CardPrêt (idMembre) = 525 000/10 000 = 52,5 lignes

La formule de base d'estimation du coût est :

TempsES (S=IS) = (HauteurI - 1) * TempsESBloc +

SelPrêt (idMembre = Valeur)/ OrdreMoyenI *TempsESBloc + SelPrêt (idMembre = Valeur) * TempsESBloc

TempsES (S=IS) = 3 * 11 ms + 52,5/ 66 *11 ms + 52,5 * 11 ms = 621,5 ms

g) 627 ms

TempsES (S=ISa) = (HauteurI - 1) * TempsESBloc +

SelPrêt (idMembre = Valeur)/ OrdreMoyenI *TempsESBloc +

(1- (1- FacteurSélectivitéPrêt (idMembre))^FB )* BPrêt * TempsESBloc

Comme l'organisation primaire est sérielle sans fragmentation interne, le facteur de blocage est maximal :

FBPrêt = FBMPrêt = 80

BPrêt = NPrêt/ FBPrêt  = 525 000/ 80  = 6 563 blocs

Le facteur de sélectivité est estimé à partir de la cardinalité de la colonne : FacteurSélectivitéPrêt (idMembre) = 1/ CardPrêt (idMembre) = 1/10 000 SelPrêt (idMembre = Valeur ) = FacteurSélectivitéPrêt (idMembre)* NPrêt = 525 000/10 000 = 52,5

On obtient :

TempsES (S=ISa) = 3 * 11ms + 52,5/ 66 *11ms + (1- (1- 1/10 000)⁸⁰ )*

6 563 * 11ms = 627ms

h) 5 897 ms et 5 676 ms

i) Le nombre de lignes pour une valeur de hachage est estimé par :

NPrêt /THPrêt = 525 000/10 000 = 52,5 lignes. Comme ce nombre est inférieur à FBMPrêt = 80, ceci constitue aussi une bonne estimation du facteur de blocage réel :

FBPrêt = 52,5.

Ceci implique en même temps qu'il y aura très peu de chaînages dus aux débordements (sous l'hypothèse d'une bonne distribution) :

TempsES (S=H) = NPrêt /( THPrêt * FBPrêt ) * TempsESBloc TempsES (S=H) = 525 000 /( 10 000 * 52,5) * 11 ms = 11 ms

Comme un bloc de l'espace d'adressage primaire peut contenir FBMPrêt = 80 lignes, le taux moyen de remplissage est estimé par :

52,5/80 = 0,66 j) 10 000 blocs k) 232 345 ms

BPrêt = NPrêt/ FBPrêt  = 525 000/ 80  = 6 563 blocs

TempsES (TRI) = 2 * (BPrêt /M * TempsPosDébut + BPrêt * TempsTrans) + BPrêt * (2 * log M-1 (BPrêt /M) - 1) * TempsESBloc

= 2 * (6 563 /50 * 10 ms + 6 563 *1ms) +

6 563 * (2 * log 49 (6 563 /50) - 1) * 11 ms = 232 345 ms

2. a)

BMembre = NMembre/ FBMembre  = 10 000/ 80  = 125 blocs BPrêt = NPrêt/ FBPrêt  = 525 000/ 80  = 6 563 blocs

Pour R=Prêt :

TempsES (BIM) = BR * TempsTrans + BR/(M-2)* TempsPosDébut + BR/(M-2)* (BS * TempsTrans + TempsPosDébut)

= 6 563 * 1 ms + 6 563 /(50-2)* 10 ms +

6 563 /(50-2)* (125* 1 ms + 10 ms) = 26 428 ms et

19 874 ms pour R=Membre b) 331 375 ms

Détail des calculs :

TempsES (BII) = B Membre* TempsESBloc + N Membre * TempsES(S=IPPrêt pour l'index sur idMembre de la table Prêt)

= 125 * 11ms + 10 000 * 33 ms (voir d))= 331 375ms

c) 6 271 375 ms Détail des calculs :

TempsES (BII) = B Membre* TempsESBloc + N Membre * TempsES(S=ISaPrêt pour l'index sur idMembre de la table Prêt)

= 125 * 11ms + 10 000 * 627 ms (voir g))= 6 271 375 ms

d) 17 397 193 ms

TempsES (BII) = B Prêt* TempsESBloc + N Prêt * TempsES(S=IPMembre pour l'index sur idMembre de la table Membre)

= 6563 (voir 1 a)) * 11ms + 525 000 * 33 ms (voir 1 d))= 17 397 193 ms

e) 23 172 193 ms

TempsES (BII) = B Prêt* TempsESBloc + N Prêt * TempsES(S=ISaMembre pour l'index sur idMembre de la table Membre)

= 6563 (voir 1 a)) * 11ms + 525 000 * 44 ms = 23 172 193 ms

NB L’estimation sans relecture est la même qu’avec relecture dans le cas d’une sélection par clé unique !

f) 111 375 ms

g) 5 847 193 ms et TH = 157

Avec un taux de remplissage de 80%, le facteur de blocage moyen est estimé par :

FBMembre = 0.8 * FBMMembre

La taille de la zône d'adressage primaire TH est donc :

THMembre = NMembre/ FBMembre  = 10 000/(0.8 * 80) = 157 blocs

TempsES (BIH) = BPrêt * TempsESBloc + N Prêt* TempsES(S=HMembre pour hachage sur idMembre)

= 6 563 * 11ms + 525 000 * 11ms = 5 847 193 ms h) 381 166 ms

TempsES (JTF) = TempsES (TRIMembre) + TempsES (TRIPrêt) + 2*(BMembre + BPrêt) * TempsESBloc

BMembre = NMembre/ FBMembre  = 10 000/ 80  = 125 blocs

TempsES (TRIMembre) = 2 * (BMembre /M * TempsPosDébut + BMembre * TempsTrans) +

BMembre * (2 * log M-1 (BMembre /M) - 1) * TempsESBloc

= 2 * (125 /50 * 10 ms + 125 *1ms) + 125 * (2 * log 49 (125 /50) - 1) * 11 ms

= 310 + 1375 = 1 685 ms

BPrêt = NPrêt/ FBPrêt  = 525 000/ 80  = 6563 blocs

TempsES (TRIPrêt) = 2 * (BPrêt/M * TempsPosDébut + BPrêt * TempsTrans) +

BPrêt * (2 * log M-1 (BPrêt /M) - 1) * TempsESBloc

= 2 * (6563 /50 * 10 ms + 6563 *1ms) + 6563 * (2 * log 49 (6563 /50) - 1) * 11 ms

= 15766 + 216579 = 232 345ms

TempsES (JTF) = TempsES (TRIMembre) + TempsES (TRIPrêt) + 2*(BMembre + BPrêt) * TempsESBloc

= 1 685 ms + 232 345ms + 2*(125+6563)* 11 ms

= 381 166 ms

i)

TempsES (BALPrêt) = BPrêt* TempsTrans + NombrePos * TempsPosDébut = 6 563 * 1 ms + 1 * 10 ms = 6 573 ms

TempsES (BALMembre) = BMembre* TempsTrans + NombrePos * TempsPosDébut

= 125 * 1 ms + 1 * 10 ms = 135 ms

TempsES (JH) = TempsES (BALMembre) + TempsES (BALPrêt) +2 * (BMembre + BPrêt)

* log M (BMembre)-1 *TempsESBloc = 135 ms + 6 573 ms +2*(135 + 6 573)*

log 50 (135)-1* 11 ms = 153 844 ms j) organisation sérielle

k)

TempsES (PJ) = TempsES (BALMembre) + TempsES (BALPrêt) = 6 708 ms

3. a)

M e m b r e P r ê t



i d M e m b r e = 1 0



n o m , d a t e P r ê t

b)

M e m b r e

P r ê t



i d M e m b r e = 1 0



n o m , i d M e m b r e



n o m , d a t e P r ê t



i d M e m b r e , d a t e P r ê t

c)

Mise en œuvre par pipeline

M e m b r e

P r ê t



i d M e m b r e = 1 0

( S é l e c t i o n p a r h a c h a g e s u r i d M e m b r e T e m p s E S = 1 1 m s)



n o m , d a t e P r ê t

( B a l a y a g e )

( B o u c l e i m b r i q u é e a v e c h a c h a g e s u r i d M e m b r e d e l a t a b l e

i n t e r n e P r ê t T e m p s E S = 1 1 m s)

( T o t a l T e m p s E S = 2 2 m s )

1. Sélection  idMembre=10 (Membre)

Pour effectuer la sélection, le temps estimé est :

TempsES(S=H sélection sur idMembre) = TempsESBloc = 11 ms (cas d'une clé candidate)

2. Jointure  idMembre=10 (Membre)  Prêt par boucle imbriquée avec hachage sur IdMembre de la table Prêt

Pour la jointure, dans la réalisation par pipeline, les lignes de la table externe ne sont pas matérialisées et le temps de lecture de la table externe est éliminé.

De plus le nombre de lignes de la table externe est 1 dans le cas présent. Donc le temps estimé pour la jointure est égal au temps nécessaire pour effectuer une sélection par hachage :

TempsES (BIH) = TempsES(S=H sur idMembre pour Prêt) = 11 ms (voir exercice 1 i))

La projection finale est effectuée en mémoire centrale et ne nécessite donc pas de transfert disque.

Au total :

TempsES(Plan avec pipeline) = TempsES(S=H sur idMembre pour Membre) + TempsES(S=H sur idMembre pour Prêt) = 22 ms

Mise en œuvre par matérialisation :

M e m b r e

P r ê t



i d M e m b r e = 1 0

( S é l e c t i o n p a r h a c h a g e s u r i d M e m b r e T e m p s E S = 1 1 m s)



n o m , d a t e P r ê t

( B a l a y a g e )

( B o u c l e i m b r i q u é e a v e c h a c h a g e s u r i d M e m b r e d e l a t a b l e

i n t e r n e P r ê t T e m p s E S = 2 2 m s)

( T o t a l T e m p s E S = 7 8 m s ) ( É c r i t u r e t a b l e i n t e r m é d i a i r e

T e m p s E S =1 1 m s )

( É c r i t u r e t a b l e i n t e r m é d i a i r e T e m p s E S =2 2 m s )

1. Sélection  idMembre=10 (Membre)

Pour effectuer la sélection, le temps estimé est le même :

TempsES(S=H sélection sur idMembre) = TempsESBloc = 11 ms

On peut faire l'estimation de la taille du résultat de la sélection en blocs en utilisant la formule de la page 242 :

BidMembre=10 =  SelCommande(idMembre)/ FBMMembre = 1/80 = 1 bloc L'écriture du résultat est estimée à

TempsES (Ecriture de la table intermédiaire résultant de  idMembre=10 (Membre))

= BidMembre=10 * TempsESBloc = 1 * 11ms = 11 ms

2. Jointure  idMembre=10 (Membre)  Prêt par boucles imbriquées avec hachage sur IdMembre de la table Prêt

TempsES (BIH) = BR * TempsESBloc + NR * TempsES (Sélection par hachage sur S)

où R =  idMembre=10 (Membre) et S = Prêt

Selon le calcul effectué précédemment,

BR = BidMembre=10 =  SelCommande(idMembre)/ FBMMembre = 1/80 = 1 bloc NR = NidMembre=10 = SelCommande(idMembre) = 1 ligne

TempsES (Sélection par hachage sur S) = TempsES(S=H sur idMembre pour Prêt) = 11 ms (voir exercice 1 i)

En remplaçant dans la formule initiale :

TempsES (BIH) = 1 * 11 ms + 1 * 11 ms = 22 ms

On peut estimer la taille du résultat de la jointure en utilisant la formule de la page 243 (cas général) :

N R S = NR * NS / maximum(CardR(cléJointure), CardS(cléJointure))

= 1*525 000 /10 000 = 52,5 lignes => 53 en arrondissant (i.e. 1 Membre et en moyenne 52,5 Prêts par Membre)

Le facteur de blocage pour les lignes du résultat peut être estimé par la formule de la page 240 :

FBM R S =  ( FBMR* FBMS)/( FBMR+ FBMS)  =  ( 80* 80)/( 80+

80)  = 40

Donc, la taille de la table intermédiaire est N R S /FBM R S  = 53 /40  = 2 blocs

TempsES (Ecriture de la table intermédiaire résultant de  idMembre=10 (Membre)

 Prêt) = 2 * 11ms = 22ms

NB. On suppose que le pire cas d'un positionnement par écriture de bloc.

3. Projection  nom,datePrêt ( idMembre=10 (Membre)  Prêt) par balayage

Balayage de ( idMembre=10 (Membre)  Prêt) :

TempsES (BAL) = BT * TempsTrans + NombrePos * TempsPosDébut BT = 2 blocs pour T =  idMembre=10 (Membre)  Prêt

On suppose un positionnement, NombrePos = 1, et on obtient : TempsES (BAL) = 2* 1 + 1 * 10 = 12 ms

On ne tient pas compte de l'écriture de la table finale.

Au total :

TempsES(Plan avec pipeline) = 11 + 11+ 22 + 22 + 12 = 78 ms

d) Par rapport à c), on remplace la sélection par hachage par une sélection avec index primaire pour la boucle imbriquée :

TempsES(Plan avec pipeline) = TempsES(S=H sur idMembre pour Membre) + TempsES(S=IP sur idMembre pour Prêt) = 44 ms

e) Par rapport à c), on remplace la sélection par hachage par une sélection avec index secondaire pour la boucle imbriquée. En utilisant l'estimation sans relecture pour la sélection par index secondaire (voir 1 g)), on obtient :

TempsES(Plan avec pipeline) = TempsES(S=H sur idMembre pour Membre) + TempsES(S=ISa sur idMembre pour Prêt) = 11 ms + 627 ms = 638 ms

f) Par rapport à c), on remplace les sélections par hachage par des sélections par index secondaire :

TempsES(Plan avec pipeline) = TempsES(S=ISa sur idMembre pour Membre) + TempsES(S=ISa sur idMembre pour Prêt) = 44 ms + 627 ms = 671 ms

g) Le temps pour la jointure est : 19 874ms (voir 2 a)). Le reste du pipeline se fait en mémoire centrale.

h) Le plan c) produit le meilleur résultat. Il faut évidemment tenir compte des hypothèses faites pour les estimations. En particulier, les estimations du plan c) sous faites sous l'hypothèse d'une organisation optimale pour le hachage.

i) Oui, en supposant une organisation hétérogène (les deux tables dans la même organisation) par hachage sur la clé idMembre.

4)

(A  B)  C A  (B  C) (A  C)  B A  (C  B) (B  A)  C B  (A  C) (B  C)  A B  (C  A) (C  B)  A C  (B  A) (C  A)  B C  (A  B)

Le nombre de plans est (2*(n-1))!/(n-1)! = 4!/2! = 12 5)

La conception du schéma interne consiste à établir les paramètres de l'organisation physique de la BD de manière à obtenir de bonnes performance pour les opérations de manipulation de données prévues. Une organisation physique est pertinente si elle est utile pour le plan d'exécution produit par l'optimiseur de requête. Il faut donc bien comprendre les mécanismes d'optimisation de requête afin de choisir une organisation physique qui sera utilisée dans le plan d'exécution produit par l'optimiseur de requête.

6)

Ceci permet une meilleure indépendance physique des données et simplifie le codage des requêtes et la maintenance des programmes. En particulier, il est possible d'améliorer la

performance du système en modifiant le schéma interne de la BD sans avoir à modifier le code SQL des opérations dans les programmes clients. D'autre part, l'optimiseur adapte le choix du plan d'exécution à l'évolution du volume de données. Le programmeur est donc libéré de la tâche de maintenir manuellement « un bon plan d'exécution » au niveau des programmes.