Kapitel 5...Extendible Hashing Aufbau 17 Beispiel: Extendible Hashing Schlüsselwert h(k) k Binärer Wert B 00 01 10 11 Verzeichnis Ersten i Bits von B (hier i = 2) 2 global depth

Architektur und Implementierung von Datenbanksystemen | WS 2009/10Melanie Herschel | Universität Tübingen

Kapitel 5Hash-basierte Indizes

• Überblick

• Statisches Hashing

• Extendible Hashing

• Linear Hashing

1

Architektur und Implementierung von Datenbanksystemen | WS 2009/10 | Melanie Herschel | Universität Tübingen

Hash-basierte Indizes

• Hash-basierte Indizes sind “unschlagbar”, wenn es um Gleichheitsanfragen geht.

• Außerdem profitieren weitere Anfrageoperationen (z.B. Nested Loop Join), die eine Menge von Gleichheitsprüfungen durchführen, von Hash-Indizes.

!In diesem Fall können Hash-basierte Indizes die Laufzeit wesentlich verbessern.

2

Beispiel einer Gleichheitsanfrage

SELECT * FROM RWHERE A = k


Hash-basierte Indizes vs. Baum-Indizes

• Hash-basierte Indizes bieten keine Unterstützung bei Bereichsanfragen.

• In einem B+-Baum lokalisieren wir ein Record mit Suchschlüsselwert k indem wir k mit anderen Schlüsselwerten k’ in der Baumstruktur vergleichen.

• Hash-basierte Indizes betrachten die bits von k selbst (unabhängig von allen anderen Schlüsselwerten k’) um das entsprechende Record zu finden.

Drei Varianten für Hash-basierte Indizes

• Statisches Hashing: Wie bei ISAM sind hier Updates problematisch.

• Extendible Hashing und Linear Hashing sind zwei Alternativen, die bei Einfüge- und Löschoperationen eine annehmbare Laufzeit aufweisen.

3



• Überblick



• Linear Hashing

4


Ein Bucket

Primärseiten

Überlaufseiten

Statisches HashingInitialisierung

• Dateneinträge werden in Buckets duch Hashfunktion einsortiert.

• Ein Bucket besteht aus einer Primärseite und ggf. ein oder mehreren Überlaufseiten.

0

h 1

N-1

Suchschlüsselwert k

h(k) mod N

5

...N Buckets


Statisches HashingWahl einer Hashfunktion

Kollisionen

•Im Allgemeinen können unterschiedliche Werte den gleichen Hashwert besitzen:

h(k) = h(k’) selbst wenn k ! k’

! Dateneinträge mit verschiedenen Suchschlüsselwerten in gleichem Bucket.

!Diese Eigenschaft ist erwünscht, da wir sonst genauso viele Buckets bräuchten, wie es Suchschlüsselwerte gibt.

Verteilung der Dateneinträge über Buckets

•Gegeben N Buckets, die von 0 bis N-1 numeriert sind, so wird k dem Bucket h(k) mod N zugewiesen.

•Die ideale Hashfunktion erreicht eine Gleichverteilung aller Schlüsselwerte über die N

Buckets. Dies vermeidet die Entwicklung sehr langer Überlaufketten in wenigen Buckets.

! Solche Hashfunktionen sind leider schwer zu finden.

• Wären Schlüsselwerte beliebig, könnte man aus diesen Werten einige Bits extrahieren und diese als Hashwert verwenden. Leider sind Datenverteilungen in der Realität nicht beliebig.

6



7

Beispiel Kollisionen: Der Geburtstagsparadox

Annahmen•Domäne: Menge von Personen.•Hashfunktion: entspricht Geburtstag einer Person: h: Person ! [0, ..., 364]

KollisionswahrscheinlichkeitWenn die Menge der Personen aus mehr als 23 Personen besteht, ist die Wahrscheinlichkeit, dass zwei

Personen am gleichen Tag Geburtstag haben > 50%.

Überprüfung: Berechne die Wahrscheinlichkeit p, dass n Personen unterschiedliche Geburtsdaten haben.

Fall 0: n = 1 ⇒ p0 = 1

Fall 1: n = 2 ⇒ p1 = 364 / 365

