Kap. 4-5

Physikalische Datenorganisation
Record
Datensatz fester oder variabler Länge
mit Feldern bestimmten Typs
Block
Speichereinheit im Hintergrundspeicher
(29 - 212 Bytes)
File
Menge von Blöcken
Pinned record
Blockadresse + Offset
Unpinned record Blockadresse + Recordschlüssel
Blockadresse + Index (Tupelidentifikator)
1
Tupelidentifikator:
Verschieben innerhalb der Seite
TID
4711
2
1
2
3
5001
Grundzüge
4052
Logik
...
5041
Ethik
...
...
4052 Mathematische
Logik ...
Seite 4711
2
Tupelidentifikator: Verdrängen auf andere Seite
TID
4711 2
1 2 3
1 2 3
5001
5041
Grundzüge
Ethik
...
4052 Mathematische
Logik für
Informatiker...
...
4052 Mathematische
4052
LogikMathematische
...
4812 3 Logik
Seite 4711
Seite 4812
3
Implementierung des E-R-Modells
• pro Entity ein Record mit den Attributen als Datenfelder
• pro Relationship ein Record mit den TIDs der beteiligten Entities
4
Speicher-Operationen
• INSERT:
Einfügen eines Records
• DELETE:
Löschen eines Records
• MODIFY:
Modifizieren eines Records
• LOOKUP:
Suchen eines Records
5
Heap-File
• INSERT:
Record am Ende einfügen
• DELETE:
Lösch-Bit setzen
• MODIFY:
Record überschreiben
• LOOKUP:
Gesamtes File durchsuchen
6
Hashing
•
•
•
•
•
alle Records sind auf Buckets verteilt
ein Bucket besteht aus einer verzeigerten Liste von Blöcken
Bucketdirectory enthält Einstiegsadressen
Hashfunktion (angewandt auf Schlüssel) liefert zuständige Liste
Bei N Buckets bildet die Hashfunktion einen Schlüssel auf eine
Zahl zwischen 0 und N-1 ab.
• Pro Datenrecord ein Frei/Belegt-Bit
7
Beispiel für Hashorganisation (|v| mod 5)
0
1 1 Peter
Fritz
1
1 0 Thomas
2
1 1 Melanie
Susanne
3
1 1 Ute
Eberhard
4
1 1 Kurt
Karl
1 0 Beate
1 0 Eva
8
Beispiel für Hash-Funktion
Sei N die Anzahl der Buckets. Fasse den Schlüssel v als k Gruppen von
jeweils n Bits auf. Sei di die i-te Gruppe als natürliche Zahl interpretiert:
dk
dk-1
d2
d1
h(v) = (dk + dk-1 + . . . + d2 + d1) mod N
9
Hash-Operationen für Schlüssel v
• LOOKUP:
Berechne h(v) = i. Lies den für i zuständigen Directory-Block ein,
und beginne bei der für i vermerkten Startadresse mit dem
Durchsuchen aller Blöcke.
• MODIFY:
Falls Schlüssel beteiligt: DELETE und INSERT durchführen.
Andernfalls: LOOKUP durchführen und dann überschreiben.
• INSERT:
Zunächst LOOKUP durchführen. Falls Satz mit v vorhanden:
Fehler. Sonst: Freien Platz im Block überschreiben und ggf.
neuen Block anfordern.
• DELETE:
Zunächst LOOKUP durchführen. Bei Record Löschbit setzen.
10
0
1 1 Peter
Fritz
1
1 0 Thomas
2
1 1 Melanie
Susanne
3
1 1 Ute
Eberhard
4
1 1 Kurt
Karl
Hashorganisation: Ausgangslage
1 0 Beate
1 0 Eva
h(s) = |s| mod 5
Paul einfügen
11
0
1 1 Peter
Fritz
1 0 Beate
1
1 0 Thomas
2
1 1 Melanie
Susanne
3
1 1 Ute
Eberhard
1 0 Eva
4
1 1 Kurt
Karl
1 0 Paul
Hashorganisation: nach Einfügen von Paul
Kurt umbenennen nach Curdt
12
0
1 1 Peter
Fritz
1 1 Beate
1
1 0 Thomas
2
1 1 Melanie
Susanne
3
1 1 Ute
Eberhard
1 0 Eva
4
0 1
Karl
1 0 Paul
Curdt
Hashorganisation: nach Umbenennen von Kurt in Curdt
13
Probleme beim Hashing
durch dynamisch sich ändernden Datenbestand:
• Blocklisten werden immer länger
• Reorganisation erforderlich
14
Erweiterbares Hashing
• Hashfunktion liefert Binärstring
• verwende geeigneten Prefix des Binärstring als Adresse
15
Beispiel für erweiterbares Hashing
Hashwert = umgekehrte Binärdarstellung von Matrikelnummer
MatNr
2125
2126
2127
2129
Name
Sokrates
Russel
Kopernikus
Descartes
Hashwert
101100100001
011100100001
111100100001
100010100001
Ein Datenblock enthalte zwei Records
16
Beispiel für erweiterbares Hashing
2125
2126
2127
2129
Sokrates 101100100001
Russel
011100100001
Kopernikus 111100100001
Descartes 100010100001
h(x)
x
2125
2126
2127
d
p
1 01100100001
0 11100100001
1 11100100001
Sokrates, Russel, Kopernikus einfügen
(2126, Russel, C4, 232)
0
t´= 1
1
(2125, Sokrates, C4, 226)
(2127, Kopernikus, C3, 310)
t´= 1
t = 1
Descartes einfügen
Bucket 1 läuft über
Setze globale Tiefe t:=2
17
Beispiel für erweiterbares Hashing
2125
2126
2127
2129
Sokrates 101100100001
Russel
011100100001
Kopernikus 111100100001
Descartes 100010100001
h(x)
x
2125
2126
2127
2129
d
10
01
11
10
p
1100100001
1100100001
1100100001
0010100001
(2126, Russel, C4, 232)
t´= 1
00
01
(2125, Sokrates, C4, 226)
10
(2129, Descartes, C3, 312)
t´= 2
11
(2127, Kopernikus, C3, 310)
t´= 2
t = 2
18
Defizite beim Hashing
• Keine Sortierung
• Keine Bereichsabfragen
19
ISAM (Index sequential access method)
• Index-Datei mit Verweisen in die Hauptdatei.
• Index-Datei enthält Tupel < Schlüssel,Blockadresse>,
sortiert nach Schlüsseln.
• Liegt < v, a > in der Index-Datei, so sind alle Record-Schlüssel
im Block, auf den a zeigt, größer oder gleich v.
20
ISAM-Operationen für Record mit Schlüssel v
• LOOKUP (für Schlüssel v):
Suche in Index-Datei den letzten Block mit erstem Eintrag v2  v.
Suche in diesem Block das letzte Paar (v3, a) mit v3  v.
Lies Block mit Adresse a und durchsuche ihn nach Schlüssel v.
• MODIFY:
Zunächst LOOKUP. Falls Schlüssel an Änderung beteiligt:
DELETE + INSERT. Sonst: Record ändern, Block
zurückschreiben.
• INSERT:
Zunächst LOOKUP. Falls Block noch Platz für Record hat:
einfügen. Falls Block voll ist: Nachfolgerblock oder neuen Block
wählen und Index anpassen.
• DELETE:
Analog zu INSERT
21
1
1
1
1
Anton
Doris
1
1
0
0
Sabine
Theo
Karl
Paul
1
1 Anton
Berta
1
1 Doris
Emil
1
1 Karl
Norbert
1
1 Paul
Peter
1
0 Sabine
1
1 Theo
Ute
Index-Organisation: Ausgangslage
Manfred einfügen
22
1
1
1
1
Anton
Doris
Karl
1
1
1
0
Paul
Sabine
Theo
Norbert
1
1 Anton
Berta
1
1 Doris
Emil
1
1 Karl
Manfred
1
0 Norbert
1
1 Paul
1
1 Sabine
1
1 Theo
Peter
Ute
Index-Organisation: nach Einfügen von Manfred
23
Sekundär-Index
Sekundärindex besteht aus Index-File
mit Einträgen der Form <Attributwert, Adresse>.
24
Sekundär-Index für Gewicht
68
71
72
78
83
25
Beispiel zur physikalischen Speicherung
Gegeben seien 300.000 Records mit folgenden Angaben:
Attribut
Bytes
Pers-Nr.
Vorname
Nachname
Straße
PLZ
Ort
15
15
15
25
5
25
Platzbedarf pro Record: 100 Bytes.
Die Blockgröße betrage 1024 Bytes.
26
Fragen zur Zahl der Records
Wieviel Daten-Records passen in einen zu 100% gefüllten Datenblock?
1024 / 100 = 10
Wieviel Daten-Records passen in einen zu 75% gefüllten Datenblock?
10 * 0,75 = 7-8
Wieviel Schlüssel / Adresspaare passen in einen zu 100% gefüllten Indexblock?
1.024 / (15+4) = 53
Wieviel Schlüssel / Adresspaare passen in einen zu 75% gefüllten Indexblock?
1.024 / (15+4)*0,75  40
27
Heapfile versus ISAM
Welcher Platzbedarf entsteht beim Heapfile?
300.000 / 10 = 30.000 Blöcke
Wieviel Blockzugriffe entstehen im Mittel beim Heapfile?
30.000 / 2 = 15.000
Welcher Platzbedarf entsteht im Mittel bei ISAM?
300.000 / 7,5
40.000 / 40
 40.000 zu 75% gefüllte Datenblöcke +
 1.000 zu 75% gefüllte Indexblöcke
