Gegevensbanken 2010 les12
Upcoming SlideShare
Loading in...5
×
 

Gegevensbanken 2010 les12

on

  • 965 views

 

Statistics

Views

Total Views
965
Views on SlideShare
850
Embed Views
115

Actions

Likes
0
Downloads
28
Comments
0

4 Embeds 115

https://cygnus.cc.kuleuven.be 59
http://www.slideshare.net 48
https://canis-major.cc.kuleuven.be 4
https://canis-major.cc.kuleuven.be 4

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • http://seanm.ca/mosaic/mosaic.gif
  • http://www.brimediation.ch/graphics/Zeigefinger.jpg
  • http://www.familienbande-genealogie.de/vorlagen/images/fb_person_index_rtf_005T.png
  • Mbt = met betrekking tot; ivm = in verband met; verhouding = relation; t.o.v. = ten opzichte van verhouding van # records dat gebruikt wordt door een toepassing t.o.v. totaal # records van het bestand Het totaal nummer
  • Dünn (ijle lucht)
  • Das sollten sie selbst ableiten können
  • Hier ist die Animationsreihenfolge gut!

Gegevensbanken 2010 les12 Gegevensbanken 2010 les12 Presentation Transcript

  • Gegevensbanken 2010 Indexstructuren Bettina Berendt www.cs.kuleuven.be/~berendt
  • Indexstructuren: Motivatie & Samenvatting
  • Waar zijn we? Fysisch model / vragen Les Nr. wie wat 1 ED intro, ER 2 ED EER 3 ED relational model 4 ED mapping EER2relational 5 KV relational algebra, relational calculus 6 KV SQL 7 KV vervolg SQL 8 KV demo Access, QBE, JDBC 9 KV functional dependencies and normalisation 10 KV functional dependencies and normalisation 11 BB file structures and hashing 12 BB indexing I 13 BB indexing II and higher-dimensional structures 14 BB query processing 15 BB transaction 16 BB query security 17 BB Data warehousing and mining 18 ED XML, oodb, multimedia db
  • Herhaling: Bestandsorganisatie
    • Vraag : Waar/hoe gegevens plaatsen?
    • Antwoord : Zo plaatsen dat de kost van operaties geminimaliseerd wordt (zoeken, invoegen, verwijderen, ...)
    • Randvoorwaarde: fysica - alles moet ergens zijn, en alles is op een plaats.
     Door de juiste bestandsorganisatie wordt effici ë nt zoeken volgens de „primaire“, fysische structuur mogelijk
  • Dit was ook een goed idee voor het Web
    • ... maar nu willen we toch een beetje anders zoeken ...
    zoeken 1994: lineair of binair
  • Hoe werkt dat? Indexstructuren (hier: volledig geïnverteerde bestanden)  Door indexstructuren wordt effici ë nt zoeken ook volgens andere criteria (velden) mogelijk
  • Gegevens zijn als … een goed boek (1) Primaire index Bestandsorganisatie
  • Gegevens zijn als een goed boek (2) Secundaire index 1 Secundaire index 2
  • Gegevens zijn als een goed boek (3) Multi-niveau index
  • PS: Dit is ook een index (of: we moeten nog dingen van de vorige les vervolledigen) * als bruin: bucket 1 * als groen: bucket 2
  • [Nog iets over les #11] Herhaling: Belangrijke parameters m.b.t. bestandsverwerking
    • Bestandsactiviteit (file activity)
    • # records dat gebruikt wordt door een toepassing / totaal # records van het bestand
    • Bestandsveranderingsgraad (file volatility)
    • # records dat in een bepaalde periode een verandering ondergaat / totaal # records van het bestand
    • Bestandsverloop of vervangingsgraad (file turnover)
    • # records dat in een bepaalde periode vervangen wordt door nieuwe records / totaal # records van het bestand
    • Bestandsgroei (file growth)
    • toename van # records gedurende een bepaalde periode / het oorspronkelijk totaal # records
  • Oefening: Vervolledig de tabel! hoge bestands... Bestands- organisatie activiteit veranderings- graad vervangings- graad groei ongeordend geordend direct
  • Agenda Indexen: definitie Soorten indexen Indexen met meerdere niveaus Boomstructuren als indexen Indexen op meerdere velden
  • Agenda Indexen: definitie Soorten indexen Indexen met meerdere niveaus Boomstructuren als indexen Indexen op meerdere velden
  • Indexstructuren
    • Definitie:
      • een index op een bestand
    • = een gegevensstructuur die de toegang op dat bestand via een bepaald veld (of een groep velden) efficiënter maakt
        • d.w.z.: laat efficiënt zoeken naar een bepaalde waarde van dat veld toe
        • vgl.: woordenlijst achteraan boek, fichebak in bibliotheek, ...
    • Index kan opgeslagen zijn:
      • in centraal geheugen (enkel redelijk kleine indexen)
      • in een bestand in het externe geheugen
  • Vb.: Op welke velden zouden het nuttig zijn om een index te plaatsen?
  • Agenda Indexen: definitie Soorten indexen Indexen met meerdere niveaus Boomstructuren als indexen Indexen op meerdere velden
    • primaire index : index op veld dat
      • de ordening van het bestand bepaalt
      • records uniek ge ï dentificeerd (d.w.z. elke waarde voor het veld is uniek)
    • clusterindex : index op veld dat
      • de ordening van het bestand bepaalt
      • niet noodzakelijk unieke waarden
    • secundaire index : index op een ander veld dan dat wat de ordening bepaalt
    Soorten indexen Sluiten elkaar uit
  • Primaire indexen: voorbeeld } 1 blok
  • Primaire indexen
    • Primaire index:
      • bestand
        • met vaste lengte records
        • fysisch geordend volgens de sleutelwaarden
      • index: bevat 1 record per blok in het gegevensbestand:
        • sleutel van "ankerrecord" van het blok (= eerste of laatste record in het blok)
        • adres van het blok
      • Gegeven een sleutelwaarde, kan adres van blok waar overeenkomstig record zit, gevonden worden door zoeken in index i.p.v. gegevensbestand
        • d.i. dankzij de ordening in het bestand
  • Eigenschappen en voordelen
    • index bevat kleinere records dan gegevensbestand
      • enkel sleutel + adres, geen andere info
    • index bevat meestal minder records dan gegevensbestand
      • is een niet-dichte of ijle (nondense, sparse) index
    •  index is kleiner dan gegevensbestand
    •  doorlopen van index gaat sneller dan doorlopen van gegevensbestand
    •  veel minder toegang tot schijf nodig
    +
  • Probleem en oplossing
    • Toevoegen / weglaten van gegevens: nu ingewikkelder!
      • Naast gegevensbestand ook index aanpassen
        • ankerrecords kunnen veranderen
      • Oplossing:
        • voor toevoegen: overloopgebieden
        • voor weglaten: markeren van weggelaten records
        • na een tijdje: reorganisatie
    -
  • Berekening van performantie van indexen
    • Berekening van tijdswinst door index
      • Toegang tot hoeveel blokken is nodig?
    • Gegevensbestand gekenmerkt door
      • # records r
      • # blokken b =  (r / bfr) 
      • recordlengte R
      • bloklengte B
      • blocking factor bfr =  B / R  (hoeveel records in één blok?)
    • Indexbestand : analoog r i , b i , R i , B i , bfr i
      • meestal B i = B
      • met ankerrecords: r i = b
      • dichte index: r i = r
  • Voorbeeld 1 (1): de gegevens
    • Geordend gegevensbestand:
      • r = 30 000
      • R = 100 bytes, B = 1 024 bytes
    •  bfr =  1024 / 100  = 10
      • b =  r / bfr  =  30 000 / 10  = 3 000
    • Binair zoeken op gegevensbestand:
      • # schijftoegangen =  log 2 b  =  log 2 3 000  = 12
  • Voorbeeld 1 (2): primaire index
    • Indexbestand:
      • vb. sleutel = 9 bytes, blokadres = 6 bytes
      • R i = 9 + 6 = 15 bytes
    •  bfr i =  1024 / 15  = 68
      • r i = b = 3 000
    •  b i =  r i / bfr i  =  3 000 / 68  = 45
    • binair zoeken op indexbestand:
      • # schijftoegangen =  log 2 b i  =  log 2 45  = 6
    • Uiteindelijk ook nog blok met gegevens inlezen:
      • 1 extra blok  7 in totaal (i.p.v. 12)
  • Clusterindex
    • Gegevensbestand
      • fysisch geordend volgens veld dat niet uniek is
        • dat veld is dus geen sleutel
        • wel "clusterveld" genoemd
        • (records met zelfde waarde voor dat veld zitten gegroepeerd)
    • Clusterindex:
      • per waarde van clusterveld 1 wijzer naar blok waar eerste record met die waarde voorkomt
    •  ijle index
  • Clusterindexen: voorbeeld
  • Probleem en oplossing
    • Toevoegen
      • records schuiven op  verandering blokadressen in index
      • kan opgelost worden door aparte blokken te gebruiken voor de verschillende waarden
  • Secundaire index
    • Index op een ander veld dan het veld dat de ordening bepaalt
      • index zelf is wel geordend volgens dat veld
      • veld kan al dan niet een sleutel zijn
    • Indien dit een secundair-sleutel-veld is:
      • 1 record in index per record in gegevensbestand
        • geen ordening  enkel ankerrecords is onvoldoende
    •  dichte index
      • nog steeds kleiner dan gegevensbestand omdat records zelf kleiner zijn (maar minder spectaculair)
    +
  • Secundaire index op sleutelveld: voorbeeld
  • Voordelen
    • Hoewel index zeer groot kan zijn: toch grote tijdswinst
      • index is geordend  binair zoeken mogelijk
      • vs. gegevensbestand: lineair zoeken nodig!
    • Eens blok gevonden: enkel nog lineair zoeken binnen blok
      • in intern geheugen  gaat snel
      • bfr meestal relatief klein
    •  verwaarloosbaar vs. inlezen van blokken
    + +
  • Voorbeeld 1 (3): dichte secundaire index
    • Uit het vorige voorbeeld:
      • r = 30 000, R = 100 bytes, B = 1 024 bytes, b = 3 000
    • Lineair zoeken in dit bestand:
      • gemiddeld b / 2 = 1 500 blokken inlezen
    • Met (dichte) secundaire index:
      • stel veld 9 bytes, adres 6 bytes  R i =15
      • r i = r = 30 000,
      • bfr i = 68  b i = 30 000 / 68 = 442
      • binair zoeken :  log 2 b i  =  log 2 442  = 9 blokken
        • opmerking: controle of record voorkomt, bij dichte index, kan zonder gegevens zelf in te lezen
      • + 1 voor gegevens zelf : 10 blokken lezen (i.p.v.1500)
  • Secundaire index op niet-sleutel veld
    • dichte index
      • elke waarde komt even vaak in index voor als in gegevensbestand
    • index met variabele lengte records
      • per waarde een lijst wijzers naar blokken
    • index met verwijzingen naar blok recordwijzers
      • m.a.w. 1 adres per waarde
      • adres wijst naar blok (evt. lijst van blokken) met wijzers naar blokken in gegevensbestand
    •  1 indirectie meer
  • Secundaire index op niet- sleutelveld: voorbeeld
  • Voor- en nadelen van 2-niveau indexen
    • toevoegen / weglaten is veel gemakkelijker
    • 1 extra blok te lezen
    + -
  • Overzicht indexen Indexveld is Indextype (op veldtype ) # index records dicht of ijl Blokanker op Gege- vensbestand (GB) ? ordenend veld primair (sleutel) # blokken in GB ijl ja clustering (niet-sleutel) # verschillende indexveld-waarden ijl ja / neen niet- ordenend veld secundair (sleutel) # records in GB dicht neen secundair (niet-sleutel) # records in GB of # verschillende indexveld-waarden dicht of ijl neen Anker : blok hangt vast aan sleutel (bemoeilijkt toevoegen / weglaten)
  • Agenda Indexen: definitie Soorten indexen Indexen met meerdere niveaus Boomstructuren als indexen Indexen op meerdere velden
  • Indexen met meerdere niveaus
    • Principe:
      • Gewone index op gegevensbestand kan nog steeds groot zijn
      •  opnieuw een index bouwen bovenop deze index
        • laat toe waarden sneller terug te vinden in deze index
        • = niveau 2 index
      • eventueel hierbovenop nog een index, enz.
      • tot top-index maar 1 blok groot is
    • Blocking factor bfr i even groot voor alle indexen
      • = "fan-out" (fo)
  •  
  • Hoeveel blokken op welk niveau?
      • 1 e niveau:
        • r 1 = r records   r 1 / fo  blokken
      • 2 e niveau:
        • r 2 =  r 1 / fo  records   r 2 / fo    r 1 / fo 2  blokken
      • k e niveau:
        • r k   r 1 / fo k  blokken
      • hoogste niveau
        • 1 blok
      •  aantal niveaus t   log fo (r 1 ) 
        • vgl. met  log 2 (r 1 )  voor binair zoeken
        • hoe groter fo, hoe minder blokken te lezen
  • Voorbeeld 1 (4): als multi-niveau index
    • Stel dat de dichte secundaire index uit voorbeeld 2 nu een multi-niveau index is
      • fo = bfr i = 68
      • 1 e niveau:
        • 442 blokken (zie eerder)
      • 2 e niveau:
        •  b 1 / fo  =  442 / 68  = 7 blokken
      • 3 e niveau:
        •  7 / 68  = 1 blok  topniveau
      • Controleren of een waarde voorkomt:
        • 3 blokken lezen
      • Ophalen van gegevens zelf:
        • 4 blokken (vgl. 10 met binair zoeken, 1 500 zonder index)
  • Algoritme voor zoeken in ijle primaire multi-niveau-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 K j (i) <= K <= K j (i+1); p := p j (i); lees het blok gegevens met adres p; zoek in p naar het record met sleutel K
  • Praktijkvoorbeeld: ISAM
    • IBM's ISAM = &quot;Indexed Sequential Access Method&quot;
    • is een speciaal geval van een multi-niveau indexstructuur
    • 2-niveau indexstructuur:
      • 1e niveau: cilinderindex
        • sleutel van ankerrecord voor die cilinder + wijzer naar spoorindex van die cilinder
      • 2e niveau: spoorindex
        • sleutel van ankerrecord voor spoor + wijzer naar spoor
        • (nu vervangen door VSAM, “virtual storage access method”)
  • 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
    + -
  • Statische en dynamische structuren
    • Problemen met toevoegen / weglaten van records
      • doordat elk niveau van de indexboom fysisch geordend is
      • hele boom van indexen moet aangepast worden
    • Meer dynamische structuren kunnen oplossing bieden: B-bomen, B + -bomen
  • Agenda Indexen: definitie Soorten indexen Indexen met meerdere niveaus Boomstructuren als indexen Indexen op meerdere velden
  • 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
      • &quot;gewoonlijk&quot; :
        • h  log 2 n
        • met n = # waarden in de boom
      • dus: zoeken is efficiënt
    +
  • ... maar ...
  • Evenwichtigheid
    • Aanpassen van boom (toevoegen, weglaten): ook tijdscomplexiteit evenredig met h
      • gemiddeld dus ook efficiënt
    • MAAR: aanname van &quot;evenwichtigheid&quot; van bomen wordt gemaakt!
      • Niet onmogelijk dat h  n i.p.v. log 2 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
  • Zoekbomen
    • Een zoekboom (niet noodzakelijk binaire)
      • heeft in elke knoop een aantal waarden
        • v 1 < v 2 < ... < v m - 1 (m kan variëren van knoop tot knoop)
      • heeft in een knoop met m - 1 waarden
        • m kinderen b 1 , ..., b m
      • voor alle waarden v die voorkomen in b i geldt:
        • v i - 1 < v < v i (v 0 = -  , v m = +  )
    • Consistent met binaire zoekbomen (overal m = 2)
  • Zoekbomen: abstract
  • Zoekbomen: voorbeeld ( een zoekboom van orde 3)
  • B-bomen
    • B-boom van orde m (m > 2) is zoekboom waarvoor :
      • elke inwendige knoop heeft hoogstens m kinderen
      • de wortel heeft minstens 2 kinderen, elke andere knoop minstens  m / 2 
      • alle bladeren zitten even diep
      • &quot;waarde&quot; 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
  • 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
  • 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 d i-1 knopen  2 d i-1 (d-1) waarden
    •  h  log d ( (n + 1) / 2 )
  • B-bomen: abstract en voorbeeld
  • Voorbeeld 2 (1): Berekening orde B-boom
    • Stel:
      • grootte van veld waarop gezocht wordt V = 9 bytes
      • B = 512 bytes
      • recordadres P r = 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
  • 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:
        • 16 2 = 256 knopen, 3 840 sleutels
      • 3 niveaus diep:
        • 16 3 = 4 096 knopen, 61 440 sleutels
      • totaal voor 3 niveaus:
        • 61 440 + 3 840 + 240 + 15 = 65 535
  • 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
    -
  • Operaties en hun kost/efficiëntie
    • Opzoeken : O (log d n)
    • Toevoegen, weglaten:
      • eerst positie opzoeken
      • wijziging aanbrengen en doorvoeren
      • alles in O (log d 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
    + + -
  • 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 &quot;wegwijzers&quot;
        • orde p i van interne knopen is nu groter  betere prestaties; orde p b van bladeren ongeveer even groot
    • extra:
      • aan het eind van een blad wijzer naar volgend blad
        • maakt sequentieel doorlopen eenvoudiger
  • B + -bomen: abstract
  • Voorbeeld 3 (1): Berekening orde B + -boom
    • Gegeven:
      • V = 9 bytes, B = 512 bytes, Pr = 7 bytes, P = 6 bytes
    • orde van interne knopen:
      • p i * P + (p i - 1) * V  B
      • 6 p i + 9 (p i - 1)  512
      •  p i = 34 (cfr. 23 voor B-boom)
    • orde van bladeren:
      • p b * (Pr + V) + P  B
      • p b * ( 7 + 9 ) + P  B
      • 16 p b + 6  512
      •  p b = 31
  • Voorbeeld 3 (2): Aantal sleutels en diepte
      • Stel 69% vol
      • dan:
        • 0.69 * 34 = 23 wijzers per knoop (22 waarden)
        • in blad: 0.69 * p b = 0.69 * 31 = 21 recordwijzers
      • gemiddeld aantal sleutels op elk niveau:
        • wortel: 1 knoop, 22 sleutels
        • niveau 1: 23 knopen, 506 sleutels
        • niveau 2: 529 knopen, 11 638 sleutels
        • bladeren: 12 167 knopen, 255 507 recordwijzers
      • Vgl. met 65 536 recordwijzers voor B-boom
  • Algoritmes
    • Algoritmes voor
      • zoeken in B + -boom en
      • voor aanpassing van B + -boom bij toevoegen / weglaten van gegevens
      • Gedetailleerde algoritmes in boek
  • 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; v 0 =-  , v 1 ..v q-1 waarden in knoop, v q =+  kies i zo dat v i < K <= v i+1 ; n := b i ; lees blok n; zoek in n een koppel (v i , Pr i ) met v i =K; indien gevonden: lees record met adres Pr i anders : meld 'niet gevonden'
  • 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
  • Oefening: toevoegen van ...
    • 8, 5, 1, 7, 3, 12, 9, 6
  •  
  •  
  • Alternatieve oplossing
  • 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...)
  • Oefening: verwijderen van ...
    • 5, 12, 9
  •  
  •  
  • B * -bomen
    • elke knoop tenminste 2/3 gevuld (i.p.v. ½)
    • splits slechts wanneer 2 naburige knopen vol zijn
  • 2 manieren om in te voegen
    • Zuiver top-down invoegen:
      • Vorig algoritme:
        • top-down positie zoeken,
        • sleutel invoegen,
        • bottom-up herstructureren
      • Alternatief:
        • tijdens top-down zoeken al knopen splitsen die bijna vol zijn
        • geen &quot;2e ronde&quot; nodig
        • probleem indien toevoeging niet kan doorgaan
  • Omgevingen met meerdere gebruikers (1)
    • B / B + -bomen in omgeving met meerdere gebruikers
      • eerst boom top-down doorlopen, dan bottom-up herstructureren
      • wat als iemand anders intussen wijzigingen aanbrengt in index? kan fout lopen!
      • oplossing: locking (zie ook later)
    • Bij opzoeken:
      • plaats grendel op knoop K
      • zoek gepaste kindknoop K i , plaats grendel op K i
      • verwijder grendel op knoop K
      •  max. 2 knopen tegelijk gereserveerd door proces
  • Omgevingen met meerdere gebruikers (2)
    • Bij aanpassen:
      • leesgrendels zetten tijdens top-down procedure
        • ander proces kan knoop lezen, maar niet veranderen en kan er geen grendel op zetten
      • bij bereiken van blad:
        • indien geen aanpassing nodig blijkt:
          • geef alle grendels vrij
        • indien wel aanpassingen nodig:
          • plaats grendels,
          • maak alle aanpassingen,
          • geef grendels vrij
  • Omgevingen met meerdere gebruikers (3)
    • Indien heel pad wortel  blad gereserveerd: hele index bezet!
      • sterke beperkingen op andere gebruikers
      • beter: enkel op lagere niveaus gendels plaatsen
        • hogere niveaus blijven meestal toch ongewijzigd
      • indien dit onvoldoende blijkt: volledig herbeginnen en nu wel hogerop al leesgrendels plaatsen
    • Alternatief: volledig top-down algoritme
      • geen 2e ronde  grendels sneller vrijgegeven
  • 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, ...)
  • Agenda Indexen: definitie Soorten indexen Indexen met meerdere niveaus Boomstructuren als indexen Indexen op meerdere velden
  • Indexen op meerdere velden
    • vb. index op combinatie van leeftijd en departement
      • &quot;geef alle werknemers van dept. 5 met leeftijd 60&quot;
      • 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?
  • Hoe de velden combineren? (1)
    • Meerdere velden samen als 1 veld beschouwen
      • Samengestelde waarden: ordening?
        • lexicografisch : cf. alfabetische ordening
        • (p 1 , q 1 ) < (p 2 , q 2 )  p 1 < p 2 OF (p 1 = p 2 en q 1 < q 2 )
        • enz. voor meer componenten
    • Hashing op samengestelde velden: &quot;partitioned hashing&quot;
      • 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 &quot;=&quot;-tests)
  • 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: M 5,5 bevat wijzer naar cel met wijzers naar records waarvoor dept = 5 en leeftijd > 50
  • 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
  • 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 = &quot;volledig geïnverteerd bestand&quot; (fully inverted file)
  • Vooruitblik Indexen: definitie Soorten indexen Indexen met meerdere niveaus Boomstructuren als indexen Indexen op meerdere velden Meerdimensionale structuren
  • 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!