Gegevensbanken_2012_Les12_HashingIndexII

Gegevensbanken 2012
Hashing en Indexstructuren II
Bettina Berendt
http://people.cs.kuleuven.be/~bettina.berendt/
Indexstructuren:
Motivatie &
Samenvatting
2
Waar zijn we?
Les #
1
2
2
3
4,5
6
7
8
9
10
11
12
13
14,15
16
17
wie
ED
ED
ED
KV
KV
KV
KV
KV
BB
BB
BB
BB
BB
BB
BB
ED
wat
intro, ER
EER, (E)ER naar relationeel schema
relationeel model
Relationele algebra & relationeel calculus
SQL
Programma's verbinden met gegevensbanken
Functionele afhankelijkheden & normalisatie
PHP
Beveiliging van gegevensbanken
Geheugen en bestandsorganisatie
Hashing en Indexstructuren I
Hashing en Indexstructuren II
Queryverwerking
Transactieverwerking en concurrentiecontrole
Data mining en data warehousing
XML, NoSQL
Fysisch model /
vragen
3
Wat doen als de keuken te klein is?
4
Wat doen als de keuken te klein is?
* Het brood
ligt in de
slaapkamer
* De eieren
liggen in de
eetkamer
5
 Externe hashing
Het brood
ligt in de
slaapkamer
* De eieren
liggen in de
eetkamer
6
Twee problemen om te vermijden
* Het brood ligt in de
slaapkamer
* De eieren liggen in de
eetkamer
.
.
.
.
* Het brood ligt in
de slaapkamer
* De volgende
lijst ...
* De eieren
liggen in de
eetkamer
7
Vraag: waarom deze twee opties?
(MySQL als maar een voorbeeld)
→ dit zijn twee structurele types van indexen
8
De twee hoorcolleges: 2 foci
Hashing en Indexstructuren I:
– Basisideen; indexen als bestanden
 principes van de les over bestandsorganisatie toepassen
Hashing en Indexstructuren II:
– „slimmere ideen“; operaties op indexen
 hoe werkt het?