Fall 2: n = 3 ⇒ p2 = p1 ! 363 / 365

...Fall i: n = i + 1 ⇒ pi = pi-1 ! ( 365 - (i - 1) / 365 )



8

Divisionsrestmethode

•Hier entspricht das Ergebnis der Hashfunktion über einen (Bit-)Wert k

h(k) = k mod N

! Hier liegt das Ergebnis von h(k) garantiert in [0, ..., N-1].

• Wählt man N = 2d so werden letztendlich die letzten d Bits von k als Hashwert betrachtet.

•Eine meist effektive Regel ist, N einer Primzahl gleichzusetzen, die nicht nahe einer Zweierpotenz liegt.

Hashing mit N = 5 bzw N = 3 von Raumnummern {103, 105, 203, 205, 305 } - Welche Verteilung ist besser?



9

Multiplikative Methode

•Intuitiver Ansatz:

(1) Der Schlüsselwert k wird mit einer Zahl Z multipliziert.

(2) Der ganzteilige Anteil des Ergebnis aus Schritt (1) wird abgeschnitten ! Abbildung auf [0,1].

(3)Das Ergebnis von Schritt (2) wird mit der Anzahl Buckets N multipliziert.

•Formal gilt

h(k) = ⎣N " (Z " k -⎣Z " k⎦)⎦, 0 < A < 1

•Der inverse Goldene Schnitt 2 / (5-1/2 + 1) hat sich als eine gute Wahl für Z erwiesen.

Hashing durch Multiplikation, gegeben N = 8 und k = 80

Der inverse Goldene Schnitt Z " 0.61803399

Z ! k = 49.4427192 --> Z " k -⎣Z " k⎦= 0.4427192

! h(60) = 3

Mehr zu Hashfunktionen

Donald E. Knuth: The Art of Computer Programming / Sorting and Searching. Volume 3.


Statisches HashingInitialisierung

10

init_static_hash_index(Colum A)

1. Alloziiere N (aufeinanderfolgende) Seiten auf der Festplatte ⇒ Primärseiten

2. Für jeden Bucket, definiere einen Pointer zu einer Kette von Überlaufseiten. Dieser wird auf null initialisiert.

3. Definiere eine Hashfunktion h mit Wertebereich [0, ..., N-1]. Die Domäne von h ist der Datentyp des Attributs A, z.B. h: INTEGER ⇒ [0, ..., N-1] wenn A von Typ

INTEGER

Implikationen der Alloziierung aufeinanderfolgender Seiten bei Schritt 1 der Initialisierung.


Statisches HashingEinfügen von Dateneinträgen

11

Einfügen eines Dateneintrags k* in einen statischen Hash-Index

Berechne h(k). Sei P die Primärseite mit Nummer h(k).

P hat freie Record Slots?

Füge Dateneintrag k* in P ein.

Hat P Überlaufseite

mit freien Slots?

Füge Dateneintrag k* in Überlaufseite

ein.

Erstelle eine Überlaufseite und setze Pointer auf

Überlaufseite, um diese mit Kette zu verbinden.

Ja

Ja

Nein

Nein


Statisches HashingLöschen von Dateneinträgen

12

Löschen eines Dateneintrags k* aus einem statischen Hash-Index

Berechne h(k). Sei P die Primärseite mit Nummer h(k).

S ist Überlaufseite?

Finde k* auf P oder in Überlaufkette.Wir

nehmen an, k* auf S, und löschen k* aus S.

Ist L nach Löschen S leer?

Lösche S und passe Pointer in Kette an.

Nein

Nein

Ja

Ja


Statisches HashingKostenanalyse

13

I/O Kosten von search, insert, delete (ohne bzw. mit Überlaufseiten).

Optimierungsmöglichkeiten


Statisches HashingDiskussion

14

•Wächst die Daten-Datei, so entstehen Überlaufketten, die die sonst vorhersehbaren I/O Kosten unvorhersehbar und teurer machen.

•Schrumpft die Daten-Datei, so kann dies dazu führen, dass ein Großteil der Buckets (fast) leer ist. Somit verschwenden wir unnötig Speicherresourcen.