Wieviel Blockzugriffe entstehen im Mittel bei ISAM?
log2(1.000) + 1  11 Blockzugriffe
28
B*-Baum
• Jeder Weg von der Wurzel zu einem Blatt hat dieselbe Länge.
• Jeder Knoten außer der Wurzel und den Blättern hat
mindestens k Nachfolger.
• Jeder Knoten hat höchstens 2 • k Nachfolger.
• Die Wurzel hat keinen oder mindestens 2 Nachfolger.
29
B*-Baum-Adressierung
Ein Knoten wird auf einem Block gespeichert
Ein Knoten mit j Nachfolgern (j  2•k)
speichert j Paare von Schlüsseln und Adressen (s1, a1), . . . , (sj, aj).
Es gilt s1  s2  . . .  sj.
Eine Adresse in einem Blattknoten führt zum Datenblock mit den
restlichen Informationen zum zugehörigen Schlüssel
Eine Adresse in einem anderen Knoten führt zu einem Baumknoten
30
Einfügen in B*Baum
17
22
31
17
42
77
42
47
53
61
77
79
eingefügt werden soll: 45
31
Einfügen in B*Baum
17
22
31
17
42
77
42
47
53
61
77
79
eingefügt werden soll: 45
Block anfordern
Überlaufblock verteilen
32
Einfügen in B*Baum
17
22
31
17
42
42
47
77
77
53
79
61
eingefügt werden soll: 45
Vorgänger korrigieren
33
Einfügen in B*Baum
17
22
31
17
42
53
42
45
47
77
77
53
79
61
eingefügt wurde: 45
34
Sequenz für B*-Baum mit k=2
27
55
12
94
37
88
72
39
25
88
74
58
64
35
27
27
36
27 55
27
37
27
55
27 55
38
27
55
12
27 55
39
27
55
12
12 27 55
40
27
55
12
94
12 27 55
41
27
55
12
94
12 27 55 94
42
27
55
12
94 37
12 27 55 94
43
27
55
12 27
12
94 37
55 94
44
27
55
12 27 37
12
94 37
55 94
45
27
55
12
94 37
12
12 27 37
55
55 94
46
27
55
12
94 37
88
12
12 27 37
55
55 94
47
27
55
12
94 37
88
12
12 27 37
55
55 88 94
48
27
55
12
94 37
88
72
12
12 27 37
55
55 88 94
49
27
55
12
94 37
88
72
12
12 27 37
55
55 72 88 94
50
27
55
12
94 37
88
72
12
12 27 37
39
55
55 72 88 94
51
27
55
12
94 37
88
72
12
12 27 37 39
39
55
55 72 88 94
52
27
55
12
94 37
88
72
12
12 27 37 39
39
25
55
55 72 88 94
53
27
55
12
94 37
88
72
39
25
12 37 55
12 27
37 39
55 72 88 94
54
27
55
12
94 37
88
72
39
25
12 37 55
12 25 27
37 39
55 72 88 94
55
27
55
12
94 37
88
72
39
25
91
12 37 55
12 25 27
37 39
55 72 88 94
56
27
55
12
94 37
88
72
39
25
91
12 37 55 88
12 25 27
37 39
55 72
88 94
57
27
55
12
94 37
88
72
39
25
91
12 37 55 88
12 25 27
37 39
55 72
88 91 94
58
27
55
12
94 37
88
72
39
25
91
74
12 37 55 88
12 25 27
37 39
55 72
88 91 94
59
27
55
12
94 37
88
72
39
25
91
74
12 37 55 88
12 25 27
37 39
55 72 74
88 91 94
60
27
55
12
94 37
88
72
39
25
88
74
58
12 37 55 88
12 25 27
37 39
55 72 74
88 91 94
61
27
55
12
94 37
88
72
39
25
88
74
58
12 37 55 88
12 25 27
37 39
55 58 72 74
88 91 94
62
27
55
12
94 37
88
72
39
25
88
74
58
64
12 37 55 88
12 25 27
37 39
55 58 72 74
88 91 94
63
27
55
12
94 37
88
72
39
25
88
74
58
64
12 37 72 88
12 25 27
37 39
55 58
72 74
88 91 94
64
27
55
12
94 37
88
72
39
25
88
74
58
64
12 37 72 88
12 25 27
37 39
55 58 64
72 74
88 91 94
65
27
55
12
94 37
88
72
39
25
12 37
12 25 27
37 39
88
74
58
64
55 72 88
55 58 64
72 74
88 91 94
66
27
55
12
94 37
88
72
39
25
88
74
58
64
12 55
12 37
12 25 27
37 39
55 72 88
55 58 64
72 74
88 91 94
67
27
55
12
94 37
88
72
39
25
88
74
58
64
12 55
12 37
12 25 27
37 39
55 72 88
55 58 64
72 74
88 91 94
Sequenz eingefügt
68
Löschen in B*Baum
17
22
31
17
42
77
42
47
53
61
77
79
Entferne 53
69
Löschen in B*Baum
17
22
31
17
42
77
42
47
61
77
79
Entferne 79
70
Löschen in B*Baum
17
22
17
31
31
47
61
61
77
Entferne 47
71
Löschen in B*Baum
17
17
22
31
77
77
79
Entferne 77
72
Löschen in B*Baum
17
17
22
31
31
79
Entferne 22
73
Löschen in B*Baum
17
31
79
74
Fragen zum B*Baum
Wie groß ist k ?
Blockgröße / (Schlüssel / Adresspaar-Größe) =
1024 / (15+4) / 2 = 26
Wieviel Söhne hat eine zu 50 % gefüllte Wurzel ?
26
Wieviel Söhne hat ein zu 75 % gefüllter Knoten ?
39
Wieviel zu 75 % gefüllte Datenblöcke sind erforderlich ?
300.000 / 7,5  40.000
75
Platzbedarf B*Baum
Wieviel Blöcke belegt der B*Baum ?
Höhe
Knoten
Zeiger aus Knoten
0
1
26
1
26
26 * 39 = 1.014
2
26*39
26*39*39 = 39.546
 drei Ebenen reichen aus
 Platzbedarf = 1 + 26 + 26*39 + 39.546  40.000 Blöcke
