10 Évaluation des
requêtes relationnelles
SQL
– QUOI
Évaluateur de requêtes du SGBD
– COMMENT
– en fonction du schéma interne
10.1 Concepts de base
D é c o m p o s i t io n R e q u ê t e ( e x : S Q L )
S c h é m a c o n c e p t u e l &
e x t e r n e
R e q u ê t e i n t e r n e
O p t i m i s a t io n
P l a n d 'e x é c u t i o n
E x é c u t io n
S c h é m a in t e r n e &
s t a t i s t i q u e s
B D
Requête interne
SELECT titre, descripteur FROM Livre, Catégorie
WHERE ISBN = 1-111-1111-1 AND Livre.code = Catégorie.code
Livre {Clé primaire : ISBN}
ISBN : CHAR(13) titre : VARCHAR(50)
annéeParution : DomaineAnnée nomEditeur : VARCHAR(20) code : VARCHAR(10)
<<table>>
Catégorie {Clé primaire : code}
code : VARCHAR(10) descripteur : VARCHAR(20) codeParent : VARCHAR(10)
<<table>>
codeParent
I S B N = 1 - 1 1 1 - 1 1 1 1 - 1
t i t r e , d e s c r i p t e u rSchéma interne
IndexSecondaire<Catégorie,{code}>
IndexSecondaire<Livre,{ISBN}>
Catégorie
<<table>>
Livre
<<table>>
Plan d ’exécution 1
( J o i n t u r e p a r t r i - f u s i o n )
I S B N = 1 - 1 1 1 - 1 1 1 1 - 1
t i t r e , d e s c r i p t e u r
C o û t t o t a l = 2 8 7 3 5 4 0 m s ( B a l a y a g e )
( B a l a y a g e )
Plan d ’exécution 2
( J o i n t u r e p a r b o u c l e i m b r i q u é e m u l t i b l o c s - t a b l e
i n t e r n e C a t é g o r i e )
I S B N = 1 - 1 1 1 - 1 1 1 1 - 1
t i t r e , d e s c r i p t e u r
C o û t t o t a l = 1 7 5 0 4 0 m s ( B a l a y a g e )
( B a l a y a g e )
Plan d ’exécution 3
C a t é g o r i e
( J o i n t u r e p a r b o u c l e i m b r i q u é e e n p a s s a n t p a r l 'i n d e x s e c o n d a i r e s u r c o d e
d e l a t a b l e i n t e r n e C a t é g o r i e )
I S B N = 1 - 1 1 1 - 1 1 1 1 - 1
t i t r e , d e s c r i p t e u r
C o û t t o t a l = 8 8 m s ( B a l a y a g e )
( S é l e c t i o n p a r l 'i n d e x s e c o n d a i r e
s u r I S B N )
10.1.1 Optimisation
statique ou dynamique
Optimisation statique
–
compilation du plan d ’exécution
à la pré-compilation pour le SQL enchâssé statique
au PREPARE du SQL enchâssé dynamique
–
plusieurs exécutions
invoque le plan d ’exécution déjà compilé
EXECUTE du SQL enchâssé dynamique
–
réoptimisation automatique suite à modification de schéma interne?
Optimisation dynamique
–
ré-optimisation (recompilation) à chaque exécution
10.2 Décomposition
1) Analyse syntaxique
2) Analyse sémantique
3) Résolution des vues
4) Simplification syntaxique
5) Simplification sémantique
10.3 Estimation du coût des opérations physiques
TempsES : temps accès à mémoire secondaire (MS)
TempsUCT
– souvent négligeable
TailleMC : espace mémoire centrale
TailleMS : espace mémoire
secondaire
10.3.1 Modèle du coût d'une entrée-sortie en mémoire secondaire
Voir Volume I, chapitre 2
Paramètre Signification
TempsESDisque ( n ) Temps de total transfert (lecture ou écriture) de n octets du disque TempsTrans ( n ) Temps de transfert des n octets sans repositionnement
TempsPosDébut Temps de positionnement au premier octet à transférer (ex : 10 ms ) TempsRotation Délai de rotation (ex : 4 ms )
TempsDépBras Temps de déplacement du bras (ex : 6 ms ) TauxTransVrac Taux de transfert en vrac (ex : 2MB/ sec) TempsESBloc Temps de transfert d'un bloc (ex : 11 ms )
TempsTrans Temps de transfert d'un bloc sans repositionnement (ex : 1 ms ) TailleBloc Taille d'un bloc (ex : 2K octets)
TempsESBloc = TempsESDisque(TailleBloc) = TempsPosDébut
+ TempsTrans (TailleBloc)
10.3.2 Statistiques au sujet des tables
Statistique Signification
N
TNombre de lignes de la table T TailleLigne
TLa taille d'un ligne de la table T FB
TFacteur de blocage moyen de T FBM
TFacteur de blocage maximal de T
Estimation :
( TailleBloc-TailleDescripteurBloc )/ TailleLigne
T . B
TNombre de blocs de la table T
Estimation : N
T/ FB
T
Statistiques (suite)
Statistique Signification
FacteurSélectivité
T( Colonne ) Facteur de sélectivité de la colonne Estimation :
1/ Card
T( Colonne ) ou 1/ 10 (constante arbitraire)
FacteurSélectivité
T( Expression ) Facteur de sélectivité de l’expression Estimation :
FacteurSélectivité
T( Colonne [ Valeur
1.. Valeur
2].) =
(( Valeur
2- Valeur
1)/ ( Max
T( Colonne )- Min
T( Colonne )))
pour Valeur
1, Valeur
2 [ Min
T( Colonne ).. Max
T( Colonne )] ou 1/ 2 (constante arbitraire)
Sel
T( Expression de sélection ) Nombre de lignes (cardinalité) de T sélectionnées par l'expression de sélection.
Estimation :
Sel
T( Colonne = Valeur ) = FacteurSélectivité ( Colonne ) * N
TStatistiques (suite)
Statistique Signification
Card
T( Colonne ): Nombre de valeurs distinctes (cardinalité) de la colonne pour la table T Min
T( Colonne ): Valeur minimum de la colonne dans la table T
Max
T( Colonne ): Valeur maximum de la colonne dans la table T Hauteur
INombre de niveaux dans l'index I
TailleEntrée
ITaille d'une entrée dans un bloc interne de l'index
Approximation : taille de la clé d'index + taille pointeur de bloc Ordre
INombre maximum de fils pour un bloc interne de l'index I
Estimation :
( TailleBloc-TailleDescripteurBloc )/ TailleEntrée
I.
OrdreMoyen
INombre moyen de fils
FBM
fNombre maximum de clés qui peuvent être insérées dans une feuille d'un index arbre-B
+F
INombre de blocs au niveau des feuilles de l'index I
TH Taille de l'espace d'adressage pour la fonction de hachage
Maintien des statistiques par le SGBD
Coût relié à la précision
Mise à jour incrémentale
–
à chaque mise à jour
Mise à jour en différé
–
périodes de faible activité
–
déclenchement contrôlé par ABD
Estimation par échantillonnage
–
tables très volumineuses
Commande ANALYSE (Oracle)
contrôle du déclenchement
paramètres d ’échantillonnage
10.3.3 Coût des
opérations de base
Algèbre physique
Hypothèses
– Néglige effet de l ’antémémoire
– Néglige écriture du résultat
– TailleLigne < TailleBloc
– Sans interruption
10.3.3.1 Balayage (BAL)
TempsES (BAL) = B
T* TempsTrans + NombrePos * TempsPosDébut
P o s it io n n e m e n t # 1
. . .
T r a n s f e r t s a n s b r i s d e s é q u e n c e
P o s i t io n n e m e n t # 2
. . .
T r a n s f e r t s a n s b r is d e s é q u e n c e
P o s it io n n e m e n t # 3
. . .
T r a n s f e r t s a n s b r i s d e s é q u e n c e
Exemple : TempsES (BAL Editeur )
Allocation sérielle sans fragmentation interne
FB
Editeur= FBM
Editeur= 60
B
Editeur= N
Editeur/ FB
Editeur = 50/ 60 = 1 bloc
TempsES (BAL
Editeur) = B
Editeur* TempsTrans + NombrePos
* TempsPosDébut
TempsES (BAL ) = 11 ms
N
Editeur50
FBM
Editeur60
Exemple : TempsES (BAL Catégorie )
Allocation sérielle sans fragmentation interne
FB
Catégorie= FBM
Catégorie= 40
B
Catégorie= N
Catégorie/ FB
Catégorie = 4 000/ 40 = 100 blocs
Meilleur cas :
– TempsES (BALCatégorie) = BCatégorie* TempsTrans + NombrePos * TempsPosDébut
–
= 100 * 1 ms + 1 * 10 ms = 110 ms
Pire cas :
–
TempsES (BAL
Catégorie) = 100 * 1 ms + 100 * 10 ms = 1 100 ms
N Catégorie 4 000
FBM Catégorie 40
Exemple : TempsES (BAL Livre )
Allocation sérielle sans fragmentation interne
FB
Livre= FBM
Livre= 20
B
Livre= N
Livre/ FB
Livre = 1 000 000/ 20 = 50 000 blocs
Meilleur cas :
–
TempsES (BAL
Livre) = 50,01 secs
Pire cas :
–
TempsES (BAL
Livre) = 9,16 minutes
N
Livre1 000 000
FBM
Livre20
Exemple : TempsES (BAL Livre )
Arbre-B
+primaire sur la clé primaire ISBN
FB
Livre= 2/3 FBM
Livre = 13
B
Livre= N
Livre/ FB
Livre = 1 000 000/ 13 = 76 924 blocs
Pire cas (consécutivité des feuilles non assurée) !
–
TempsES (BAL
Livre) = B
Livre* TempsTrans + NombrePos * TempsPosDébut
– = 76 924* 1ms + 76 924 * 10ms = 848 164 ms =
14,1 minutes
N Livre 1 000 000
FBM Livre 20
10.3.3.2 Sélection par égalité dans un index arbre-B + primaire (S=IP)
TempsES (S=IP) =
– Parcours des niveaux d ’index
(Hauteur
I-1) * TempsESBloc + – Parcours des feuilles
. . . . . .
. . .
. . . . . . . . .
. . .
H a u t e u r - 1
F e u il l e s à t r a n s f é r e r
Suite
Cas d ’une clé candidate
–
TempsES (S=IP sur clé candidate) = Hauteur
I* TempsESBloc
Estimation de Hauteur I (voir Volume I, chapitre 3)
– 1 + log
OrdreMoyenI(Card
T(CléIndex) / FB
T)
OrdreMoyen
I= 2/3 Ordre
I
FB
T= 2/3 FBM
T
Hauteur d'un index primaire (FBM =20)
Application Maple V
–
http://www.info.uqam.ca/~godin/INF5180/Chap6Formules
.mws
Index primaire code de la table Catégorie (clé primaire )
OrdreMoyen
I= 2/3 Ordre
I = 66
FB
Catégorie= 2/3 FBM
Catégorie = 26
Hauteur
I= 1 + log
OrdreMoyenI(Card
Catégorie(code) / FB
Catégorie)
= 1+ log
66(4 000 / 26) = 3
TempsES (S=IP) = Hauteur
I*TempsESBloc = 33 ms
N
Catégorie4 000
FBM
Catégorie40
Card
Catégorie( code ) 4 000
Ordre
I100
Index primaire sur code de la table Livre (clé étrangère)
OrdreMoyen
I= 2/3 Ordre
I = 66
FB
Livre= 2/3 FBM
Livre = 13
Hauteur
I= 1 + log
OrdreMoyenI(Card
Livre(code) / FB
Livre) = 3
FacteurSélectivité
Livre(code) = 1/ Card
Livre(code) = 1/4 000
Sel
Livre(code = Valeur ) = = 1 000 000/4000 = 250 lignes
TempsES (S=IP) =
–
(Hauteur
I-1) * TempsESBloc + Sel
Livre(code = Valeur)/ FB
Livre)*
TempsESBloc
N
Livre1 000 000
FBM
Livre20
Card
Livre( code ) 4 000
Ordre
I100
Index primaire sur ISBN de Livre (clé primaire)
OrdreMoyen
I= 2/3 Ordre
I = 66
FB
Livre= 2/3 FBM
Livre = 13
Hauteur
I= 1 + log
OrdreMoyenI(Card
Livre(ISBN) / FB
Livre)
= 4
TempsES (S=IP) = Hauteur
I*TempsESBloc = 44 ms
N
Livre1 000 000
FBM
Livre20
Card
Livre( ISBN ) 1 000 000
Ordre
I100
Comparaison entre le balayage et la sélection par index primaire
(N = 1 000 000, FBM =20)
Comparaison entre le balayage et la
sélection par index primaire (OrdreI =
100, FBM =20)
10.3.3.2.1 Taille de l'index primaire
TailleMS(IP) = TailleIndexInterne + B livre
– FB T = 2/3 FBM T
– B T = N T / FB T
– TailleIndexInterne
Card T (CléIndex)/ OrdreMoyen I
Index primaire sur code de Livre
FB
Livre= 2/3*FBM
Livre = 13
B
Livre= N
Livre/ FB
Livre = 1 000 000/ 13 = 76
924 blocs
TailleIndexInterne Card
Livre(code)/
OrdreMoyen
I = 61 blocs
TailleMS(IP) = TailleIndexInterne + B
Livre 76 985 blocs
–
50 000 blocs pour allocation sérielle
10.3.3.3 Sélection par égalité dans un index arbre-B + secondaire (S=IS)
. . . . . .
. . .
. . . . . . . . .
. . .
H a u t e u r - 1
F e u il l e s à t r a n s f é r e r c o n t e n a n t l e s r é f é r e n c e s
a u x b l o c s d e l 'o r g a n is a t io n p r i m a i r e
. . .
. . .. . . . . . . . .
B lo c s d e l'o r g a n i s a t i o n p r i m a i r e à t r a n s f é r e r. . .
Estimation de
TempsES (S=IS)
Niveaux d ’index
– (Hauteur
I-1) * TempsESBloc
Feuilles de l ’index
Sel
T(CléIndex = Valeur)/ OrdreMoyen
I
*TempsESBloc
Blocs de l ’organisation primaire
– Sel
T(CléIndex = Valeur)*TempsESBloc
TempsES (S=IS sur clé candidate)
– (Hauteur
I+1)*TempsESBloc
10.3.3.3.1 Estimation sans relecture de blocs
Éviter de relire les blocs de données de l ’organisation primaire
Nombre moyen de blocs à lire :
(1- (1- FacteurSélectivité T
(CléIndex)) FB )* B T
Estimation de Hauteur I pour index secondaire
Hypothèses
– clés répétées
– OrdreMoyen = FB
Hauteur I = log OrdreMoyenI
(N T )
Index secondaire code de Livre (clé étrangère)
Hauteur
I= log
66(1 000 000) = 4
Sel
Livre(code = Valeur )= 250 lignes
TempsES (S=IS) = 2 827ms
TempsES (S=ISa) = 2 827ms
TempsES (S=IP) = 242ms
N Livre 1 000 000
FBM Livre 20
Card Livre ( code ) 4 000
Ordre I 100
Index secondaire sur code de Livre (clé étrangère)
Hauteur
I= log
66(1 000 000) = 4
Sel
Livre(code = Valeur) = 50 000 lignes
TempsES (S=IS) = 558 371ms
TempsES (S=ISa) = 361 207ms
Pire que TempsES (BAL
Livre) = 50,01 secs !
N
Livre1 000 000
FBM
Livre20
Card
Livre( code ) 20
Ordre
I100
Index secondaire sur ISBN de Livre (clé primaire)
Hauteur I = log 66 (1 000 000) = 4
TempsES (S=IS sur clé candidate) = (Hauteur
I+1)*TempsESBloc = 55 ms
~TempsES (S=IP) = Hauteur
I44 ms
N
Livre1 000 000
FBM
Livre20
Card
Livre( ISBN ) 1 000 000
Ordre
I100
Comparaison entre le balayage et la sélection par index secondaire
(N = 1 000 000, FBM =20)
Comparaison entre le balayage et la sélection par index secondaire
(OrdreI = 100, FBM =20)
10.3.3.3.2 Taille de l'index secondaire
Index secondaire code de Livre (clé étrangère)
TailleMS(IS) = N
Livre/ OrdreMoyen
I = 15 152 blocs
–
~ 1/3 taille de la table !
TailleMS(IS) (15 152) +
BLivre(50 000)< TailleMS(IP) (76 985)
N Livre 1 000 000
FBM Livre 20
Card Livre ( code ) 4 000
Ordre I 100
10.3.3.4 Sélection par intervalle dans un index arbre-B + primaire (S>IP)
~ clé non unique
CléIndex [Valeur 1 ..Valeur 2 ]
TempsES (S>IP) =
–
(Hauteur
I-1) * TempsESBloc +
Sel
T(CléIndex [Valeur
1..Valeur
2])/ FB
T*
TempsESBloc
Index primaire sur code de la table Livre (clé étrangère)
OrdreMoyen
I= 2/3 Ordre
I = 66
FB
Livre= 2/3 FBM
Livre = 13
Hauteur
I= 3
TempsES (S>IP) = 4 257 ms
N
Livre1 000 000
FBM
Livre20
Card
Livre( code ) 4 000
Sel
Livre( code [ Valeur
1.. Valeur
2] ) 5 000
Ordre
I100
10.3.3.6 Sélection par intervalle dans un index arbre-B + secondaire (S>IS)
~ clé non unique
10.3.3.8 Sélection par égalité avec hachage (S=H)
Hachage statique + chaînage
TempsES (S=H) = N T /( TH T * FB T ) * TempsESBloc
...
A d r e s s e d u p a q u e t
0
1
2
3
Hachage sur ISBN de Livre (clé primaire)
Hypothèse ~ idéale
– TR = 80%
– FB
Livre= 0,8* FBM
Livre= 16
– TH
Livre= N
Livre/ FB
Livre = 62 500 blocs
– pas de débordements
TempsES (S=H) = 1 000 000/( 62 500* 16) * 11ms = 11 ms
TempsES (S=IP) = Hauteur
I*TempsESBloc = 44 ms
N Livre 1 000 000
FBM Livre 20
Hachage sur code de Livre (clé étrangère)
Hypothèse ~ idéale
– TH Livre = Card Livre (code) = 4 000
– FB Livre = FBM Livre = 20
TempsES (S=H) = 1 000 000/( 4 000 * 20) * 11ms = 143 ms
TempsES (S=IP) = 242 ms
N
Livre1 000 000
FBM
Livre20
Card
Livre( code ) 4 000
10.3.3.8.1 Taille de
l'organisation par hachage
TailleMS(S=H) = N T /FB T
Hachage sur ISBN de Livre (clé primaire)
– Hypothèse ~ idéale
– TailleMS(S=H) = TH Livre = N Livre /
FB Livre = 62 500 blocs
10.3.3.9 Sélection par clé composée
Hypothèse de distribution indépendante
FacteurSélectivité
T(C
1= V
1et C
2= V
2et… et C
n= V
n) = FacteurSélectivité
T(C
1)*
FacteurSélectivité
T(C
2) * …*
FacteurSélectivité
T(C
n)
Index secondaire sur clé composée {code, annéeParution} de Livre
Hauteur
I= log
33(1 000 000) = 4
FacteurSélectivité
Livre(code = V
1et annéeParution = V
2) =
– FacteurSélectivitéLivre (code)* FacteurSélectivitéLivre (annéeParution)
– = 1/CardLivre (code) * 1/CardLivre (annéeParution) = 1/200 000
Sel
Livre(code = V
1et annéeParution = V
2)= N
Livre/ 200 000 = 5 lignes
TempsES (S=IS) = (Hauteur
I- 1) * TempsESBloc +
SelLivre (code = V1 et annéeParution = V2)/ OrdreMoyenI *TempsESBloc +
SelLivre (code = V1 et annéeParution = V2) * TempsESBloc
TempsES (S=IS) = 3 * 11 ms + 5/ 33 *11 ms + 5 * 11 ms = 99 ms
SELECT *FROM Livre
WHERE code = unCode AND annéeParution = uneAnnée
NLivre 1 000 000
FBMLivre 20
CardLivre (code) 4 000
CardLivre (annéeParution) 50
OrdreI 50
Index secondaire sur clé composée {code, annéeParution} de Livre
Hauteur
I= log
33(1 000 000) = 4
TempsES (S=IS) = (HauteurI - 1) * TempsESBloc +
SelLivre ({code, annéeParution} [{unCode, min} .. {unCode, max}])/
OrdreMoyenI *TempsESBloc +
– SelLivre ({code, annéeParution} [{unCode, min} .. {unCode, max}]) *
TempsESBloc
FacteurSélectivité
Livre({code, annéeParution} [{unCode, min} ..
{unCode, max}]) ~ FacteurSélectivité
Livre(code) = 1/4 000
TempsES (S=IS) = 2 827ms (idem index sur code seul)
SELECT *
FROM Livre
WHERE code = unCode
N
Livre1 000 000
FBM
Livre20
Card
Livre( code ) 4 000 Card
Livre( annéeParution ) 50
Ordre
I50
Index secondaire sur clé composée {code, titre} de Livre
Hauteur I = log 6 (1 000 000) = 8
TempsES (S=IS) = 3 289 ms
SELECT *
FROM Livre
WHERE code = unCode
N
Livre1 000 000
FBM
Livre20
Card
Livre( code ) 4 000
Ordre
I10
10.3.3.10 ORGANISATIONS HÉTÉROGÈNES
Adapter les formules
– facteur de blocage doit tenir compte
de la présence de plusieurs tables
10.3.3.11 TRI D'UNE TABLE (TRI)
Utilité
– jointure par tri-fusion
– élimination des doubles (DISTINCT)
– opérations d ’agrégation (GROUP BY)
– résultats triés (ORDER BY)
Tri externe si M est petit
– tri-fusion
Tri fusion externe
Étape tri
–
nombre de groupes = B
T/M = 12 /3 = 4
–
Coût = 2 * ( B
T/M * TempsPosDébut + B
T* TempsTrans)
= 104 ms
1 5 4 3
P o s i t i o n n e m e n t L e c t u r e
C r é a t i o n d e 1 2 / 3 = 4 g r o u p e s
9 1 8 1 2
L e c t u r e P o s i t i o n n e m e n t
1 6 2 5
L e c t u r e P o s i t i o n n e m e n t
7 1 4 6
P o s i t i o n n e m e n t L e c t u r e
P o s i t i o n n e m e n t
E c r i t u r e E c r i t u r e
P o s i t i o n n e m e n t
E c r i t u r e
P o s i t i o n n e m e n t P o s i t i o n n e m e n t E c r i t u r e
Étape fusion
Coût des passes de fusion
–
= B
T*(2*log
M-1(B
T/M)-1) * TempsESBloc
–
= 12*(2*log
2(12 /3)-1) *11ms = 396 ms
3 4 1 5 9 1 2 1 8 2 5 1 6 6 7 1 4
3 4 9 1 2 1 5 1 8 2 5 6 7 1 4 1 6
2 3 4 5 6 7 9 1 2 1 4 1 5 1 6 1 8
P a s s e d e f u s io n # 1 p r o d u it 4 / 2 = 2
g r o u p e s
P a s s e d e f u s i o n # 2 p r o d u i t 2 / 2 = 1
g r o u p e
Coût total du tri-fusion externe
TempsES (TRI) =
– 2*( B T /M * TempsPosDébut + B T *TempsTrans) + B T *(2*log M-1 (B T /M)-1) * TempsESBloc
– = 104 ms + 396 ms = 500 ms
Tri de Livre
Allocation sérielle sans fragmentation interne
M = 50
TempsES (TRI) = 29,5 mins
N Livre 1 000 000
FBM Livre 20
B Livre 50 000
Estimation du coût d'un tri-
fudion externe (FBM = 20)
10.3.3.12 SÉLECTION CONJONCTIVE PAR INTERSECTION (S)
Index I1 sur code
Index I2 sur annéeParution
TempsES(S) =
–
TempsES(Extraction de la liste des références de I1) +
–
TempsES(Extraction de la liste des références de I2) +
–
TempsES(Lecture des blocs de données)
SELECT *
FROM Livre
WHERE code = unCode AND annéeParution = uneAnnée
N
Livre1 000 000
FBM
Livre20
Card
Livre( code ) 4 000
Card
Livre( annéeParution ) 50
Ordre
I1100
Ordre
I2100
Suite
TempsES(Extraction de la liste des références de I1) =
– (HauteurI1 - 1) * TempsESBloc + SelLivre (code = Valeur)/
OrdreMoyenI *TempsESBloc =
77 ms
TempsES(Extraction de la liste des références de I2) =
– (HauteurI2 - 1) * TempsESBloc + SelLivre (annéeParution = Valeur)/
OrdreMoyenI *TempsESBloc =
3 377 ms
TempsES(Lecture des blocs de données) =
– SelLivre (code = V1 et annéeParution = V2)*TempsESBloc =
55 ms
TempsES(S) = 3 509 ms
– > TempsES (S=IS pour index I1) = 2 827 ms
Si Card Livre
(annéeParution) = 100
TempsES(S) = 1809,5 ms
< TempsES (S=IS pour index I1)
= 2 827 ms
N
Livre1,000,000
FBM
Livre20
Card
Livre( code ) 4,000
Card
Livre( annéeParution ) 100
Ordre
I1100
Ordre
I2100
10.3.3.13 SÉLECTION DISJONCTIVE PAR UNION (S)
FacteurSélectivité
T(C
1= V
1ou C
2= V
2ou… ou C
n= V
n) =
–
1-((1-FacteurSélectivité
T(C
1))* (1-FacteurSélectivité
T(C
2)) * …* (1-FacteurSélectivité
T(C
n)))
10.3.3.14 OPÉRATIONS DE JOINTURE
Cas de deux tables R S
Extension directe à d ’autres cas
– union, intersection, jointure
externe, ...
10.3.3.14.1 Jointure par boucles imbriquées
Boucles imbriquées par lignes (BI)
TempsES (BI) =
–
B
R* TempsESBloc + N
R* (B
S* TempsTrans + TempsPosDébut)
Meilleur cas (antémémoire suffisamment grande) :
–
TempsES (BI) = TempsES (BAL
R) + TempsES (BAL
S) =
–
(B
R+ B
S) * TempsTrans + 2*TempsPosDébut
POUR chaque ligne l
Rde R
POUR chaque ligne l
Sde S
SI sur l
Ret l
Sest satisfait
Produire la ligne concaténée à partir de l
Ret l
SFINSI
FINPOUR
FINPOUR
BI : Livre Catégorie
R=Livre et S=Catégorie
–
TempsES (BI) = 30,57 hrs
R = Catégorie et S = Livre
–
TempsES (BI) = 56,57 hrs
Meilleur cas (sans relecture)
–
TempsES (BI) = 50 120 ms
N
Livre1 000 000
FB
Livre20
B
Livre50 000
N
Catégorie4 000
FB
Catégorie40
B
Catégorie100
Boucles imbriquées par blocs (BIB)
TempsES (BIB) =
– B
R* TempsESBloc +
– B
R* (B
S* TempsTrans + TempsPosDébut)
POUR chaque bloc b
Rde R
POUR chaque bloc b
Sde S
POUR chaque ligne l
Rde b
RPOUR chaque ligne l
Sde b
SSI sur l
Ret l
Sest satisfait
Produire la ligne concaténée à partir de l
Ret l
SFINSI
FINPOUR FINPOUR
FINPOUR
FINPOUR
BIB: Livre Catégorie
R=Livre et S=Catégorie
–
TempsES (BIB) = 100,83 mins
R = Catégorie et S = Livre
–
TempsES (BIB) = 83,37 mins
Meilleur cas (sans relecture)
–
TempsES (BIB) = 50 120 ms
N Livre 1 000 000 FB Livre 20
B Livre 50 000 N Catégorie 4 000
FB Catégorie 40
B Catégorie 100
Boucles imbriquées multi-blocs (BIM)
TempsES (BIM) =
– B
R* TempsTrans + B
R/(M-2) * TempsPosDébut +
B
R/(M-2) * (B
S* TempsTrans + TempsPosDébut)
POUR chaque tranche de M-2 blocs de R POUR chaque bloc b
Sde S
POUR chaque ligne l
Rde la tranche POUR chaque ligne l
Sde b
SSI sur l
Ret l
Sest satisfait
Produire la ligne concaténée à partir de l
Ret l
SFINSI FINPOUR FINPOUR
FINPOUR
FINPOUR
BIM: Livre Catégorie
M = 50
R=Livre et S=Catégorie
– TempsES (BIM) = 175,04secs
R = Catégorie et S = Livre
– TempsES (BIM) = 150,16secs
N
Livre1 000 000 FB
Livre20
B
Livre50 000 N
Catégorie4 000
FB
Catégorie40
B
Catégorie100
Estimation du coût de la jointure (RS) par boucles
imbriquées multi-blocs (M = 10, FBM = 20 pour les deux
tables) en fonction des tailles (NS et NR) des deux tables
10.3.3.14.2 Jointure par boucles imbriquées avec index sur la table interne (BII)
TempsES (BII) =
– B R * TempsESBloc +
– N R * TempsES (Sélection par index)
POUR chaque ligne l
Rde R
POUR chaque ligne l
Sde S satisfaisant (sélection en utilisant un index) Produire la ligne concaténée à partir de l
Ret l
SFINPOUR
FINPOUR
BII: Livre Catégorie
Cas des index primaires
R=Livre et S=Catégorie
–
TempsES (BII) = B
Livre* TempsESBloc + N
Livre* TempsES(S=IP
Catégoriepour l'index primaire sur code) = 9,32 hrs
R = Catégorie et S = Livre
–
TempsES (BII) = B
Catégorie* TempsESBloc + N
Catégorie* TempsES(S=IP
Livrepour l'index primaire sur code) = 16,15 mins
N
Livre1 000 000
FB
Livre20
B
Livre50 000
N
Catégorie4 000
FB
Catégorie40
B
Catégorie100
TempsES ( S=IP
Catégoriepour l'index primaire sur code ) 33 ms
TempsES ( S=IP
Livrepour l'index primaire sur code ) 242 ms
Contexte avantageux pour BII
Jointure sélective
Peu de mémoire vive L i v r e
C a t é g o r i e
I S B N = 1 - 1 1 - 1 1 1 - 1 1 1 1 - 1
( S é le c t io n p a r in d e x s e c o n d a ir e s u r I S B N )
t i t r e , d e s c r i p t e u r
( B a la y a g e )
( B o u c le im b r iq u é e a v e c i n d e x s e c o n d a i r e
s u r c o d e d e l a t a b l e in t e r n e C a t é g o r ie )
Comparaison entre la boucle imbriquée multi-
blocs et la boucle imbriquée avec index primaire
(NS = 1 000 000 et que FBM = 20)
10.3.3.14.3 Jointure par boucles imbriquées avec hachage sur la table interne (BIH)
TempsES (BIH) =
– B R * TempsESBloc +
– N R * TempsES(Sélection par hachage)
POUR chaque ligne l
Rde R
POUR chaque ligne l
Sde S satisfaisant (sélection en utilisant le hachage) Produire la ligne concaténée à partir de l
Ret l
SFINPOUR
FINPOUR
BIH: Livre Catégorie
R=Livre et S=Catégorie
–
TempsES (BIH) = B
Livre* TempsESBloc + N
Livre* TempsES(S=H
Catégoriepour hachage sur code) = 3,21 hrs
R = Catégorie et S = Livre
–
TempsES (BIH) = B
Catégorie* TempsESBloc + N
Catégorie* TempsES(S=H
Livrepour hachage sur code)= 9,55 mins TempsES ( S=H
Catégoriepour hachage sur code ) 11 ms
TempsES ( S=H
Livrepour hachage sur code ) 143 ms
N
Livre1 000 000
FB
Livre20
B
Livre50 000
N
Catégorie4 000
FB
Catégorie40
B
Catégorie100
10.3.3.14.4 Jointure par tri-fusion (JTF)
Trier R et S par tri externe et réécrire dans des fichiers temporaires
Lire groupe de lignes G
R(c
R) de R pour la première valeur c
Rde clé de jointure Lire groupe de lignes G
S(c
S) de S pour la première valeur c
Sde clé de jointure TANT QUE il reste des lignes de R et S à traiter
SI c
R= c
SProduire les lignes concaténées pour chacune des combinaisons de lignes de G
R(c
R) et G
S(c
S);
Lire les groupes suivants G
R(c
R) de R et G
S(c
S) de S;
SINON
SI c
R< c
SLire le groupe suivant G
R(c
R) de R SINON
SI c
R> c
SLire le groupe G
S(c
S) suivant dans S FINSI
FINSI FINSI
TempsES (JTF) = TempsES (TRIR) + TempsES (TRIS) + 2*(BR + Bs) *
JTF: Livre Catégorie
M = 50
TempsES (JTF) =
– TempsES (TRI
Livre) + TempsES (TRI
Catégorie) + 2*(B
Livre+ B
Catégorie) * TempsESBloc = 2 873 540 ms
– >> TempsES (BIM) = 150 160 ms ( R = Catégorie )
N
Livre1 000 000
FBM
Livre20
B
Livre50,000
TempsES ( TRI
Livre) 1 770 000 ms
N
Catégorie4 000
FBM
Catégorie40
B
Catégorie100
TempsES ( TRI
Catégorie) 1 340 ms
Si 100 fois plus de Catégories
M = 50
–
TempsES (JTF) = 3 444 000 ms
–
< TempsES (BIM) = 10 464 180 ms
M = 10
–
TempsES (JTF) = 6 180 000 ms
–
<< TempsES (BIM) = 62 535 000 ms
N
Livre1 000 000
FBM
Livre20
B
Livre50,000
TempsES ( TRI
Livre) 1 770 000 ms
N
Catégorie400 000
FBM
Catégorie40
B
Catégorie10 000
TempsES ( TRI
Catégorie) 350 000 ms
Comparaison entre la jointure par tri-fusion et par boucles imbriquées multi-blocs
(NS = 1 000 000 et que FBM = 20)
10.3.3.14.5 Jointure par hachage (JH)
Égalité seulement
1- Partition des tables ( Si h [0..n-1], M ≥ n)
{Partitionner R par hachage}
POUR chaque ligne l
Rde R
Ajouter l
Rau tampon de R
ioù i = h(v) et v est la valeur de l'attribut de jointure de l
RSI le tampon de R
idevient plein
Evacuer le tampon de R
iet le chaîner au paquet correspondant FINSI
FINPOUR
{Partitionner S par hachage}
POUR chaque ligne l
Sde S
Ajouter l
Sau tampon de S
ioù i = h(v) et v est la valeur de l'attribut de jointure de t
SSI le tampon de S
idevient plein
Jointure par hachage (suite)
Jointure par itération sur les parties
TempsES (JH) =
– TempsES (BAL
R) + TempsES (BAL
s) +
– 2 * (B
R+ B
s) *TempsESBloc
POUR chaque partie R
iLire tous les blocs de la partie R
iPOUR chaque bloc de la partie S
iPOUR chaque ligne t
Sde chaque bloc de S
iApparier t
Savec les lignes correspondantes t
Rde R
iet produire les lignes concaténées à partir de t
Ret t
SFINPOUR FINPOUR
FINPOUR
Hypothèse :
taille de R < taille de S
taille de R
i M blocs
10.3.3.14.5.1 Hachage récursif
Si M < R
i(~ B
R/M )
–
hacher récursivement
–
~log
M(B
R)-1 passes
ne dépend que de la plus petite table
TempsES (JH) =
–
TempsES (BAL
R) + TempsES (BAL
s) +
–
2 * (B
R+ B
s) * log
M(B
R)-1 *TempsESBloc
Si B
R M
–
TempsES (JH) = TempsES (BAL ) + TempsES (BAL )
JH: Livre Catégorie
R = Catégorie (la plus petite table)
M = 50
TempsES (JH) = 1 152 320 ms
– > TempsES (BIM) = 150 160 ms ( R = Catégorie )
– < TempsES (JTF) = 3 444 000 ms
N
Livre1 000 000
FB
Livre20
B
Livre50 000
TempsES ( BAL
Livre) 50 010 ms
N
Catégorie4 000
FB
Catégorie40
B
Catégorie100
TempsES ( BAL
Catégorie) 110 ms
Si 100 fois plus de Catégories
R = Catégorie (la plus petite table)
M = 50
TempsES (JH) = 2 700 020 ms
– << TempsES (BIM) = 10 464 180 ms ( R
= Catégorie )
N
Livre1 000 000
FB
Livre20
B
Livre50 000
TempsES ( BAL
Livre) 50 010 ms
N
Catégorie400 000
FB
Catégorie40
B
Catégorie10 000
TempsES ( BAL
Catégorie) 10 010 ms
Comparaison entre la jointure par hachage et par boucles imbriquées multi-blocs
(NS = 1 000 000 et FBM = 20)
Comparaison entre la jointure par hachage et par tri-fusion
(NS = 1 000 000 et que FBM = 20)
10.3.3.14.6 Pré-jointure par une organisation hétérogène (PJ)
Organisation hétérogène
– sériel par grappe
– index primaire
– hachage
TempsES (PJ) ~
– TempsES (BAL R ) + TempsES (BAL s )
– meilleur cas
pas de fragmentation interne...
PJ: Livre Catégorie
TempsES (PJ) = 50 120 ms
– meilleur cas
N
Livre1 000 000
FB
Livre20
B
Livre50 000
TempsES ( BAL
Livre) 50 010 ms
N
Catégorie4 000
FB
Catégorie40
B
Catégorie100
TempsES ( BAL
Catégorie) 110 ms
Comparaison des
méthodes de jointure
BIM
–
une des deux tables est petite
JTF
–
2 grandes tables
nombre de passes de tri dépend de la plus grande table
–
ordre intéressant
JH
–
2 grandes tables
–
nombre de passes ne dépend que de la plus petite table
BII ou BIH
–
utilisation partielle d ’une des deux tables
PJ
–
optimal pour jointure si peu de fragmentation interne
–
pénalise opérations sur une table
10.3.3.15 AGRÉGATION,
ÉLIMINATION DES DOUBLES, OPÉRATIONS ENSEMBLISTES
Principe général
– appariement de lignes sur valeurs communes
Adapter les algorithmes de
jointure et estimation de coût
10.4 Optimisation
Chercher le meilleur plan d ’exécution?
– coût excessif
Solution approchée à un coût raisonnable
– Générer les alternatives
heuristiques
– Choisir la meilleure
estimation approximative du coût
10.4.1 Plans d'exécutions équivalents
Plusieurs arbres algébriques équivalents
Livreetc.
Catégorie
ISBN = 1-111-1111-1
titre, descripteurL i v r e
C a t é g o r i e
I S B N = 1 - 1 1 1 - 1 1 1 1 - 1
t i t r e , d e s c r i p t e u rRègles d ’équivalences de l ’algèbre relationnelle
Eclatement d'une sélection conjonctive (SE)
–
e1 ET e2(T) =
e1(
e2(T))
Commutativité de la sélection (SC)
e1(
e2(T)) =
e2(
e1(T))
Elimination des projections en cascades (PE)
liste1(
liste2(T)) =
liste1(T)
Commutativité de la jointure (JC)
–
T
1 T
2= T
2 T
1
Associativité de la jointure (JA)
–
T
1 (T
2 T
3) = (T
1 T
2) T
3Suite
Commutativité restreinte de la sélection et de la jointure (CSJ)
e(T
1 T
2) =
e(T
1) T
2 si l'expression de sélection e ne contient que des colonnes de T1
Commutativité restreinte de la projection et de la sélection (CPS)
listeColonnes(
e(T)) =
listeColonnes(
e(
listeColonnes colonnes de eT))
Commutativité restreinte de la projection et de la jointure (CPJ)
listeColonnes(T
1 T
2) =