•Wie auch ISAM ist statisches Hashing vorteilhaft, wenn mehrfacher Zugriff auf den Index benötigt wird.

•Die einzige Möglichkeit, den Index zu reorganisieren um die ideale Situation wiederherzustellen (20% freier Speicher, keine Überlaufketten) ist, einen Rehash durchzuführen.

! Rehash ist selbst eine teure Operation und der Index ist dabei nicht mehr zugreifbar.



• Überblick



• Linear Hashing

15


Extendible Hashing

16

ZielsetzungVermeiden von langen Überlaufketten, um Disk-I/O gering und voraussehbar zu halten.

Naiver Ansatz

•Benötigt statisches Hashing eine Überlaufseite, so verdoppeln wir die Anzahl Buckets und verteilen die Dateneinträge neu.

•Nachteile

•Die ganze Indexdatei muss dabei gelesen werden.

•Das Schreiben der neuen Datei benötigt doppelt so viel Disk-I/O.

Lösung: Extendible Hashing

•Verwendung eines Verzeichnisses, das Pointer auf Buckets verwaltet.

•Bei einem Seitenüberlauf wird das Verzeichnis verdoppelt, wie auch der spezifische Bucket, der übergelaufen ist.


Extendible HashingAufbau

17

Beispiel: Extendible Hashing

h(k)Schlüsselwert

k

Binärer Wert B

00

01

10

11

Verzeichnis

Ersten i Bits von B(hier i = 2)

2

global depth 4* 12* 32* 16*

1* 5* 21*

10*

15* 7* 19*

Buckets

Bucket A

Bucket B

Bucket C

Bucket D

2

2

2

2

local depth


Extendible HashingEinfügen in Buckets mit freien Slots

18

Beispiel: Einfügen von 13*

h(k)Schlüsselwert

k

Binärer Wert B

00

01

10

11

Verzeichnis

Ersten i Bits von B(hier i = 2)

2

global depth 4* 12* 32* 16*

1* 5* 21*

10*

15* 7* 19*

Buckets

Bucket A

Bucket B

Bucket C

Bucket D

2

2

2

2

local depth

13* 100113*


Extendible HashingVerdoppeln des Verzeichnisses nach Bucket Split

20


h(k)Schlüsselwert

k

Binärer Wert B

000

001

Ersten i Bits von B(jetzt i = 3)

3

global depth

32* 16*

1* 5* 21* 13*

10*

15* 7* 19*

Buckets

Bucket A

Bucket B

Bucket C

Bucket D

3

2

2

2

20* 10100

local depth

4* 12* 20* Bucket A23

010

011

100

101

110

111


Extendible HashingKein Verdoppeln des Verzeichnisses nach Bucket Split

21


h(k)Schlüsselwert

k

Binärer Wert B

000

001

Ersten i Bits von B(jetzt i = 3)

3

global depth

32* 16*

1* 5* 21* 13*

10*

15* 7* 19*

Buckets

Bucket A

Bucket B

Bucket C

Bucket D

3

2

2

2

9* 1001

local depth

4* 12* 20* Bucket A23

010

011

100

101

110

111

5* 21* 13* Bucket B23

1* 9* Bucket B3


Extendible HashingGlobal Depth vs. Local Depth

22

Global Depth (Globale Tiefe)

•Sei n die globale Tiefe.

•n ist die Anzahl Bits von h(k), die im Verzeichis verwendet wird, um ein Bucket zu finden.

•Die Größe des Verzeichnisses ist 2n.

•In unserem Beispiel ist n von 2 auf 3 (nach einem Bucket Split) gestiegen.

Local Depth (Lokale Tiefe)

•Sei d die lokale Tiefe eines Buckets.

•d ist die Anzahl niedrigster Bitstellenwerte, die bei den Hashwerten aller Dateneinträge in einem Bucket garantiert übereinstimmen.

•Während in unserem Beispiel für Bucket D die 2 niedrigsten Stellenwerte von 15 (1111), 7 (111), 20 (10011) übereinstimmen, sind es bei Bucket A2 bereits 3 Stellenwerte für 5 (101), 21 (10101), 13 (1101).

Verwendung