Wieviel Blockzugriffe sind erforderlich ?
4
76
Hashing versus B*Baum
Welcher Platzbedarf entsteht beim Hashing, wenn dieselbe
Zugriffszeit erreicht werden soll wie beim B*Baum?
4 Blockzugriffe = 1 Directory-Blockzugriff + 3 Datenblockzugriffe.
 Buckets bestehen im Mittel aus 5 Blöcken.
 von 5 Blöcken sind 4 voll und der letzte halb voll.
 4,5 * 10 = 45 Records pro Bucket
 300.000 / 45 = 6666 Buckets erforderlich
 6666 / (1024 / 4) = 26 Directory-Blöcke
 Platzbedarf = 26 + 5 * 6.666 = 33.356
77
B*Baum versus Hashing
B*Baum
Hashing
Vorteile
Dynamisch
Sortierung möglich
Schnell
platzsparend
Nachteile
Speicheroverhead
kompliziert
keine Sortierung
Neuorganisation
78
Mehrdimensionale Suchstrukturen
Alter
zwischen 20 und 30
Einkommen
zwischen 2000 und 3000
PLZ
zwischen 40000 und 50000
79
Query-Rechteck
y
G
y2
H
F
I
B
K
y1
C
J
A
D
E
x
x1
x2
80
k-d-Baum
y
z
x
zur Verwaltung von mehrdimensionalen Datenpunkten
Verallgemeinerung des binären Suchbaums
mit k-dimensionalem Sortierschlüssel
Homogene Variante:
Baumknoten enthält Datenrecord + Zeiger
Inhomogene Variante:
Baumknoten enthält Schlüssel + Zeiger
Blätter enthalten Zeiger auf Datenrecord
Ebene i modulo k diskriminiert bzgl. Dimension i
81
2-d-Baum
Im 2-dimensionalen Fall gilt für Knoten mit Schlüssel [x/y]:
im linken Sohn
im rechten Sohn
Auf ungerader Ebene
alle Schlüssel  x
alle Schlüssel > x
Auf gerader Ebene
alle Schlüssel  y
alle Schlüssel > y
82
2-d-Baum
10
9
E
8
G
F
7
6
A
5
H
C
4
3
B
2
D
1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
83
Beispiel für 2-d-Baum
A 5/6
bzgl.y kleiner
bzgl.y grösser
BB14/3
14/3
C 9/4
bzgl.y kleiner
D 6/2
E 7/9
bzgl.x grösser
bzgl.x kleiner
Ebene 0
G 1/8
bzgl.x grösser
F 12/7
bzgl.y grösser
H 8/5
84
Beispiel für 2-d-Baum
A 5/6
bzgl.y kleiner
bzgl.y grösser
BB14/3
14/3
bzgl.x grösser
bzgl.x kleiner
C 9/4
bzgl.y kleiner
D 6/2
Insert
E 7/9
bzgl.x grösser
F 12/7
G 1/8
bzgl.y grösser
H 8/5
I 3/9
z.B. füge Record [3/9]
85
Beispiel für 2-d-Baum
A 5/6
bzgl.y kleiner
bzgl.y grösser
BB14/3
14/3
bzgl.x grösser
bzgl.x kleiner
C 9/4
bzgl.y kleiner
D 6/2
Exact Match
E 7/9
G 1/8
bzgl.x grösser
F 12/7
bzgl.y grösser
H 8/5
z.B. finde Record [15/5]
86
Beispiel für 2-d-Baum
A 5/6
bzgl.y kleiner
bzgl.y grösser
BB14/3
14/3
bzgl.x grösser
bzgl.x kleiner
C 9/4
bzgl.y kleiner
D 6/2
Partial Match
E 7/9
G 1/8
bzgl.x grösser
F 12/7
bzgl.y grösser
H 8/5
z.B. finde alle Records [x/y] mit x=7
87
Beispiel für 2-d-Baum
A 5/6
bzgl.y kleiner
bzgl.y grösser
BB14/3
14/3
bzgl.x grösser
bzgl.x kleiner
C 9/4
bzgl.y kleiner
D 6/2
Range-Query
E 7/9
G 1/8
bzgl.x grösser
F 12/7
bzgl.y grösser
H 8/5
z.B. finde alle Records [x/y] mit 8  x  13, 5  y  8
88
Beispiel für 2-d-Baum
A 5/6
bzgl.y kleiner
bzgl.y grösser
BB14/3
14/3
bzgl.x grösser
bzgl.x kleiner
C 9/4
bzgl.y kleiner
D 6/2
Best Match
E 7/9
G 1/8
bzgl.x grösser
F 12/7
bzgl.y grösser
H 8/5
z.B. finde nächsten Nachbarn zu [7/3]
89
2-d-Baum
10
9
E
8
G
F
7
6
A
5
H
C
4
3
B
2
D
1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
90
Inhomogene Variante
91
Partitionierungen
92
Gitterverfahren mit konstanter Gittergröße
93
Grid File
Alternative zu fester Gittergröße
1981 vorgestellt von Hinrichs & Nievergelt
2-Platten-Zugriffsgarantie
Bei k-dimensionalen Tupeln:
• k Skalen zum Einstieg ins Grid-Directory
(im Hauptspeicher)
• Grid Directory zum Finden der Bucket-Nr.
(Hintergrundspeicher)
• Bucket für Datensätze
(Hintergrundspeicher)
94
Grid File im 2-dimensionalen Fall
y
3030
x
0
30
0
800
40
85
120
x[i],i=0,.. max_x
2050 2500 3030
y[i],i=0,.. max_y
2500
2050
y
800
0
30 40
85
120
x
Gitterzelle: rechteckiger Teilbereich
Region: benachbarte Gitterzellen
Bucket: speichert Records einer Region
Alle Records der roten Gitterzelle sind im Bucket mit Adresse G[1,2]
95
Bucket Directory
3030
2500
2050
800
0
4
3
2
1
0
wi00808ß3jsßsa9ßß
dxcvß98dspa0s9fxc0
9v8asßfimo98csi98a
aasdf0cß03j400d0v
0
1
0 30
2
40
3
4
asp07nk99jh056509
85 120
Suche Record [35 / 2400]
Lade G[1,2] vom Bucketdirectory
Befrage Skalen
Lade Datenblock
96
Beispiel für Bucket Directory
1.000.000 Datenrecords
4 Datenrecords passen in ein Bucket
G[280,2] auf Block 5
an Position 30
X-Achse und Y-Achse habe 500 Unterteilungen
250.000 Einträge im Bucketdirectory
4 Bytes pro Adresse + 1.024 Bytes pro Block
250 Zeiger pro Directory-Block
1.000 Directory-Blöcke
.
.
.
2
1
0
.....................................
.....................................
.....................................
.....................................
.....................................
.....................................
.....................................
0
249
499
i  249: G[i,j] befindet sich auf Block 2*j als i-te Adresse
i > 249: G[i,j] befindet sich auf Block 2*j+1 als (i-250)-te Adresse
97
Bucket-Überlauf
Eine Zelle in Region
Mehrere Zellen in Region
98
Aufspalten der Regionen
Insert A = [5 / 6]
8
6
4
2
2
4
6
8
10
12
14
99
Aufspalten der Regionen
Insert B = [14 / 3]
A
8
6
A
4
2
2
4
6
8
10
12
14
100
Aufspalten der Regionen
Insert C = [9 / 4]
A B
8
6
A
4
B
2
2
4
6
8
10
12
14
101
Aufspalten der Regionen
B C
A
Insert D = [6 / 2]
8
6
A
4
C
B
2
2
4
6
8
10
12
14
102
Aufspalten der Regionen
B C
A D
Insert E = [7 / 9]
8
6
A
4
C
B
2
D
2
4
6
8
10
12
14
103
Aufspalten der Regionen
Insert F = [12 / 7]
A E
8
E
6
A
4
C
B
2
B C
D
2
4
6
8
10
12
14
D
104
Aufspalten der Regionen
Insert G = [1 / 8]
A E
8
E
F
F
6
A
4
C
B
2
B C
D
2
4
6
8
10
12
14
D
105
Aufspalten der Regionen
G
Insert A = [5 / 6]
A E
8
E
G
F
F
6
A
4
C
B
2
B C
D
2
4
6
8
10
12
14
D
106
Dynamik des Grid Directory
Insert A=[12 / 280]
300
200
10
50
3 Datenrecords pro Bucket
107
Dynamik des Grid Directory
Insert B=[25 / 220]
300
A
300
200
10
50
300
200
10
200
10
50
50
108
Dynamik des Grid Directory
Insert C=[45 / 270]
300
A
300
200
10
50
300
200
10
50
B
200
10
50
109
Dynamik des Grid Directory
Insert D=[22 / 275]
300
A
C
300
200
10
50
300
200
10
50
B
200
10
50
110
Dynamik des Grid Directory
Insert E=[24 / 260]
300
A
C
D
300
200
10
30
50
300
200
10
50
B
200
10
30
50
111
Dynamik des Grid Directory
Insert F=[26 / 280]
300
300
A
C
D
250
E
200
250
10
30
50
300
200
10
50
B
200
10
30
50
112
Dynamik des Grid Directory
Directory Block
vergröbern
300
300
F
A
C
D
250
E
200
250
10
20
30
300
200
10
50
300
B
200
10
30
30
50
250
200
30
50
113
Dynamik des Grid Directory
300
300
F
A
C
D
250
E
200
250
10
20
30
300
200
10
30
50
B
200
10
30
50
300
200
30
50
114
Vereinigung von Regionen
bei zu geringer Bucketauslastung:
• Benachbarte Regionen vereinigen
• Vereinigung muß Rechteck ergeben
Vereinigung wird ausgelöst
• wenn Bucket < 30 % Auslastung
• wenn vereinigtes Bucket < 70 % Auslastung
115
Nearest Neighbor
P
R
Q
116
Verwaltung von geometrischen Objekten
Grid File unterstützt Range-Query
bisher:
k Attribute
Jetzt:
k-dimensionale Punkte
117
Verwaltung von Intervallen
5
A
4
3
E
2
B
1
C
D
A
1
2
3
4
5
6
7
8
F
9
10
11
12
13
14
E
A
C
B
[Anfang / Ende]
F
D
Besser: [Mittelpunkt / halbe Länge]
118
15
Query-Punkt gegen Intervall
m-d
m
m+d
Punkt p liegt im Intervall mit Mitte m und halber Länge d 
m-d  p  m+d
119
Query-Punkt gegen Intervall
5
4
3
E
2
B
1
C
D
A
1
2
3
4
5
6
7
8
F
9
10
11
12
13
14
E
A
C
B
F
D
Punkt p liegt im Intervall mit Mitte m und halber Länge d 
m-d  p  m+d
p=5  m-d  5  m+d
120
15
Query-Intervall gegen Intervall
m-d
m+d
s-t
s+t
Intervall mit Mitte s und halber Länge t schneidet
Intervall mit Mitte m und halber Länge d 
m-d  s+t und s-t  m+d
121
Query-Intervall gegen Intervall
5
4
3
E
2
B
1
C
D
A
1
2
3
4
5
6
7
8
F
9
10
11
12
13
14
E
A
C
B
F
D
Intervall mit Mitte s und halber Länge t schneidet
Intervall mit Mitte m und halber Länge d 
m-d  s+t und s-t  m+d
s=10, t=1  m-d  11 und 9  m+d
122
15
Query-Rechteck gegen Rechteck
Stelle Rechteck durch vierdimensionalen Punkt dar
123