9
Agenda
Dynamische hashing
Uitbreidbare hashing
Lineaire hashing
Boomstructuren als indexen
Indexen op meerdere velden
10
Agenda
Dynamische hashing
Uitbreidbare hashing
Lineaire hashing
Boomstructuren als indexen
Indexen op meerdere velden
11
Externe “static” hashing: voor- en nadelen
+•
+•
-•
-•
-
record snel bereikbaar via sleutel
)
toevoegen en weglaten redelijk eenvoudig
) Ketening
opzoeken via ander dan sleutelveld is moeilijk
)
doorlopen van bestand in sleutelvolgorde kan traag zijn )
• En:
• vaste ruimte gereserveerd voor bestand (“static
hashing”)
• indien te groot: veel verloren ruimte
• indien te klein: veel overloop  snelheidsverlies
• na een tijdje eventueel reorganisatie nodig
12
Dynamische bestandsuitbreiding
• Sommige hashing technieken laten dynamische
expansie van bestanden toe
• aantal voorziene cellen groeit en krimpt met bestand
• We behandelen 3 methoden:
• “dynamische hashing“
• uitbreidbare (extendible) hashing
• lineaire hashing
13
Dynamische & Uitbreidbare hashing: idee
* als bruin: bucket 1
* als groen: bucket 2
* als bruin EN eieren: bucket 1
* als bruin EN brood: bucket 2
* als groen: bucket 3
14
Dynamische hashing: voorbeeld (1)
• vb. (met 1 record per cel)
• record A heeft hashwaarde 001101
• 1 cel, geen trie nodig
• record B met hashwaarde 010011 wordt toegevoegd
• Trie bouwen
• Trie moet meteen naar eerste 2 bits kijken, want eerste bit is zelfde
15
Dynamische hashing: voorbeeld (2)
• C met hashwaarde 111001 wordt toegevoegd
• Bij weglaten van records evt. cellen weer
samensmelten  trie krimpt
16
Dynamische hashing: samenvatting
• Begin met 1 cel
• Bij overloop: cel splitst in twee
• records verdeeld volgens 1-ste bit van hashwaarden
• index wordt gebouwd
• ("trie“ - van retrieve : boomvormige indexstructuur )
• interne knooppunten: binaire splitsing 0 - 1
• externe knooppunten: wijzen naar een cel
• Telkens een cel overloopt:
• splitsing van cel + aanpassing index volgens 1-ste bit van
hashwaarde die een goede splitsing oplevert
17
Dynamische hashing: zoeken via een trie
h := hashwaarde van record;
t := topknoop van trie;
i := 1;
zolang t geen blad is:
als de i-de bit van h een 1 is dan t := linkerkind
anders t := rechterkind;
i := i+1
zoek in de cel waarvan het adres in t zit
18
Agenda
Dynamische hashing
Uitbreidbare hashing
Lineaire hashing
Boomstructuren als indexen
Indexen op meerdere velden
19
Uitbreidbare hashing: voorbeeld (1)
Bron: Hakan (2009). File Organization.
http://www.powershow.com/view/27b55-YzBlN/File_Organization
20
Uitbreidbare hashing: voorbeeld (2)
21
Uitbreidbare hashing: voorbeeld (3)
22
Uitbreidbare hashing: voorbeeld (4)
23
Uitbreidbare hashing: voorbeeld (5)
24
Uitbreidbare hashing: voorbeeld (6)
25
Uitbreidbare hashing: voorbeeld (7)
26
Uitbreidbare hashing: voorbeeld (8)
27
Uitbreidbare hashing: voorbeeld (9)
28
Uitbreidbare hashing: voorbeeld (10)
29
Taak: Uitbreidbare hashing: voorbeeld (11)
30
Uitbreidbare hashing: voorbeeld (12)
31
Uitbreidbare hashing: voorbeeld (13)
32
Uitbreidbare hashing: samenvatting
• Index = tabel met 2d elementen
• d = globale diepte van de index
• eerste d bits van hashwaarde bepalen plaats in index
• d' = lokale diepte van een cel
• voor deze cel wordt enkel naar de eerste d' bits van de hashwaarde
gekeken
• d' ≤ d
• Waarde van d kan met 1 verhogen of
verminderen
• grootte van tabel verdubbelt of halveert hierdoor
• Tabel vergelijkbaar met "vervolledigde" trie
(waarbij alle bladeren op hetzelfde niveau zitten)
33
Uitbreidbare hashing: vraag
„Wat gebeurt er als er nog een 1001 toegevoegt wordt?“ (= x keer dezelfde
sleutel, met x > bucket size m)
• Antwoord 1: M.A. Weiss. Data structures and algorithms in C. retrieved
from http://www.scribd.com/naresh_kumar_31/d/51164216/64-ExtendibleHashing, p. 363: “[…] there is the possibility of duplicate keys; if there are
more than m duplicates, then this algorithm does not work at all. In this
case, some other arrangements need to be made.”
• Dit “andere arrangement” kan bv. ketening zijn, zoals voorgesteld als een
mogelijkheid in het originele paper on Uitbreidbare Hashing:
• Antwoord 2: Ronald Fagin, Jurg Nievergelt, Nicholas Pippenger, and H.
Raymond Strong. 1979. Extendible hashing—a fast access method for
dynamic files. ACM Trans. Database Syst. 4, 3 (Sept. 1979), 315-344
34
Uitbreidbare hashing: Voor- en nadelen
+•
+
-
extra ruimte voor tabel is klein
• max grootte is 2k met k # bits in hashwaarden
• uitbreiding van bestand relatief goedkoop
• bij overloop slechts 1 cel te splitsen
• enkel verdubbeling van tabel
vraagt redelijk veel werk
groeit exponentieel
• 1 extra indirectie
• eerst blok met index lezen, dan pas juiste cel, en daarna
gegevensblok zelf
• relatief klein nadeel
35
Agenda
Dynamische hashing
Uitbreidbare hashing
Lineaire hashing
Boomstructuren als indexen
Indexen op meerdere velden
36
Lineaire hashing: idee
• Gebruikt geen extra index
• Beginsituatie:
• M cellen genummerd 0 .. M-1
• Hashfunctie h0(k) = k mod M
• Bij eerste overloop:
• keten nieuw record vast aan zijn cel
• splits cel 0 (dus niet noodzakelijk de overgelopen cel!)
• records naar cel 0 en cel M volgens h1(k) = k mod 2M
• Bij elke volgende overloop:
• ketening
• splits cel i-1 naar i-1 en M+i-1 volgens h1(k)
37
Lineaire hashing: eigenschappen
• geen index, enkel aantal reeds gesplitste cellen n
bijhouden
• gebruik h1 voor eerste n cellen, h0 voor de andere
• Zolang n < M : zelfde hashfuncties blijven toepassen
• Wanneer n = M:
• M := 2M; h0 := h1; n := 0
• laadfactor l = r / (d*N)
• r = aantal aanwezige records, d = celdiepte, N = aantal cellen
• wanneer l klein wordt, cellen weer samensmelten
38
Lineaire hashing: voorbeeld (1)
• bucket capacity = 2
• collision resolution strategy: chaining
• split rule: load factor > 0.7
• Load factor = r / (bfr * N)
• r : current number of file records
• bfr: max. number of records that can fit into a bucket
• N: current number of file buckets
• initially M = 4 (M: size of the primary area)
• hash functions: hi(key) = key mod 2i  M (i = 0, 1, 2, …)
• Trace the insertion process of the following keys into a
linear hashing file:
3, 2, 14, 1, 8, 4, 5, 10, 7, 24
Bron: Chen, Y. (2009). File Organization.
http://ion.uwinnipeg.ca/~ychen2/databaseNotes/hashing.ppt (minimaal veranderd)
39
Lineaire hashing:
voorbeeld (2)
0
1
2
3
Insert 3
Initial
hash function:
hi(key) =
key mod 2i  M,
i=0
40
3
0
1
2
3
Lineaire hashing:
voorbeeld (2)
Insert 3
Initial
hash function:
hi(key) =
key mod 2i  M,
i=0
41
3
0
1
2
2
3
Lineaire hashing:
voorbeeld (3)
Insert 3
Insert 2
3
Initial
hash function:
hi(key) =
key mod 2i  M,
i=0
42
3
0
1
2
2
2
14
3
Lineaire hashing:
voorbeeld (4)
Insert 3
Insert 2
3
3
Initial
hash function:
Insert 14 hi(key) =
key mod 2i  M,
i=0
43
3
0
1
1
2
3
Lineaire hashing:
voorbeeld (5)
Insert 3
Insert 2
2
14
3
2
14
3
2
14
3
Initial
hash function:
Insert 14 hi(key) =
key mod 2i  M,
i=0
Insert 1
44
3
0
1
2
2
1
8
1
3
Insert 3
Insert 2
3
2
14
3
2
14
3
2
14
Lineaire hashing:
voorbeeld (6)
Initial
hash function:
Insert 14 hi(key) =
key mod 2i  M,
i=0
Insert 1
Insert 8
3
45
Lineaire hashing: voorbeeld (7)
The first phase – phase0
• when inserting the 6th record (4) we would have
4
8
1
0
1
2
14
3
2
3
n=0 before the split
(n is the point to the
bucket to be split.)
• but the load factor 6/8= 0.75 > 0.70 and so bucket 0 must be
split (using h1 = Key mod 2M):
8
2
14
1
0
1
2
3
n=1 after the split
load factor: 6/10=0.6
no split
4
3
4
46
Lineaire hashing: voorbeeld (7)
The first phase – phase0
• when inserting the 6th record (4) we would have
4
8
1
0
1
2
14
3
2
3
n=0 before the split
(n is the point to the
bucket to be split.)
• but the load factor 6/8= 0.75 > 0.70 and so bucket 0 must be
split (using h1 = Key mod 2M):
8
2
14
1
0
1
2
3
n=1 after the split
load factor: 6/10=0.6
no split
4
3
4
47
Lineaire hashing: voorbeeld (8)
insert(5)
8
0
8
0
1
1
1
5
1
2
14
3
2
3
2
14
3
2
3
4
4
4
n=1
load factor: 7/10=0.7
no split
4
48
Lineaire hashing: voorbeeld (8)
insert(5)
8
0
8
0
1
1
1
5
1
2
14
3
2
3
2
14
3
2
3
4
4
4
n=1
load factor: 7/10=0.7
no split
4
49
Lineaire hashing: voorbeeld (9)
insert(10)
8
0
8
1
5
1
1
5
2
14
3
2
3
2
14
3
4
4
4
n=1
load factor: 8/10=0.8
split using h1.
overflow
10
50
Lineaire hashing: voorbeeld (9)
insert(10)
8
0
8
1
5
1
1
5
2
14
3
2
3
2
14
3
4
4
4
n=1
load factor: 8/10=0.8
split using h1.
overflow
10
51
Lineaire hashing: voorbeeld (9)
8
0
1
1
2
14
3
2
3
4
4
5
5
overflow
10
n=2
load factor: 8/12=0.66
no split
52
Lineaire hashing: voorbeeld (10)
insert(7)
8
1
2
14
3
4
n=2
load factor: 9/12=0.75
split using h1.
overflow
10
8
0
1
1
5
2
14
3
7
2
3
4
4
5
5
overflow
10
53
Lineaire hashing: voorbeeld (10)
8
1
2
10
3
7
4
5
14
n=3
load factor: 9/14=0.642
no split.
insert(24)
8
1
2
10
3
7
4
5
14
54
Taak: Lineaire hashing: voorbeeld (11)
8
1
2
10
3
7
4
5
14
n=3
load factor: 9/14=0.642
no split.
insert(24)
8
1
2
10
3
7
4
5
14
55
Lineaire hashing: voorbeeld (11)
8
24
1
2
10
3
7
4
5
14
n=3
load factor: 10/14=0.71
split using h1.
8
24
1
2
10
3
4
5
14
7
56
Lineaire hashing: voorbeeld (8)
8
24
1
2
10
3
7
4
5
14
n=3
load factor: 10/14=0.71
split using h1.
8
24
1
2
10
3
4
5
14
7
57
Op dit moment hebben we de volgende
structuur:
Een lineaire hash met
• file level j = 1
• 8 cellen
• h0 = k mod (2j * 4) = k mod (21 * 4) = k mod 8
• (de naastvolgende h1 wordt h1 = k mod (22 * 4) = k mod 16)
• n=0
Door het laatste wordt het mogelijk dat elke cel herhaald gesplitst
wordt en dan ook waarden die bij de eerste splitsing niet worden
herverdeeld nu worden herverdeelt!
Vb: sleutelwaarde 18
18 mod 4 = 18 mod 8 = 18 mod 16 = 2  18 blijft lang in cel 2,
misschien in een overloopgebied, en wordt niet herverdeeld
MAAR: als h1 = k mod 32 bereikt wordt, dan gaat 18 naar cel 18
58
Lineaire hashing: zoeken
als n=0
dan m := hj(k)
anders
m := hj(k);
als m<n dan m := hj+1(k);
zoek in de cel met hashwaarde m (en evt. in de overloop
ervan)
59
Agenda
Dynamische hashing
Uitbreidbare hashing
Lineaire hashing
Boomstructuren als indexen
Indexen op meerdere velden
60
Algoritme voor zoeken in ijle primaire multiniveau-index naar record met sleutel K
p := adres van top-blok van index;
voor j := t tot 1:
lees blok met adres p (op niveau j in index);
zoek in p een record i zodat Kj(i) <= K < Kj(i+1);
p := pj(i);
lees het blok gegevens met adres p;
zoek in p naar het record met sleutel K
61
Operaties in multi-niveau indexen
• Weglaten:
– door te markeren
• Toevoegen:
– m.b.v. overloopgebieden
• Na een tijdje: reorganisatie
– heel het bestand wordt sequentieel doorlopen en herschreven naar
nieuw bestand
– overloop en markeringen worden opgeruimd
– nieuwe index wordt gebouwd op nieuw bestand
+
• Voordelen:
– snelle toegang tot bestand, toevoegingen en weglatingen tamelijk
efficiënt
• Nadelen:
-
– overloop werkt vertragend, verkwisting van ruimte, geregelde
reorganisatie vraagt tijd
62
Boomstructuren als indexen
• Binaire zoekboom is geordend:
– 1 waarde in knoop
– in linkerdeelboom enkel kleinere waarden
– in rechterdeelboom enkel grotere waarden
• Opzoeken van waarde vraagt tijd evenredig met hoogte h van
boom
– "gewoonlijk" :
• h  log2 n
• met n = # waarden in de boom
+
– dus: zoeken is efficiënt
+–
Boom groeit en krimpt naarmate van de gegevens  dynamisch
63
... maar ...
64
Evenwichtigheid
• Aanpassen van boom (toevoegen, weglaten): ook
tijdscomplexiteit evenredig met h
– gemiddeld dus ook efficiënt
• MAAR: aanname van "evenwichtigheid" van bomen wordt
gemaakt!
– Niet onmogelijk dat h  n i.p.v. log2 n
– vb. bij eenvoudig toevoeg-algoritme dat waarden reeds in
volgorde krijgt
•  concept van evenwichtige zoekbomen
– toevoegen, weglaten worden zo geïmplementeerd dat
evenwicht steeds bewaard blijft
65
B-bomen
• B-boom van orde p (p > 2) is zoekboom waarvoor :
– elke inwendige knoop heeft hoogstens p kinderen
– de wortel heeft minstens 2 kinderen, elke andere knoop
minstens  p / 2 
– alle bladeren zitten even diep
– "waarde" in B-boom = sleutel + adres
– speciale gevallen: 2-3 bomen, 3-5 bomen, ...
– beperkingen i.v.m. min en max aantal kinderen garanderen
• redelijke gebalanceerdheid
• beperkte verspilling van geheugen
66
Adressen in knopen van B-bomen
• Adres is een blokadres of recordadres
– recordadres = blokadres + positie van record in blok
• voor niet-sleutelveld:
– adres van blok met wijzers naar adressen (cfr. eerdere
voorbeelden)  extra indirectie
67
Maximale hoogte van B-bomen
• orde p  minstens d =  p / 2  deelbomen per knoop
• op niveau 1 (onder wortel)
– minstens 2 knopen,
• op niveau i
– minstens 2 di-1 knopen  2 di-1 (d-1) waarden

h  logd ( (n + 1) / 2 )
68
B-bomen: abstract en voorbeeld
69
Voorbeeld 2 (1):
Berekening orde B-boom
• Stel:
– grootte van veld waarop gezocht wordt V = 9 bytes
– B = 512 bytes
– recordadres Pr = 7 bytes, blokadres P = 6 bytes
• 1 knoop van B-boom moet in 1 blok passen
–  max aantal deelbomen p van een knoop:
•
•
•
•
p * P + (p - 1) * (Pr + V)  B
6 p + 16 (p - 1)  512
p  24
meestal nog wat extra (administratieve) info in blok  kies p = 23
70
Voorbeeld 2 (2):
Aantal blokken en diepte
– empirisch onderzoek toont: B-boom gemiddeld 69% vol
• dus:
– Gemiddeld 0.69p = 0.69 x 23 = 16 wijzers
• gemiddelde fan-out fo = 16
• gemiddeld aantal waarden per knoop = 15
– wortel : 15 sleutels
– 1 niveau onder wortel :
• 16 knopen  16 * 15 = 240 sleutels
– 2 niveaus diep:
• 162 = 256 knopen, 3 840 sleutels
– 3 niveaus diep:
• 163 = 4 096 knopen, 61 440 sleutels
– totaal voor 3 niveaus:
• 61 440 + 3 840 + 240 + 15 = 65 535
71
Extra informatie (niet voor het examen)
„empirisch onderzoek toont: B-boom gemiddeld 69% vol“ - hoe weten we dat?
bron:
Author: Yao, Andrew Chi-Chih, Primary Title: On random 2–3 trees
Journal Name: Acta Informatica, Cover Date: 1978-06-01
Publisher: Springer Berlin / Heidelberg, Start Page: 159, End Page: 170
Volume: 9, Issue: 2, Url: http://dx.doi.org/10.1007/BF00289075
Verder werk bv. Hier:
T. Johnson and D. Shasha. 1989. Utilization of B-trees with inserts, deletes and
modifies. In Proceedings of the eighth ACM SIGACT-SIGMOD-SIGART symposium
on Principles of database systems (PODS '89). ACM, New York, NY, USA, 235-246.
DOI=10.1145/73721.73745 http://doi.acm.org/10.1145/73721.73745
http://portal.acm.org/citation.cfm?id=73745
72
Wanneer B-bomen gebruiken?
• Gebruik van B-bomen als primaire bestandsorganisatie
– dus niet voor index op bestand, maar bestand zelf
– 1 waarde in knoop = sleutel + het hele record
-
• Enkel goed bruikbaar indien
– klein aantal records
– kleine recordgrootte
• Anders fo te klein
 # niveaus van boom te groot
 inefficiënt
73
Operaties en hun kost/efficiëntie
+
+
-
• Opzoeken : O (logd n)
• Toevoegen, weglaten:
– eerst positie opzoeken
– wijziging aanbrengen en doorvoeren
– alles in O (logd n) tijd
• Sequentiele verwerking:
– boom doorlopen in in-orde (links, knoop, rechts)
– interne knopen vaak opnieuw gelezen, tenzij ze in centraal
geheugen onthouden worden
– kan beter : met B+-bomen
74
B+-bomen
• Bij B-bomen:
– sommige record-wijzers in interne knopen, andere in bladeren
• Bij B+-bomen:
– interne knopen bevatten enkel sleutels, geen adressen van
records
• recordadressen enkel in de bladeren
• interne knopen bevatten enkel "wegwijzers"
• orde pi van interne knopen is nu groter  betere prestaties; orde
pb van bladeren ongeveer even groot
• extra:
– aan het eind van een blad wijzer naar volgend blad
• maakt sequentieel doorlopen eenvoudiger
75
B+-bomen: abstract
76
Voorbeeld 3 (1):
Berekening orde B+-boom
• Gegeven:
– V = 9 bytes, B = 512 bytes, Pr = 7 bytes, P = 6 bytes
• orde van interne knopen:
– pi * P + (pi - 1) * V  B
– 6 pi + 9 (pi - 1)  512
–  pi = 34 (cfr. 23 voor B-boom)
• orde van bladeren:
–
–
–
–
pb * (Pr + V) + P  B
pb * ( 7 + 9 ) + P  B
16 pb + 6  512
 pb = 31
77
Voorbeeld 3 (2):
Aantal sleutels en diepte
– Stel 69% vol
– dan:
• 0.69 * 34 = 23 wijzers per knoop (22 waarden)
• in blad: 0.69 * pb = 0.69 * 31 = 21 recordwijzers
– gemiddeld aantal sleutels op elk niveau:
•
•
•
•
wortel:
1 knoop,
niveau 1:
23 knopen,
niveau 2:
529 knopen,
bladeren: 12 167 knopen,
22 sleutels
506 sleutels
11 638 sleutels
255 507 recordwijzers
– Vgl. met 65 536 recordwijzers voor B-boom
78
Algoritmes
• Algoritmes voor
– zoeken in B+-boom en
– voor aanpassing van B+-boom bij toevoegen / weglaten van
gegevens
– Gedetailleerde algoritmes in boek
79
B+-boom: Opzoeken van een sleutelwaarde
{ K = gezochte sleutel }
n := blok dat wortel van B+-boom bevat;
lees blok n;
zolang n geen blad is:
q := #deelbomen van n;
v0=- , v1..vq-1 waarden in knoop, vq=+ 
kies i zo dat vi < K <= vi+1;
n := bi;
lees blok n;
zoek in n een koppel (vi, Pri) met vi=K;
indien gevonden: lees record met adres Pri
anders: meld 'niet gevonden'
80
B+-boom:
Toevoegen van een record met sleutel K
• zoek blad waar sleutel hoort
• indien niet vol: voeg sleutel gewoon toe
• indien blad al vol: splits blad
–
–
–
–
1e helft blijft, 2e helft naar nieuw blad
voeg sleutel toe aan juiste blad
pas ook bladwijzers aan
voeg laatste waarde van blad 1 in ouderknoop toe
• herhaal zolang ouderknoop overvol is:
– splits knoop : helft van waarden naar nieuwe knoop; verhuis
laatste waarde van 1e knoop naar ouder
81
Taak: toevoegen van ...
8, 5, 1, 7, 3, 12, 9, 6
… aan een leeg B+-boom met orde
3 (inwendige knopen) en 2 (bladeren)
82
83
84
Alternatieve
oplossing
85
B+-boom:
Verwijderen van een sleutel K uit gegevens
• zoek blad met sleutel, verwijder sleutel daaruit
• indien sleutel ergens in interne knopen voorkomt:
– vervang door waarde net links ervan
• indien onderloop (te weinig waarden in blad):
– steel enkele waarden van naburig blad (en pas bovenliggende
knoop aan)
– indien nog niet voldoende: voeg 2 bladeren samen
– verwijder 1 wegwijzer uit bovenliggende knoop
• indien onderloop in interne knoop:
– herverdeel of voeg samen (met evt. verwijdering van 1 waarde
uit bovenliggende knoop...)
86
Taak: verwijderen van ...
6, 8, 5 (uit opgebouwde boom versie 1)
of
5, 12, 9 (uit opgebouwde boom versie 2)
87
88
89
B*-bomen
• elke knoop tenminste 2/3 gevuld (i.p.v. ½)
– splits slechts wanneer 2 naburige knopen vol zijn
90
Praktijkvoorbeeld: VSAM
• VSAM = Virtual Storage Access Method (IBM)
– Gebaseerd op B+-bomen
– Ontworpen om aan meerdere criteria te voldoen:
• sequentiële toegang
• toevoegen, weglaten, opzoeken : O (log n)
• geen reorganisatie nodig
– Blokken met gegevens die bij 1 blad horen, allemaal op 1
cilinder  tijdwinst
– Andere aanpassingen om efficiëntie verder te verhogen (index
apart plaatsen, sleutelcompressie, ...)
91
Agenda
Dynamische hashing
Uitbreidbare hashing
Lineaire hashing
Boomstructuren als indexen
Indexen op meerdere velden
92
Indexen op meerdere velden
• vb. index op combinatie van leeftijd en departement
– "geef alle werknemers van dept. 5 met leeftijd 60"
– met aparte indexen: eerst verz. werknemers van dept. 5 (A),
dan verz. met leeftijd 60 (B), vervolgens doorsnede nemen 
niet zo efficiënt
• resultaat waarschijnlijk veel kleinere verzameling dan A en B
– Samengestelde index veel efficiënter:
• levert direct het goede resultaat
• Hoe indexeren op meerdere velden?
93
Hoe de velden combineren? (1)
• Meerdere velden samen als 1 veld beschouwen
– Samengestelde waarden: ordening?
• lexicografisch : cf. alfabetische ordening
• (p1, q1) < (p2, q2)  p1 < p2 OF (p1 = p2 en q1< q2)
• enz. voor meer componenten
• Hashing op samengestelde velden: "partitioned hashing"
– resultaat hashfunctie is combinatie van resultaten van aparte
hashfuncties op componenten
– bv.
• 5  101;
• 60  10110
 (5, 60)  10110110
– geen aparte toegangsstructuren voor componenten nodig
(maar: enkel voor "="-tests)
94
Hoe de velden combineren? (2)
• i.p.v. rij met adressen : matrix met adressen
– indices voor matrix = waarden van componenten
• evt. code voor interval van waarden
– vb. matrix M: M5,5 bevat wijzer naar cel met wijzers naar records
waarvoor dept = 5 en leeftijd > 50
95
Fysische en logische indexen
• Naast bomen ook hashing of andere datastructuren mogelijk
voor index
• In onze bespreking: fysische indexen
– steeds fysische adressen gebruikt
– indien deze veel wijzigen: probleem
– logische index verhelpt dit:
• i.p.v. fysisch adres, wordt sleutel voor primaire
bestandsorganisatie teruggegeven
• dan zoeken volgens primaire structuur
– nadeel van logische index: 1 extra indirectie
96
Indexen: samenvatting
• Grootste voordeel van indexen:
– kunnen in principe gebruikt worden met eender welke primaire
bestandsorganisatie
– bemerk dat primaire organisatie enkel efficiënt zoeken op 1 veld
mogelijk maakt
• Indexen o.a. handig voor opleggen van uniciteit van velden
(naast efficiënt opzoeken van waarden)
• Bestand met secundaire index op elk veld = "volledig
geïnverteerd bestand" (fully inverted file)
97
Vooruitblik
Dynamische hashing
Uitbreidbare hashing
Lineaire hashing
Boomstructuren als indexen
Indexen op meerdere velden
Queryverwerking
98
Vraag: waarom deze twee opties?
(MySQL als maar een voorbeeld)
→ dit zijn twee structurele types van indexen
99
Bronnen
• Deze slides zijn gebaseerd op Henk Olivié‘s slides voor
Gegevensbanken 2009 en op Elmasri & Navathe,
Fundamentals of Database Systems, Addison Wesley /
Pearson, 5e editie 2007.
• Alle kopieën zonder bronspecificatie: Elmasri & Navathe,
Fundamentals of Database Systems, Addison Wesley /
Pearson, 5e editie 2007.
• Verdere figuren: bronnen zie “Powerpoint comments field”
• Bedankt iedereen!
100