•Entscheidung, ob nach Bucket Split eine Verdopplung des Verzeichnisses nötig ist.

• local depth (vor Split) = global depth ⇒ Verdopplung, sonst nicht.


Extendible HashingInitialisierung & Suche

23

Initialisierung

1. Sei N = 2n die anfängliche Anzahl Buckets.

2. Erstelle ein Verzeichnis mit N Einträgen.

3. Alloziiere N Seiten für die Primärseiten der einzelnen Buckets und setze Pointer in Verzeichnis auf jeweilige Buckets.

4. Setze die globale Tiefe n.

5. Setze die lokale Tiefe jedes Buckets d = n.

Suche hsearch(k)

Gegeben: bucket[0, ..., 2n-1]: Array, der das Bucket-Verzeichnis enthält


Extendible HashingEinfügen

24

Einfügen

function hinsert(k*)

begin

n := n; /* global depth*/

b := hsearch(k); /*gibt Primärseite b des Buckets von k zurück*/

if b hat freie Slots then

begin

Füge k* auf b ein;

return;

end

/*overflow in Bucket b benötigt Split */

b2 := neuer Bucket;

d := db; /*db ist local depth des Buckets b*/

/*Verteile die Einträge von b und k* über existierenden und neuen Bucket*/

...


Extendible HashingEinfügen

25

Einfügen (ctd)

/*Verteile die Einträge von b und k* über existierenden und neuen Bucket*/

foreach k’* ! b do

if h(k’) & 2d ! 0 then

Verschiebe k’* in Bucket b2;

/*Wir setzen die neue lokale Tiefe von b und b2*/

db := d + 1;

db2 := d + 1;

if n < d + 1 then

begin /* Wir müssen das Verzeichnis verdoppeln*/

Alloziiere 2n neue Verzeichniseinträge bucket[2n, ..., 2n+1 - 1];

Kopiere bucket[0, ..., 2n - 1] in bucket[2n, ..., 2n+1 - 1];

n := n+1;

/*Setze Pointer für b2*/

bucket[(h(k) & (2n - 1)) | 2n ] := addr(b2);

end

end


Extendible HashingLöschen - Merge ohne Verzeichnishalbierung

27

Beispiel: Löschen von 9*

h(k)Schlüsselwert

k

Binärer Wert B

000

001

3

global depth

32* 16*

10*

15* 7* 19*

Buckets

Bucket A

Bucket C

Bucket D

3

2

2

local depth

4* 12* 20* Bucket A23

010

011

100

101

110

111

Bucket B2

1* 9* Bucket B3

3 5* 21* 13*


Extendible HashingLöschen - Merge ohne Verzeichnishalbierung

27


h(k)Schlüsselwert

k

Binärer Wert B

000

001

3

global depth

32* 16*

10*

15* 7* 19*

Buckets

Bucket A

Bucket C

Bucket D

3

2

2

local depth

4* 12* 20* Bucket A23

010

011

100

101

110

111

1* 9* Bucket B3 Bucket B33 5* 21* 13*1*2


Extendible HashingLöschen - Merge mit Verzeichnishalbierung

28


h(k)Schlüsselwert

k

Binärer Wert B

000

001

3

global depth

32* 16*

10*

15* 7* 19*

Bucket A

Bucket C

Bucket D

3

2

2

local depth

4* 12* 20* Bucket A23

010

011

100

101

110

111

1* 5* 21* 13* Bucket B2


Extendible HashingLöschen - Merge mit Verzeichnishalbierung

28


h(k)Schlüsselwert

k

Binärer Wert B

3

global depth

32* 16*

10*

15* 7* 19*

Bucket A

Bucket C

Bucket D

3

2

2

local depth

1* 5* 21* 13* Bucket B2

12* 202

00

01

10

11

2


Extendible HashingDiskussion

29

Varianten des Algorithmus

•Theoretisch kann man auch die Bits mit dem höchsten Stellenwert verwenden, allerdings kann man in diesem Fall das Verzeichnis bei Verdopplung nicht einfach kopieren (siehe Einfügealgorithmus).

•In der Praxis wird der Merge Schritt (siehe Löschen) nicht durchgeführt.


Extendible HashingDiskussion

29

Varianten des Algorithmus

•Theoretisch kann man auch die Bits mit dem höchsten Stellenwert verwenden, allerdings kann man in diesem Fall das Verzeichnis bei Verdopplung nicht einfach kopieren (siehe Einfügealgorithmus).

•In der Praxis wird der Merge Schritt (siehe Löschen) nicht durchgeführt.

Überlaufketten bei Extendible Hashing



• Überblick



• Linear Hashing

30


Linear Hashing

31

•Wie Extendible Hashing passt sich die Indexdatei bei Einfüge- und Löschoperationen an, um lange Überlaufketten zu vermeiden.

•Linear Hashing benötigt kein Verzeichnis.

•Linear Hashing ermöglicht im Vergleich zu Extendible Hashing mehr Flexibilität bei der Festlegung des Zeitpunkts, wann ein Bucket gesplittet wird.

•Bei stark ungleich verteilten Daten kann Linear Hashing allerdings eine schlechtere Disk-I/O Performance aufweisen als Extendible Hashing.


Linear HashingFamilie von Hashfunktionen

32

•Verwendung einer Familie von Hashfunktionen h0, h1, h2, ...

•Gegeben hi, so ist i das Level der Funktion h.

•Es gilt, dass der Wertebereich von hlevel+1 zweimal so groß ist wie der Wertebereich von hlevel.

•Beispiel: hlevel mit Wertebereich [0, ..., N - 1]

0

N - 1N

2N - 1

hlevel

hlevel+1

0

2N - 12N

4N - 1

hlevel+1

hlevel+2


Linear HashingDefinition Geeigneter Hashfunktionen

33

•Gegeben eine initiale Hashfunktion h und die Anzahl Buckets N.

•Eine Möglichkeit, eine Familie von Hashfunktionen zu definieren ist

hlevel(k) = h(k) mod (2level * N) für level = 0, 1, 2, ...

Was ergibt sich, wenn N einer Zweierpotenz entspricht?


Linear HashingGrundlegendes Schema

35

1.Wir initialisieren

a.level := 0;

b.Einen Pointer auf ein bucket: next := 0 (Bucket zu hlevel(k) = 0 )

2.Die aktuelle Hashfunktion ist hlevel und diese wird verwendet, um Such-, Einfüge-, und Löschoperationen durchzuführen.

3.Aktive Buckets sind Buckets, die im Wertebereich von hlevel liegen [0, ..., 2level N-1]

4.Wann immer die Hashtabelle überläuft, z.B.,

a. Wenn Einfügeoperationen die Primärseite eines Buckets zu mehr als c% füllen;

b.Oder die Überlaufketten eines Buckets länger als ein Schwellwert p sind;

c. Oder ... 〈fügen Sie hier weitere Kriterien ein〉

dann Splitten wir den Bucket, auf den der next Pointer zeigt. Dieser entspricht im Allgemeinen nicht dem Bucket, der den Split ausgelöst hat!


Linear HashingBucket Split

36

k1*, ..., ki*, ... 0

2level N - 1

next

1Alloziiere Seite für neuen Bucket und füge diesen am Ende der Indexdatei hinzu.

k1*, ..., ki*, ... 0next

2level N - 1

2level N + next

Split durch Einfügen von kj* verursacht

2

Rehash Dateneinträge in Bucket next mit hlevel+1

k1*, ... 0next

ki*, ...

2level N - 1

2level N + next3 Erhöhe next um 1.

k1*, ... 0

next

ki*, ...

2level N - 1

2level N + next

• kj* spielt bei Split keine Rolle, nur die Position von next ist entscheidend.

• Einfügen von kj* wie bei statischem Hashing.

• Da Splits durch next nach Round-Robin-Prinzip durchgeführt werden, werden Überlaufketten durch Rehash regelmäßig reduziert/entfernt.

!Überlaufketten sind in der Regel kurz (1 - 2 Seiten)


Linear HashingBuckets innerhalb einer Runde

37

Beispiel: Verteilung von Buckets innerhalb einer Runde (entspricht level)

0

2levelN - 1

hlevel

hlevel+1

next

Bereits gesplittete Buckets

Nächster Bucket, der gesplittet wird

Nicht gesplittete Buckets

Split-Partner der bereits gesplitteten Buckets


Suche eines Schlüssels k

Linear HashingImplikationen der Bucketverteilung auf die Suche

38

0

2levelN - 1

hlevel

hlevel+1

next


Linear HashingAuf in die Nächste Runde

41

Beispiel: next hat Ende der Hashtabelle (laut hlevel) erreicht

0

2levelN - 1

hlevel

hlevel+1next

•Ist next = 2level N - 1, wurden alle aktiven Buckets bereits via hlevel+1 rehashed.

! Führe folgenden Algorithmus durch:

1. level := level + 1;

2. Setze next wieder auf 0 und fahre wie in vorhergehenden Runde fort (siehe Bucket Split).

•Im Allgemeinen wird ein Überlaufbucket nicht sofort bei Überlauf gesplittet, aber, dank des Round-Robin-Splittings, nicht später als in der nächsten Runde.


Extendible HashingSuchalgorithmus

42

Linear Hashing: Suche

function hsearch(k)

begin

b := hlevel(k);

if b < next then

/* b wurde bereits gesplittet, daher kann Dateneintrag für k sowohl in b als auch in Bucket 2levelN - 1 + b liegen --> rehash */b := hlevel+1(k);

/* Gebe Addresse des Buckets an Position b zurück */return bucket[b];

end

• Algorithmen verwenden einen Array von Bucket-(Seiten-)Adressenbucket[0, ..., 2level N - 1].

• Die Variablen level und next sind global für die Hashtabelle definiert, N ist konstant.


Extendible HashingEinfügealgorithmus

43

Linear Hashing: Einfügen eines Dateneintrags k*

function hinsert(k*)

begin

b := hlevel(k);

if b < next then

b := hlevel+1(k); /* rehash */Platziere k* in bucket[b];if overflow(bucket[b]) then /*Overflow kann flexibel definiert werden*/begin

Alloziiere neue Seite b’;bucket[2level N + next] := addr(b’); /*Vergrößern der Hashtabelle*/foreach k’* in bucket[next] do

Platziere k’* in bucket[hlevel+1(k’)];next := next + 1;if next > 2level N-1 then /*Beginn einer neuen Runde*/ begin

level := level + 1;next := 0;

endendreturn;

end


Extendible HashingLöschalgorithmus

44

Linear Hashing: Löschen eines Suchschlüsselwerts k (sketch, da konzeptuell Invers von Insert)

function hdelete(k)

begin

...

if empty(bucket[2level N + next) then /*Verursacht Löschen, dass letzter Bucket leer?*/

begin

Entferne Seite aus Hashtabelle, die von bucket[2level N + next] referenziert wird;

next := next - 1;

if next < 0 then /* Zürück in die vorhergehende Runde */

begin

level := level - 1;

next := 2level N - 1;

end

...

end

end


Zusammenfassung

Static Hashing

• Wie bei statischer ISAM Struktur hat Static Hashing das Problem, dass lange Überlaufketten die Performance negativ beeinflussen.

• Kann bei parallelem Zugriff auf den Index dennoch nützlich sein.

• Die Wahl der Hashfunktion ist entscheidend für die gleichmäßige Verteilung der Dateneinträge über alle vorhandenen Buckets (gilt auch für andere Hashing Varianten)

Extendible Hashing

• Verwendet ein Verzeichnis, um die Menge von Buckets bei Überlauf eines Buckets zu erhöhen.

• Das Verzeichnis wird ggf. verdoppelt, wenn ein Bucket überläuft und die Daten des Buckets werden über zwei Buckets neu verteilt.

Extendible Hashing

• Dynamischer Hash-Index ohne Verzeichnis.

• Verwendet eine Famile von Hashfunktionen.

• Buckets werden im Round-Robin-Verfahren gesplittet, so dass Überlauf-ketten regelmäßig reduziert werden.

45

Documents

Kapitel 5...Extendible Hashing Aufbau 17 Beispiel: Extendible Hashing Schlüsselwert h(k) k Binärer Wert B 00 01 10 11 Verzeichnis Ersten i Bits von B (hier i = 2) 2 global depth